#include "postgres_fe.h"
#include <string.h>
#include <stdio.h>
#include "common/jsonapi.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	NEVER_ACCESS_STR "\xff never-to-be-touched"

#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

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 void	escapify (PQExpBuffer buf, const char *str, size_t len)

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

static bool	encoding_conflicts_ascii (int encoding)

static void	test_gb18030_page_multiple (pe_test_config *tc)

static void	test_gb18030_json (pe_test_config *tc)

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 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"

Definition at line 35 of file test_escape.c.

◆ 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 443 of file test_escape.c.

◆ TV_LEN

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

Definition at line 444 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 156 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 376 of file test_escape.c.

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

References appendStringLiteral(), conn, fb(), 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 386 of file test_escape.c.

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

References appendPQExpBufferStr(), conn, fb(), 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 274 of file test_escape.c.

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

References appendPQExpBufferStr(), conn, fb(), 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 251 of file test_escape.c.

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

References appendPQExpBufferStr(), conn, fb(), 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 350 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(), fb(), 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 327 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(), fb(), 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 297 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)
    {
        appendPQExpBufferStr(escape_err, PQerrorMessage(conn));
        escape_err->data[escape_err->len - 1] = 0;
        escape_err->len--;
        return false;
    }
    else
    {
        return true;
    }
}

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

◆ escapify()

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

static

Definition at line 100 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, fb(), i, len, and str.

Referenced by test_gb18030_json(), test_gb18030_page_multiple(), test_one_vector_escape(), and test_psql_parse().

◆ main()

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

Definition at line 904 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);
    }
 
    test_gb18030_page_multiple(&tc);
    test_gb18030_json(&tc);
 
    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 CONNECTION_OK, fb(), fprintf, getopt_long(), i, lengthof, no_argument, optarg, optind, pe_test_vectors, PQconnectdb(), PQerrorMessage(), PQfinish(), PQstatus(), printf, required_argument, test_gb18030_json(), test_gb18030_page_multiple(), test_one_vector(), and usage().

◆ report_result()

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

static

Definition at line 119 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);
 
    if (print_result)
        printf("%s %d - %s: %s: %s\n",
               success ? "ok" : "not ok",
               test_id, testname,
               subname,
               resultdesc);
}

References fb(), printf, subname, and success.

Referenced by test_gb18030_json(), test_gb18030_page_multiple(), test_one_vector_escape(), and test_psql_parse().

◆ scan_res_s()

static const char * scan_res_s ( PsqlScanResult res )

static

Definition at line 555 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_gb18030_json()

static void test_gb18030_json ( pe_test_config * tc )

static

Definition at line 213 of file test_escape.c.

{
    PQExpBuffer raw_buf;
    PQExpBuffer testname;
    const char  input[] = "{\"\\u\xFE";
    size_t      input_len = sizeof(input) - 1;
    JsonLexContext *lex;
    JsonSemAction sem = {0};    /* no callbacks */
    JsonParseErrorType json_error;
 
    /* prepare input like test_one_vector_escape() does */
    raw_buf = createPQExpBuffer();
    appendBinaryPQExpBuffer(raw_buf, input, input_len);
    appendPQExpBufferStr(raw_buf, NEVER_ACCESS_STR);
    VALGRIND_MAKE_MEM_NOACCESS(&raw_buf->data[input_len],
                               raw_buf->len - input_len);
 
    /* name to describe the test */
    testname = createPQExpBuffer();
    appendPQExpBuffer(testname, ">");
    escapify(testname, input, input_len);
    appendPQExpBuffer(testname, "< - GB18030 - pg_parse_json");
 
    /* test itself */
    lex = makeJsonLexContextCstringLen(NULL, raw_buf->data, input_len,
                                       PG_GB18030, false);
    json_error = pg_parse_json(lex, &sem);
    report_result(tc, json_error == JSON_UNICODE_ESCAPE_FORMAT,
                  testname->data, "",
                  "diagnosed", json_errdetail(json_error, lex));
 
    freeJsonLexContext(lex);
    destroyPQExpBuffer(testname);
    destroyPQExpBuffer(raw_buf);
}

References appendBinaryPQExpBuffer(), appendPQExpBuffer(), appendPQExpBufferStr(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), escapify(), fb(), freeJsonLexContext(), input, json_errdetail(), JSON_UNICODE_ESCAPE_FORMAT, PQExpBufferData::len, makeJsonLexContextCstringLen(), NEVER_ACCESS_STR, PG_GB18030, pg_parse_json(), report_result(), sem, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by main().

◆ test_gb18030_page_multiple()

static void test_gb18030_page_multiple ( pe_test_config * tc )

static

Definition at line 180 of file test_escape.c.

{
    PQExpBuffer testname;
    size_t      input_len = 0x20000;
    char       *input;
 
    /* prepare input */
    input = pg_malloc(input_len);
    memset(input, '-', input_len - 1);
    input[input_len - 1] = 0xfe;
 
    /* name to describe the test */
    testname = createPQExpBuffer();
    appendPQExpBuffer(testname, ">repeat(%c, %zu)", input[0], input_len - 1);
    escapify(testname, input + input_len - 1, 1);
    appendPQExpBuffer(testname, "< - GB18030 - PQescapeLiteral");
 
    /* test itself */
    PQsetClientEncoding(tc->conn, "GB18030");
    report_result(tc, PQescapeLiteral(tc->conn, input, input_len) == NULL,
                  testname->data, "",
                  "input validity vs escape success", "ok");
 
    destroyPQExpBuffer(testname);
    pg_free(input);
}

References appendPQExpBuffer(), createPQExpBuffer(), destroyPQExpBuffer(), escapify(), fb(), input, pg_free(), pg_malloc(), PQescapeLiteral(), PQsetClientEncoding(), and report_result().

Referenced by main().

◆ test_one_vector()

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

static

Definition at line 863 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, fb(), 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 634 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 */
    appendPQExpBufferChar(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);
    appendPQExpBufferChar(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);
 
    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->data, details->data,
                      "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->data, details->data,
                      "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->data, details->data,
                      "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, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), encoding_conflicts_ascii(), pe_test_vector::escape, pe_test_vector::escape_len, escapify(), fb(), PQExpBufferData::len, NEVER_ACCESS_STR, pg_encoding_verifymbstr(), PQclientEncoding(), report_result(), 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 577 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);
        appendPQExpBufferChar(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->data, details->data,
                  "psql parse",
                  resdesc);
}

References appendPQExpBuffer(), appendPQExpBufferChar(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), escapify(), fb(), 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 881 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 fb(), fprintf, and printf.

Variable Documentation

◆ pe_test_escape_funcs

pe_test_escape_func pe_test_escape_funcs[]

static

Definition at line 396 of file test_escape.c.

{
    {
        .name = "PQescapeLiteral",
        .reports_errors = true,
        .supports_input_length = true,
        .escape = escape_literal,
    },
    {
        .name = "PQescapeIdentifier",
        .reports_errors = true,
        .supports_input_length = true,
        .escape = escape_identifier
    },
    {
        .name = "PQescapeStringConn",
        .reports_errors = true,
        .supports_input_length = true,
        .escape = escape_string_conn
    },
    {
        .name = "PQescapeString",
        .reports_errors = false,
        .supports_input_length = true,
        .escape = escape_string
    },
    {
        .name = "replace",
        .reports_errors = false,
        .supports_only_valid = true,
        .supports_only_ascii_overlap = true,
        .supports_input_length = true,
        .escape = escape_replace
    },
    {
        .name = "appendStringLiteral",
        .reports_errors = false,
        .escape = escape_append_literal
    },
    {
        .name = "fmtId",
        .reports_errors = false,
        .escape = escape_fmt_id
    },
};

Referenced by test_one_vector().

◆ pe_test_vectors

pe_test_vector pe_test_vectors[]

static

Definition at line 445 of file test_escape.c.

{
    /* expected to work sanity checks */
    TV("UTF-8", "1"),
    TV("UTF-8", "'"),
    TV("UTF-8", "\""),
 
    TV("UTF-8", "\'"),
    TV("UTF-8", "\""),
 
    TV("UTF-8", "\\"),
 
    TV("UTF-8", "\\'"),
    TV("UTF-8", "\\\""),
 
    /* trailing multi-byte character, paddable in available space */
    TV("UTF-8", "1\xC0"),
    TV("UTF-8", "1\xE0 "),
    TV("UTF-8", "1\xF0 "),
    TV("UTF-8", "1\xF0  "),
    TV("UTF-8", "1\xF0   "),
 
    /* trailing multi-byte character, not enough space to pad */
    TV("UTF-8", "1\xE0"),
    TV("UTF-8", "1\xF0"),
    TV("UTF-8", "\xF0"),
 
    /* try to smuggle in something in invalid characters */
    TV("UTF-8", "1\xE0'"),
    TV("UTF-8", "1\xE0\""),
    TV("UTF-8", "1\xF0'"),
    TV("UTF-8", "1\xF0\""),
    TV("UTF-8", "1\xF0'; "),
    TV("UTF-8", "1\xF0\"; "),
    TV("UTF-8", "1\xF0';;;;"),
    TV("UTF-8", "1\xF0  ';;;;"),
    TV("UTF-8", "1\xF0  \";;;;"),
    TV("UTF-8", "1\xE0'; \\l ; "),
    TV("UTF-8", "1\xE0\"; \\l ; "),
 
    /* null byte handling */
    TV("UTF-8", "some\0thing"),
    TV("UTF-8", "some\0"),
    TV("UTF-8", "some\xF0'\0"),
    TV("UTF-8", "some\xF0'\0'"),
    TV("UTF-8", "some\xF0" "ab\0'"),
 
    /* GB18030's 4 byte encoding requires a 2nd byte limited values */
    TV("GB18030", "\x90\x31"),
    TV("GB18030", "\\\x81\x5c'"),
    TV("GB18030", "\\\x81\x5c\""),
    TV("GB18030", "\\\x81\x5c\0'"),
 
    /*
     * \x81 indicates a 2 byte char. ' and " are not a valid second byte, but
     * that requires encoding verification to know. E.g. replace_string()
     * doesn't cope.
     */
    TV("GB18030", "\\\x81';"),
    TV("GB18030", "\\\x81\";"),
 
    /*
     * \x81 indicates a 2 byte char. \ is a valid second character.
     */
    TV("GB18030", "\\\x81\\';"),
    TV("GB18030", "\\\x81\\\";"),
    TV("GB18030", "\\\x81\0;"),
    TV("GB18030", "\\\x81\0'"),
    TV("GB18030", "\\\x81'\0"),
 
    TV("SJIS", "\xF0\x40;"),
 
    TV("SJIS", "\xF0';"),
    TV("SJIS", "\xF0\";"),
    TV("SJIS", "\xF0\0'"),
    TV("SJIS", "\\\xF0\\';"),
    TV("SJIS", "\\\xF0\\\";"),
 
    TV("gbk", "\x80';"),
    TV("gbk", "\x80"),
    TV("gbk", "\x80'"),
    TV("gbk", "\x80\""),
    TV("gbk", "\x80\\"),
 
    TV("mule_internal", "\\\x9c';\0;"),
 
    TV("sql_ascii", "1\xC0'"),
 
    /*
     * Testcases that are not null terminated for the specified input length.
     * That's interesting to verify that escape functions don't read beyond
     * the intended input length.
     *
     * One interesting special case is GB18030, which has the odd behaviour
     * needing to read beyond the first byte to determine the length of a
     * multi-byte character.
     */
    TV_LEN("gbk", "\x80", 1),
    TV_LEN("GB18030", "\x80", 1),
    TV_LEN("GB18030", "\x80\0", 2),
    TV_LEN("GB18030", "\x80\x30", 2),
    TV_LEN("GB18030", "\x80\x30\0", 3),
    TV_LEN("GB18030", "\x80\x30\x30", 3),
    TV_LEN("GB18030", "\x80\x30\x30\0", 4),
    TV_LEN("UTF-8", "\xC3\xb6  ", 1),
    TV_LEN("UTF-8", "\xC3\xb6  ", 2),
};

Referenced by main().

◆ test_scan_callbacks

const PsqlScanCallbacks test_scan_callbacks

static

Initial value:

= {
    NULL
}

Definition at line 87 of file test_escape.c.

                                                     {
    NULL
};

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_gb18030_json()

◆ test_gb18030_page_multiple()

◆ test_one_vector()

◆ test_one_vector_escape()

◆ test_psql_parse()

◆ usage()

Variable Documentation

◆ pe_test_escape_funcs

◆ pe_test_vectors

◆ test_scan_callbacks