#include "postgres_fe.h"
#include <string.h>
#include <stdio.h>
#include "fe_utils/psqlscan.h"
#include "fe_utils/string_utils.h"
#include "getopt_long.h"
#include "libpq-fe.h"
#include "mb/pg_wchar.h"
#include "utils/memdebug.h"

Include dependency graph for test_escape.c:

Data Structures
struct	pe_test_config

struct	pe_test_escape_func

struct	pe_test_vector

Macros
#define	TV(enc, string) {.client_encoding = (enc), .escape=string, .escape_len=sizeof(string) - 1, }

#define	TV_LEN(enc, string, len) {.client_encoding = (enc), .escape=string, .escape_len=len, }

#define	TOSTR_CASE(sym) case sym: return #sym

#define	NEVER_ACCESS_STR "\xff never-to-be-touched"

Typedefs
typedef struct pe_test_config	pe_test_config

typedef struct pe_test_escape_func	pe_test_escape_func

typedef struct pe_test_vector	pe_test_vector

Functions
static bool	escape_literal (PGconn conn, PQExpBuffer target, const char unescaped, size_t unescaped_len, PQExpBuffer escape_err)

static bool	escape_identifier (PGconn conn, PQExpBuffer target, const char unescaped, size_t unescaped_len, PQExpBuffer escape_err)

static bool	escape_string_conn (PGconn conn, PQExpBuffer target, const char unescaped, size_t unescaped_len, PQExpBuffer escape_err)

static bool	escape_string (PGconn conn, PQExpBuffer target, const char unescaped, size_t unescaped_len, PQExpBuffer escape_err)

static bool	escape_replace (PGconn conn, PQExpBuffer target, const char unescaped, size_t unescaped_len, PQExpBuffer escape_err)

static bool	escape_append_literal (PGconn conn, PQExpBuffer target, const char unescaped, size_t unescaped_len, PQExpBuffer escape_err)

static bool	escape_fmt_id (PGconn conn, PQExpBuffer target, const char unescaped, size_t unescaped_len, PQExpBuffer escape_err)

static void	escapify (PQExpBuffer buf, const char *str, size_t len)

static void	report_result (pe_test_config tc, bool success, PQExpBuffer testname, PQExpBuffer details, const char subname, const char *resultdesc)

static bool	encoding_conflicts_ascii (int encoding)

static const char *	scan_res_s (PsqlScanResult res)

static void	test_psql_parse (pe_test_config *tc, PQExpBuffer testname, PQExpBuffer input_buf, PQExpBuffer details)

static void	test_one_vector_escape (pe_test_config tc, const pe_test_vector tv, const pe_test_escape_func *ef)

static void	test_one_vector (pe_test_config tc, const pe_test_vector tv)

static void	usage (const char *hint)

int	main (int argc, char *argv[])

Variables
static const PsqlScanCallbacks	test_scan_callbacks

static pe_test_escape_func	pe_test_escape_funcs []

static pe_test_vector	pe_test_vectors []

Macro Definition Documentation

◆ NEVER_ACCESS_STR

#define NEVER_ACCESS_STR "\xff never-to-be-touched"

◆ TOSTR_CASE

#define TOSTR_CASE ( sym ) case sym: return #sym

◆ TV

#define TV	(	enc,
		string
	)	{.client_encoding = (enc), .escape=string, .escape_len=sizeof(string) - 1, }

Definition at line 285 of file test_escape.c.

◆ TV_LEN

#define TV_LEN	(	enc,
		string,
		len
	)	{.client_encoding = (enc), .escape=string, .escape_len=len, }

Definition at line 286 of file test_escape.c.

Typedef Documentation

◆ pe_test_config

typedef struct pe_test_config pe_test_config

◆ pe_test_escape_func

typedef struct pe_test_escape_func pe_test_escape_func

◆ pe_test_vector

typedef struct pe_test_vector pe_test_vector

Function Documentation

◆ encoding_conflicts_ascii()

static bool encoding_conflicts_ascii ( int encoding )

static

Definition at line 450 of file test_escape.c.

{
    /*
     * We don't store this property directly anywhere, but whether an encoding
     * is a client-only encoding is a good proxy.
     */
    if (encoding > PG_ENCODING_BE_LAST)
        return true;
    return false;
}

References encoding, and PG_ENCODING_BE_LAST.

Referenced by test_one_vector_escape().

◆ escape_append_literal()

static bool escape_append_literal	(	PGconn *	conn,
		PQExpBuffer	target,
		const char *	unescaped,
		size_t	unescaped_len,
		PQExpBuffer	escape_err
	)

static

Definition at line 218 of file test_escape.c.

{
    appendStringLiteral(target, unescaped, PQclientEncoding(conn), 1);
 
    return true;
}

References appendStringLiteral(), conn, and PQclientEncoding().

◆ escape_fmt_id()

static bool escape_fmt_id	(	PGconn *	conn,
		PQExpBuffer	target,
		const char *	unescaped,
		size_t	unescaped_len,
		PQExpBuffer	escape_err
	)

static

Definition at line 228 of file test_escape.c.

{
    setFmtEncoding(PQclientEncoding(conn));
    appendPQExpBufferStr(target, fmtId(unescaped));
 
    return true;
}

References appendPQExpBufferStr(), conn, fmtId(), PQclientEncoding(), and setFmtEncoding().

◆ escape_identifier()

static bool escape_identifier	(	PGconn *	conn,
		PQExpBuffer	target,
		const char *	unescaped,
		size_t	unescaped_len,
		PQExpBuffer	escape_err
	)

static

Definition at line 114 of file test_escape.c.

{
    char       *escaped;
 
    escaped = PQescapeIdentifier(conn, unescaped, unescaped_len);
    if (!escaped)
    {
        appendPQExpBuffer(escape_err, "%s",
                          PQerrorMessage(conn));
        escape_err->data[escape_err->len - 1] = 0;
        escape_err->len--;
        return false;
    }
    else
    {
        appendPQExpBufferStr(target, escaped);
        PQfreemem(escaped);
        return true;
    }
}

References appendPQExpBuffer(), appendPQExpBufferStr(), conn, PQExpBufferData::data, PQExpBufferData::len, PQerrorMessage(), PQescapeIdentifier(), and PQfreemem().

◆ escape_literal()

static bool escape_literal	(	PGconn *	conn,
		PQExpBuffer	target,
		const char *	unescaped,
		size_t	unescaped_len,
		PQExpBuffer	escape_err
	)

static

Definition at line 90 of file test_escape.c.

{
    char       *escaped;
 
    escaped = PQescapeLiteral(conn, unescaped, unescaped_len);
    if (!escaped)
    {
        appendPQExpBuffer(escape_err, "%s",
                          PQerrorMessage(conn));
        escape_err->data[escape_err->len - 1] = 0;
        escape_err->len--;
        return false;
    }
    else
    {
        appendPQExpBufferStr(target, escaped);
        PQfreemem(escaped);
        return true;
    }
}

References appendPQExpBuffer(), appendPQExpBufferStr(), conn, PQExpBufferData::data, PQExpBufferData::len, PQerrorMessage(), PQescapeLiteral(), and PQfreemem().

◆ escape_replace()

static bool escape_replace	(	PGconn *	conn,
		PQExpBuffer	target,
		const char *	unescaped,
		size_t	unescaped_len,
		PQExpBuffer	escape_err
	)

static

Definition at line 192 of file test_escape.c.

{
    const char *s = unescaped;
 
    appendPQExpBufferChar(target, '\'');
 
    for (int i = 0; i < unescaped_len; i++)
    {
        char        c = *s;
 
        if (c == '\'')
        {
            appendPQExpBufferStr(target, "''");
        }
        else
            appendPQExpBufferChar(target, c);
        s++;
    }
    appendPQExpBufferChar(target, '\'');
 
    return true;
}

References appendPQExpBufferChar(), appendPQExpBufferStr(), and i.

◆ escape_string()

static bool escape_string	(	PGconn *	conn,
		PQExpBuffer	target,
		const char *	unescaped,
		size_t	unescaped_len,
		PQExpBuffer	escape_err
	)

static

Definition at line 169 of file test_escape.c.

{
    size_t      sz;
 
    appendPQExpBufferChar(target, '\'');
    enlargePQExpBuffer(target, unescaped_len * 2 + 1);
    sz = PQescapeString(target->data + target->len,
                        unescaped, unescaped_len);
    target->len += sz;
    appendPQExpBufferChar(target, '\'');
 
 
    return true;
}

References appendPQExpBufferChar(), PQExpBufferData::data, enlargePQExpBuffer(), PQExpBufferData::len, and PQescapeString().

◆ escape_string_conn()

static bool escape_string_conn	(	PGconn *	conn,
		PQExpBuffer	target,
		const char *	unescaped,
		size_t	unescaped_len,
		PQExpBuffer	escape_err
	)

static

Definition at line 138 of file test_escape.c.

{
    int         error;
    size_t      sz;
 
    appendPQExpBufferChar(target, '\'');
    enlargePQExpBuffer(target, unescaped_len * 2 + 1);
    sz = PQescapeStringConn(conn, target->data + target->len,
                            unescaped, unescaped_len,
                            &error);
 
    target->len += sz;
    appendPQExpBufferChar(target, '\'');
 
    if (error)
    {
        appendPQExpBuffer(escape_err, "%s",
                          PQerrorMessage(conn));
        escape_err->data[escape_err->len - 1] = 0;
        escape_err->len--;
        return false;
    }
    else
    {
        return true;
    }
}

References appendPQExpBuffer(), appendPQExpBufferChar(), conn, PQExpBufferData::data, enlargePQExpBuffer(), error(), PQExpBufferData::len, PQerrorMessage(), and PQescapeStringConn().

◆ escapify()

static void escapify	(	PQExpBuffer	buf,
		const char *	str,
		size_t	len
	)

static

Definition at line 394 of file test_escape.c.

{
    for (size_t i = 0; i < len; i++)
    {
        char        c = *str;
 
        if (c == '\n')
            appendPQExpBufferStr(buf, "\\n");
        else if (c == '\0')
            appendPQExpBufferStr(buf, "\\0");
        else if (c < ' ' || c > '~')
            appendPQExpBuffer(buf, "\\x%2x", (uint8_t) c);
        else
            appendPQExpBufferChar(buf, c);
        str++;
    }
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), buf, i, len, and str.

Referenced by test_one_vector_escape(), and test_psql_parse().

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 812 of file test_escape.c.

{
    pe_test_config tc = {0};
    int         c;
    int         option_index;
 
    static const struct option long_options[] = {
        {"help", no_argument, NULL, 'h'},
        {"conninfo", required_argument, NULL, 'c'},
        {"verbose", no_argument, NULL, 'v'},
        {"quiet", no_argument, NULL, 'q'},
        {"force-unsupported", no_argument, NULL, 'f'},
        {NULL, 0, NULL, 0},
    };
 
    while ((c = getopt_long(argc, argv, "c:fhqv", long_options, &option_index)) != -1)
    {
        switch (c)
        {
            case 'h':
                usage(NULL);
                exit(0);
                break;
            case 'c':
                tc.conninfo = optarg;
                break;
            case 'v':
                tc.verbosity++;
                break;
            case 'q':
                tc.verbosity--;
                break;
            case 'f':
                tc.force_unsupported = true;
                break;
        }
    }
 
    if (argc - optind >= 1)
        usage("unused option(s) specified");
 
    if (tc.conninfo == NULL)
        usage("--conninfo needs to be specified");
 
    tc.conn = PQconnectdb(tc.conninfo);
 
    if (!tc.conn || PQstatus(tc.conn) != CONNECTION_OK)
    {
        fprintf(stderr, "could not connect: %s\n",
                PQerrorMessage(tc.conn));
        exit(1);
    }
 
    for (int i = 0; i < lengthof(pe_test_vectors); i++)
    {
        test_one_vector(&tc, &pe_test_vectors[i]);
    }
 
    PQfinish(tc.conn);
 
    printf("# %d failures\n", tc.failure_count);
    printf("1..%d\n", tc.test_count);
    return tc.failure_count > 0;
}

References pe_test_config::conn, CONNECTION_OK, pe_test_config::conninfo, pe_test_config::failure_count, pe_test_config::force_unsupported, fprintf, getopt_long(), i, lengthof, no_argument, optarg, optind, pe_test_vectors, PQconnectdb(), PQerrorMessage(), PQfinish(), PQstatus(), printf, required_argument, pe_test_config::test_count, test_one_vector(), usage(), and pe_test_config::verbosity.

◆ report_result()

static void report_result	(	pe_test_config *	tc,
		bool	success,
		PQExpBuffer	testname,
		PQExpBuffer	details,
		const char *	subname,
		const char *	resultdesc
	)

static

Definition at line 413 of file test_escape.c.

{
    int         test_id = ++tc->test_count;
    bool        print_details = true;
    bool        print_result = true;
 
    if (success)
    {
        if (tc->verbosity <= 0)
            print_details = false;
        if (tc->verbosity < 0)
            print_result = false;
    }
    else
        tc->failure_count++;
 
    if (print_details)
        printf("%s", details->data);
 
    if (print_result)
        printf("%s %d - %s: %s: %s\n",
               success ? "ok" : "not ok",
               test_id, testname->data,
               subname,
               resultdesc);
}

References PQExpBufferData::data, pe_test_config::failure_count, printf, subname, success, pe_test_config::test_count, and pe_test_config::verbosity.

Referenced by test_one_vector_escape(), and test_psql_parse().

◆ scan_res_s()

static const char * scan_res_s ( PsqlScanResult res )

static

Definition at line 462 of file test_escape.c.

{
#define TOSTR_CASE(sym) case sym: return #sym
 
    switch (res)
    {
            TOSTR_CASE(PSCAN_SEMICOLON);
            TOSTR_CASE(PSCAN_BACKSLASH);
            TOSTR_CASE(PSCAN_INCOMPLETE);
            TOSTR_CASE(PSCAN_EOL);
    }
 
    pg_unreachable();
    return "";                  /* silence compiler */
}

References pg_unreachable, PSCAN_BACKSLASH, PSCAN_EOL, PSCAN_INCOMPLETE, PSCAN_SEMICOLON, and TOSTR_CASE.

Referenced by test_psql_parse().

◆ test_one_vector()

static void test_one_vector	(	pe_test_config *	tc,
		const pe_test_vector *	tv
	)

static

Definition at line 771 of file test_escape.c.

{
    if (PQsetClientEncoding(tc->conn, tv->client_encoding))
    {
        fprintf(stderr, "failed to set encoding to %s:\n%s\n",
                tv->client_encoding, PQerrorMessage(tc->conn));
        exit(1);
    }
 
    for (int escoff = 0; escoff < lengthof(pe_test_escape_funcs); escoff++)
    {
        const pe_test_escape_func *ef = &pe_test_escape_funcs[escoff];
 
        test_one_vector_escape(tc, tv, ef);
    }
}

References pe_test_vector::client_encoding, pe_test_config::conn, fprintf, lengthof, pe_test_escape_funcs, PQerrorMessage(), PQsetClientEncoding(), and test_one_vector_escape().

Referenced by main().

◆ test_one_vector_escape()

static void test_one_vector_escape	(	pe_test_config *	tc,
		const pe_test_vector *	tv,
		const pe_test_escape_func *	ef
	)

static

Definition at line 541 of file test_escape.c.

{
    PQExpBuffer testname;
    PQExpBuffer details;
    PQExpBuffer raw_buf;
    PQExpBuffer escape_buf;
    PQExpBuffer escape_err;
    size_t      input_encoding_validlen;
    bool        input_encoding_valid;
    size_t      input_encoding0_validlen;
    bool        input_encoding0_valid;
    bool        escape_success;
    size_t      escape_encoding_length;
    bool        escape_encoding_valid;
 
    escape_err = createPQExpBuffer();
    testname = createPQExpBuffer();
    details = createPQExpBuffer();
    raw_buf = createPQExpBuffer();
    escape_buf = createPQExpBuffer();
 
    if (ef->supports_only_ascii_overlap &&
        encoding_conflicts_ascii(PQclientEncoding(tc->conn)))
    {
        goto out;
    }
 
    /* name to describe the test */
    appendPQExpBuffer(testname, ">");
    escapify(testname, tv->escape, tv->escape_len);
    appendPQExpBuffer(testname, "< - %s - %s",
                      tv->client_encoding, ef->name);
 
    /* details to describe the test, to allow for debugging */
    appendPQExpBuffer(details, "#\t input: %zd bytes: ",
                      tv->escape_len);
    escapify(details, tv->escape, tv->escape_len);
    appendPQExpBufferStr(details, "\n");
    appendPQExpBuffer(details, "#\t encoding: %s\n",
                      tv->client_encoding);
 
 
    /* check encoding of input, to compare with after the test */
    input_encoding_validlen = pg_encoding_verifymbstr(PQclientEncoding(tc->conn),
                                                      tv->escape,
                                                      tv->escape_len);
    input_encoding_valid = input_encoding_validlen == tv->escape_len;
    appendPQExpBuffer(details, "#\t input encoding valid: %d\n",
                      input_encoding_valid);
 
    input_encoding0_validlen = pg_encoding_verifymbstr(PQclientEncoding(tc->conn),
                                                       tv->escape,
                                                       strnlen(tv->escape, tv->escape_len));
    input_encoding0_valid = input_encoding0_validlen == strnlen(tv->escape, tv->escape_len);
    appendPQExpBuffer(details, "#\t input encoding valid till 0: %d\n",
                      input_encoding0_valid);
 
    appendPQExpBuffer(details, "#\t escape func: %s\n",
                      ef->name);
 
    if (!input_encoding_valid && ef->supports_only_valid
        && !tc->force_unsupported)
        goto out;
 
 
    /*
     * Put the to-be-escaped data into a buffer, so that we
     *
     * a) can mark memory beyond end of the string as inaccessible when using
     * valgrind
     *
     * b) can append extra data beyond the length passed to the escape
     * function, to verify that that data is not processed.
     *
     * TODO: Should we instead/additionally escape twice, once with unmodified
     * and once with appended input? That way we could compare the two.
     */
    appendBinaryPQExpBuffer(raw_buf, tv->escape, tv->escape_len);
 
#define NEVER_ACCESS_STR "\xff never-to-be-touched"
    if (ef->supports_input_length)
    {
        /*
         * Append likely invalid string that does *not* contain a null byte
         * (which'd prevent some invalid accesses to later memory).
         */
        appendPQExpBufferStr(raw_buf, NEVER_ACCESS_STR);
 
        VALGRIND_MAKE_MEM_NOACCESS(&raw_buf->data[tv->escape_len],
                                   raw_buf->len - tv->escape_len);
    }
    else
    {
        /* append invalid string, after \0 */
        appendPQExpBufferChar(raw_buf, 0);
        appendPQExpBufferStr(raw_buf, NEVER_ACCESS_STR);
 
        VALGRIND_MAKE_MEM_NOACCESS(&raw_buf->data[tv->escape_len + 1],
                                   raw_buf->len - tv->escape_len - 1);
    }
 
    /* call the to-be-tested escape function */
    escape_success = ef->escape(tc->conn, escape_buf,
                                raw_buf->data, tv->escape_len,
                                escape_err);
    if (!escape_success)
    {
        appendPQExpBuffer(details, "#\t escape error: %s\n",
                          escape_err->data);
    }
 
    if (escape_buf->len > 0)
    {
        bool        contains_never;
 
        appendPQExpBuffer(details, "#\t escaped string: %zd bytes: ", escape_buf->len);
        escapify(details, escape_buf->data, escape_buf->len);
        appendPQExpBufferChar(details, '\n');
 
        escape_encoding_length = pg_encoding_verifymbstr(PQclientEncoding(tc->conn),
                                                         escape_buf->data,
                                                         escape_buf->len);
        escape_encoding_valid = escape_encoding_length == escape_buf->len;
 
        appendPQExpBuffer(details, "#\t escape encoding valid: %d\n",
                          escape_encoding_valid);
 
        /*
         * Verify that no data beyond the end of the input is included in the
         * escaped string.  It'd be better to use something like memmem()
         * here, but that's not available everywhere.
         */
        contains_never = strstr(escape_buf->data, NEVER_ACCESS_STR) == NULL;
        report_result(tc, contains_never, testname, details,
                      "escaped data beyond end of input",
                      contains_never ? "no" : "all secrets revealed");
    }
    else
    {
        escape_encoding_length = 0;
        escape_encoding_valid = 1;
    }
 
    /*
     * If the test reports errors, and the input was invalidly encoded,
     * escaping should fail.  One edge-case that we accept for now is that the
     * input could have an embedded null byte, which the escape functions will
     * just treat as a shorter string. If the encoding error is after the zero
     * byte, the output thus won't contain it.
     */
    if (ef->reports_errors)
    {
        bool        ok = true;
        const char *resdesc = "ok";
 
        if (escape_success)
        {
            if (!input_encoding0_valid)
            {
                ok = false;
                resdesc = "invalid input escaped successfully";
            }
            else if (!input_encoding_valid)
                resdesc = "invalid input escaped successfully, due to zero byte";
        }
        else
        {
            if (input_encoding0_valid)
            {
                ok = false;
                resdesc = "valid input failed to escape";
            }
            else if (input_encoding_valid)
                resdesc = "valid input failed to escape, due to zero byte";
        }
 
        report_result(tc, ok, testname, details,
                      "input validity vs escape success",
                      resdesc);
    }
 
    /*
     * If the input is invalidly encoded, the output should also be invalidly
     * encoded. We accept the same zero-byte edge case as above.
     */
    {
        bool        ok = true;
        const char *resdesc = "ok";
 
        if (input_encoding0_valid && !input_encoding_valid && escape_encoding_valid)
        {
            resdesc = "invalid input produced valid output, due to zero byte";
        }
        else if (input_encoding0_valid && !escape_encoding_valid)
        {
            ok = false;
            resdesc = "valid input produced invalid output";
        }
        else if (!input_encoding0_valid &&
                 (!ef->reports_errors || escape_success) &&
                 escape_encoding_valid)
        {
            ok = false;
            resdesc = "invalid input produced valid output";
        }
 
        report_result(tc, ok, testname, details,
                      "input and escaped encoding validity",
                      resdesc);
    }
 
    /*
     * Test psql parsing whenever we get any string back, even if the escape
     * function returned a failure.
     */
    if (escape_buf->len > 0)
    {
        test_psql_parse(tc, testname,
                        escape_buf, details);
    }
 
out:
    destroyPQExpBuffer(escape_err);
    destroyPQExpBuffer(details);
    destroyPQExpBuffer(testname);
    destroyPQExpBuffer(escape_buf);
    destroyPQExpBuffer(raw_buf);
}

References appendBinaryPQExpBuffer(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), pe_test_vector::client_encoding, pe_test_config::conn, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), encoding_conflicts_ascii(), pe_test_escape_func::escape, pe_test_vector::escape, pe_test_vector::escape_len, escapify(), pe_test_config::force_unsupported, PQExpBufferData::len, pe_test_escape_func::name, NEVER_ACCESS_STR, pg_encoding_verifymbstr(), PQclientEncoding(), report_result(), pe_test_escape_func::reports_errors, strnlen(), pe_test_escape_func::supports_input_length, pe_test_escape_func::supports_only_ascii_overlap, pe_test_escape_func::supports_only_valid, test_psql_parse(), and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by test_one_vector().

◆ test_psql_parse()

static void test_psql_parse	(	pe_test_config *	tc,
		PQExpBuffer	testname,
		PQExpBuffer	input_buf,
		PQExpBuffer	details
	)

static

Definition at line 484 of file test_escape.c.

{
    PsqlScanState scan_state;
    PsqlScanResult scan_result;
    PQExpBuffer query_buf;
    promptStatus_t prompt_status = PROMPT_READY;
    int         matches = 0;
    bool        test_fails;
    const char *resdesc;
 
    query_buf = createPQExpBuffer();
 
    scan_state = psql_scan_create(&test_scan_callbacks);
 
    /*
     * TODO: This hardcodes standard conforming strings, it would be useful to
     * test without as well.
     */
    psql_scan_setup(scan_state, input_buf->data, input_buf->len,
                    PQclientEncoding(tc->conn), 1);
 
    do
    {
        resetPQExpBuffer(query_buf);
 
        scan_result = psql_scan(scan_state, query_buf,
                                &prompt_status);
 
        appendPQExpBuffer(details,
                          "#\t\t %d: scan_result: %s prompt: %u, query_buf: ",
                          matches, scan_res_s(scan_result), prompt_status);
        escapify(details, query_buf->data, query_buf->len);
        appendPQExpBuffer(details, "\n");
 
        matches++;
    }
    while (scan_result != PSCAN_INCOMPLETE && scan_result != PSCAN_EOL);
 
    psql_scan_destroy(scan_state);
    destroyPQExpBuffer(query_buf);
 
    test_fails = matches > 1 || scan_result != PSCAN_EOL;
 
    if (matches > 1)
        resdesc = "more than one match";
    else if (scan_result != PSCAN_EOL)
        resdesc = "unexpected end state";
    else
        resdesc = "ok";
 
    report_result(tc, !test_fails, testname, details,
                  "psql parse",
                  resdesc);
}

References appendPQExpBuffer(), pe_test_config::conn, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), escapify(), PQExpBufferData::len, PQclientEncoding(), PROMPT_READY, PSCAN_EOL, PSCAN_INCOMPLETE, psql_scan(), psql_scan_create(), psql_scan_destroy(), psql_scan_setup(), report_result(), resetPQExpBuffer(), scan_res_s(), and test_scan_callbacks.

Referenced by test_one_vector_escape().

◆ usage()

static void usage ( const char * hint )

static

Definition at line 789 of file test_escape.c.

{
    if (hint)
        fprintf(stderr, "Error: %s\n\n", hint);
 
    printf("PostgreSQL escape function test\n"
           "\n"
           "Usage:\n"
           "  test_escape --conninfo=CONNINFO [OPTIONS]\n"
           "\n"
           "Options:\n"
           "  -h, --help                show this help\n"
           "  -c, --conninfo=CONNINFO   connection information to use\n"
           "  -v, --verbose             show test details even for successes\n"
           "  -q, --quiet               only show failures\n"
           "  -f, --force-unsupported   test invalid input even if unsupported\n"
        );
 
    if (hint)
        exit(1);
}

References fprintf, and printf.

Referenced by main().

Variable Documentation

◆ pe_test_escape_funcs

pe_test_escape_func pe_test_escape_funcs[]

static

Definition at line 238 of file test_escape.c.

Referenced by test_one_vector().

◆ pe_test_vectors

pe_test_vector pe_test_vectors[]

static

Definition at line 287 of file test_escape.c.

Referenced by main().

◆ test_scan_callbacks

const PsqlScanCallbacks test_scan_callbacks

static

Initial value:

= {
    NULL
}

Definition at line 84 of file test_escape.c.

Referenced by test_psql_parse().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ NEVER_ACCESS_STR

◆ TOSTR_CASE

◆ TV

◆ TV_LEN

Typedef Documentation

◆ pe_test_config

◆ pe_test_escape_func

◆ pe_test_vector

Function Documentation

◆ encoding_conflicts_ascii()

◆ escape_append_literal()

◆ escape_fmt_id()

◆ escape_identifier()

◆ escape_literal()

◆ escape_replace()

◆ escape_string()

◆ escape_string_conn()

◆ escapify()

◆ main()

◆ report_result()

◆ scan_res_s()

◆ test_one_vector()

◆ test_one_vector_escape()

◆ test_psql_parse()

◆ usage()

Variable Documentation

◆ pe_test_escape_funcs

◆ pe_test_vectors

◆ test_scan_callbacks