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