src/src/dbfn.c

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