3aca1832650440aeed61e6abf16e27f7c60fe791
[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 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 */