5d52f28b1cc59a22ec2a2cebee6fe6ecc9fdc281
[exim.git] / src / src / lookups / pgsql.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
9
10 /* Thanks to Petr Cech for contributing the original code for these
11 functions. Thanks to Joachim Wieland for the initial patch for the Unix domain
12 socket extension. */
13
14 #include "../exim.h"
15 #include "lf_functions.h"
16
17 #include <libpq-fe.h>       /* The system header */
18
19 /* Structure and anchor for caching connections. */
20
21 typedef struct pgsql_connection {
22   struct pgsql_connection *next;
23   uschar *server;
24   PGconn *handle;
25 } pgsql_connection;
26
27 static pgsql_connection *pgsql_connections = NULL;
28
29
30
31 /*************************************************
32 *              Open entry point                  *
33 *************************************************/
34
35 /* See local README for interface description. */
36
37 static void *
38 pgsql_open(const uschar * filename, uschar ** errmsg)
39 {
40 return (void *)(1);    /* Just return something non-null */
41 }
42
43
44
45 /*************************************************
46 *               Tidy entry point                 *
47 *************************************************/
48
49 /* See local README for interface description. */
50
51 static void
52 pgsql_tidy(void)
53 {
54 pgsql_connection *cn;
55 while ((cn = pgsql_connections) != NULL)
56   {
57   pgsql_connections = cn->next;
58   DEBUG(D_lookup) debug_printf_indent("close PGSQL connection: %s\n", cn->server);
59   PQfinish(cn->handle);
60   }
61 }
62
63
64 /*************************************************
65 *       Notice processor function for pgsql      *
66 *************************************************/
67
68 /* This function is passed to pgsql below, and called for any PostgreSQL
69 "notices". By default they are written to stderr, which is undesirable.
70
71 Arguments:
72   arg        an opaque user cookie (not used)
73   message    the notice
74
75 Returns:     nothing
76 */
77
78 static void
79 notice_processor(void *arg, const char *message)
80 {
81 arg = arg;   /* Keep compiler happy */
82 DEBUG(D_lookup) debug_printf_indent("PGSQL: %s\n", message);
83 }
84
85
86
87 /*************************************************
88 *        Internal search function                *
89 *************************************************/
90
91 /* This function is called from the find entry point to do the search for a
92 single server. The server string is of the form "server/dbname/user/password".
93
94 PostgreSQL supports connections through Unix domain sockets. This is usually
95 faster and costs less cpu time than a TCP/IP connection. However it can only be
96 used if the mail server runs on the same machine as the database server. A
97 configuration line for PostgreSQL via Unix domain sockets looks like this:
98
99 hide pgsql_servers = (/tmp/.s.PGSQL.5432)/db/user/password[:<nextserver>]
100
101 We enclose the path name in parentheses so that its slashes aren't visually
102 confused with the delimiters for the other pgsql_server settings.
103
104 For TCP/IP connections, the server is a host name and optional port (with a
105 colon separator).
106
107 NOTE:
108  1) All three '/' must be present.
109  2) If host is omitted the local unix socket is used.
110
111 Arguments:
112   query        the query string
113   server       the server string; this is in dynamic memory and can be updated
114   resultptr    where to store the result
115   errmsg       where to point an error message
116   defer_break  set TRUE if no more servers are to be tried after DEFER
117   do_cache     set FALSE if data is changed
118   opts         options list
119
120 Returns:       OK, FAIL, or DEFER
121 */
122
123 static int
124 perform_pgsql_search(const uschar *query, uschar *server, uschar **resultptr,
125   uschar **errmsg, BOOL *defer_break, uint *do_cache, const uschar * opts)
126 {
127 PGconn *pg_conn = NULL;
128 PGresult *pg_result = NULL;
129
130 gstring * result = NULL;
131 int yield = DEFER;
132 unsigned int num_fields, num_tuples;
133 pgsql_connection *cn;
134 rmark reset_point = store_mark();
135 uschar *server_copy = NULL;
136 uschar *sdata[3];
137
138 /* Disaggregate the parameters from the server argument. The order is host or
139 path, database, user, password. We can write to the string, since it is in a
140 nextinlist temporary buffer. The copy of the string that is used for caching
141 has the password removed. This copy is also used for debugging output. */
142
143 for (int i = 2; i >= 0; i--)
144   {
145   uschar *pp = Ustrrchr(server, '/');
146   if (!pp)
147     {
148     *errmsg = string_sprintf("incomplete pgSQL server data: %s",
149       (i == 2)? server : server_copy);
150     *defer_break = TRUE;
151     return DEFER;
152     }
153   *pp++ = 0;
154   sdata[i] = pp;
155   if (i == 2) server_copy = string_copy(server);  /* sans password */
156   }
157
158 /* The total server string has now been truncated so that what is left at the
159 start is the identification of the server (host or path). See if we have a
160 cached connection to the server. */
161
162 for (cn = pgsql_connections; cn; cn = cn->next)
163   if (Ustrcmp(cn->server, server_copy) == 0)
164     {
165     pg_conn = cn->handle;
166     break;
167     }
168
169 /* If there is no cached connection, we must set one up. */
170
171 if (!cn)
172   {
173   uschar *port = US"";
174
175   /* For a Unix domain socket connection, the path is in parentheses */
176
177   if (*server == '(')
178     {
179     uschar *last_slash, *last_dot, *p;
180
181     p = ++server;
182     while (*p && *p != ')') p++;
183     *p = 0;
184
185     last_slash = Ustrrchr(server, '/');
186     last_dot = Ustrrchr(server, '.');
187
188     DEBUG(D_lookup) debug_printf_indent("PGSQL new connection: socket=%s "
189       "database=%s user=%s\n", server, sdata[0], sdata[1]);
190
191     /* A valid socket name looks like this: /var/run/postgresql/.s.PGSQL.5432
192     We have to call PQsetdbLogin with '/var/run/postgresql' as the hostname
193     argument and put '5432' into the port variable. */
194
195     if (!last_slash || !last_dot)
196       {
197       *errmsg = string_sprintf("PGSQL invalid filename for socket: %s", server);
198       *defer_break = TRUE;
199       return DEFER;
200       }
201
202     /* Terminate the path name and set up the port: we'll have something like
203     server = "/var/run/postgresql" and port = "5432". */
204
205     *last_slash = 0;
206     port = last_dot + 1;
207     }
208
209   /* Host connection; sort out the port */
210
211   else
212     {
213     uschar *p;
214     if ((p = Ustrchr(server, ':')))
215       {
216       *p++ = 0;
217       port = p;
218       }
219
220     if (Ustrchr(server, '/'))
221       {
222       *errmsg = string_sprintf("unexpected slash in pgSQL server hostname: %s",
223         server);
224       *defer_break = TRUE;
225       return DEFER;
226       }
227
228     DEBUG(D_lookup) debug_printf_indent("PGSQL new connection: host=%s port=%s "
229       "database=%s user=%s\n", server, port, sdata[0], sdata[1]);
230     }
231
232   /* If the database is the empty string, set it NULL - the query must then
233   define it. */
234
235   if (sdata[0][0] == 0) sdata[0] = NULL;
236
237   /* Get store for a new handle, initialize it, and connect to the server */
238
239   pg_conn=PQsetdbLogin(
240     /*  host      port  options tty   database       user       passwd */
241     CS server, CS port,  NULL, NULL, CS sdata[0], CS sdata[1], CS sdata[2]);
242
243   if(PQstatus(pg_conn) == CONNECTION_BAD)
244     {
245     reset_point = store_reset(reset_point);
246     *errmsg = string_sprintf("PGSQL connection failed: %s",
247       PQerrorMessage(pg_conn));
248     PQfinish(pg_conn);
249     goto PGSQL_EXIT;
250     }
251
252   /* Set the client encoding to SQL_ASCII, which means that the server will
253   not try to interpret the query as being in any fancy encoding such as UTF-8
254   or other multibyte code that might cause problems with escaping. */
255
256   PQsetClientEncoding(pg_conn, "SQL_ASCII");
257
258   /* Set the notice processor to prevent notices from being written to stderr
259   (which is what the default does). Our function (above) just produces debug
260   output. */
261
262   PQsetNoticeProcessor(pg_conn, notice_processor, NULL);
263
264   /* Add the connection to the cache */
265
266   cn = store_get(sizeof(pgsql_connection), GET_UNTAINTED);
267   cn->server = server_copy;
268   cn->handle = pg_conn;
269   cn->next = pgsql_connections;
270   pgsql_connections = cn;
271   }
272
273 /* Else use a previously cached connection */
274
275 else
276   {
277   DEBUG(D_lookup) debug_printf_indent("PGSQL using cached connection for %s\n",
278     server_copy);
279   }
280
281 /* Run the query */
282
283 pg_result = PQexec(pg_conn, CS query);
284 switch(PQresultStatus(pg_result))
285   {
286   case PGRES_EMPTY_QUERY:
287   case PGRES_COMMAND_OK:
288     /* The command was successful but did not return any data since it was
289     not SELECT but either an INSERT, UPDATE or DELETE statement. Tell the
290     high level code to not cache this query, and clean the current cache for
291     this handle by setting *do_cache zero. */
292
293     result = string_cat(result, US PQcmdTuples(pg_result));
294     *do_cache = 0;
295     DEBUG(D_lookup) debug_printf_indent("PGSQL: command does not return any data "
296       "but was successful. Rows affected: %Y\n", result);
297     break;
298
299   case PGRES_TUPLES_OK:
300     break;
301
302   default:
303     /* This was the original code:
304     *errmsg = string_sprintf("PGSQL: query failed: %s\n",
305                              PQresultErrorMessage(pg_result));
306     This was suggested by a user:
307     */
308
309     *errmsg = string_sprintf("PGSQL: query failed: %s (%s) (%s)\n",
310                            PQresultErrorMessage(pg_result),
311                            PQresStatus(PQresultStatus(pg_result)), query);
312     goto PGSQL_EXIT;
313   }
314
315 /* Result is in pg_result. Find the number of fields returned. If this is one,
316 we don't add field names to the data. Otherwise we do. If the query did not
317 return anything we skip the for loop; this also applies to the case
318 PGRES_COMMAND_OK. */
319
320 num_fields = PQnfields(pg_result);
321 num_tuples = PQntuples(pg_result);
322
323 /* Get the fields and construct the result string. If there is more than one
324 row, we insert '\n' between them. */
325
326 for (int i = 0; i < num_tuples; i++)
327   {
328   if (result)
329     result = string_catn(result, US"\n", 1);
330
331   if (num_fields == 1)
332     result = string_catn(result,
333         US PQgetvalue(pg_result, i, 0), PQgetlength(pg_result, i, 0));
334   else
335     for (int j = 0; j < num_fields; j++)
336       {
337       uschar *tmp = US PQgetvalue(pg_result, i, j);
338       result = lf_quote(US PQfname(pg_result, j), tmp, Ustrlen(tmp), result);
339       }
340   if (!result) result = string_get(1);
341   }
342
343 /* If result is NULL then no data has been found and so we return FAIL. */
344
345 if (!result)
346   {
347   yield = FAIL;
348   *errmsg = US"PGSQL: no data found";
349   }
350
351 /* Get here by goto from various error checks. */
352
353 PGSQL_EXIT:
354
355 /* Free store for any result that was got; don't close the connection, as
356 it is cached. */
357
358 if (pg_result) PQclear(pg_result);
359
360 /* Non-NULL result indicates a successful result */
361
362 if (result)
363   {
364   gstring_release_unused(result);
365   *resultptr = string_from_gstring(result);
366   return OK;
367   }
368 else
369   {
370   DEBUG(D_lookup) debug_printf_indent("%s\n", *errmsg);
371   return yield;      /* FAIL or DEFER */
372   }
373 }
374
375
376
377
378 /*************************************************
379 *               Find entry point                 *
380 *************************************************/
381
382 /* See local README for interface description. The handle and filename
383 arguments are not used. The code to loop through a list of servers while the
384 query is deferred with a retryable error is now in a separate function that is
385 shared with other SQL lookups. */
386
387 static int
388 pgsql_find(void * handle, const uschar * filename, const uschar * query,
389   int length, uschar ** result, uschar ** errmsg, uint * do_cache,
390   const uschar * opts)
391 {
392 return lf_sqlperform(US"PostgreSQL", US"pgsql_servers", pgsql_servers, query,
393   result, errmsg, do_cache, opts, perform_pgsql_search);
394 }
395
396
397
398 /*************************************************
399 *               Quote entry point                *
400 *************************************************/
401
402 /* The characters that always need to be quoted (with backslash) are newline,
403 tab, carriage return, backspace, backslash itself, and the quote characters.
404
405 The original code quoted single quotes as \' which is documented as valid in
406 the O'Reilly book "Practical PostgreSQL" (first edition) as an alternative to
407 the SQL standard '' way of representing a single quote as data. However, in
408 June 2006 there was some security issue with using \' and so this has been
409 changed.
410
411 [Note: There is a function called PQescapeStringConn() that quotes strings.
412 This cannot be used because it needs a PGconn argument (the connection handle).
413 Why, I don't know. Seems odd for just string escaping...]
414
415 Arguments:
416   s          the string to be quoted
417   opt        additional option text or NULL if none
418   idx        lookup type index
419
420 Returns:     the processed string or NULL for a bad option
421 */
422
423 static uschar *
424 pgsql_quote(uschar * s, uschar * opt, unsigned idx)
425 {
426 int count = 0, c;
427 uschar * t = s, * quoted;
428
429 if (opt) return NULL;     /* No options recognized */
430
431 while ((c = *t++))
432   if (Ustrchr("\n\t\r\b\'\"\\", c) != NULL) count++;
433
434 t = quoted = store_get_quoted(Ustrlen(s) + count + 1, s, idx);
435
436 while ((c = *s++))
437   {
438   if (c == '\'')
439     {
440     *t++ = '\'';
441     *t++ = '\'';
442     }
443   else if (Ustrchr("\n\t\r\b\"\\", c) != NULL)
444     {
445     *t++ = '\\';
446     switch(c)
447       {
448       case '\n': *t++ = 'n'; break;
449       case '\t': *t++ = 't'; break;
450       case '\r': *t++ = 'r'; break;
451       case '\b': *t++ = 'b'; break;
452       default:   *t++ = c;   break;
453       }
454     }
455   else *t++ = c;
456   }
457
458 *t = 0;
459 return quoted;
460 }
461
462
463 /*************************************************
464 *         Version reporting entry point          *
465 *************************************************/
466
467 /* See local README for interface description. */
468
469 #include "../version.h"
470
471 gstring *
472 pgsql_version_report(gstring * g)
473 {
474 #ifdef DYNLOOKUP
475 g = string_fmt_append(g, "Library version: PostgreSQL: Exim version %s\n", EXIM_VERSION_STR);
476 #endif
477
478 /* Version reporting: there appears to be no available information about
479 the client library in libpq-fe.h; once you have a connection object, you
480 can access the server version and the chosen protocol version, but those
481 aren't really what we want.  It might make sense to debug_printf those
482 when the connection is established though? */
483
484 return g;
485 }
486
487
488 static lookup_info _lookup_info = {
489   .name = US"pgsql",                    /* lookup name */
490   .type = lookup_querystyle,            /* query-style lookup */
491   .open = pgsql_open,                   /* open function */
492   .check = NULL,                        /* no check function */
493   .find = pgsql_find,                   /* find function */
494   .close = NULL,                        /* no close function */
495   .tidy = pgsql_tidy,                   /* tidy function */
496   .quote = pgsql_quote,                 /* quoting function */
497   .version_report = pgsql_version_report           /* version reporting */
498 };
499
500 #ifdef DYNLOOKUP
501 #define pgsql_lookup_module_info _lookup_module_info
502 #endif
503
504 static lookup_info *_lookup_list[] = { &_lookup_info };
505 lookup_module_info pgsql_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 1 };
506
507 /* End of lookups/pgsql.c */