test_escape.c File Reference

#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:

Go to the source code of this file.

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, 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, 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, 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 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, 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 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(), 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(), 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(), 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, 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 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_gb18030_json(), test_gb18030_page_multiple(), test_one_vector(), usage(), and pe_test_config::verbosity.

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 pe_test_config::failure_count, printf, subname, success, pe_test_config::test_count, and pe_test_config::verbosity.

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(), 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(), pe_test_config::conn, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), escapify(), 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, 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 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, 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 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(), 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 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 fprintf, and printf.

Referenced by main().

Variable Documentation

pe_test_escape_funcs

pe_test_escape_func pe_test_escape_funcs[]

static

Definition at line 396 of file test_escape.c.

Referenced by test_one_vector().

pe_test_vectors

pe_test_vector pe_test_vectors[]

static

Definition at line 445 of file test_escape.c.

Referenced by main().

test_scan_callbacks

const PsqlScanCallbacks test_scan_callbacks

static

Initial value:

= {
    NULL
}

Definition at line 87 of file test_escape.c.

Referenced by test_psql_parse().