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