X-Git-Url: https://git.exim.org/exim.git/blobdiff_plain/184e88237dea64ce48076cdd0184612d057cbafd..a85c067ba6c6940512cf57ec213277a370d87e70:/src/src/lookups/pgsql.c diff --git a/src/src/lookups/pgsql.c b/src/src/lookups/pgsql.c index e6e8f70ba..4fcd0e3ed 100644 --- a/src/src/lookups/pgsql.c +++ b/src/src/lookups/pgsql.c @@ -1,11 +1,11 @@ -/* $Cambridge: exim/src/src/lookups/pgsql.c,v 1.9 2007/01/08 10:50:19 ph10 Exp $ */ - /************************************************* * Exim - an Internet mail transport agent * *************************************************/ -/* Copyright (c) University of Cambridge 1995 - 2007 */ +/* Copyright (c) The Exim Maintainers 2020 - 2022 */ +/* Copyright (c) University of Cambridge 1995 - 2018 */ /* See the file NOTICE for conditions of use and distribution. */ +/* SPDX-License-Identifier: GPL-2.0-only */ /* Thanks to Petr Cech for contributing the original code for these functions. Thanks to Joachim Wieland for the initial patch for the Unix domain @@ -13,21 +13,6 @@ socket extension. */ #include "../exim.h" #include "lf_functions.h" -#include "pgsql.h" /* The local header */ - -/* We can't just compile this code and allow the library mechanism to omit the -functions if they are not wanted, because we need to have the PGSQL header -available for compiling. Therefore, compile these functions only if -LOOKUP_PGSQL is defined. However, some compilers don't like compiling empty -modules, so keep them happy with a dummy when skipping the rest. Make it -reference itself to stop picky compilers complaining that it is unused, and put -in a dummy argument to stop even pickier compilers complaining about infinite -loops. */ - -#ifndef LOOKUP_PGSQL -static void dummy(int x) { dummy(x-1); } -#else - #include /* The system header */ @@ -49,8 +34,8 @@ static pgsql_connection *pgsql_connections = NULL; /* See local README for interface description. */ -void * -pgsql_open(uschar *filename, uschar **errmsg) +static void * +pgsql_open(const uschar * filename, uschar ** errmsg) { return (void *)(1); /* Just return something non-null */ } @@ -63,14 +48,14 @@ return (void *)(1); /* Just return something non-null */ /* See local README for interface description. */ -void +static void pgsql_tidy(void) { pgsql_connection *cn; while ((cn = pgsql_connections) != NULL) { pgsql_connections = cn->next; - DEBUG(D_lookup) debug_printf("close PGSQL connection: %s\n", cn->server); + DEBUG(D_lookup) debug_printf_indent("close PGSQL connection: %s\n", cn->server); PQfinish(cn->handle); } } @@ -94,7 +79,7 @@ static void notice_processor(void *arg, const char *message) { arg = arg; /* Keep compiler happy */ -DEBUG(D_lookup) debug_printf("PGSQL: %s\n", message); +DEBUG(D_lookup) debug_printf_indent("PGSQL: %s\n", message); } @@ -114,7 +99,7 @@ configuration line for PostgreSQL via Unix domain sockets looks like this: hide pgsql_servers = (/tmp/.s.PGSQL.5432)/db/user/password[:] We enclose the path name in parentheses so that its slashes aren't visually -confused with the delimeters for the other pgsql_server settings. +confused with the delimiters for the other pgsql_server settings. For TCP/IP connections, the server is a host name and optional port (with a colon separator). @@ -130,24 +115,23 @@ Arguments: errmsg where to point an error message defer_break set TRUE if no more servers are to be tried after DEFER do_cache set FALSE if data is changed + opts options list Returns: OK, FAIL, or DEFER */ static int -perform_pgsql_search(uschar *query, uschar *server, uschar **resultptr, - uschar **errmsg, BOOL *defer_break, BOOL *do_cache) +perform_pgsql_search(const uschar *query, uschar *server, uschar **resultptr, + uschar **errmsg, BOOL *defer_break, uint *do_cache, const uschar * opts) { PGconn *pg_conn = NULL; PGresult *pg_result = NULL; -int i; -int ssize = 0; -int offset = 0; +gstring * result = NULL; int yield = DEFER; unsigned int num_fields, num_tuples; -uschar *result = NULL; pgsql_connection *cn; +rmark reset_point = store_mark(); uschar *server_copy = NULL; uschar *sdata[3]; @@ -156,10 +140,10 @@ path, database, user, password. We can write to the string, since it is in a nextinlist temporary buffer. The copy of the string that is used for caching has the password removed. This copy is also used for debugging output. */ -for (i = 2; i >= 0; i--) +for (int i = 2; i >= 0; i--) { uschar *pp = Ustrrchr(server, '/'); - if (pp == NULL) + if (!pp) { *errmsg = string_sprintf("incomplete pgSQL server data: %s", (i == 2)? server : server_copy); @@ -175,18 +159,16 @@ for (i = 2; i >= 0; i--) start is the identification of the server (host or path). See if we have a cached connection to the server. */ -for (cn = pgsql_connections; cn != NULL; cn = cn->next) - { +for (cn = pgsql_connections; cn; cn = cn->next) if (Ustrcmp(cn->server, server_copy) == 0) { pg_conn = cn->handle; break; } - } /* If there is no cached connection, we must set one up. */ -if (cn == NULL) +if (!cn) { uschar *port = US""; @@ -197,23 +179,22 @@ if (cn == NULL) uschar *last_slash, *last_dot, *p; p = ++server; - while (*p != 0 && *p != ')') p++; + while (*p && *p != ')') p++; *p = 0; last_slash = Ustrrchr(server, '/'); last_dot = Ustrrchr(server, '.'); - DEBUG(D_lookup) debug_printf("PGSQL new connection: socket=%s " + DEBUG(D_lookup) debug_printf_indent("PGSQL new connection: socket=%s " "database=%s user=%s\n", server, sdata[0], sdata[1]); /* A valid socket name looks like this: /var/run/postgresql/.s.PGSQL.5432 We have to call PQsetdbLogin with '/var/run/postgresql' as the hostname argument and put '5432' into the port variable. */ - if (last_slash == NULL || last_dot == NULL) + if (!last_slash || !last_dot) { - *errmsg = string_sprintf("PGSQL invalid filename for socket: %s", - server); + *errmsg = string_sprintf("PGSQL invalid filename for socket: %s", server); *defer_break = TRUE; return DEFER; } @@ -230,13 +211,13 @@ if (cn == NULL) else { uschar *p; - if ((p = Ustrchr(server, ':')) != NULL) + if ((p = Ustrchr(server, ':'))) { *p++ = 0; port = p; } - if (Ustrchr(server, '/') != NULL) + if (Ustrchr(server, '/')) { *errmsg = string_sprintf("unexpected slash in pgSQL server hostname: %s", server); @@ -244,7 +225,7 @@ if (cn == NULL) return DEFER; } - DEBUG(D_lookup) debug_printf("PGSQL new connection: host=%s port=%s " + DEBUG(D_lookup) debug_printf_indent("PGSQL new connection: host=%s port=%s " "database=%s user=%s\n", server, port, sdata[0], sdata[1]); } @@ -261,7 +242,7 @@ if (cn == NULL) if(PQstatus(pg_conn) == CONNECTION_BAD) { - store_reset(server_copy); + reset_point = store_reset(reset_point); *errmsg = string_sprintf("PGSQL connection failed: %s", PQerrorMessage(pg_conn)); PQfinish(pg_conn); @@ -282,7 +263,7 @@ if (cn == NULL) /* Add the connection to the cache */ - cn = store_get(sizeof(pgsql_connection)); + cn = store_get(sizeof(pgsql_connection), GET_UNTAINTED); cn->server = server_copy; cn->handle = pg_conn; cn->next = pgsql_connections; @@ -293,42 +274,43 @@ if (cn == NULL) else { - DEBUG(D_lookup) debug_printf("PGSQL using cached connection for %s\n", + DEBUG(D_lookup) debug_printf_indent("PGSQL using cached connection for %s\n", server_copy); } /* Run the query */ - pg_result = PQexec(pg_conn, CS query); - switch(PQresultStatus(pg_result)) - { - case PGRES_EMPTY_QUERY: - case PGRES_COMMAND_OK: +pg_result = PQexec(pg_conn, CS query); +switch(PQresultStatus(pg_result)) + { + case PGRES_EMPTY_QUERY: + case PGRES_COMMAND_OK: /* The command was successful but did not return any data since it was - * not SELECT but either an INSERT, UPDATE or DELETE statement. Tell the - * high level code to not cache this query, and clean the current cache for - * this handle by setting *do_cache FALSE. */ - result = string_copy(US PQcmdTuples(pg_result)); - offset = Ustrlen(result); - *do_cache = FALSE; - DEBUG(D_lookup) debug_printf("PGSQL: command does not return any data " - "but was successful. Rows affected: %s\n", result); - - case PGRES_TUPLES_OK: + not SELECT but either an INSERT, UPDATE or DELETE statement. Tell the + high level code to not cache this query, and clean the current cache for + this handle by setting *do_cache zero. */ + + result = string_cat(result, US PQcmdTuples(pg_result)); + *do_cache = 0; + DEBUG(D_lookup) debug_printf_indent("PGSQL: command does not return any data " + "but was successful. Rows affected: %s\n", string_from_gstring(result)); + break; + + case PGRES_TUPLES_OK: break; - default: + default: /* This was the original code: *errmsg = string_sprintf("PGSQL: query failed: %s\n", - PQresultErrorMessage(pg_result)); + PQresultErrorMessage(pg_result)); This was suggested by a user: */ *errmsg = string_sprintf("PGSQL: query failed: %s (%s) (%s)\n", - PQresultErrorMessage(pg_result), - PQresStatus(PQresultStatus(pg_result)), query); + PQresultErrorMessage(pg_result), + PQresStatus(PQresultStatus(pg_result)), query); goto PGSQL_EXIT; - } + } /* Result is in pg_result. Find the number of fields returned. If this is one, we don't add field names to the data. Otherwise we do. If the query did not @@ -341,43 +323,30 @@ num_tuples = PQntuples(pg_result); /* Get the fields and construct the result string. If there is more than one row, we insert '\n' between them. */ -for (i = 0; i < num_tuples; i++) +for (int i = 0; i < num_tuples; i++) { - if (result != NULL) - result = string_cat(result, &ssize, &offset, US"\n", 1); - - if (num_fields == 1) - { - result = string_cat(result, &ssize, &offset, - US PQgetvalue(pg_result, i, 0), PQgetlength(pg_result, i, 0)); - } + if (result) + result = string_catn(result, US"\n", 1); - else - { - int j; - for (j = 0; j < num_fields; j++) + if (num_fields == 1) + result = string_catn(result, + US PQgetvalue(pg_result, i, 0), PQgetlength(pg_result, i, 0)); + else + for (int j = 0; j < num_fields; j++) { uschar *tmp = US PQgetvalue(pg_result, i, j); - result = lf_quote(US PQfname(pg_result, j), tmp, Ustrlen(tmp), result, - &ssize, &offset); + result = lf_quote(US PQfname(pg_result, j), tmp, Ustrlen(tmp), result); } - } + if (!result) result = string_get(1); } -/* If result is NULL then no data has been found and so we return FAIL. -Otherwise, we must terminate the string which has been built; string_cat() -always leaves enough room for a terminating zero. */ +/* If result is NULL then no data has been found and so we return FAIL. */ -if (result == NULL) +if (!result) { yield = FAIL; *errmsg = US"PGSQL: no data found"; } -else - { - result[offset] = 0; - store_reset(result + offset + 1); - } /* Get here by goto from various error checks. */ @@ -386,18 +355,19 @@ PGSQL_EXIT: /* Free store for any result that was got; don't close the connection, as it is cached. */ -if (pg_result != NULL) PQclear(pg_result); +if (pg_result) PQclear(pg_result); -/* Non-NULL result indicates a sucessful result */ +/* Non-NULL result indicates a successful result */ -if (result != NULL) +if (result) { - *resultptr = result; + gstring_release_unused(result); + *resultptr = string_from_gstring(result); return OK; } else { - DEBUG(D_lookup) debug_printf("%s\n", *errmsg); + DEBUG(D_lookup) debug_printf_indent("%s\n", *errmsg); return yield; /* FAIL or DEFER */ } } @@ -410,33 +380,17 @@ else *************************************************/ /* See local README for interface description. The handle and filename -arguments are not used. Loop through a list of servers while the query is -deferred with a retryable error. */ +arguments are not used. The code to loop through a list of servers while the +query is deferred with a retryable error is now in a separate function that is +shared with other SQL lookups. */ -int -pgsql_find(void *handle, uschar *filename, uschar *query, int length, - uschar **result, uschar **errmsg, BOOL *do_cache) +static int +pgsql_find(void * handle, const uschar * filename, const uschar * query, + int length, uschar ** result, uschar ** errmsg, uint * do_cache, + const uschar * opts) { -int sep = 0; -uschar *server; -uschar *list = pgsql_servers; -uschar buffer[512]; - -DEBUG(D_lookup) debug_printf("PGSQL query: %s\n", query); - -while ((server = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) - != NULL) - { - BOOL defer_break = FALSE; - int rc = perform_pgsql_search(query, server, result, errmsg, &defer_break, - do_cache); - if (rc != DEFER || defer_break) return rc; - } - -if (pgsql_servers == NULL) - *errmsg = US"no PGSQL servers defined (pgsql_servers option)"; - -return DEFER; +return lf_sqlperform(US"PostgreSQL", US"pgsql_servers", pgsql_servers, query, + result, errmsg, do_cache, opts, perform_pgsql_search); } @@ -447,12 +401,6 @@ return DEFER; /* The characters that always need to be quoted (with backslash) are newline, tab, carriage return, backspace, backslash itself, and the quote characters. -Percent and underscore are only special in contexts where they can be wild -cards, and this isn't usually the case for data inserted from messages, since -that isn't likely to be treated as a pattern of any kind. However, pgsql seems -to allow escaping "on spec". If you use something like "where id="ab\%cd" it -does treat the string as "ab%cd". So we can safely quote percent and -underscore. [This is different to MySQL, where you can't do this.] The original code quoted single quotes as \' which is documented as valid in the O'Reilly book "Practical PostgreSQL" (first edition) as an alternative to @@ -467,48 +415,41 @@ Why, I don't know. Seems odd for just string escaping...] Arguments: s the string to be quoted opt additional option text or NULL if none + idx lookup type index Returns: the processed string or NULL for a bad option */ -uschar * -pgsql_quote(uschar *s, uschar *opt) +static uschar * +pgsql_quote(uschar * s, uschar * opt, unsigned idx) { -register int c; -int count = 0; -uschar *t = s; -uschar *quoted; +int count = 0, c; +uschar * t = s, * quoted; -if (opt != NULL) return NULL; /* No options recognized */ +if (opt) return NULL; /* No options recognized */ -while ((c = *t++) != 0) - if (Ustrchr("\n\t\r\b\'\"\\%_", c) != NULL) count++; +while ((c = *t++)) + if (Ustrchr("\n\t\r\b\'\"\\", c) != NULL) count++; -if (count == 0) return s; -t = quoted = store_get(Ustrlen(s) + count + 1); +t = quoted = store_get_quoted(Ustrlen(s) + count + 1, s, idx); -while ((c = *s++) != 0) +while ((c = *s++)) { if (c == '\'') { *t++ = '\''; *t++ = '\''; } - else if (Ustrchr("\n\t\r\b\"\\%_", c) != NULL) + else if (Ustrchr("\n\t\r\b\"\\", c) != NULL) { *t++ = '\\'; switch(c) { - case '\n': *t++ = 'n'; - break; - case '\t': *t++ = 't'; - break; - case '\r': *t++ = 'r'; - break; - case '\b': *t++ = 'b'; - break; - default: *t++ = c; - break; + case '\n': *t++ = 'n'; break; + case '\t': *t++ = 't'; break; + case '\r': *t++ = 'r'; break; + case '\b': *t++ = 'b'; break; + default: *t++ = c; break; } } else *t++ = c; @@ -518,6 +459,49 @@ while ((c = *s++) != 0) return quoted; } -#endif /* PGSQL_LOOKUP */ + +/************************************************* +* Version reporting entry point * +*************************************************/ + +/* See local README for interface description. */ + +#include "../version.h" + +gstring * +pgsql_version_report(gstring * g) +{ +#ifdef DYNLOOKUP +g = string_fmt_append(g, "Library version: PostgreSQL: Exim version %s\n", EXIM_VERSION_STR); +#endif + +/* Version reporting: there appears to be no available information about +the client library in libpq-fe.h; once you have a connection object, you +can access the server version and the chosen protocol version, but those +aren't really what we want. It might make sense to debug_printf those +when the connection is established though? */ + +return g; +} + + +static lookup_info _lookup_info = { + .name = US"pgsql", /* lookup name */ + .type = lookup_querystyle, /* query-style lookup */ + .open = pgsql_open, /* open function */ + .check = NULL, /* no check function */ + .find = pgsql_find, /* find function */ + .close = NULL, /* no close function */ + .tidy = pgsql_tidy, /* tidy function */ + .quote = pgsql_quote, /* quoting function */ + .version_report = pgsql_version_report /* version reporting */ +}; + +#ifdef DYNLOOKUP +#define pgsql_lookup_module_info _lookup_module_info +#endif + +static lookup_info *_lookup_list[] = { &_lookup_info }; +lookup_module_info pgsql_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 1 }; /* End of lookups/pgsql.c */