src/src/dbfn.c

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