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