src/src/dbfn.c

   1 /* $Cambridge: exim/src/src/dbfn.c,v 1.3 2005/06/14 10:32:01 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2005 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10
  11 #include "exim.h"
  12
  13
  14 /* Functions for accessing Exim's hints database, which consists of a number of
  15 different DBM files. This module does not contain code for reading DBM files
  16 for (e.g.) alias expansion. That is all contained within the general search
  17 functions. As Exim now has support for several DBM interfaces, all the relevant
  18 functions are called as macros.
  19
  20 All the data in Exim's database is in the nature of *hints*. Therefore it
  21 doesn't matter if it gets destroyed by accident. These functions are not
  22 supposed to implement a "safe" database.
  23
  24 Keys are passed in as C strings, and the terminating zero *is* used when
  25 building the dbm files. This just makes life easier when scanning the files
  26 sequentially.
  27
  28 Synchronization is required on the database files, and this is achieved by
  29 means of locking on independent lock files. (Earlier attempts to lock on the
  30 DBM files themselves were never completely successful.) Since callers may in
  31 general want to do more than one read or write while holding the lock, there
  32 are separate open and close functions. However, the calling modules should
  33 arrange to hold the locks for the bare minimum of time. */
  34
  35
  36
  37 /*************************************************
  38 *         Berkeley DB error callback             *
  39 *************************************************/
  40
  41 /* For Berkeley DB >= 2, we can define a function to be called in case of DB
  42 errors. This should help with debugging strange DB problems, e.g. getting "File
  43 exists" when you try to open a db file. The API for this function was changed
  44 at DB release 4.3. */
  45
  46 #if defined(USE_DB) && defined(DB_VERSION_STRING)
  47 void
  48 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
  49 dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
  50 {
  51 dbenv = dbenv;
  52 #else
  53 dbfn_bdb_error_callback(const char *pfx, char *msg)
  54 {
  55 #endif
  56 pfx = pfx;
  57 log_write(0, LOG_MAIN, "Berkeley DB error: %s", msg);
  58 }
  59 #endif
  60
  61
  62
  63
  64 /*************************************************
  65 *          Open and lock a database file         *
  66 *************************************************/
  67
  68 /* Used for accessing Exim's hints databases.
  69
  70 Arguments:
  71   name     The single-component name of one of Exim's database files.
  72   flags    Either O_RDONLY or O_RDWR, indicating the type of open required;
  73              O_RDWR implies "create if necessary"
  74   dbblock  Points to an open_db block to be filled in.
  75   lof      If TRUE, write to the log for actual open failures (locking failures
  76            are always logged).
  77
  78 Returns:   NULL if the open failed, or the locking failed. After locking
  79            failures, errno is zero.
  80
  81            On success, dbblock is returned. This contains the dbm pointer and
  82            the fd of the locked lock file.
  83 */
  84
  85 open_db *
  86 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof)
  87 {
  88 int rc, save_errno;
  89 BOOL read_only = flags == O_RDONLY;
  90 BOOL created = FALSE;
  91 flock_t lock_data;
  92 uschar buffer[256];
  93
  94 /* The first thing to do is to open a separate file on which to lock. This
  95 ensures that Exim has exclusive use of the database before it even tries to
  96 open it. Early versions tried to lock on the open database itself, but that
  97 gave rise to mysterious problems from time to time - it was suspected that some
  98 DB libraries "do things" on their open() calls which break the interlocking.
  99 The lock file is never written to, but we open it for writing so we can get a
 100 write lock if required. If it does not exist, we create it. This is done
 101 separately so we know when we have done it, because when running as root we
 102 need to change the ownership - see the bottom of this function. We also try to
 103 make the directory as well, just in case. We won't be doing this many times
 104 unnecessarily, because usually the lock file will be there. If the directory
 105 exists, there is no error. */
 106
 107 sprintf(CS buffer, "%s/db/%s.lockfile", spool_directory, name);
 108
 109 if ((dbblock->lockfd = Uopen(buffer, O_RDWR, EXIMDB_LOCKFILE_MODE)) < 0)
 110   {
 111   created = TRUE;
 112   (void)directory_make(spool_directory, US"db", EXIMDB_DIRECTORY_MODE, TRUE);
 113   dbblock->lockfd = Uopen(buffer, O_RDWR|O_CREAT, EXIMDB_LOCKFILE_MODE);
 114   }
 115
 116 if (dbblock->lockfd < 0)
 117   {
 118   log_write(0, LOG_MAIN, "%s",
 119     string_open_failed(errno, "database lock file %s", buffer));
 120   errno = 0;      /* Indicates locking failure */
 121   return NULL;
 122   }
 123
 124 /* Now we must get a lock on the opened lock file; do this with a blocking
 125 lock that times out. */
 126
 127 lock_data.l_type = read_only? F_RDLCK : F_WRLCK;
 128 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
 129
 130 DEBUG(D_hints_lookup|D_retry|D_route|D_deliver)
 131   debug_printf("locking %s\n", buffer);
 132
 133 sigalrm_seen = FALSE;
 134 alarm(EXIMDB_LOCK_TIMEOUT);
 135 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
 136 alarm(0);
 137
 138 if (sigalrm_seen) errno = ETIMEDOUT;
 139 if (rc < 0)
 140   {
 141   log_write(0, LOG_MAIN, "Failed to get %s lock for %s: %s",
 142     ((flags & O_RDONLY) != 0)? "read" : "write", buffer,
 143     (errno == ETIMEDOUT)? "timed out" : strerror(errno));
 144   close(dbblock->lockfd);
 145   errno = 0;       /* Indicates locking failure */
 146   return NULL;
 147   }
 148
 149 DEBUG(D_hints_lookup) debug_printf("locked %s\n", buffer);
 150
 151 /* At this point we have an opened and locked separate lock file, that is,
 152 exclusive access to the database, so we can go ahead and open it. If we are
 153 expected to create it, don't do so at first, again so that we can detect
 154 whether we need to change its ownership (see comments about the lock file
 155 above.) */
 156
 157 sprintf(CS buffer, "%s/db/%s", spool_directory, name);
 158 EXIM_DBOPEN(buffer, flags, EXIMDB_MODE, &(dbblock->dbptr));
 159
 160 if (dbblock->dbptr == NULL && errno == ENOENT && flags == O_RDWR)
 161   {
 162   DEBUG(D_hints_lookup)
 163     debug_printf("%s appears not to exist: trying to create\n", buffer);
 164   created = TRUE;
 165   EXIM_DBOPEN(buffer, flags|O_CREAT, EXIMDB_MODE, &(dbblock->dbptr));
 166   }
 167
 168 save_errno = errno;
 169
 170 /* If we are running as root and this is the first access to the database, its
 171 files will be owned by root. We want them to be owned by exim. We detect this
 172 situation by noting above when we had to create the lock file or the database
 173 itself. Because the different dbm libraries use different extensions for their
 174 files, I don't know of any easier way of arranging this than scanning the
 175 directory for files with the appropriate base name. At least this deals with
 176 the lock file at the same time. Also, the directory will typically have only
 177 half a dozen files, so the scan will be quick.
 178
 179 This code is placed here, before the test for successful opening, because there
 180 was a case when a file was created, but the DBM library still returned NULL
 181 because of some problem. It also sorts out the lock file if that was created
 182 but creation of the database file failed. */
 183
 184 if (created && geteuid() == root_uid)
 185   {
 186   DIR *dd;
 187   struct dirent *ent;
 188   uschar *lastname = Ustrrchr(buffer, '/') + 1;
 189   int namelen = Ustrlen(name);
 190
 191   *lastname = 0;
 192   dd = opendir(CS buffer);
 193
 194   while ((ent = readdir(dd)) != NULL)
 195     {
 196     if (Ustrncmp(ent->d_name, name, namelen) == 0)
 197       {
 198       struct stat statbuf;
 199       Ustrcpy(lastname, ent->d_name);
 200       if (Ustat(buffer, &statbuf) >= 0 && statbuf.st_uid != exim_uid)
 201         {
 202         DEBUG(D_hints_lookup) debug_printf("ensuring %s is owned by exim\n", buffer);
 203         Uchown(buffer, exim_uid, exim_gid);
 204         }
 205       }
 206     }
 207
 208   closedir(dd);
 209   }
 210
 211 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
 212 log the event - also for debugging - but not if the file just doesn't exist. */
 213
 214 if (dbblock->dbptr == NULL)
 215   {
 216   if (save_errno != ENOENT)
 217     {
 218     if (lof)
 219       log_write(0, LOG_MAIN, "%s", string_open_failed(save_errno, "DB file %s",
 220         buffer));
 221     else
 222       DEBUG(D_hints_lookup)
 223         debug_printf("%s", CS string_open_failed(save_errno, "DB file %s\n",
 224           buffer));
 225     }
 226   close(dbblock->lockfd);
 227   errno = save_errno;
 228   return NULL;
 229   }
 230
 231 DEBUG(D_hints_lookup)
 232   debug_printf("opened hints database %s: flags=%x\n", buffer, flags);
 233
 234 /* Pass back the block containing the opened database handle and the open fd
 235 for the lock. */
 236
 237 return dbblock;
 238 }
 239
 240
 241
 242
 243 /*************************************************
 244 *         Unlock and close a database file       *
 245 *************************************************/
 246
 247 /* Closing a file automatically unlocks it, so after closing the database, just
 248 close the lock file.
 249
 250 Argument: a pointer to an open database block
 251 Returns:  nothing
 252 */
 253
 254 void
 255 dbfn_close(open_db *dbblock)
 256 {
 257 EXIM_DBCLOSE(dbblock->dbptr);
 258 close(dbblock->lockfd);
 259 }
 260
 261
 262
 263
 264 /*************************************************
 265 *             Read from database file            *
 266 *************************************************/
 267
 268 /* Passing back the pointer unchanged is useless, because there is
 269 no guarantee of alignment. Since all the records used by Exim need
 270 to be properly aligned to pick out the timestamps, etc., we might as
 271 well do the copying centrally here.
 272
 273 Most calls don't need the length, so there is a macro called dbfn_read which
 274 has two arguments; it calls this function adding NULL as the third.
 275
 276 Arguments:
 277   dbblock   a pointer to an open database block
 278   key       the key of the record to be read
 279   length    a pointer to an int into which to return the length, if not NULL
 280
 281 Returns: a pointer to the retrieved record, or
 282          NULL if the record is not found
 283 */
 284
 285 void *
 286 dbfn_read_with_length(open_db *dbblock, uschar *key, int *length)
 287 {
 288 void *yield;
 289 EXIM_DATUM key_datum, result_datum;
 290
 291 DEBUG(D_hints_lookup) debug_printf("dbfn_read: key=%s\n", key);
 292
 293 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
 294 EXIM_DATUM_INIT(result_datum);      /* to be cleared before use. */
 295 EXIM_DATUM_DATA(key_datum) = CS key;
 296 EXIM_DATUM_SIZE(key_datum) = Ustrlen(key) + 1;
 297
 298 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
 299
 300 yield = store_get(EXIM_DATUM_SIZE(result_datum));
 301 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
 302 if (length != NULL) *length = EXIM_DATUM_SIZE(result_datum);
 303
 304 EXIM_DATUM_FREE(result_datum);    /* Some DBM libs require freeing */
 305 return yield;
 306 }
 307
 308
 309
 310 /*************************************************
 311 *             Write to database file             *
 312 *************************************************/
 313
 314 /*
 315 Arguments:
 316   dbblock   a pointer to an open database block
 317   key       the key of the record to be written
 318   ptr       a pointer to the record to be written
 319   length    the length of the record to be written
 320
 321 Returns:    the yield of the underlying dbm or db "write" function. If this
 322             is dbm, the value is zero for OK.
 323 */
 324
 325 int
 326 dbfn_write(open_db *dbblock, uschar *key, void *ptr, int length)
 327 {
 328 EXIM_DATUM key_datum, value_datum;
 329 dbdata_generic *gptr = (dbdata_generic *)ptr;
 330 gptr->time_stamp = time(NULL);
 331
 332 DEBUG(D_hints_lookup) debug_printf("dbfn_write: key=%s\n", key);
 333
 334 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
 335 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
 336 EXIM_DATUM_DATA(key_datum) = CS key;
 337 EXIM_DATUM_SIZE(key_datum) = Ustrlen(key) + 1;
 338 EXIM_DATUM_DATA(value_datum) = CS ptr;
 339 EXIM_DATUM_SIZE(value_datum) = length;
 340 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
 341 }
 342
 343
 344
 345 /*************************************************
 346 *           Delete record from database file     *
 347 *************************************************/
 348
 349 /*
 350 Arguments:
 351   dbblock    a pointer to an open database block
 352   key        the key of the record to be deleted
 353
 354 Returns: the yield of the underlying dbm or db "delete" function.
 355 */
 356
 357 int
 358 dbfn_delete(open_db *dbblock, uschar *key)
 359 {
 360 EXIM_DATUM key_datum;
 361 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require clearing */
 362 EXIM_DATUM_DATA(key_datum) = CS key;
 363 EXIM_DATUM_SIZE(key_datum) = Ustrlen(key) + 1;
 364 return EXIM_DBDEL(dbblock->dbptr, key_datum);
 365 }
 366
 367
 368
 369 /*************************************************
 370 *         Scan the keys of a database file       *
 371 *************************************************/
 372
 373 /*
 374 Arguments:
 375   dbblock  a pointer to an open database block
 376   start    TRUE if starting a new scan
 377            FALSE if continuing with the current scan
 378   cursor   a pointer to a pointer to a cursor anchor, for those dbm libraries
 379            that use the notion of a cursor
 380
 381 Returns:   the next record from the file, or
 382            NULL if there are no more
 383 */
 384
 385 uschar *
 386 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
 387 {
 388 EXIM_DATUM key_datum, value_datum;
 389 uschar *yield;
 390 value_datum = value_datum;    /* dummy; not all db libraries use this */
 391
 392 /* Some dbm require an initialization */
 393
 394 if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
 395
 396 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
 397 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
 398
 399 yield = (EXIM_DBSCAN(dbblock->dbptr, key_datum, value_datum, start, *cursor))?
 400   US EXIM_DATUM_DATA(key_datum) : NULL;
 401
 402 /* Some dbm require a termination */
 403
 404 if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
 405 return yield;
 406 }
 407
 408
 409
 410 /*************************************************
 411 **************************************************
 412 *             Stand-alone test program           *
 413 **************************************************
 414 *************************************************/
 415
 416 #ifdef STAND_ALONE
 417
 418 int
 419 main(int argc, char **cargv)
 420 {
 421 open_db dbblock[8];
 422 int max_db = sizeof(dbblock)/sizeof(open_db);
 423 int current = -1;
 424 int showtime = 0;
 425 int i;
 426 dbdata_wait *dbwait = NULL;
 427 uschar **argv = USS cargv;
 428 uschar buffer[256];
 429 uschar structbuffer[1024];
 430
 431 if (argc != 2)
 432   {
 433   printf("Usage: test_dbfn directory\n");
 434   printf("The subdirectory called \"db\" in the given directory is used for\n");
 435   printf("the files used in this test program.\n");
 436   return 1;
 437   }
 438
 439 /* Initialize */
 440
 441 spool_directory = argv[1];
 442 debug_selector = D_all - D_memory;
 443 debug_file = stderr;
 444 big_buffer = malloc(big_buffer_size);
 445
 446 for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
 447
 448 printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
 449 printf("DBM library: ");
 450
 451 #ifdef DB_VERSION_STRING
 452 printf("Berkeley DB: %s\n", DB_VERSION_STRING);
 453 #elif defined(BTREEVERSION) && defined(HASHVERSION)
 454   #ifdef USE_DB
 455   printf("probably Berkeley DB version 1.8x (native mode)\n");
 456   #else
 457   printf("probably Berkeley DB version 1.8x (compatibility mode)\n");
 458   #endif
 459 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
 460 printf("probably ndbm\n");
 461 #elif defined(USE_TDB)
 462 printf("using tdb\n");
 463 #else
 464   #ifdef USE_GDBM
 465   printf("probably GDBM (native mode)\n");
 466   #else
 467   printf("probably GDBM (compatibility mode)\n");
 468   #endif
 469 #endif
 470
 471 /* Test the functions */
 472
 473 printf("\nTest the functions\n> ");
 474
 475 while (Ufgets(buffer, 256, stdin) != NULL)
 476   {
 477   int len = Ustrlen(buffer);
 478   int count = 1;
 479   clock_t start = 1;
 480   clock_t stop = 0;
 481   uschar *cmd = buffer;
 482   while (len > 0 && isspace((uschar)buffer[len-1])) len--;
 483   buffer[len] = 0;
 484
 485   if (isdigit((uschar)*cmd))
 486     {
 487     count = Uatoi(cmd);
 488     while (isdigit((uschar)*cmd)) cmd++;
 489     while (isspace((uschar)*cmd)) cmd++;
 490     }
 491
 492   if (Ustrncmp(cmd, "open", 4) == 0)
 493     {
 494     int i;
 495     open_db *odb;
 496     uschar *s = cmd + 4;
 497     while (isspace((uschar)*s)) s++;
 498
 499     for (i = 0; i < max_db; i++)
 500       if (dbblock[i].dbptr == NULL) break;
 501
 502     if (i >= max_db)
 503       {
 504       printf("Too many open databases\n> ");
 505       continue;
 506       }
 507
 508     start = clock();
 509     odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE);
 510     stop = clock();
 511
 512     if (odb != NULL)
 513       {
 514       current = i;
 515       printf("opened %d\n", current);
 516       }
 517     /* Other error cases will have written messages */
 518     else if (errno == ENOENT)
 519       {
 520       printf("open failed: %s%s\n", strerror(errno),
 521         #ifdef USE_DB
 522         " (or other Berkeley DB error)"
 523         #else
 524         ""
 525         #endif
 526         );
 527       }
 528     }
 529
 530   else if (Ustrncmp(cmd, "write", 5) == 0)
 531     {
 532     int rc = 0;
 533     uschar *key = cmd + 5;
 534     uschar *data;
 535
 536     if (current < 0)
 537       {
 538       printf("No current database\n");
 539       continue;
 540       }
 541
 542     while (isspace((uschar)*key)) key++;
 543     data = key;
 544     while (*data != 0 && !isspace((uschar)*data)) data++;
 545     *data++ = 0;
 546     while (isspace((uschar)*data)) data++;
 547
 548     dbwait = (dbdata_wait *)(&structbuffer);
 549     Ustrcpy(dbwait->text, data);
 550
 551     start = clock();
 552     while (count-- > 0)
 553       rc = dbfn_write(dbblock + current, key, dbwait,
 554         Ustrlen(data) + sizeof(dbdata_wait));
 555     stop = clock();
 556     if (rc != 0) printf("Failed: %s\n", strerror(errno));
 557     }
 558
 559   else if (Ustrncmp(cmd, "read", 4) == 0)
 560     {
 561     uschar *key = cmd + 4;
 562     if (current < 0)
 563       {
 564       printf("No current database\n");
 565       continue;
 566       }
 567     while (isspace((uschar)*key)) key++;
 568     start = clock();
 569     while (count-- > 0)
 570       dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock+ current, key, NULL);
 571     stop = clock();
 572     printf("%s\n", (dbwait == NULL)? "<not found>" : CS dbwait->text);
 573     }
 574
 575   else if (Ustrncmp(cmd, "delete", 6) == 0)
 576     {
 577     uschar *key = cmd + 6;
 578     if (current < 0)
 579       {
 580       printf("No current database\n");
 581       continue;
 582       }
 583     while (isspace((uschar)*key)) key++;
 584     dbfn_delete(dbblock + current, key);
 585     }
 586
 587   else if (Ustrncmp(cmd, "scan", 4) == 0)
 588     {
 589     EXIM_CURSOR *cursor;
 590     BOOL startflag = TRUE;
 591     uschar *key;
 592     uschar keybuffer[256];
 593     if (current < 0)
 594       {
 595       printf("No current database\n");
 596       continue;
 597       }
 598     start = clock();
 599     while ((key = dbfn_scan(dbblock + current, startflag, &cursor)) != NULL)
 600       {
 601       startflag = FALSE;
 602       Ustrcpy(keybuffer, key);
 603       dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock + current,
 604         keybuffer, NULL);
 605       printf("%s: %s\n", keybuffer, dbwait->text);
 606       }
 607     stop = clock();
 608     printf("End of scan\n");
 609     }
 610
 611   else if (Ustrncmp(cmd, "close", 5) == 0)
 612     {
 613     uschar *s = cmd + 5;
 614     while (isspace((uschar)*s)) s++;
 615     i = Uatoi(s);
 616     if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n"); else
 617       {
 618       start = clock();
 619       dbfn_close(dbblock + i);
 620       stop = clock();
 621       dbblock[i].dbptr = NULL;
 622       if (i == current) current = -1;
 623       }
 624     }
 625
 626   else if (Ustrncmp(cmd, "file", 4) == 0)
 627     {
 628     uschar *s = cmd + 4;
 629     while (isspace((uschar)*s)) s++;
 630     i = Uatoi(s);
 631     if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n");
 632       else current = i;
 633     }
 634
 635   else if (Ustrncmp(cmd, "time", 4) == 0)
 636     {
 637     showtime = ~showtime;
 638     printf("Timing %s\n", showtime? "on" : "off");
 639     }
 640
 641   else if (Ustrcmp(cmd, "q") == 0 || Ustrncmp(cmd, "quit", 4) == 0) break;
 642
 643   else if (Ustrncmp(cmd, "help", 4) == 0)
 644     {
 645     printf("close  [<number>]              close file [<number>]\n");
 646     printf("delete <key>                   remove record from current file\n");
 647     printf("file   <number>                make file <number> current\n");
 648     printf("open   <name>                  open db file\n");
 649     printf("q[uit]                         exit program\n");
 650     printf("read   <key>                   read record from current file\n");
 651     printf("scan                           scan current file\n");
 652     printf("time                           time display on/off\n");
 653     printf("write  <key> <rest-of-line>    write record to current file\n");
 654     }
 655
 656   else printf("Eh?\n");
 657
 658   if (showtime && stop >= start)
 659     printf("start=%d stop=%d difference=%d\n", (int)start, (int)stop,
 660      (int)(stop - start));
 661
 662   printf("> ");
 663   }
 664
 665 for (i = 0; i < max_db; i++)
 666   {
 667   if (dbblock[i].dbptr != NULL)
 668     {
 669     printf("\nClosing %d", i);
 670     dbfn_close(dbblock + i);
 671     }
 672   }
 673
 674 printf("\n");
 675 return 0;
 676 }
 677
 678 #endif
 679
 680 /* End of dbfn.c */