1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
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.
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.
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
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. */
35 /*************************************************
36 * Berkeley DB error callback *
37 *************************************************/
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
44 #if defined(USE_DB) && defined(DB_VERSION_STRING)
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)
51 dbfn_bdb_error_callback(const char *pfx, char *msg)
55 log_write(0, LOG_MAIN, "Berkeley DB error: %s", msg);
62 /*************************************************
63 * Open and lock a database file *
64 *************************************************/
66 /* Used for accessing Exim's hints databases.
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
76 Returns: NULL if the open failed, or the locking failed. After locking
77 failures, errno is zero.
79 On success, dbblock is returned. This contains the dbm pointer and
80 the fd of the locked lock file.
82 There are some calls that use O_RDWR|O_CREAT for the flags. Having discovered
83 this in December 2005, I'm not sure if this is correct or not, but for the
84 moment I haven't changed them.
88 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof)
91 BOOL read_only = flags == O_RDONLY;
96 /* The first thing to do is to open a separate file on which to lock. This
97 ensures that Exim has exclusive use of the database before it even tries to
98 open it. Early versions tried to lock on the open database itself, but that
99 gave rise to mysterious problems from time to time - it was suspected that some
100 DB libraries "do things" on their open() calls which break the interlocking.
101 The lock file is never written to, but we open it for writing so we can get a
102 write lock if required. If it does not exist, we create it. This is done
103 separately so we know when we have done it, because when running as root we
104 need to change the ownership - see the bottom of this function. We also try to
105 make the directory as well, just in case. We won't be doing this many times
106 unnecessarily, because usually the lock file will be there. If the directory
107 exists, there is no error. */
109 sprintf(CS buffer, "%s/db/%s.lockfile", spool_directory, name);
111 if ((dbblock->lockfd = Uopen(buffer, O_RDWR, EXIMDB_LOCKFILE_MODE)) < 0)
114 (void)directory_make(spool_directory, US"db", EXIMDB_DIRECTORY_MODE, TRUE);
115 dbblock->lockfd = Uopen(buffer, O_RDWR|O_CREAT, EXIMDB_LOCKFILE_MODE);
118 if (dbblock->lockfd < 0)
120 log_write(0, LOG_MAIN, "%s",
121 string_open_failed(errno, "database lock file %s", buffer));
122 errno = 0; /* Indicates locking failure */
126 /* Now we must get a lock on the opened lock file; do this with a blocking
127 lock that times out. */
129 lock_data.l_type = read_only? F_RDLCK : F_WRLCK;
130 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
132 DEBUG(D_hints_lookup|D_retry|D_route|D_deliver)
133 debug_printf("locking %s\n", buffer);
135 sigalrm_seen = FALSE;
136 alarm(EXIMDB_LOCK_TIMEOUT);
137 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
140 if (sigalrm_seen) errno = ETIMEDOUT;
143 log_write(0, LOG_MAIN|LOG_PANIC, "Failed to get %s lock for %s: %s",
144 read_only ? "read" : "write", buffer,
145 errno == ETIMEDOUT ? "timed out" : strerror(errno));
146 (void)close(dbblock->lockfd);
147 errno = 0; /* Indicates locking failure */
151 DEBUG(D_hints_lookup) debug_printf("locked %s\n", buffer);
153 /* At this point we have an opened and locked separate lock file, that is,
154 exclusive access to the database, so we can go ahead and open it. If we are
155 expected to create it, don't do so at first, again so that we can detect
156 whether we need to change its ownership (see comments about the lock file
157 above.) There have been regular reports of crashes while opening hints
158 databases - often this is caused by non-matching db.h and the library. To make
159 it easy to pin this down, there are now debug statements on either side of the
162 sprintf(CS buffer, "%s/db/%s", spool_directory, name);
163 DEBUG(D_hints_lookup) debug_printf("EXIM_DBOPEN(%s)\n", buffer);
164 EXIM_DBOPEN(buffer, flags, EXIMDB_MODE, &(dbblock->dbptr));
165 DEBUG(D_hints_lookup) debug_printf("returned from EXIM_DBOPEN\n");
167 if (!dbblock->dbptr && errno == ENOENT && flags == O_RDWR)
169 DEBUG(D_hints_lookup)
170 debug_printf("%s appears not to exist: trying to create\n", buffer);
172 EXIM_DBOPEN(buffer, flags|O_CREAT, EXIMDB_MODE, &(dbblock->dbptr));
173 DEBUG(D_hints_lookup) debug_printf("returned from EXIM_DBOPEN\n");
178 /* If we are running as root and this is the first access to the database, its
179 files will be owned by root. We want them to be owned by exim. We detect this
180 situation by noting above when we had to create the lock file or the database
181 itself. Because the different dbm libraries use different extensions for their
182 files, I don't know of any easier way of arranging this than scanning the
183 directory for files with the appropriate base name. At least this deals with
184 the lock file at the same time. Also, the directory will typically have only
185 half a dozen files, so the scan will be quick.
187 This code is placed here, before the test for successful opening, because there
188 was a case when a file was created, but the DBM library still returned NULL
189 because of some problem. It also sorts out the lock file if that was created
190 but creation of the database file failed. */
192 if (created && geteuid() == root_uid)
196 uschar *lastname = Ustrrchr(buffer, '/') + 1;
197 int namelen = Ustrlen(name);
200 dd = opendir(CS buffer);
202 while ((ent = readdir(dd)))
203 if (Ustrncmp(ent->d_name, name, namelen) == 0)
206 Ustrcpy(lastname, ent->d_name);
207 if (Ustat(buffer, &statbuf) >= 0 && statbuf.st_uid != exim_uid)
209 DEBUG(D_hints_lookup) debug_printf("ensuring %s is owned by exim\n", buffer);
210 if (Uchown(buffer, exim_uid, exim_gid))
211 DEBUG(D_hints_lookup) debug_printf("failed setting %s to owned by exim\n", buffer);
218 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
219 log the event - also for debugging - but not if the file just doesn't exist. */
223 if (save_errno != ENOENT)
225 log_write(0, LOG_MAIN, "%s", string_open_failed(save_errno, "DB file %s",
228 DEBUG(D_hints_lookup)
229 debug_printf("%s", CS string_open_failed(save_errno, "DB file %s\n",
231 (void)close(dbblock->lockfd);
236 DEBUG(D_hints_lookup)
237 debug_printf("opened hints database %s: flags=%s\n", buffer,
238 flags == O_RDONLY ? "O_RDONLY"
239 : flags == O_RDWR ? "O_RDWR"
240 : flags == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"
243 /* Pass back the block containing the opened database handle and the open fd
252 /*************************************************
253 * Unlock and close a database file *
254 *************************************************/
256 /* Closing a file automatically unlocks it, so after closing the database, just
259 Argument: a pointer to an open database block
264 dbfn_close(open_db *dbblock)
266 EXIM_DBCLOSE(dbblock->dbptr);
267 (void)close(dbblock->lockfd);
268 DEBUG(D_hints_lookup) debug_printf("closed hints database and lockfile\n");
274 /*************************************************
275 * Read from database file *
276 *************************************************/
278 /* Passing back the pointer unchanged is useless, because there is
279 no guarantee of alignment. Since all the records used by Exim need
280 to be properly aligned to pick out the timestamps, etc., we might as
281 well do the copying centrally here.
283 Most calls don't need the length, so there is a macro called dbfn_read which
284 has two arguments; it calls this function adding NULL as the third.
287 dbblock a pointer to an open database block
288 key the key of the record to be read
289 length a pointer to an int into which to return the length, if not NULL
291 Returns: a pointer to the retrieved record, or
292 NULL if the record is not found
296 dbfn_read_with_length(open_db *dbblock, const uschar *key, int *length)
299 EXIM_DATUM key_datum, result_datum;
300 int klen = Ustrlen(key) + 1;
301 uschar * key_copy = store_get(klen);
303 memcpy(key_copy, key, klen);
305 DEBUG(D_hints_lookup) debug_printf("dbfn_read: key=%s\n", key);
307 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
308 EXIM_DATUM_INIT(result_datum); /* to be cleared before use. */
309 EXIM_DATUM_DATA(key_datum) = CS key_copy;
310 EXIM_DATUM_SIZE(key_datum) = klen;
312 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
314 yield = store_get(EXIM_DATUM_SIZE(result_datum));
315 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
316 if (length != NULL) *length = EXIM_DATUM_SIZE(result_datum);
318 EXIM_DATUM_FREE(result_datum); /* Some DBM libs require freeing */
324 /*************************************************
325 * Write to database file *
326 *************************************************/
330 dbblock a pointer to an open database block
331 key the key of the record to be written
332 ptr a pointer to the record to be written
333 length the length of the record to be written
335 Returns: the yield of the underlying dbm or db "write" function. If this
336 is dbm, the value is zero for OK.
340 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
342 EXIM_DATUM key_datum, value_datum;
343 dbdata_generic *gptr = (dbdata_generic *)ptr;
344 int klen = Ustrlen(key) + 1;
345 uschar * key_copy = store_get(klen);
347 memcpy(key_copy, key, klen);
348 gptr->time_stamp = time(NULL);
350 DEBUG(D_hints_lookup) debug_printf("dbfn_write: key=%s\n", key);
352 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
353 EXIM_DATUM_INIT(value_datum); /* to be cleared before use. */
354 EXIM_DATUM_DATA(key_datum) = CS key_copy;
355 EXIM_DATUM_SIZE(key_datum) = klen;
356 EXIM_DATUM_DATA(value_datum) = CS ptr;
357 EXIM_DATUM_SIZE(value_datum) = length;
358 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
363 /*************************************************
364 * Delete record from database file *
365 *************************************************/
369 dbblock a pointer to an open database block
370 key the key of the record to be deleted
372 Returns: the yield of the underlying dbm or db "delete" function.
376 dbfn_delete(open_db *dbblock, const uschar *key)
378 int klen = Ustrlen(key) + 1;
379 uschar * key_copy = store_get(klen);
381 memcpy(key_copy, key, klen);
382 EXIM_DATUM key_datum;
383 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require clearing */
384 EXIM_DATUM_DATA(key_datum) = CS key_copy;
385 EXIM_DATUM_SIZE(key_datum) = klen;
386 return EXIM_DBDEL(dbblock->dbptr, key_datum);
391 /*************************************************
392 * Scan the keys of a database file *
393 *************************************************/
397 dbblock a pointer to an open database block
398 start TRUE if starting a new scan
399 FALSE if continuing with the current scan
400 cursor a pointer to a pointer to a cursor anchor, for those dbm libraries
401 that use the notion of a cursor
403 Returns: the next record from the file, or
404 NULL if there are no more
408 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
410 EXIM_DATUM key_datum, value_datum;
412 value_datum = value_datum; /* dummy; not all db libraries use this */
414 /* Some dbm require an initialization */
416 if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
418 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
419 EXIM_DATUM_INIT(value_datum); /* to be cleared before use. */
421 yield = (EXIM_DBSCAN(dbblock->dbptr, key_datum, value_datum, start, *cursor))?
422 US EXIM_DATUM_DATA(key_datum) : NULL;
424 /* Some dbm require a termination */
426 if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
432 /*************************************************
433 **************************************************
434 * Stand-alone test program *
435 **************************************************
436 *************************************************/
441 main(int argc, char **cargv)
444 int max_db = sizeof(dbblock)/sizeof(open_db);
448 dbdata_wait *dbwait = NULL;
449 uschar **argv = USS cargv;
451 uschar structbuffer[1024];
455 printf("Usage: test_dbfn directory\n");
456 printf("The subdirectory called \"db\" in the given directory is used for\n");
457 printf("the files used in this test program.\n");
463 spool_directory = argv[1];
464 debug_selector = D_all - D_memory;
466 big_buffer = malloc(big_buffer_size);
468 for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
470 printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
471 printf("DBM library: ");
473 #ifdef DB_VERSION_STRING
474 printf("Berkeley DB: %s\n", DB_VERSION_STRING);
475 #elif defined(BTREEVERSION) && defined(HASHVERSION)
477 printf("probably Berkeley DB version 1.8x (native mode)\n");
479 printf("probably Berkeley DB version 1.8x (compatibility mode)\n");
481 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
482 printf("probably ndbm\n");
483 #elif defined(USE_TDB)
484 printf("using tdb\n");
487 printf("probably GDBM (native mode)\n");
489 printf("probably GDBM (compatibility mode)\n");
493 /* Test the functions */
495 printf("\nTest the functions\n> ");
497 while (Ufgets(buffer, 256, stdin) != NULL)
499 int len = Ustrlen(buffer);
503 uschar *cmd = buffer;
504 while (len > 0 && isspace((uschar)buffer[len-1])) len--;
507 if (isdigit((uschar)*cmd))
510 while (isdigit((uschar)*cmd)) cmd++;
511 while (isspace((uschar)*cmd)) cmd++;
514 if (Ustrncmp(cmd, "open", 4) == 0)
519 while (isspace((uschar)*s)) s++;
521 for (i = 0; i < max_db; i++)
522 if (dbblock[i].dbptr == NULL) break;
526 printf("Too many open databases\n> ");
531 odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE);
537 printf("opened %d\n", current);
539 /* Other error cases will have written messages */
540 else if (errno == ENOENT)
542 printf("open failed: %s%s\n", strerror(errno),
544 " (or other Berkeley DB error)"
552 else if (Ustrncmp(cmd, "write", 5) == 0)
555 uschar *key = cmd + 5;
560 printf("No current database\n");
564 while (isspace((uschar)*key)) key++;
566 while (*data != 0 && !isspace((uschar)*data)) data++;
568 while (isspace((uschar)*data)) data++;
570 dbwait = (dbdata_wait *)(&structbuffer);
571 Ustrcpy(dbwait->text, data);
575 rc = dbfn_write(dbblock + current, key, dbwait,
576 Ustrlen(data) + sizeof(dbdata_wait));
578 if (rc != 0) printf("Failed: %s\n", strerror(errno));
581 else if (Ustrncmp(cmd, "read", 4) == 0)
583 uschar *key = cmd + 4;
586 printf("No current database\n");
589 while (isspace((uschar)*key)) key++;
592 dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock+ current, key, NULL);
594 printf("%s\n", (dbwait == NULL)? "<not found>" : CS dbwait->text);
597 else if (Ustrncmp(cmd, "delete", 6) == 0)
599 uschar *key = cmd + 6;
602 printf("No current database\n");
605 while (isspace((uschar)*key)) key++;
606 dbfn_delete(dbblock + current, key);
609 else if (Ustrncmp(cmd, "scan", 4) == 0)
612 BOOL startflag = TRUE;
614 uschar keybuffer[256];
617 printf("No current database\n");
621 while ((key = dbfn_scan(dbblock + current, startflag, &cursor)) != NULL)
624 Ustrcpy(keybuffer, key);
625 dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock + current,
627 printf("%s: %s\n", keybuffer, dbwait->text);
630 printf("End of scan\n");
633 else if (Ustrncmp(cmd, "close", 5) == 0)
636 while (isspace((uschar)*s)) s++;
638 if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n"); else
641 dbfn_close(dbblock + i);
643 dbblock[i].dbptr = NULL;
644 if (i == current) current = -1;
648 else if (Ustrncmp(cmd, "file", 4) == 0)
651 while (isspace((uschar)*s)) s++;
653 if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n");
657 else if (Ustrncmp(cmd, "time", 4) == 0)
659 showtime = ~showtime;
660 printf("Timing %s\n", showtime? "on" : "off");
663 else if (Ustrcmp(cmd, "q") == 0 || Ustrncmp(cmd, "quit", 4) == 0) break;
665 else if (Ustrncmp(cmd, "help", 4) == 0)
667 printf("close [<number>] close file [<number>]\n");
668 printf("delete <key> remove record from current file\n");
669 printf("file <number> make file <number> current\n");
670 printf("open <name> open db file\n");
671 printf("q[uit] exit program\n");
672 printf("read <key> read record from current file\n");
673 printf("scan scan current file\n");
674 printf("time time display on/off\n");
675 printf("write <key> <rest-of-line> write record to current file\n");
678 else printf("Eh?\n");
680 if (showtime && stop >= start)
681 printf("start=%d stop=%d difference=%d\n", (int)start, (int)stop,
682 (int)(stop - start));
687 for (i = 0; i < max_db; i++)
689 if (dbblock[i].dbptr != NULL)
691 printf("\nClosing %d", i);
692 dbfn_close(dbblock + i);