1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
13 /* We have buffers holding path names for database files.
14 PATH_MAX could be used here, but would be wasting memory, as we deal
15 with database files like $spooldirectory/db/<name> */
19 /* Functions for accessing Exim's hints database, which consists of a number of
20 different DBM files. This module does not contain code for reading DBM files
21 for (e.g.) alias expansion. That is all contained within the general search
22 functions. As Exim now has support for several DBM interfaces, all the relevant
23 functions are called as macros.
25 All the data in Exim's database is in the nature of *hints*. Therefore it
26 doesn't matter if it gets destroyed by accident. These functions are not
27 supposed to implement a "safe" database.
29 Keys are passed in as C strings, and the terminating zero *is* used when
30 building the dbm files. This just makes life easier when scanning the files
33 Synchronization is required on the database files, and this is achieved by
34 means of locking on independent lock files. (Earlier attempts to lock on the
35 DBM files themselves were never completely successful.) Since callers may in
36 general want to do more than one read or write while holding the lock, there
37 are separate open and close functions. However, the calling modules should
38 arrange to hold the locks for the bare minimum of time. */
42 /*************************************************
43 * Open and lock a database file *
44 *************************************************/
46 /* Used for accessing Exim's hints databases.
49 name The single-component name of one of Exim's database files.
50 flags Either O_RDONLY or O_RDWR, indicating the type of open required;
51 O_RDWR implies "create if necessary"
52 dbblock Points to an open_db block to be filled in.
53 lof If TRUE, write to the log for actual open failures (locking failures
55 panic If TRUE, panic on failure to create the db directory
57 Returns: NULL if the open failed, or the locking failed. After locking
58 failures, errno is zero.
60 On success, dbblock is returned. This contains the dbm pointer and
61 the fd of the locked lock file.
63 There are some calls that use O_RDWR|O_CREAT for the flags. Having discovered
64 this in December 2005, I'm not sure if this is correct or not, but for the
65 moment I haven't changed them.
69 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof, BOOL panic)
72 BOOL read_only = flags == O_RDONLY;
74 uschar dirname[PATHLEN], filename[PATHLEN];
76 DEBUG(D_hints_lookup) acl_level++;
78 /* The first thing to do is to open a separate file on which to lock. This
79 ensures that Exim has exclusive use of the database before it even tries to
80 open it. Early versions tried to lock on the open database itself, but that
81 gave rise to mysterious problems from time to time - it was suspected that some
82 DB libraries "do things" on their open() calls which break the interlocking.
83 The lock file is never written to, but we open it for writing so we can get a
84 write lock if required. If it does not exist, we create it. This is done
85 separately so we know when we have done it, because when running as root we
86 need to change the ownership - see the bottom of this function. We also try to
87 make the directory as well, just in case. We won't be doing this many times
88 unnecessarily, because usually the lock file will be there. If the directory
89 exists, there is no error. */
91 snprintf(CS dirname, sizeof(dirname), "%s/db", spool_directory);
92 snprintf(CS filename, sizeof(filename), "%s/%s.lockfile", dirname, name);
94 priv_drop_temp(exim_uid, exim_gid);
95 if ((dbblock->lockfd = Uopen(filename, O_RDWR, EXIMDB_LOCKFILE_MODE)) < 0)
97 (void)directory_make(spool_directory, US"db", EXIMDB_DIRECTORY_MODE, panic);
98 dbblock->lockfd = Uopen(filename, O_RDWR|O_CREAT, EXIMDB_LOCKFILE_MODE);
102 if (dbblock->lockfd < 0)
104 log_write(0, LOG_MAIN, "%s",
105 string_open_failed("database lock file %s", filename));
106 errno = 0; /* Indicates locking failure */
107 DEBUG(D_hints_lookup) acl_level--;
111 /* Now we must get a lock on the opened lock file; do this with a blocking
112 lock that times out. */
114 lock_data.l_type = read_only? F_RDLCK : F_WRLCK;
115 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
117 DEBUG(D_hints_lookup|D_retry|D_route|D_deliver)
118 debug_printf_indent("locking %s\n", filename);
120 sigalrm_seen = FALSE;
121 ALARM(EXIMDB_LOCK_TIMEOUT);
122 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
125 if (sigalrm_seen) errno = ETIMEDOUT;
128 log_write(0, LOG_MAIN|LOG_PANIC, "Failed to get %s lock for %s: %s",
129 read_only ? "read" : "write", filename,
130 errno == ETIMEDOUT ? "timed out" : strerror(errno));
131 (void)close(dbblock->lockfd);
132 errno = 0; /* Indicates locking failure */
133 DEBUG(D_hints_lookup) acl_level--;
137 DEBUG(D_hints_lookup) debug_printf_indent("locked %s\n", filename);
139 /* At this point we have an opened and locked separate lock file, that is,
140 exclusive access to the database, so we can go ahead and open it. If we are
141 expected to create it, don't do so at first, again so that we can detect
142 whether we need to change its ownership (see comments about the lock file
143 above.) There have been regular reports of crashes while opening hints
144 databases - often this is caused by non-matching db.h and the library. To make
145 it easy to pin this down, there are now debug statements on either side of the
148 snprintf(CS filename, sizeof(filename), "%s/%s", dirname, name);
150 priv_drop_temp(exim_uid, exim_gid);
151 dbblock->dbptr = exim_dbopen(filename, dirname, flags, EXIMDB_MODE);
152 if (!dbblock->dbptr && errno == ENOENT && flags == O_RDWR)
154 DEBUG(D_hints_lookup)
155 debug_printf_indent("%s appears not to exist: trying to create\n", filename);
156 dbblock->dbptr = exim_dbopen(filename, dirname, flags|O_CREAT, EXIMDB_MODE);
161 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
162 log the event - also for debugging - but debug only if the file just doesn't
168 if (lof && save_errno != ENOENT)
169 log_write(0, LOG_MAIN, "%s", string_open_failed("DB file %s",
172 DEBUG(D_hints_lookup)
173 debug_printf_indent("%s\n", CS string_open_failed("DB file %s",
175 (void)close(dbblock->lockfd);
177 DEBUG(D_hints_lookup) acl_level--;
181 DEBUG(D_hints_lookup)
182 debug_printf_indent("opened hints database %s: flags=%s\n", filename,
183 flags == O_RDONLY ? "O_RDONLY"
184 : flags == O_RDWR ? "O_RDWR"
185 : flags == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"
188 /* Pass back the block containing the opened database handle and the open fd
197 /*************************************************
198 * Unlock and close a database file *
199 *************************************************/
201 /* Closing a file automatically unlocks it, so after closing the database, just
204 Argument: a pointer to an open database block
209 dbfn_close(open_db *dbblock)
211 exim_dbclose(dbblock->dbptr);
212 (void)close(dbblock->lockfd);
213 DEBUG(D_hints_lookup)
214 { debug_printf_indent("closed hints database and lockfile\n"); acl_level--; }
220 /*************************************************
221 * Read from database file *
222 *************************************************/
224 /* Passing back the pointer unchanged is useless, because there is
225 no guarantee of alignment. Since all the records used by Exim need
226 to be properly aligned to pick out the timestamps, etc., we might as
227 well do the copying centrally here.
229 Most calls don't need the length, so there is a macro called dbfn_read which
230 has two arguments; it calls this function adding NULL as the third.
233 dbblock a pointer to an open database block
234 key the key of the record to be read
235 length a pointer to an int into which to return the length, if not NULL
237 Returns: a pointer to the retrieved record, or
238 NULL if the record is not found
242 dbfn_read_with_length(open_db * dbblock, const uschar * key, int * length)
245 EXIM_DATUM key_datum, result_datum;
246 int klen = Ustrlen(key) + 1;
247 uschar * key_copy = store_get(klen, key);
250 memcpy(key_copy, key, klen);
252 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_read: key=%s\n", key);
254 exim_datum_init(&key_datum); /* Some DBM libraries require the datum */
255 exim_datum_init(&result_datum); /* to be cleared before use. */
256 exim_datum_data_set(&key_datum, key_copy);
257 exim_datum_size_set(&key_datum, klen);
259 if (!exim_dbget(dbblock->dbptr, &key_datum, &result_datum)) return NULL;
261 /* Assume the data store could have been tainted. Properly, we should
262 store the taint status with the data. */
264 dlen = exim_datum_size_get(&result_datum);
265 yield = store_get(dlen, GET_TAINTED);
266 memcpy(yield, exim_datum_data_get(&result_datum), dlen);
267 if (length) *length = dlen;
269 exim_datum_free(&result_datum); /* Some DBM libs require freeing */
274 /* Read a record. If the length is not as expected then delete it, write
275 an error log line, delete the record and return NULL.
276 Use this for fixed-size records (so not retry or wait records).
279 dbblock a pointer to an open database block
280 key the key of the record to be read
281 length the expected record length
283 Returns: a pointer to the retrieved record, or
284 NULL if the record is not found/bad
288 dbfn_read_enforce_length(open_db * dbblock, const uschar * key, size_t length)
291 void * yield = dbfn_read_with_length(dbblock, key, &rlen);
295 if (rlen == length) return yield;
296 log_write(0, LOG_MAIN|LOG_PANIC, "Bad db record size for '%s'", key);
297 dbfn_delete(dbblock, key);
303 /*************************************************
304 * Write to database file *
305 *************************************************/
309 dbblock a pointer to an open database block
310 key the key of the record to be written
311 ptr a pointer to the record to be written
312 length the length of the record to be written
314 Returns: the yield of the underlying dbm or db "write" function. If this
315 is dbm, the value is zero for OK.
319 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
321 EXIM_DATUM key_datum, value_datum;
322 dbdata_generic *gptr = (dbdata_generic *)ptr;
323 int klen = Ustrlen(key) + 1;
324 uschar * key_copy = store_get(klen, key);
326 memcpy(key_copy, key, klen);
327 gptr->time_stamp = time(NULL);
329 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_write: key=%s\n", key);
331 exim_datum_init(&key_datum); /* Some DBM libraries require the datum */
332 exim_datum_init(&value_datum); /* to be cleared before use. */
333 exim_datum_data_set(&key_datum, key_copy);
334 exim_datum_size_set(&key_datum, klen);
335 exim_datum_data_set(&value_datum, ptr);
336 exim_datum_size_set(&value_datum, length);
337 return exim_dbput(dbblock->dbptr, &key_datum, &value_datum);
342 /*************************************************
343 * Delete record from database file *
344 *************************************************/
348 dbblock a pointer to an open database block
349 key the key of the record to be deleted
351 Returns: the yield of the underlying dbm or db "delete" function.
355 dbfn_delete(open_db *dbblock, const uschar *key)
357 int klen = Ustrlen(key) + 1;
358 uschar * key_copy = store_get(klen, key);
359 EXIM_DATUM key_datum;
361 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_delete: key=%s\n", key);
363 memcpy(key_copy, key, klen);
364 exim_datum_init(&key_datum); /* Some DBM libraries require clearing */
365 exim_datum_data_set(&key_datum, key_copy);
366 exim_datum_size_set(&key_datum, klen);
367 return exim_dbdel(dbblock->dbptr, &key_datum);
372 /*************************************************
373 * Scan the keys of a database file *
374 *************************************************/
378 dbblock a pointer to an open database block
379 start TRUE if starting a new scan
380 FALSE if continuing with the current scan
381 cursor a pointer to a pointer to a cursor anchor, for those dbm libraries
382 that use the notion of a cursor
384 Returns: the next record from the file, or
385 NULL if there are no more
389 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
391 EXIM_DATUM key_datum, value_datum;
394 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_scan\n");
396 /* Some dbm require an initialization */
398 if (start) *cursor = exim_dbcreate_cursor(dbblock->dbptr);
400 exim_datum_init(&key_datum); /* Some DBM libraries require the datum */
401 exim_datum_init(&value_datum); /* to be cleared before use. */
403 yield = exim_dbscan(dbblock->dbptr, &key_datum, &value_datum, start, *cursor)
404 ? US exim_datum_data_get(&key_datum) : NULL;
406 /* Some dbm require a termination */
408 if (!yield) exim_dbdelete_cursor(*cursor);
414 /*************************************************
415 **************************************************
416 * Stand-alone test program *
417 **************************************************
418 *************************************************/
423 main(int argc, char **cargv)
426 int max_db = sizeof(dbblock)/sizeof(open_db);
430 dbdata_wait *dbwait = NULL;
431 uschar **argv = USS cargv;
433 uschar structbuffer[1024];
437 printf("Usage: test_dbfn directory\n");
438 printf("The subdirectory called \"db\" in the given directory is used for\n");
439 printf("the files used in this test program.\n");
445 spool_directory = argv[1];
446 debug_selector = D_all - D_memory;
448 big_buffer = malloc(big_buffer_size);
450 for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
452 printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
453 printf("DBM library: ");
455 #ifdef DB_VERSION_STRING
456 printf("Berkeley DB: %s\n", DB_VERSION_STRING);
457 #elif defined(BTREEVERSION) && defined(HASHVERSION)
459 printf("probably Berkeley DB version 1.8x (native mode)\n");
461 printf("probably Berkeley DB version 1.8x (compatibility mode)\n");
463 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
464 printf("probably ndbm\n");
465 #elif defined(USE_TDB)
466 printf("using tdb\n");
469 printf("probably GDBM (native mode)\n");
471 printf("probably GDBM (compatibility mode)\n");
475 /* Test the functions */
477 printf("\nTest the functions\n> ");
479 while (Ufgets(buffer, 256, stdin) != NULL)
481 int len = Ustrlen(buffer);
485 uschar *cmd = buffer;
486 while (len > 0 && isspace((uschar)buffer[len-1])) len--;
489 if (isdigit((uschar)*cmd))
492 while (isdigit((uschar)*cmd)) cmd++;
493 Uskip_whitespace(&cmd);
496 if (Ustrncmp(cmd, "open", 4) == 0)
501 Uskip_whitespace(&s);
503 for (i = 0; i < max_db; i++)
504 if (dbblock[i].dbptr == NULL) break;
508 printf("Too many open databases\n> ");
513 odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE, TRUE);
519 printf("opened %d\n", current);
521 /* Other error cases will have written messages */
522 else if (errno == ENOENT)
524 printf("open failed: %s%s\n", strerror(errno),
526 " (or other Berkeley DB error)"
534 else if (Ustrncmp(cmd, "write", 5) == 0)
537 uschar * key = cmd + 5, * data;
541 printf("No current database\n");
545 Uskip_whitespace(&key);
547 Uskip_nonwhite(&data);
549 Uskip_whitespace(&data);
551 dbwait = (dbdata_wait *)(&structbuffer);
552 Ustrcpy(dbwait->text, data);
556 rc = dbfn_write(dbblock + current, key, dbwait,
557 Ustrlen(data) + sizeof(dbdata_wait));
559 if (rc != 0) printf("Failed: %s\n", strerror(errno));
562 else if (Ustrncmp(cmd, "read", 4) == 0)
564 uschar * key = cmd + 4;
567 printf("No current database\n");
570 Uskip_whitespace(&key);
573 dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock+ current, key, NULL);
575 printf("%s\n", (dbwait == NULL)? "<not found>" : CS dbwait->text);
578 else if (Ustrncmp(cmd, "delete", 6) == 0)
580 uschar * key = cmd + 6;
583 printf("No current database\n");
586 Uskip_whitespace(&key);
587 dbfn_delete(dbblock + current, key);
590 else if (Ustrncmp(cmd, "scan", 4) == 0)
593 BOOL startflag = TRUE;
595 uschar keybuffer[256];
598 printf("No current database\n");
602 while ((key = dbfn_scan(dbblock + current, startflag, &cursor)) != NULL)
605 Ustrcpy(keybuffer, key);
606 dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock + current,
608 printf("%s: %s\n", keybuffer, dbwait->text);
611 printf("End of scan\n");
614 else if (Ustrncmp(cmd, "close", 5) == 0)
616 uschar * s = cmd + 5;
617 Uskip_whitespace(&s);
619 if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n"); else
622 dbfn_close(dbblock + i);
624 dbblock[i].dbptr = NULL;
625 if (i == current) current = -1;
629 else if (Ustrncmp(cmd, "file", 4) == 0)
631 uschar * s = cmd + 4;
632 Uskip_whitespace(&s);
634 if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n");
638 else if (Ustrncmp(cmd, "time", 4) == 0)
640 showtime = ~showtime;
641 printf("Timing %s\n", showtime? "on" : "off");
644 else if (Ustrcmp(cmd, "q") == 0 || Ustrncmp(cmd, "quit", 4) == 0) break;
646 else if (Ustrncmp(cmd, "help", 4) == 0)
648 printf("close [<number>] close file [<number>]\n");
649 printf("delete <key> remove record from current file\n");
650 printf("file <number> make file <number> current\n");
651 printf("open <name> open db file\n");
652 printf("q[uit] exit program\n");
653 printf("read <key> read record from current file\n");
654 printf("scan scan current file\n");
655 printf("time time display on/off\n");
656 printf("write <key> <rest-of-line> write record to current file\n");
659 else printf("Eh?\n");
661 if (showtime && stop >= start)
662 printf("start=%d stop=%d difference=%d\n", (int)start, (int)stop,
663 (int)(stop - start));
668 for (i = 0; i < max_db; i++)
670 if (dbblock[i].dbptr != NULL)
672 printf("\nClosing %d", i);
673 dbfn_close(dbblock + i);