src/src/dbfn.c

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