src/src/lookups/oracle.c

   1 /* $Cambridge: exim/src/src/lookups/oracle.c,v 1.6 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 /* Interface to an Oracle database. This code was originally supplied by
  11 Paul Kelly, but I have hacked it around for various reasons, and tried to add
  12 some comments from my position of Oracle ignorance. */
  13
  14
  15 #include "../exim.h"
  16
  17
  18 /* We can't just compile this code and allow the library mechanism to omit the
  19 functions if they are not wanted, because we need to have the ORACLE headers
  20 available for compiling. Therefore, compile these functions only if
  21 LOOKUP_ORACLE is defined. However, some compilers don't like compiling empty
  22 modules, so keep them happy with a dummy when skipping the rest. Make it
  23 reference itself to stop picky compilers complaining that it is unused, and put
  24 in a dummy argument to stop even pickier compilers complaining about infinite
  25 loops. */
  26
  27 #ifndef LOOKUP_ORACLE
  28 static void dummy(int x) { dummy(x-1); }
  29 #else
  30
  31 /* The Oracle system headers */
  32
  33 #include <oratypes.h>
  34 #include <ocidfn.h>
  35 #include <ocikpr.h>
  36
  37 #include "oracle.h"                    /* The local header */
  38
  39 #define PARSE_NO_DEFER           0     /* parse straight away */
  40 #define PARSE_V7_LNG             2
  41 #define MAX_ITEM_BUFFER_SIZE  1024     /* largest size of a cell of data */
  42 #define MAX_SELECT_LIST_SIZE    32     /* maximum number of columns (not rows!) */
  43
  44 /* Paul's comment on this was "change this to 512 for 64bit cpu", but I don't
  45 understand why. The Oracle manual just asks for 256 bytes.
  46
  47 That was years ago. Jin Choi suggested (March 2007) that this change should
  48 be made in the source, as at worst it wastes 256 bytes, and it saves people
  49 having to discover about this for themselves as more and more systems are
  50 64-bit. So I have changed 256 to 512. */
  51
  52 #define HDA_SIZE 512
  53
  54 /* Internal/external datatype codes */
  55
  56 #define NUMBER_TYPE              2
  57 #define INT_TYPE                 3
  58 #define FLOAT_TYPE               4
  59 #define STRING_TYPE              5
  60 #define ROWID_TYPE              11
  61 #define DATE_TYPE               12
  62
  63 /*  ORACLE error codes used in demonstration programs */
  64
  65 #define VAR_NOT_IN_LIST       1007
  66 #define NO_DATA_FOUND         1403
  67
  68 typedef struct Ora_Describe {
  69   sb4   dbsize;
  70   sb2   dbtype;
  71   sb1   buf[MAX_ITEM_BUFFER_SIZE];
  72   sb4   buflen;
  73   sb4   dsize;
  74   sb2   precision;
  75   sb2   scale;
  76   sb2   nullok;
  77 } Ora_Describe;
  78
  79 typedef struct Ora_Define {
  80   ub1   buf[MAX_ITEM_BUFFER_SIZE];
  81   float flt_buf;
  82   sword int_buf;
  83   sb2   indp;
  84   ub2   col_retlen, col_retcode;
  85 } Ora_Define;
  86
  87 /* Structure and anchor for caching connections. */
  88
  89 typedef struct oracle_connection {
  90   struct oracle_connection *next;
  91   uschar *server;
  92   struct cda_def *handle;
  93   void   *hda_mem;
  94 } oracle_connection;
  95
  96 static oracle_connection *oracle_connections = NULL;
  97
  98
  99
 100
 101
 102 /*************************************************
 103 *        Set up message after error              *
 104 *************************************************/
 105
 106 /* Sets up a message from a local string plus whatever Oracle gives.
 107
 108 Arguments:
 109   oracle_handle   the handle of the connection
 110   rc              the return code
 111   msg             local text message
 112 */
 113
 114 static uschar *
 115 oracle_error(struct cda_def *oracle_handle, int rc, uschar *msg)
 116 {
 117 uschar tmp[1024];
 118 oerhms(oracle_handle, rc, tmp, sizeof(tmp));
 119 return string_sprintf("ORACLE %s: %s", msg, tmp);
 120 }
 121
 122
 123
 124 /*************************************************
 125 *     Describe and define the select list items  *
 126 *************************************************/
 127
 128 /* Figures out sizes, types, and numbers.
 129
 130 Arguments:
 131   cda        the connection
 132   def
 133   desc       descriptions put here
 134
 135 Returns:     number of fields
 136 */
 137
 138 static sword
 139 describe_define(Cda_Def *cda, Ora_Define *def, Ora_Describe *desc)
 140 {
 141 sword col, deflen, deftyp;
 142 static ub1 *defptr;
 143 static sword numwidth = 8;
 144
 145 /* Describe the select-list items. */
 146
 147 for (col = 0; col < MAX_SELECT_LIST_SIZE; col++)
 148   {
 149   desc[col].buflen = MAX_ITEM_BUFFER_SIZE;
 150
 151   if (odescr(cda, col + 1, &desc[col].dbsize,
 152              &desc[col].dbtype, &desc[col].buf[0],
 153              &desc[col].buflen, &desc[col].dsize,
 154              &desc[col].precision, &desc[col].scale,
 155              &desc[col].nullok) != 0)
 156     {
 157     /* Break on end of select list. */
 158     if (cda->rc == VAR_NOT_IN_LIST) break; else return -1;
 159     }
 160
 161   /* Adjust sizes and types for display, handling NUMBER with scale as float. */
 162
 163   if (desc[col].dbtype == NUMBER_TYPE)
 164     {
 165     desc[col].dbsize = numwidth;
 166     if (desc[col].scale != 0)
 167       {
 168       defptr = (ub1 *)&def[col].flt_buf;
 169       deflen = (sword) sizeof(float);
 170       deftyp = FLOAT_TYPE;
 171       desc[col].dbtype = FLOAT_TYPE;
 172       }
 173     else
 174       {
 175       defptr = (ub1 *)&def[col].int_buf;
 176       deflen = (sword) sizeof(sword);
 177       deftyp = INT_TYPE;
 178       desc[col].dbtype = INT_TYPE;
 179       }
 180     }
 181   else
 182     {
 183     if (desc[col].dbtype == DATE_TYPE)
 184         desc[col].dbsize = 9;
 185     if (desc[col].dbtype == ROWID_TYPE)
 186         desc[col].dbsize = 18;
 187     defptr = def[col].buf;
 188     deflen = desc[col].dbsize > MAX_ITEM_BUFFER_SIZE ?
 189       MAX_ITEM_BUFFER_SIZE : desc[col].dbsize + 1;
 190     deftyp = STRING_TYPE;
 191     desc[col].dbtype = STRING_TYPE;
 192     }
 193
 194   /* Define an output variable */
 195
 196   if (odefin(cda, col + 1,
 197              defptr, deflen, deftyp,
 198              -1, &def[col].indp, (text *) 0, -1, -1,
 199              &def[col].col_retlen,
 200              &def[col].col_retcode) != 0)
 201     return -1;
 202   }  /* Loop for each column */
 203
 204 return col;
 205 }
 206
 207
 208
 209 /*************************************************
 210 *              Open entry point                  *
 211 *************************************************/
 212
 213 /* See local README for interface description. */
 214
 215 void *
 216 oracle_open(uschar *filename, uschar **errmsg)
 217 {
 218 return (void *)(1);    /* Just return something non-null */
 219 }
 220
 221
 222
 223 /*************************************************
 224 *               Tidy entry point                 *
 225 *************************************************/
 226
 227 /* See local README for interface description. */
 228
 229 void
 230 oracle_tidy(void)
 231 {
 232 oracle_connection *cn;
 233 while ((cn = oracle_connections) != NULL)
 234   {
 235   oracle_connections = cn->next;
 236   DEBUG(D_lookup) debug_printf("close ORACLE connection: %s\n", cn->server);
 237   ologof(cn->handle);
 238   }
 239 }
 240
 241
 242
 243 /*************************************************
 244 *        Internal search function                *
 245 *************************************************/
 246
 247 /* This function is called from the find entry point to do the search for a
 248 single server.
 249
 250 Arguments:
 251   query        the query string
 252   server       the server string
 253   resultptr    where to store the result
 254   errmsg       where to point an error message
 255   defer_break  TRUE if no more servers are to be tried after DEFER
 256
 257 The server string is of the form "host/dbname/user/password", for compatibility
 258 with MySQL and pgsql, but at present, the dbname is not used. This string is in
 259 a nextinlist temporary buffer, so can be overwritten.
 260
 261 Returns:       OK, FAIL, or DEFER
 262 */
 263
 264 static int
 265 perform_oracle_search(uschar *query, uschar *server, uschar **resultptr,
 266   uschar **errmsg, BOOL *defer_break)
 267 {
 268 Cda_Def *cda = NULL;
 269 struct cda_def *oracle_handle = NULL;
 270 Ora_Describe *desc = NULL;
 271 Ora_Define *def = NULL;
 272 void *hda = NULL;
 273
 274 int i;
 275 int ssize = 0;
 276 int offset = 0;
 277 int yield = DEFER;
 278 unsigned int num_fields = 0;
 279 uschar *result = NULL;
 280 oracle_connection *cn = NULL;
 281 uschar *server_copy = NULL;
 282 uschar *sdata[4];
 283 uschar tmp[1024];
 284
 285 /* Disaggregate the parameters from the server argument. The order is host,
 286 database, user, password. We can write to the string, since it is in a
 287 nextinlist temporary buffer. The copy of the string that is used for caching
 288 has the password removed. This copy is also used for debugging output. */
 289
 290 for (i = 3; i > 0; i--)
 291   {
 292   uschar *pp = Ustrrchr(server, '/');
 293   if (pp == NULL)
 294     {
 295     *errmsg = string_sprintf("incomplete ORACLE server data: %s", server);
 296     *defer_break = TRUE;
 297     return DEFER;
 298     }
 299   *pp++ = 0;
 300   sdata[i] = pp;
 301   if (i == 3) server_copy = string_copy(server);  /* sans password */
 302   }
 303 sdata[0] = server;   /* What's left at the start */
 304
 305 /* If the database is the empty string, set it NULL - the query must then
 306 define it. */
 307
 308 if (sdata[1][0] == 0) sdata[1] = NULL;
 309
 310 /* See if we have a cached connection to the server */
 311
 312 for (cn = oracle_connections; cn != NULL; cn = cn->next)
 313   {
 314   if (strcmp(cn->server, server_copy) == 0)
 315     {
 316     oracle_handle = cn->handle;
 317     hda = cn->hda_mem;
 318     break;
 319     }
 320   }
 321
 322 /* If no cached connection, we must set one up */
 323
 324 if (cn == NULL)
 325   {
 326   DEBUG(D_lookup) debug_printf("ORACLE new connection: host=%s database=%s "
 327     "user=%s\n", sdata[0], sdata[1], sdata[2]);
 328
 329   /* Get store for a new connection, initialize it, and connect to the server */
 330
 331    oracle_handle = store_get(sizeof(struct cda_def));
 332    hda = store_get(HDA_SIZE);
 333    memset(hda,'\0',HDA_SIZE);
 334
 335   /*
 336    * Perform a default (blocking) login
 337    *
 338    * sdata[0] = tnsname (service name - typically host name)
 339    * sdata[1] = dbname - not used at present
 340    * sdata[2] = username
 341    * sdata[3] = passwd
 342    */
 343
 344   if(olog(oracle_handle, hda, sdata[2], -1, sdata[3], -1, sdata[0], -1,
 345          (ub4)OCI_LM_DEF) != 0)
 346     {
 347     *errmsg = oracle_error(oracle_handle, oracle_handle->rc,
 348       US"connection failed");
 349     *defer_break = FALSE;
 350     goto ORACLE_EXIT_NO_VALS;
 351     }
 352
 353   /* Add the connection to the cache */
 354
 355   cn = store_get(sizeof(oracle_connection));
 356   cn->server = server_copy;
 357   cn->handle = oracle_handle;
 358   cn->next = oracle_connections;
 359   cn->hda_mem = hda;
 360   oracle_connections = cn;
 361   }
 362
 363 /* Else use a previously cached connection - we can write to the server string
 364 to obliterate the password because it is in a nextinlist temporary buffer. */
 365
 366 else
 367   {
 368   DEBUG(D_lookup)
 369     debug_printf("ORACLE using cached connection for %s\n", server_copy);
 370   }
 371
 372 /* We have a connection. Open a cursor and run the query */
 373
 374 cda = store_get(sizeof(Cda_Def));
 375
 376 if (oopen(cda, oracle_handle, (text *)0, -1, -1, (text *)0, -1) != 0)
 377   {
 378   *errmsg = oracle_error(oracle_handle, cda->rc, "failed to open cursor");
 379   *defer_break = FALSE;
 380   goto ORACLE_EXIT_NO_VALS;
 381   }
 382
 383 if (oparse(cda, (text *)query, (sb4) -1,
 384       (sword)PARSE_NO_DEFER, (ub4)PARSE_V7_LNG) != 0)
 385   {
 386   *errmsg = oracle_error(oracle_handle, cda->rc, "query failed");
 387   *defer_break = FALSE;
 388   oclose(cda);
 389   goto ORACLE_EXIT_NO_VALS;
 390   }
 391
 392 /* Find the number of fields returned and sort out their types. If the number
 393 is one, we don't add field names to the data. Otherwise we do. */
 394
 395 def = store_get(sizeof(Ora_Define)*MAX_SELECT_LIST_SIZE);
 396 desc = store_get(sizeof(Ora_Describe)*MAX_SELECT_LIST_SIZE);
 397
 398 if ((num_fields = describe_define(cda,def,desc)) == -1)
 399   {
 400   *errmsg = oracle_error(oracle_handle, cda->rc, "describe_define failed");
 401   *defer_break = FALSE;
 402   goto ORACLE_EXIT;
 403   }
 404
 405 if (oexec(cda)!=0)
 406   {
 407   *errmsg = oracle_error(oracle_handle, cda->rc, "oexec failed");
 408   *defer_break = FALSE;
 409   goto ORACLE_EXIT;
 410   }
 411
 412 /* Get the fields and construct the result string. If there is more than one
 413 row, we insert '\n' between them. */
 414
 415 while (cda->rc != NO_DATA_FOUND)  /* Loop for each row */
 416   {
 417   ofetch(cda);
 418   if(cda->rc == NO_DATA_FOUND) break;
 419
 420   if (result != NULL) result = string_cat(result, &ssize, &offset, "\n", 1);
 421
 422   /* Single field - just add on the data */
 423
 424   if (num_fields == 1)
 425     result = string_cat(result, &ssize, &offset, def[0].buf, def[0].col_retlen);
 426
 427   /* Multiple fields - precede by file name, removing {lead,trail}ing WS */
 428
 429   else for (i = 0; i < num_fields; i++)
 430     {
 431     int slen;
 432     uschar *s = US desc[i].buf;
 433
 434     while (*s != 0 && isspace(*s)) s++;
 435     slen = Ustrlen(s);
 436     while (slen > 0 && isspace(s[slen-1])) slen--;
 437     result = string_cat(result, &ssize, &offset, s, slen);
 438     result = string_cat(result, &ssize, &offset, US"=", 1);
 439
 440     /* int and float type wont ever need escaping. Otherwise, quote the value
 441     if it contains spaces or is empty. */
 442
 443     if (desc[i].dbtype != INT_TYPE && desc[i].dbtype != FLOAT_TYPE &&
 444        (def[i].buf[0] == 0 || strchr(def[i].buf, ' ') != NULL))
 445       {
 446       int j;
 447       result = string_cat(result, &ssize, &offset, "\"", 1);
 448       for (j = 0; j < def[i].col_retlen; j++)
 449         {
 450         if (def[i].buf[j] == '\"' || def[i].buf[j] == '\\')
 451           result = string_cat(result, &ssize, &offset, "\\", 1);
 452         result = string_cat(result, &ssize, &offset, def[i].buf+j, 1);
 453         }
 454       result = string_cat(result, &ssize, &offset, "\"", 1);
 455       }
 456
 457     else switch(desc[i].dbtype)
 458       {
 459       case INT_TYPE:
 460       sprintf(CS tmp, "%d", def[i].int_buf);
 461       result = string_cat(result, &ssize, &offset, tmp, Ustrlen(tmp));
 462       break;
 463
 464       case FLOAT_TYPE:
 465       sprintf(CS tmp, "%f", def[i].flt_buf);
 466       result = string_cat(result, &ssize, &offset, tmp, Ustrlen(tmp));
 467       break;
 468
 469       case STRING_TYPE:
 470       result = string_cat(result, &ssize, &offset, def[i].buf,
 471         def[i].col_retlen);
 472       break;
 473
 474       default:
 475       *errmsg = string_sprintf("ORACLE: unknown field type %d", desc[i].dbtype);
 476       *defer_break = FALSE;
 477       result = NULL;
 478       goto ORACLE_EXIT;
 479       }
 480
 481     result = string_cat(result, &ssize, &offset, " ", 1);
 482     }
 483   }
 484
 485 /* If result is NULL then no data has been found and so we return FAIL.
 486 Otherwise, we must terminate the string which has been built; string_cat()
 487 always leaves enough room for a terminating zero. */
 488
 489 if (result == NULL)
 490   {
 491   yield = FAIL;
 492   *errmsg = "ORACLE: no data found";
 493   }
 494 else
 495   {
 496   result[offset] = 0;
 497   store_reset(result + offset + 1);
 498   }
 499
 500 /* Get here by goto from various error checks. */
 501
 502 ORACLE_EXIT:
 503
 504 /* Close the cursor; don't close the connection, as it is cached. */
 505
 506 oclose(cda);
 507
 508 ORACLE_EXIT_NO_VALS:
 509
 510 /* Non-NULL result indicates a sucessful result */
 511
 512 if (result != NULL)
 513   {
 514   *resultptr = result;
 515   return OK;
 516   }
 517 else
 518   {
 519   DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
 520   return yield;      /* FAIL or DEFER */
 521   }
 522 }
 523
 524
 525
 526
 527 /*************************************************
 528 *               Find entry point                 *
 529 *************************************************/
 530
 531 /* See local README for interface description. The handle and filename
 532 arguments are not used. Loop through a list of servers while the query is
 533 deferred with a retryable error. */
 534
 535 int
 536 oracle_find(void *handle, uschar *filename, uschar *query, int length,
 537   uschar **result, uschar **errmsg, BOOL *do_cache)
 538 {
 539 int sep = 0;
 540 uschar *server;
 541 uschar *list = oracle_servers;
 542 uschar buffer[512];
 543
 544 do_cache = do_cache;   /* Placate picky compilers */
 545
 546 DEBUG(D_lookup) debug_printf("ORACLE query: %s\n", query);
 547
 548 while ((server = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
 549   {
 550   BOOL defer_break;
 551   int rc = perform_oracle_search(query, server, result, errmsg, &defer_break);
 552   if (rc != DEFER || defer_break) return rc;
 553   }
 554
 555 if (oracle_servers == NULL)
 556   *errmsg = "no ORACLE servers defined (oracle_servers option)";
 557
 558 return DEFER;
 559 }
 560
 561
 562
 563 /*************************************************
 564 *               Quote entry point                *
 565 *************************************************/
 566
 567 /* The only characters that need to be quoted (with backslash) are newline,
 568 tab, carriage return, backspace, backslash itself, and the quote characters.
 569 Percent and underscore are not escaped. They are only special in contexts where
 570 they can be wild cards, and this isn't usually the case for data inserted from
 571 messages, since that isn't likely to be treated as a pattern of any kind.
 572
 573 Arguments:
 574   s          the string to be quoted
 575   opt        additional option text or NULL if none
 576
 577 Returns:     the processed string or NULL for a bad option
 578 */
 579
 580 uschar *
 581 oracle_quote(uschar *s, uschar *opt)
 582 {
 583 register int c;
 584 int count = 0;
 585 uschar *t = s;
 586 uschar *quoted;
 587
 588 if (opt != NULL) return NULL;    /* No options are recognized */
 589
 590 while ((c = *t++) != 0)
 591   if (strchr("\n\t\r\b\'\"\\", c) != NULL) count++;
 592
 593 if (count == 0) return s;
 594 t = quoted = store_get((int)strlen(s) + count + 1);
 595
 596 while ((c = *s++) != 0)
 597   {
 598   if (strchr("\n\t\r\b\'\"\\", c) != NULL)
 599     {
 600     *t++ = '\\';
 601     switch(c)
 602       {
 603       case '\n': *t++ = 'n';
 604       break;
 605       case '\t': *t++ = 't';
 606       break;
 607       case '\r': *t++ = 'r';
 608       break;
 609       case '\b': *t++ = 'b';
 610       break;
 611       default:   *t++ = c;
 612       break;
 613       }
 614     }
 615   else *t++ = c;
 616   }
 617
 618 *t = 0;
 619 return quoted;
 620 }
 621
 622 #endif  /* LOOKUP_ORACLE */
 623
 624 /* End of lookups/oracle.c */