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