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 */