1 /* $Cambridge: exim/src/src/lookups/ibase.c,v 1.5 2009/11/16 19:50:38 nm4 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* The code in this module was contributed by Ard Biesheuvel. */
13 #include "lf_functions.h"
15 #include <ibase.h> /* The system header */
17 /* Structure and anchor for caching connections. */
19 typedef struct ibase_connection {
20 struct ibase_connection *next;
26 static ibase_connection *ibase_connections = NULL;
30 /*************************************************
32 *************************************************/
34 /* See local README for interface description. */
36 static void *ibase_open(uschar * filename, uschar ** errmsg)
38 return (void *) (1); /* Just return something non-null */
43 /*************************************************
45 *************************************************/
47 /* See local README for interface description. */
49 static void ibase_tidy(void)
52 ISC_STATUS status[20];
54 while ((cn = ibase_connections) != NULL) {
55 ibase_connections = cn->next;
56 DEBUG(D_lookup) debug_printf("close Interbase connection: %s\n",
58 isc_commit_transaction(status, &cn->transh);
59 isc_detach_database(status, &cn->dbh);
63 static int fetch_field(char *buffer, int buffer_size, XSQLVAR * var)
65 if (buffer_size < var->sqllen)
68 switch (var->sqltype & ~1) {
70 strncpy(buffer, &var->sqldata[2], *(short *) var->sqldata);
71 return *(short *) var->sqldata;
73 strncpy(buffer, var->sqldata, var->sqllen);
76 return sprintf(buffer, "%d", *(short *) var->sqldata);
78 return sprintf(buffer, "%ld", *(ISC_LONG *) var->sqldata);
81 return sprintf(buffer, "%lld", *(ISC_INT64 *) var->sqldata);
89 /*************************************************
90 * Internal search function *
91 *************************************************/
93 /* This function is called from the find entry point to do the search for a
97 query the query string
98 server the server string
99 resultptr where to store the result
100 errmsg where to point an error message
101 defer_break TRUE if no more servers are to be tried after DEFER
103 The server string is of the form "host:dbname|user|password". The host can be
104 host:port. This string is in a nextinlist temporary buffer, so can be
107 Returns: OK, FAIL, or DEFER
111 perform_ibase_search(uschar * query, uschar * server, uschar ** resultptr,
112 uschar ** errmsg, BOOL * defer_break)
114 isc_stmt_handle stmth = NULL;
119 ISC_STATUS status[20], *statusp = status;
125 uschar *result = NULL;
126 ibase_connection *cn;
127 uschar *server_copy = NULL;
130 /* Disaggregate the parameters from the server argument. The order is host,
131 database, user, password. We can write to the string, since it is in a
132 nextinlist temporary buffer. The copy of the string that is used for caching
133 has the password removed. This copy is also used for debugging output. */
135 for (i = 2; i > 0; i--) {
136 uschar *pp = Ustrrchr(server, '|');
139 string_sprintf("incomplete Interbase server data: %s",
140 (i == 3) ? server : server_copy);
147 server_copy = string_copy(server); /* sans password */
149 sdata[0] = server; /* What's left at the start */
151 /* See if we have a cached connection to the server */
153 for (cn = ibase_connections; cn != NULL; cn = cn->next) {
154 if (Ustrcmp(cn->server, server_copy) == 0) {
159 /* Use a previously cached connection ? */
162 static char db_info_options[] = { isc_info_base_level };
164 /* test if the connection is alive */
165 if (isc_database_info
166 (status, &cn->dbh, sizeof(db_info_options), db_info_options,
167 sizeof(buffer), buffer)) {
168 /* error occurred: assume connection is down */
171 ("Interbase cleaning up cached connection: %s\n",
173 isc_detach_database(status, &cn->dbh);
176 debug_printf("Interbase using cached connection for %s\n",
180 cn = store_get(sizeof(ibase_connection));
181 cn->server = server_copy;
184 cn->next = ibase_connections;
185 ibase_connections = cn;
188 /* If no cached connection, we must set one up. */
190 if (cn->dbh == NULL || cn->transh == NULL) {
194 static char trans_options[] =
195 { isc_tpb_version3, isc_tpb_read, isc_tpb_read_committed,
199 /* Construct the database parameter buffer. */
201 *dpb++ = isc_dpb_version1;
202 *dpb++ = isc_dpb_user_name;
203 *dpb++ = strlen(sdata[1]);
204 for (p = sdata[1]; *p;)
206 *dpb++ = isc_dpb_password;
207 *dpb++ = strlen(sdata[2]);
208 for (p = sdata[2]; *p;)
210 dpb_length = dpb - buffer;
213 debug_printf("new Interbase connection: database=%s user=%s\n",
216 /* Connect to the database */
217 if (isc_attach_database
218 (status, 0, sdata[0], &cn->dbh, dpb_length, buffer)) {
219 isc_interprete(buffer, &statusp);
221 string_sprintf("Interbase attach() failed: %s", buffer);
222 *defer_break = FALSE;
226 /* Now start a read-only read-committed transaction */
227 if (isc_start_transaction
228 (status, &cn->transh, 1, &cn->dbh, sizeof(trans_options),
230 isc_interprete(buffer, &statusp);
231 isc_detach_database(status, &cn->dbh);
233 string_sprintf("Interbase start_transaction() failed: %s",
235 *defer_break = FALSE;
241 if (isc_dsql_allocate_statement(status, &cn->dbh, &stmth)) {
242 isc_interprete(buffer, &statusp);
244 string_sprintf("Interbase alloc_statement() failed: %s",
246 *defer_break = FALSE;
250 out_sqlda = store_get(XSQLDA_LENGTH(1));
251 out_sqlda->version = SQLDA_VERSION1;
255 (status, &cn->transh, &stmth, 0, query, 1, out_sqlda)) {
256 isc_interprete(buffer, &statusp);
257 store_reset(out_sqlda);
260 string_sprintf("Interbase prepare_statement() failed: %s",
262 *defer_break = FALSE;
266 /* re-allocate the output structure if there's more than one field */
267 if (out_sqlda->sqln < out_sqlda->sqld) {
268 XSQLDA *new_sqlda = store_get(XSQLDA_LENGTH(out_sqlda->sqld));
269 if (isc_dsql_describe
270 (status, &stmth, out_sqlda->version, new_sqlda)) {
271 isc_interprete(buffer, &statusp);
272 isc_dsql_free_statement(status, &stmth, DSQL_drop);
273 store_reset(out_sqlda);
276 string_sprintf("Interbase describe_statement() failed: %s",
278 *defer_break = FALSE;
281 out_sqlda = new_sqlda;
284 /* allocate storage for every returned field */
285 for (i = 0, var = out_sqlda->sqlvar; i < out_sqlda->sqld; i++, var++) {
286 switch (var->sqltype & ~1) {
289 (char *) store_get(sizeof(char) * var->sqllen + 2);
293 (char *) store_get(sizeof(char) * var->sqllen);
296 var->sqldata = (char *) store_get(sizeof(short));
299 var->sqldata = (char *) store_get(sizeof(ISC_LONG));
303 var->sqldata = (char *) store_get(sizeof(ISC_INT64));
307 var->sqldata = (char *) store_get(sizeof(float));
310 var->sqldata = (char *) store_get(sizeof(double));
314 var->sqldata = (char *) store_get(sizeof(ISC_QUAD));
318 var->sqldata = (char *) store_get(sizeof(ISC_TIMESTAMP));
321 var->sqldata = (char *) store_get(sizeof(ISC_DATE));
324 var->sqldata = (char *) store_get(sizeof(ISC_TIME));
328 if (var->sqltype & 1) {
329 var->sqlind = (short *) store_get(sizeof(short));
333 /* finally, we're ready to execute the statement */
335 (status, &cn->transh, &stmth, out_sqlda->version, NULL)) {
336 isc_interprete(buffer, &statusp);
338 string_sprintf("Interbase describe_statement() failed: %s",
340 isc_dsql_free_statement(status, &stmth, DSQL_drop);
341 *defer_break = FALSE;
345 while (isc_dsql_fetch(status, &stmth, out_sqlda->version, out_sqlda) !=
347 /* check if an error occurred */
348 if (status[0] & status[1]) {
349 isc_interprete(buffer, &statusp);
351 string_sprintf("Interbase fetch() failed: %s", buffer);
352 isc_dsql_free_statement(status, &stmth, DSQL_drop);
353 *defer_break = FALSE;
358 result = string_cat(result, &ssize, &offset, US "\n", 1);
360 /* Find the number of fields returned. If this is one, we don't add field
361 names to the data. Otherwise we do. */
362 if (out_sqlda->sqld == 1) {
363 if (out_sqlda->sqlvar[0].sqlind == NULL || *out_sqlda->sqlvar[0].sqlind != -1) /* NULL value yields nothing */
365 string_cat(result, &ssize, &offset, US buffer,
366 fetch_field(buffer, sizeof(buffer),
367 &out_sqlda->sqlvar[0]));
371 for (i = 0; i < out_sqlda->sqld; i++) {
372 int len = fetch_field(buffer, sizeof(buffer),
373 &out_sqlda->sqlvar[i]);
376 string_cat(result, &ssize, &offset,
377 US out_sqlda->sqlvar[i].aliasname,
378 out_sqlda->sqlvar[i].aliasname_length);
379 result = string_cat(result, &ssize, &offset, US "=", 1);
381 /* Quote the value if it contains spaces or is empty */
383 if (*out_sqlda->sqlvar[i].sqlind == -1) { /* NULL value */
385 string_cat(result, &ssize, &offset, US "\"\"", 2);
388 else if (buffer[0] == 0 || Ustrchr(buffer, ' ') != NULL) {
391 string_cat(result, &ssize, &offset, US "\"", 1);
392 for (j = 0; j < len; j++) {
393 if (buffer[j] == '\"' || buffer[j] == '\\')
395 string_cat(result, &ssize, &offset,
398 string_cat(result, &ssize, &offset,
402 string_cat(result, &ssize, &offset, US "\"", 1);
405 string_cat(result, &ssize, &offset, US buffer,
408 result = string_cat(result, &ssize, &offset, US " ", 1);
412 /* If result is NULL then no data has been found and so we return FAIL.
413 Otherwise, we must terminate the string which has been built; string_cat()
414 always leaves enough room for a terminating zero. */
416 if (result == NULL) {
418 *errmsg = US "Interbase: no data found";
421 store_reset(result + offset + 1);
425 /* Get here by goto from various error checks. */
430 isc_dsql_free_statement(status, &stmth, DSQL_drop);
432 /* Non-NULL result indicates a sucessful result */
434 if (result != NULL) {
438 DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
439 return yield; /* FAIL or DEFER */
446 /*************************************************
448 *************************************************/
450 /* See local README for interface description. The handle and filename
451 arguments are not used. Loop through a list of servers while the query is
452 deferred with a retryable error. */
455 ibase_find(void *handle, uschar * filename, uschar * query, int length,
456 uschar ** result, uschar ** errmsg, BOOL *do_cache)
460 uschar *list = ibase_servers;
463 /* Keep picky compilers happy */
466 DEBUG(D_lookup) debug_printf("Interbase query: %s\n", query);
469 string_nextinlist(&list, &sep, buffer,
470 sizeof(buffer))) != NULL) {
471 BOOL defer_break = FALSE;
472 int rc = perform_ibase_search(query, server, result, errmsg,
474 if (rc != DEFER || defer_break)
478 if (ibase_servers == NULL)
479 *errmsg = US "no Interbase servers defined (ibase_servers option)";
486 /*************************************************
487 * Quote entry point *
488 *************************************************/
490 /* The only characters that need to be quoted (with backslash) are newline,
491 tab, carriage return, backspace, backslash itself, and the quote characters.
492 Percent, and underscore and not escaped. They are only special in contexts
493 where they can be wild cards, and this isn't usually the case for data inserted
494 from messages, since that isn't likely to be treated as a pattern of any kind.
495 Sadly, MySQL doesn't seem to behave like other programs. If you use something
496 like "where id="ab\%cd" it does not treat the string as "ab%cd". So you really
497 can't quote "on spec".
500 s the string to be quoted
501 opt additional option text or NULL if none
503 Returns: the processed string or NULL for a bad option
506 static uschar *ibase_quote(uschar * s, uschar * opt)
514 return NULL; /* No options recognized */
516 while ((c = *t++) != 0)
517 if (Ustrchr("\n\t\r\b\'\"\\", c) != NULL)
522 t = quoted = store_get(Ustrlen(s) + count + 1);
524 while ((c = *s++) != 0) {
525 if (Ustrchr("'", c) != NULL) {
530 case '\n': *t++ = 'n';
532 case '\t': *t++ = 't';
534 case '\r': *t++ = 'r';
536 case '\b': *t++ = 'b';
550 /*************************************************
551 * Version reporting entry point *
552 *************************************************/
554 /* See local README for interface description. */
556 #include "../version.h"
559 ibase_version_report(FILE *f)
562 fprintf(f, "Library version: ibase: Exim version %s\n", EXIM_VERSION_STR);
567 static lookup_info _lookup_info = {
568 US"ibase", /* lookup name */
569 lookup_querystyle, /* query-style lookup */
570 ibase_open, /* open function */
571 NULL, /* no check function */
572 ibase_find, /* find function */
573 NULL, /* no close function */
574 ibase_tidy, /* tidy function */
575 ibase_quote, /* quoting function */
576 ibase_version_report /* version reporting */
580 #define ibase_lookup_module_info _lookup_module_info
583 static lookup_info *_lookup_list[] = { &_lookup_info };
584 lookup_module_info ibase_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 1 };
586 /* End of lookups/ibase.c */