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