1f058ef7236621305af047b42c8e9def9d900799
[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 /* 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   struct dirent *ent;
199   uschar *lastname = Ustrrchr(filename, '/') + 1;
200   int namelen = Ustrlen(name);
201
202   *lastname = 0;
203   dd = opendir(CS filename);
204
205   while ((ent = readdir(dd)))
206     if (Ustrncmp(ent->d_name, name, namelen) == 0)
207       {
208       struct stat statbuf;
209       /* Filenames from readdir() are trusted, 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) debug_printf_indent("ensuring %s is owned by exim\n", filename);
214         if (exim_chown(filename, exim_uid, exim_gid))
215           DEBUG(D_hints_lookup) debug_printf_indent("failed setting %s to owned by exim\n", filename);
216         }
217       }
218
219   closedir(dd);
220   }
221
222 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
223 log the event - also for debugging - but debug only if the file just doesn't
224 exist. */
225
226 if (!dbblock->dbptr)
227   {
228   if (lof && save_errno != ENOENT)
229     log_write(0, LOG_MAIN, "%s", string_open_failed(save_errno, "DB file %s",
230         filename));
231   else
232     DEBUG(D_hints_lookup)
233       debug_printf_indent("%s\n", CS string_open_failed(save_errno, "DB file %s",
234           filename));
235   (void)close(dbblock->lockfd);
236   errno = save_errno;
237   DEBUG(D_hints_lookup) acl_level--;
238   return NULL;
239   }
240
241 DEBUG(D_hints_lookup)
242   debug_printf_indent("opened hints database %s: flags=%s\n", filename,
243     flags == O_RDONLY ? "O_RDONLY"
244     : flags == O_RDWR ? "O_RDWR"
245     : flags == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"
246     : "??");
247
248 /* Pass back the block containing the opened database handle and the open fd
249 for the lock. */
250
251 return 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
262 close the lock file.
263
264 Argument: a pointer to an open database block
265 Returns:  nothing
266 */
267
268 void
269 dbfn_close(open_db *dbblock)
270 {
271 EXIM_DBCLOSE(dbblock->dbptr);
272 (void)close(dbblock->lockfd);
273 DEBUG(D_hints_lookup)
274   { debug_printf_indent("closed hints database and lockfile\n"); acl_level--; }
275 }
276
277
278
279
280 /*************************************************
281 *             Read from database file            *
282 *************************************************/
283
284 /* Passing back the pointer unchanged is useless, because there is
285 no guarantee of alignment. Since all the records used by Exim need
286 to be properly aligned to pick out the timestamps, etc., we might as
287 well do the copying centrally here.
288
289 Most calls don't need the length, so there is a macro called dbfn_read which
290 has two arguments; it calls this function adding NULL as the third.
291
292 Arguments:
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
297 Returns: a pointer to the retrieved record, or
298          NULL if the record is not found
299 */
300
301 void *
302 dbfn_read_with_length(open_db *dbblock, const uschar *key, int *length)
303 {
304 void *yield;
305 EXIM_DATUM key_datum, result_datum;
306 int klen = Ustrlen(key) + 1;
307 uschar * key_copy = store_get(klen, is_tainted(key));
308
309 memcpy(key_copy, key, klen);
310
311 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_read: key=%s\n", key);
312
313 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
314 EXIM_DATUM_INIT(result_datum);      /* to be cleared before use. */
315 EXIM_DATUM_DATA(key_datum) = CS key_copy;
316 EXIM_DATUM_SIZE(key_datum) = klen;
317
318 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
319
320 /* Assume the data store could have been tainted.  Properly, we should
321 store the taint status with the data. */
322
323 yield = store_get(EXIM_DATUM_SIZE(result_datum), TRUE);
324 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
325 if (length != NULL) *length = EXIM_DATUM_SIZE(result_datum);
326
327 EXIM_DATUM_FREE(result_datum);    /* Some DBM libs require freeing */
328 return yield;
329 }
330
331
332
333 /*************************************************
334 *             Write to database file             *
335 *************************************************/
336
337 /*
338 Arguments:
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
344 Returns:    the yield of the underlying dbm or db "write" function. If this
345             is dbm, the value is zero for OK.
346 */
347
348 int
349 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
350 {
351 EXIM_DATUM key_datum, value_datum;
352 dbdata_generic *gptr = (dbdata_generic *)ptr;
353 int klen = Ustrlen(key) + 1;
354 uschar * key_copy = store_get(klen, is_tainted(key));
355
356 memcpy(key_copy, key, klen);
357 gptr->time_stamp = time(NULL);
358
359 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_write: key=%s\n", key);
360
361 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
362 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
363 EXIM_DATUM_DATA(key_datum) = CS key_copy;
364 EXIM_DATUM_SIZE(key_datum) = klen;
365 EXIM_DATUM_DATA(value_datum) = CS ptr;
366 EXIM_DATUM_SIZE(value_datum) = length;
367 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
368 }
369
370
371
372 /*************************************************
373 *           Delete record from database file     *
374 *************************************************/
375
376 /*
377 Arguments:
378   dbblock    a pointer to an open database block
379   key        the key of the record to be deleted
380
381 Returns: the yield of the underlying dbm or db "delete" function.
382 */
383
384 int
385 dbfn_delete(open_db *dbblock, const uschar *key)
386 {
387 int klen = Ustrlen(key) + 1;
388 uschar * key_copy = store_get(klen, is_tainted(key));
389
390 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_delete: key=%s\n", key);
391
392 memcpy(key_copy, key, klen);
393 EXIM_DATUM key_datum;
394 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require clearing */
395 EXIM_DATUM_DATA(key_datum) = CS key_copy;
396 EXIM_DATUM_SIZE(key_datum) = klen;
397 return EXIM_DBDEL(dbblock->dbptr, key_datum);
398 }
399
400
401
402 /*************************************************
403 *         Scan the keys of a database file       *
404 *************************************************/
405
406 /*
407 Arguments:
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
414 Returns:   the next record from the file, or
415            NULL if there are no more
416 */
417
418 uschar *
419 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
420 {
421 EXIM_DATUM key_datum, value_datum;
422 uschar *yield;
423 value_datum = value_datum;    /* dummy; not all db libraries use this */
424
425 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_scan\n");
426
427 /* Some dbm require an initialization */
428
429 if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
430
431 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
432 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
433
434 yield = (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
439 if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
440 return yield;
441 }
442
443
444
445 /*************************************************
446 **************************************************
447 *             Stand-alone test program           *
448 **************************************************
449 *************************************************/
450
451 #ifdef STAND_ALONE
452
453 int
454 main(int argc, char **cargv)
455 {
456 open_db dbblock[8];
457 int max_db = sizeof(dbblock)/sizeof(open_db);
458 int current = -1;
459 int showtime = 0;
460 int i;
461 dbdata_wait *dbwait = NULL;
462 uschar **argv = USS cargv;
463 uschar buffer[256];
464 uschar structbuffer[1024];
465
466 if (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
476 spool_directory = argv[1];
477 debug_selector = D_all - D_memory;
478 debug_file = stderr;
479 big_buffer = malloc(big_buffer_size);
480
481 for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
482
483 printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
484 printf("DBM library: ");
485
486 #ifdef DB_VERSION_STRING
487 printf("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)
495 printf("probably ndbm\n");
496 #elif defined(USE_TDB)
497 printf("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
508 printf("\nTest the functions\n> ");
509
510 while (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();
544     odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE, TRUE);
545     stop = clock();
546
547     if (odb)
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
700 for (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
709 printf("\n");
710 return 0;
711 }
712
713 #endif
714
715 /* End of dbfn.c */