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