aa083200a5784d7465f914459033c383518e1562
[users/heiko/exim.git] / src / src / dbfn.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9
10 #include "exim.h"
11
12
13 /* Functions for accessing Exim's hints database, which consists of a number of
14 different DBM files. This module does not contain code for reading DBM files
15 for (e.g.) alias expansion. That is all contained within the general search
16 functions. As Exim now has support for several DBM interfaces, all the relevant
17 functions are called as macros.
18
19 All the data in Exim's database is in the nature of *hints*. Therefore it
20 doesn't matter if it gets destroyed by accident. These functions are not
21 supposed to implement a "safe" database.
22
23 Keys are passed in as C strings, and the terminating zero *is* used when
24 building the dbm files. This just makes life easier when scanning the files
25 sequentially.
26
27 Synchronization is required on the database files, and this is achieved by
28 means of locking on independent lock files. (Earlier attempts to lock on the
29 DBM files themselves were never completely successful.) Since callers may in
30 general want to do more than one read or write while holding the lock, there
31 are separate open and close functions. However, the calling modules should
32 arrange to hold the locks for the bare minimum of time. */
33
34
35
36 /*************************************************
37 *         Berkeley DB error callback             *
38 *************************************************/
39
40 /* For Berkeley DB >= 2, we can define a function to be called in case of DB
41 errors. This should help with debugging strange DB problems, e.g. getting "File
42 exists" when you try to open a db file. The API for this function was changed
43 at DB release 4.3. */
44
45 #if defined(USE_DB) && defined(DB_VERSION_STRING)
46 void
47 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
48 dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
49 {
50 dbenv = dbenv;
51 #else
52 dbfn_bdb_error_callback(const char *pfx, char *msg)
53 {
54 #endif
55 pfx = pfx;
56 log_write(0, LOG_MAIN, "Berkeley DB error: %s", msg);
57 }
58 #endif
59
60
61
62
63 /*************************************************
64 *          Open and lock a database file         *
65 *************************************************/
66
67 /* Used for accessing Exim's hints databases.
68
69 Arguments:
70   name     The single-component name of one of Exim's database files.
71   flags    Either O_RDONLY or O_RDWR, indicating the type of open required;
72              O_RDWR implies "create if necessary"
73   dbblock  Points to an open_db block to be filled in.
74   lof      If TRUE, write to the log for actual open failures (locking failures
75            are always logged).
76   panic    If TRUE, panic on failure to create the db directory
77
78 Returns:   NULL if the open failed, or the locking failed. After locking
79            failures, errno is zero.
80
81            On success, dbblock is returned. This contains the dbm pointer and
82            the fd of the locked lock file.
83
84 There are some calls that use O_RDWR|O_CREAT for the flags. Having discovered
85 this in December 2005, I'm not sure if this is correct or not, but for the
86 moment I haven't changed them.
87 */
88
89 open_db *
90 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof, BOOL panic)
91 {
92 int rc, save_errno;
93 BOOL read_only = flags == O_RDONLY;
94 BOOL created = FALSE;
95 flock_t lock_data;
96 uschar dirname[256], filename[256];
97
98 DEBUG(D_hints_lookup) acl_level++;
99
100 /* The first thing to do is to open a separate file on which to lock. This
101 ensures that Exim has exclusive use of the database before it even tries to
102 open it. Early versions tried to lock on the open database itself, but that
103 gave rise to mysterious problems from time to time - it was suspected that some
104 DB libraries "do things" on their open() calls which break the interlocking.
105 The lock file is never written to, but we open it for writing so we can get a
106 write lock if required. If it does not exist, we create it. This is done
107 separately so we know when we have done it, because when running as root we
108 need to change the ownership - see the bottom of this function. We also try to
109 make the directory as well, just in case. We won't be doing this many times
110 unnecessarily, because usually the lock file will be there. If the directory
111 exists, there is no error. */
112
113 snprintf(CS dirname, sizeof(dirname), "%s/db", spool_directory);
114 snprintf(CS filename, sizeof(filename), "%s/%s.lockfile", dirname, name);
115
116 if ((dbblock->lockfd = Uopen(filename, O_RDWR, EXIMDB_LOCKFILE_MODE)) < 0)
117   {
118   created = TRUE;
119   (void)directory_make(spool_directory, US"db", EXIMDB_DIRECTORY_MODE, panic);
120   dbblock->lockfd = Uopen(filename, O_RDWR|O_CREAT, EXIMDB_LOCKFILE_MODE);
121   }
122
123 if (dbblock->lockfd < 0)
124   {
125   log_write(0, LOG_MAIN, "%s",
126     string_open_failed(errno, "database lock file %s", filename));
127   errno = 0;      /* Indicates locking failure */
128   DEBUG(D_hints_lookup) acl_level--;
129   return NULL;
130   }
131
132 /* Now we must get a lock on the opened lock file; do this with a blocking
133 lock that times out. */
134
135 lock_data.l_type = read_only? F_RDLCK : F_WRLCK;
136 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
137
138 DEBUG(D_hints_lookup|D_retry|D_route|D_deliver)
139   debug_printf_indent("locking %s\n", filename);
140
141 sigalrm_seen = FALSE;
142 ALARM(EXIMDB_LOCK_TIMEOUT);
143 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
144 ALARM_CLR(0);
145
146 if (sigalrm_seen) errno = ETIMEDOUT;
147 if (rc < 0)
148   {
149   log_write(0, LOG_MAIN|LOG_PANIC, "Failed to get %s lock for %s: %s",
150     read_only ? "read" : "write", filename,
151     errno == ETIMEDOUT ? "timed out" : strerror(errno));
152   (void)close(dbblock->lockfd);
153   errno = 0;       /* Indicates locking failure */
154   DEBUG(D_hints_lookup) acl_level--;
155   return NULL;
156   }
157
158 DEBUG(D_hints_lookup) debug_printf_indent("locked  %s\n", filename);
159
160 /* At this point we have an opened and locked separate lock file, that is,
161 exclusive access to the database, so we can go ahead and open it. If we are
162 expected to create it, don't do so at first, again so that we can detect
163 whether we need to change its ownership (see comments about the lock file
164 above.) There have been regular reports of crashes while opening hints
165 databases - often this is caused by non-matching db.h and the library. To make
166 it easy to pin this down, there are now debug statements on either side of the
167 open call. */
168
169 snprintf(CS filename, sizeof(filename), "%s/%s", dirname, name);
170 EXIM_DBOPEN(filename, dirname, flags, EXIMDB_MODE, &(dbblock->dbptr));
171
172 if (!dbblock->dbptr && errno == ENOENT && flags == O_RDWR)
173   {
174   DEBUG(D_hints_lookup)
175     debug_printf_indent("%s appears not to exist: trying to create\n", filename);
176   created = TRUE;
177   EXIM_DBOPEN(filename, dirname, flags|O_CREAT, EXIMDB_MODE, &(dbblock->dbptr));
178   }
179
180 save_errno = errno;
181
182 /* If we are running as root and this is the first access to the database, its
183 files will be owned by root. We want them to be owned by exim. We detect this
184 situation by noting above when we had to create the lock file or the database
185 itself. Because the different dbm libraries use different extensions for their
186 files, I don't know of any easier way of arranging this than scanning the
187 directory for files with the appropriate base name. At least this deals with
188 the lock file at the same time. Also, the directory will typically have only
189 half a dozen files, so the scan will be quick.
190
191 This code is placed here, before the test for successful opening, because there
192 was a case when a file was created, but the DBM library still returned NULL
193 because of some problem. It also sorts out the lock file if that was created
194 but creation of the database file failed. */
195
196 if (created && geteuid() == root_uid)
197   {
198   DIR * dd;
199   uschar *lastname = Ustrrchr(filename, '/') + 1;
200   int namelen = Ustrlen(name);
201
202   *lastname = 0;
203
204   if ((dd = exim_opendir(filename)))
205     for (struct dirent *ent; ent = readdir(dd); )
206       if (Ustrncmp(ent->d_name, name, namelen) == 0)
207         {
208         struct stat statbuf;
209         /* Filenames from readdir() are trusted,
210         so use a taint-nonchecking copy */
211         strcpy(CS lastname, CCS ent->d_name);
212         if (Ustat(filename, &statbuf) >= 0 && statbuf.st_uid != exim_uid)
213           {
214           DEBUG(D_hints_lookup)
215             debug_printf_indent("ensuring %s is owned by exim\n", filename);
216           if (exim_chown(filename, exim_uid, exim_gid))
217             DEBUG(D_hints_lookup)
218               debug_printf_indent("failed setting %s to owned by exim\n", filename);
219           }
220         }
221
222   closedir(dd);
223   }
224
225 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
226 log the event - also for debugging - but debug only if the file just doesn't
227 exist. */
228
229 if (!dbblock->dbptr)
230   {
231   if (lof && save_errno != ENOENT)
232     log_write(0, LOG_MAIN, "%s", string_open_failed(save_errno, "DB file %s",
233         filename));
234   else
235     DEBUG(D_hints_lookup)
236       debug_printf_indent("%s\n", CS string_open_failed(save_errno, "DB file %s",
237           filename));
238   (void)close(dbblock->lockfd);
239   errno = save_errno;
240   DEBUG(D_hints_lookup) acl_level--;
241   return NULL;
242   }
243
244 DEBUG(D_hints_lookup)
245   debug_printf_indent("opened hints database %s: flags=%s\n", filename,
246     flags == O_RDONLY ? "O_RDONLY"
247     : flags == O_RDWR ? "O_RDWR"
248     : flags == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"
249     : "??");
250
251 /* Pass back the block containing the opened database handle and the open fd
252 for the lock. */
253
254 return dbblock;
255 }
256
257
258
259
260 /*************************************************
261 *         Unlock and close a database file       *
262 *************************************************/
263
264 /* Closing a file automatically unlocks it, so after closing the database, just
265 close the lock file.
266
267 Argument: a pointer to an open database block
268 Returns:  nothing
269 */
270
271 void
272 dbfn_close(open_db *dbblock)
273 {
274 EXIM_DBCLOSE(dbblock->dbptr);
275 (void)close(dbblock->lockfd);
276 DEBUG(D_hints_lookup)
277   { debug_printf_indent("closed hints database and lockfile\n"); acl_level--; }
278 }
279
280
281
282
283 /*************************************************
284 *             Read from database file            *
285 *************************************************/
286
287 /* Passing back the pointer unchanged is useless, because there is
288 no guarantee of alignment. Since all the records used by Exim need
289 to be properly aligned to pick out the timestamps, etc., we might as
290 well do the copying centrally here.
291
292 Most calls don't need the length, so there is a macro called dbfn_read which
293 has two arguments; it calls this function adding NULL as the third.
294
295 Arguments:
296   dbblock   a pointer to an open database block
297   key       the key of the record to be read
298   length    a pointer to an int into which to return the length, if not NULL
299
300 Returns: a pointer to the retrieved record, or
301          NULL if the record is not found
302 */
303
304 void *
305 dbfn_read_with_length(open_db *dbblock, const uschar *key, int *length)
306 {
307 void *yield;
308 EXIM_DATUM key_datum, result_datum;
309 int klen = Ustrlen(key) + 1;
310 uschar * key_copy = store_get(klen, is_tainted(key));
311
312 memcpy(key_copy, key, klen);
313
314 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_read: key=%s\n", key);
315
316 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
317 EXIM_DATUM_INIT(result_datum);      /* to be cleared before use. */
318 EXIM_DATUM_DATA(key_datum) = CS key_copy;
319 EXIM_DATUM_SIZE(key_datum) = klen;
320
321 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
322
323 /* Assume the data store could have been tainted.  Properly, we should
324 store the taint status with the data. */
325
326 yield = store_get(EXIM_DATUM_SIZE(result_datum), TRUE);
327 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
328 if (length != NULL) *length = EXIM_DATUM_SIZE(result_datum);
329
330 EXIM_DATUM_FREE(result_datum);    /* Some DBM libs require freeing */
331 return yield;
332 }
333
334
335
336 /*************************************************
337 *             Write to database file             *
338 *************************************************/
339
340 /*
341 Arguments:
342   dbblock   a pointer to an open database block
343   key       the key of the record to be written
344   ptr       a pointer to the record to be written
345   length    the length of the record to be written
346
347 Returns:    the yield of the underlying dbm or db "write" function. If this
348             is dbm, the value is zero for OK.
349 */
350
351 int
352 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
353 {
354 EXIM_DATUM key_datum, value_datum;
355 dbdata_generic *gptr = (dbdata_generic *)ptr;
356 int klen = Ustrlen(key) + 1;
357 uschar * key_copy = store_get(klen, is_tainted(key));
358
359 memcpy(key_copy, key, klen);
360 gptr->time_stamp = time(NULL);
361
362 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_write: key=%s\n", key);
363
364 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
365 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
366 EXIM_DATUM_DATA(key_datum) = CS key_copy;
367 EXIM_DATUM_SIZE(key_datum) = klen;
368 EXIM_DATUM_DATA(value_datum) = CS ptr;
369 EXIM_DATUM_SIZE(value_datum) = length;
370 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
371 }
372
373
374
375 /*************************************************
376 *           Delete record from database file     *
377 *************************************************/
378
379 /*
380 Arguments:
381   dbblock    a pointer to an open database block
382   key        the key of the record to be deleted
383
384 Returns: the yield of the underlying dbm or db "delete" function.
385 */
386
387 int
388 dbfn_delete(open_db *dbblock, const uschar *key)
389 {
390 int klen = Ustrlen(key) + 1;
391 uschar * key_copy = store_get(klen, is_tainted(key));
392
393 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_delete: key=%s\n", key);
394
395 memcpy(key_copy, key, klen);
396 EXIM_DATUM key_datum;
397 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require clearing */
398 EXIM_DATUM_DATA(key_datum) = CS key_copy;
399 EXIM_DATUM_SIZE(key_datum) = klen;
400 return EXIM_DBDEL(dbblock->dbptr, key_datum);
401 }
402
403
404
405 /*************************************************
406 *         Scan the keys of a database file       *
407 *************************************************/
408
409 /*
410 Arguments:
411   dbblock  a pointer to an open database block
412   start    TRUE if starting a new scan
413            FALSE if continuing with the current scan
414   cursor   a pointer to a pointer to a cursor anchor, for those dbm libraries
415            that use the notion of a cursor
416
417 Returns:   the next record from the file, or
418            NULL if there are no more
419 */
420
421 uschar *
422 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
423 {
424 EXIM_DATUM key_datum, value_datum;
425 uschar *yield;
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 */