src/dbfn.c

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