58bced201912c993f3f28d63b7ba0d134add11f6
[exim.git] / src / src / lookups / ibase.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* The code in this module was contributed by Ard Biesheuvel. */
9
10 #include "../exim.h"
11 #include "lf_functions.h"
12
13 #include <ibase.h>              /* The system header */
14
15 /* Structure and anchor for caching connections. */
16
17 typedef struct ibase_connection {
18     struct ibase_connection *next;
19     uschar *server;
20     isc_db_handle dbh;
21     isc_tr_handle transh;
22 } ibase_connection;
23
24 static ibase_connection *ibase_connections = NULL;
25
26
27
28 /*************************************************
29 *              Open entry point                  *
30 *************************************************/
31
32 /* See local README for interface description. */
33
34 static void *ibase_open(uschar * filename, uschar ** errmsg)
35 {
36     return (void *) (1);        /* Just return something non-null */
37 }
38
39
40
41 /*************************************************
42 *               Tidy entry point                 *
43 *************************************************/
44
45 /* See local README for interface description. */
46
47 static void ibase_tidy(void)
48 {
49     ibase_connection *cn;
50     ISC_STATUS status[20];
51
52     while ((cn = ibase_connections) != NULL) {
53         ibase_connections = cn->next;
54         DEBUG(D_lookup) debug_printf("close Interbase connection: %s\n",
55                                      cn->server);
56         isc_commit_transaction(status, &cn->transh);
57         isc_detach_database(status, &cn->dbh);
58     }
59 }
60
61 static int fetch_field(char *buffer, int buffer_size, XSQLVAR * var)
62 {
63     if (buffer_size < var->sqllen)
64         return 0;
65
66     switch (var->sqltype & ~1) {
67     case SQL_VARYING:
68         strncpy(buffer, &var->sqldata[2], *(short *) var->sqldata);
69         return *(short *) var->sqldata;
70     case SQL_TEXT:
71         strncpy(buffer, var->sqldata, var->sqllen);
72         return var->sqllen;
73     case SQL_SHORT:
74         return sprintf(buffer, "%d", *(short *) var->sqldata);
75     case SQL_LONG:
76         return sprintf(buffer, "%ld", *(ISC_LONG *) var->sqldata);
77 #ifdef SQL_INT64
78     case SQL_INT64:
79         return sprintf(buffer, "%lld", *(ISC_INT64 *) var->sqldata);
80 #endif
81     default:
82         /* not implemented */
83         return 0;
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.
93
94 Arguments:
95   query        the query string
96   server       the server string
97   resultptr    where to store the result
98   errmsg       where to point an error message
99   defer_break  TRUE if no more servers are to be tried after DEFER
100
101 The server string is of the form "host:dbname|user|password". The host can be
102 host:port. This string is in a nextinlist temporary buffer, so can be
103 overwritten.
104
105 Returns:       OK, FAIL, or DEFER
106 */
107
108 static int
109 perform_ibase_search(uschar * query, uschar * server, uschar ** resultptr,
110                      uschar ** errmsg, BOOL * defer_break)
111 {
112 isc_stmt_handle stmth = NULL;
113 XSQLDA *out_sqlda;
114 XSQLVAR *var;
115
116 char buffer[256];
117 ISC_STATUS status[20], *statusp = status;
118
119 gstring * result;
120 int i;
121 int yield = DEFER;
122 ibase_connection *cn;
123 uschar *server_copy = NULL;
124 uschar *sdata[3];
125
126 /* Disaggregate the parameters from the server argument. The order is host,
127 database, user, password. We can write to the string, since it is in a
128 nextinlist temporary buffer. The copy of the string that is used for caching
129 has the password removed. This copy is also used for debugging output. */
130
131 for (i = 2; i > 0; i--)
132   {
133   uschar *pp = Ustrrchr(server, '|');
134
135   if (pp == NULL)
136     {
137     *errmsg = string_sprintf("incomplete Interbase server data: %s",
138                        (i == 3) ? server : server_copy);
139     *defer_break = TRUE;
140     return DEFER;
141     }
142   *pp++ = 0;
143   sdata[i] = pp;
144   if (i == 2)
145       server_copy = string_copy(server);   /* sans password */
146   }
147 sdata[0] = server;          /* What's left at the start */
148
149 /* See if we have a cached connection to the server */
150
151 for (cn = ibase_connections; cn != NULL; cn = cn->next)
152   if (Ustrcmp(cn->server, server_copy) == 0)
153     break;
154
155 /* Use a previously cached connection ? */
156
157 if (cn)
158   {
159   static char db_info_options[] = { isc_info_base_level };
160
161   /* test if the connection is alive */
162   if (isc_database_info(status, &cn->dbh, sizeof(db_info_options),
163         db_info_options, sizeof(buffer), buffer))
164     {
165     /* error occurred: assume connection is down */
166     DEBUG(D_lookup)
167         debug_printf
168         ("Interbase cleaning up cached connection: %s\n",
169          cn->server);
170     isc_detach_database(status, &cn->dbh);
171     }
172   else
173     {
174     DEBUG(D_lookup) debug_printf("Interbase using cached connection for %s\n",
175                      server_copy);
176     }
177   }
178 else
179   {
180   cn = store_get(sizeof(ibase_connection));
181   cn->server = server_copy;
182   cn->dbh = NULL;
183   cn->transh = NULL;
184   cn->next = ibase_connections;
185   ibase_connections = cn;
186   }
187
188 /* If no cached connection, we must set one up. */
189
190 if (cn->dbh == NULL || cn->transh == NULL)
191   {
192   char *dpb, *p;
193   short dpb_length;
194   static char trans_options[] =
195       { isc_tpb_version3, isc_tpb_read, isc_tpb_read_committed,
196       isc_tpb_rec_version
197   };
198
199   /* Construct the database parameter buffer. */
200   dpb = buffer;
201   *dpb++ = isc_dpb_version1;
202   *dpb++ = isc_dpb_user_name;
203   *dpb++ = strlen(sdata[1]);
204   for (p = sdata[1]; *p;)
205       *dpb++ = *p++;
206   *dpb++ = isc_dpb_password;
207   *dpb++ = strlen(sdata[2]);
208   for (p = sdata[2]; *p;)
209       *dpb++ = *p++;
210   dpb_length = dpb - buffer;
211
212   DEBUG(D_lookup)
213       debug_printf("new Interbase connection: database=%s user=%s\n",
214                    sdata[0], sdata[1]);
215
216   /* Connect to the database */
217   if (isc_attach_database
218       (status, 0, sdata[0], &cn->dbh, dpb_length, buffer))
219     {
220     isc_interprete(buffer, &statusp);
221     *errmsg =
222         string_sprintf("Interbase attach() failed: %s", buffer);
223     *defer_break = FALSE;
224     goto IBASE_EXIT;
225     }
226
227   /* Now start a read-only read-committed transaction */
228   if (isc_start_transaction
229       (status, &cn->transh, 1, &cn->dbh, sizeof(trans_options),
230        trans_options))
231     {
232     isc_interprete(buffer, &statusp);
233     isc_detach_database(status, &cn->dbh);
234     *errmsg =
235         string_sprintf("Interbase start_transaction() failed: %s",
236                        buffer);
237     *defer_break = FALSE;
238     goto IBASE_EXIT;
239     }
240   }
241
242 /* Run the query */
243 if (isc_dsql_allocate_statement(status, &cn->dbh, &stmth))
244   {
245   isc_interprete(buffer, &statusp);
246   *errmsg =
247       string_sprintf("Interbase alloc_statement() failed: %s",
248                      buffer);
249   *defer_break = FALSE;
250   goto IBASE_EXIT;
251   }
252
253 out_sqlda = store_get(XSQLDA_LENGTH(1));
254 out_sqlda->version = SQLDA_VERSION1;
255 out_sqlda->sqln = 1;
256
257 if (isc_dsql_prepare
258     (status, &cn->transh, &stmth, 0, query, 1, out_sqlda))
259   {
260   isc_interprete(buffer, &statusp);
261   store_reset(out_sqlda);
262   out_sqlda = NULL;
263   *errmsg =
264       string_sprintf("Interbase prepare_statement() failed: %s",
265                      buffer);
266   *defer_break = FALSE;
267   goto IBASE_EXIT;
268   }
269
270 /* re-allocate the output structure if there's more than one field */
271 if (out_sqlda->sqln < out_sqlda->sqld)
272   {
273   XSQLDA *new_sqlda = store_get(XSQLDA_LENGTH(out_sqlda->sqld));
274   if (isc_dsql_describe
275       (status, &stmth, out_sqlda->version, new_sqlda))
276     {
277     isc_interprete(buffer, &statusp);
278     isc_dsql_free_statement(status, &stmth, DSQL_drop);
279     store_reset(out_sqlda);
280     out_sqlda = NULL;
281     *errmsg = string_sprintf("Interbase describe_statement() failed: %s",
282                        buffer);
283     *defer_break = FALSE;
284     goto IBASE_EXIT;
285     }
286   out_sqlda = new_sqlda;
287   }
288
289 /* allocate storage for every returned field */
290 for (i = 0, var = out_sqlda->sqlvar; i < out_sqlda->sqld; i++, var++)
291   {
292   switch (var->sqltype & ~1)
293     {
294     case SQL_VARYING:
295         var->sqldata = CS store_get(sizeof(char) * var->sqllen + 2);
296         break;
297     case SQL_TEXT:
298         var->sqldata = CS store_get(sizeof(char) * var->sqllen);
299         break;
300     case SQL_SHORT:
301         var->sqldata = CS  store_get(sizeof(short));
302         break;
303     case SQL_LONG:
304         var->sqldata = CS  store_get(sizeof(ISC_LONG));
305         break;
306 #ifdef SQL_INT64
307     case SQL_INT64:
308         var->sqldata = CS  store_get(sizeof(ISC_INT64));
309         break;
310 #endif
311     case SQL_FLOAT:
312         var->sqldata = CS  store_get(sizeof(float));
313         break;
314     case SQL_DOUBLE:
315         var->sqldata = CS  store_get(sizeof(double));
316         break;
317 #ifdef SQL_TIMESTAMP
318     case SQL_DATE:
319         var->sqldata = CS  store_get(sizeof(ISC_QUAD));
320         break;
321 #else
322     case SQL_TIMESTAMP:
323         var->sqldata = CS  store_get(sizeof(ISC_TIMESTAMP));
324         break;
325     case SQL_TYPE_DATE:
326         var->sqldata = CS  store_get(sizeof(ISC_DATE));
327         break;
328     case SQL_TYPE_TIME:
329         var->sqldata = CS  store_get(sizeof(ISC_TIME));
330         break;
331   #endif
332     }
333   if (var->sqltype & 1)
334     var->sqlind = (short *) store_get(sizeof(short));
335   }
336
337 /* finally, we're ready to execute the statement */
338 if (isc_dsql_execute
339     (status, &cn->transh, &stmth, out_sqlda->version, NULL))
340   {
341   isc_interprete(buffer, &statusp);
342   *errmsg = string_sprintf("Interbase describe_statement() failed: %s",
343                      buffer);
344   isc_dsql_free_statement(status, &stmth, DSQL_drop);
345   *defer_break = FALSE;
346   goto IBASE_EXIT;
347   }
348
349 while (isc_dsql_fetch(status, &stmth, out_sqlda->version, out_sqlda) != 100L)
350   {
351   /* check if an error occurred */
352   if (status[0] & status[1])
353     {
354     isc_interprete(buffer, &statusp);
355     *errmsg =
356         string_sprintf("Interbase fetch() failed: %s", buffer);
357     isc_dsql_free_statement(status, &stmth, DSQL_drop);
358     *defer_break = FALSE;
359     goto IBASE_EXIT;
360     }
361
362   if (result)
363     result = string_catn(result, US "\n", 1);
364
365   /* Find the number of fields returned. If this is one, we don't add field
366      names to the data. Otherwise we do. */
367   if (out_sqlda->sqld == 1)
368     {
369     if (out_sqlda->sqlvar[0].sqlind == NULL || *out_sqlda->sqlvar[0].sqlind != -1)     /* NULL value yields nothing */
370       result = string_catn(result, US buffer,
371                        fetch_field(buffer, sizeof(buffer),
372                                    &out_sqlda->sqlvar[0]));
373     }
374
375   else
376     for (i = 0; i < out_sqlda->sqld; i++)
377       {
378       int len = fetch_field(buffer, sizeof(buffer), &out_sqlda->sqlvar[i]);
379
380       result = string_catn(result, US out_sqlda->sqlvar[i].aliasname,
381                      out_sqlda->sqlvar[i].aliasname_length);
382       result = string_catn(result, US "=", 1);
383
384       /* Quote the value if it contains spaces or is empty */
385
386       if (*out_sqlda->sqlvar[i].sqlind == -1)       /* NULL value */
387         result = string_catn(result, US "\"\"", 2);
388
389       else if (buffer[0] == 0 || Ustrchr(buffer, ' ') != NULL)
390         {
391         int j;
392
393         result = string_catn(result, US "\"", 1);
394         for (j = 0; j < len; j++)
395           {
396           if (buffer[j] == '\"' || buffer[j] == '\\')
397               result = string_cat(result, US "\\", 1);
398           result = string_cat(result, US buffer + j, 1);
399           }
400         result = string_catn(result, US "\"", 1);
401         }
402       else
403         result = string_catn(result, US buffer, len);
404       result = string_catn(result, US " ", 1);
405       }
406   }
407
408 /* If result is NULL then no data has been found and so we return FAIL.
409 Otherwise, we must terminate the string which has been built; string_cat()
410 always leaves enough room for a terminating zero. */
411
412 if (!result)
413   {
414   yield = FAIL;
415   *errmsg = US "Interbase: no data found";
416   }
417 else
418   store_reset(result->s + result->ptr + 1);
419
420
421 /* Get here by goto from various error checks. */
422
423 IBASE_EXIT:
424
425 if (stmth)
426   isc_dsql_free_statement(status, &stmth, DSQL_drop);
427
428 /* Non-NULL result indicates a successful result */
429
430 if (result)
431   {
432   *resultptr = string_from_gstring(result);
433   return OK;
434   }
435 else
436   {
437   DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
438   return yield;           /* FAIL or DEFER */
439   }
440 }
441
442
443
444
445 /*************************************************
446 *               Find entry point                 *
447 *************************************************/
448
449 /* See local README for interface description. The handle and filename
450 arguments are not used. Loop through a list of servers while the query is
451 deferred with a retryable error. */
452
453 static int
454 ibase_find(void *handle, uschar * filename, uschar * query, int length,
455            uschar ** result, uschar ** errmsg, uint *do_cache)
456 {
457     int sep = 0;
458     uschar *server;
459     uschar *list = ibase_servers;
460     uschar buffer[512];
461
462     /* Keep picky compilers happy */
463     do_cache = do_cache;
464
465     DEBUG(D_lookup) debug_printf("Interbase query: %s\n", query);
466
467     while ((server =
468             string_nextinlist(&list, &sep, buffer,
469                               sizeof(buffer))) != NULL) {
470         BOOL defer_break = FALSE;
471         int rc = perform_ibase_search(query, server, result, errmsg,
472                                       &defer_break);
473         if (rc != DEFER || defer_break)
474             return rc;
475     }
476
477     if (ibase_servers == NULL)
478         *errmsg = US "no Interbase servers defined (ibase_servers option)";
479
480     return DEFER;
481 }
482
483
484
485 /*************************************************
486 *               Quote entry point                *
487 *************************************************/
488
489 /* The only characters that need to be quoted (with backslash) are newline,
490 tab, carriage return, backspace, backslash itself, and the quote characters.
491 Percent, and underscore and not escaped. They are only special in contexts
492 where they can be wild cards, and this isn't usually the case for data inserted
493 from messages, since that isn't likely to be treated as a pattern of any kind.
494 Sadly, MySQL doesn't seem to behave like other programs. If you use something
495 like "where id="ab\%cd" it does not treat the string as "ab%cd". So you really
496 can't quote "on spec".
497
498 Arguments:
499   s          the string to be quoted
500   opt        additional option text or NULL if none
501
502 Returns:     the processed string or NULL for a bad option
503 */
504
505 static uschar *ibase_quote(uschar * s, uschar * opt)
506 {
507     register int c;
508     int count = 0;
509     uschar *t = s;
510     uschar *quoted;
511
512     if (opt != NULL)
513         return NULL;            /* No options recognized */
514
515     while ((c = *t++) != 0)
516         if (Ustrchr("\n\t\r\b\'\"\\", c) != NULL)
517             count++;
518
519     if (count == 0)
520         return s;
521     t = quoted = store_get(Ustrlen(s) + count + 1);
522
523     while ((c = *s++) != 0) {
524         if (Ustrchr("'", c) != NULL) {
525             *t++ = '\'';
526             *t++ = '\'';
527 /*    switch(c)
528       {
529       case '\n': *t++ = 'n';
530       break;
531       case '\t': *t++ = 't';
532       break;
533       case '\r': *t++ = 'r';
534       break;
535       case '\b': *t++ = 'b';
536       break;
537       default:   *t++ = c;
538       break;
539       }*/
540         } else
541             *t++ = c;
542     }
543
544     *t = 0;
545     return quoted;
546 }
547
548
549 /*************************************************
550 *         Version reporting entry point          *
551 *************************************************/
552
553 /* See local README for interface description. */
554
555 #include "../version.h"
556
557 void
558 ibase_version_report(FILE *f)
559 {
560 #ifdef DYNLOOKUP
561 fprintf(f, "Library version: ibase: Exim version %s\n", EXIM_VERSION_STR);
562 #endif
563 }
564
565
566 static lookup_info _lookup_info = {
567   US"ibase",                     /* lookup name */
568   lookup_querystyle,             /* query-style lookup */
569   ibase_open,                    /* open function */
570   NULL,                          /* no check function */
571   ibase_find,                    /* find function */
572   NULL,                          /* no close function */
573   ibase_tidy,                    /* tidy function */
574   ibase_quote,                   /* quoting function */
575   ibase_version_report           /* version reporting */
576 };
577
578 #ifdef DYNLOOKUP
579 #define ibase_lookup_module_info _lookup_module_info
580 #endif
581
582 static lookup_info *_lookup_list[] = { &_lookup_info };
583 lookup_module_info ibase_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 1 };
584
585 /* End of lookups/ibase.c */