src/src/dbfn.c

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