src/src/dbfn.c

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