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