336cfe73e262119c53f3322c73af77c336de9a03
[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
76 Returns: NULL if the open failed, or the locking failed. After locking
77 failures, errno is zero.
78
79 On success, dbblock is returned. This contains the dbm pointer and
80 the fd of the locked lock file.
81
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.
85 */
86
87 open_db *
88 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof)
89 {
90 int rc, save_errno;
91 BOOL read_only = flags == O_RDONLY;
92 BOOL created = FALSE;
93 flock_t lock_data;
94 uschar dirname[256], filename[256];
95
96 DEBUG(D_hints_lookup) acl_level++;
97
98 /* The first thing to do is to open a separate file on which to lock. This
99 ensures that Exim has exclusive use of the database before it even tries to
100 open it. Early versions tried to lock on the open database itself, but that
101 gave rise to mysterious problems from time to time - it was suspected that some
102 DB libraries "do things" on their open() calls which break the interlocking.
103 The lock file is never written to, but we open it for writing so we can get a
104 write lock if required. If it does not exist, we create it. This is done
105 separately so we know when we have done it, because when running as root we
106 need to change the ownership - see the bottom of this function. We also try to
107 make the directory as well, just in case. We won't be doing this many times
108 unnecessarily, because usually the lock file will be there. If the directory
109 exists, there is no error. */
110
111 snprintf(CS dirname, sizeof(dirname), "%s/db", spool_directory);
112 snprintf(CS filename, sizeof(filename), "%s/%s.lockfile", dirname, name);
113
114 if ((dbblock->lockfd = Uopen(filename, O_RDWR, EXIMDB_LOCKFILE_MODE)) < 0)
115 {
116 created = TRUE;
117 (void)directory_make(spool_directory, US"db", EXIMDB_DIRECTORY_MODE, TRUE);
118 dbblock->lockfd = Uopen(filename, O_RDWR|O_CREAT, EXIMDB_LOCKFILE_MODE);
119 }
120
121 if (dbblock->lockfd < 0)
122 {
123 log_write(0, LOG_MAIN, "%s",
124 string_open_failed(errno, "database lock file %s", filename));
125 errno = 0; /* Indicates locking failure */
126 DEBUG(D_hints_lookup) acl_level--;
127 return NULL;
128 }
129
130 /* Now we must get a lock on the opened lock file; do this with a blocking
131 lock that times out. */
132
133 lock_data.l_type = read_only? F_RDLCK : F_WRLCK;
134 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
135
136 DEBUG(D_hints_lookup|D_retry|D_route|D_deliver)
137 debug_printf_indent("locking %s\n", filename);
138
139 sigalrm_seen = FALSE;
140 ALARM(EXIMDB_LOCK_TIMEOUT);
141 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
142 ALARM_CLR(0);
143
144 if (sigalrm_seen) errno = ETIMEDOUT;
145 if (rc < 0)
146 {
147 log_write(0, LOG_MAIN|LOG_PANIC, "Failed to get %s lock for %s: %s",
148 read_only ? "read" : "write", filename,
149 errno == ETIMEDOUT ? "timed out" : strerror(errno));
150 (void)close(dbblock->lockfd);
151 errno = 0; /* Indicates locking failure */
152 DEBUG(D_hints_lookup) acl_level--;
153 return NULL;
154 }
155
156 DEBUG(D_hints_lookup) debug_printf_indent("locked %s\n", filename);
157
158 /* At this point we have an opened and locked separate lock file, that is,
159 exclusive access to the database, so we can go ahead and open it. If we are
160 expected to create it, don't do so at first, again so that we can detect
161 whether we need to change its ownership (see comments about the lock file
162 above.) There have been regular reports of crashes while opening hints
163 databases - often this is caused by non-matching db.h and the library. To make
164 it easy to pin this down, there are now debug statements on either side of the
165 open call. */
166
167 snprintf(CS filename, sizeof(filename), "%s/%s", dirname, name);
168 EXIM_DBOPEN(filename, dirname, flags, EXIMDB_MODE, &(dbblock->dbptr));
169
170 if (!dbblock->dbptr && errno == ENOENT && flags == O_RDWR)
171 {
172 DEBUG(D_hints_lookup)
173 debug_printf_indent("%s appears not to exist: trying to create\n", filename);
174 created = TRUE;
175 EXIM_DBOPEN(filename, dirname, flags|O_CREAT, EXIMDB_MODE, &(dbblock->dbptr));
176 }
177
178 save_errno = errno;
179
180 /* If we are running as root and this is the first access to the database, its
181 files will be owned by root. We want them to be owned by exim. We detect this
182 situation by noting above when we had to create the lock file or the database
183 itself. Because the different dbm libraries use different extensions for their
184 files, I don't know of any easier way of arranging this than scanning the
185 directory for files with the appropriate base name. At least this deals with
186 the lock file at the same time. Also, the directory will typically have only
187 half a dozen files, so the scan will be quick.
188
189 This code is placed here, before the test for successful opening, because there
190 was a case when a file was created, but the DBM library still returned NULL
191 because of some problem. It also sorts out the lock file if that was created
192 but creation of the database file failed. */
193
194 if (created && geteuid() == root_uid)
195 {
196 DIR *dd;
197 struct dirent *ent;
198 uschar *lastname = Ustrrchr(filename, '/') + 1;
199 int namelen = Ustrlen(name);
200
201 *lastname = 0;
202 dd = opendir(CS filename);
203
204 while ((ent = readdir(dd)))
205 if (Ustrncmp(ent->d_name, name, namelen) == 0)
206 {
207 struct stat statbuf;
208 Ustrcpy(lastname, ent->d_name);
209 if (Ustat(filename, &statbuf) >= 0 && statbuf.st_uid != exim_uid)
210 {
211 DEBUG(D_hints_lookup) debug_printf_indent("ensuring %s is owned by exim\n", filename);
212 if (Uchown(filename, exim_uid, exim_gid))
213 DEBUG(D_hints_lookup) debug_printf_indent("failed setting %s to owned by exim\n", filename);
214 }
215 }
216
217 closedir(dd);
218 }
219
220 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
221 log the event - also for debugging - but debug only if the file just doesn't
222 exist. */
223
224 if (!dbblock->dbptr)
225 {
226 if (lof && save_errno != ENOENT)
227 log_write(0, LOG_MAIN, "%s", string_open_failed(save_errno, "DB file %s",
228 filename));
229 else
230 DEBUG(D_hints_lookup)
231 debug_printf_indent("%s\n", CS string_open_failed(save_errno, "DB file %s",
232 filename));
233 (void)close(dbblock->lockfd);
234 errno = save_errno;
235 DEBUG(D_hints_lookup) acl_level--;
236 return NULL;
237 }
238
239 DEBUG(D_hints_lookup)
240 debug_printf_indent("opened hints database %s: flags=%s\n", filename,
241 flags == O_RDONLY ? "O_RDONLY"
242 : flags == O_RDWR ? "O_RDWR"
243 : flags == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"
244 : "??");
245
246 /* Pass back the block containing the opened database handle and the open fd
247 for the lock. */
248
249 return dbblock;
250 }
251
252
253
254
255 /*************************************************
256 * Unlock and close a database file *
257 *************************************************/
258
259 /* Closing a file automatically unlocks it, so after closing the database, just
260 close the lock file.
261
262 Argument: a pointer to an open database block
263 Returns: nothing
264 */
265
266 void
267 dbfn_close(open_db *dbblock)
268 {
269 EXIM_DBCLOSE(dbblock->dbptr);
270 (void)close(dbblock->lockfd);
271 DEBUG(D_hints_lookup)
272 { debug_printf_indent("closed hints database and lockfile\n"); acl_level--; }
273 }
274
275
276
277
278 /*************************************************
279 * Read from database file *
280 *************************************************/
281
282 /* Passing back the pointer unchanged is useless, because there is
283 no guarantee of alignment. Since all the records used by Exim need
284 to be properly aligned to pick out the timestamps, etc., we might as
285 well do the copying centrally here.
286
287 Most calls don't need the length, so there is a macro called dbfn_read which
288 has two arguments; it calls this function adding NULL as the third.
289
290 Arguments:
291 dbblock a pointer to an open database block
292 key the key of the record to be read
293 length a pointer to an int into which to return the length, if not NULL
294
295 Returns: a pointer to the retrieved record, or
296 NULL if the record is not found
297 */
298
299 void *
300 dbfn_read_with_length(open_db *dbblock, const uschar *key, int *length)
301 {
302 void *yield;
303 EXIM_DATUM key_datum, result_datum;
304 int klen = Ustrlen(key) + 1;
305 uschar * key_copy = store_get(klen);
306
307 memcpy(key_copy, key, klen);
308
309 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_read: key=%s\n", key);
310
311 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
312 EXIM_DATUM_INIT(result_datum); /* to be cleared before use. */
313 EXIM_DATUM_DATA(key_datum) = CS key_copy;
314 EXIM_DATUM_SIZE(key_datum) = klen;
315
316 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
317
318 yield = store_get(EXIM_DATUM_SIZE(result_datum));
319 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
320 if (length != NULL) *length = EXIM_DATUM_SIZE(result_datum);
321
322 EXIM_DATUM_FREE(result_datum); /* Some DBM libs require freeing */
323 return yield;
324 }
325
326
327
328 /*************************************************
329 * Write to database file *
330 *************************************************/
331
332 /*
333 Arguments:
334 dbblock a pointer to an open database block
335 key the key of the record to be written
336 ptr a pointer to the record to be written
337 length the length of the record to be written
338
339 Returns: the yield of the underlying dbm or db "write" function. If this
340 is dbm, the value is zero for OK.
341 */
342
343 int
344 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
345 {
346 EXIM_DATUM key_datum, value_datum;
347 dbdata_generic *gptr = (dbdata_generic *)ptr;
348 int klen = Ustrlen(key) + 1;
349 uschar * key_copy = store_get(klen);
350
351 memcpy(key_copy, key, klen);
352 gptr->time_stamp = time(NULL);
353
354 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_write: key=%s\n", key);
355
356 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
357 EXIM_DATUM_INIT(value_datum); /* to be cleared before use. */
358 EXIM_DATUM_DATA(key_datum) = CS key_copy;
359 EXIM_DATUM_SIZE(key_datum) = klen;
360 EXIM_DATUM_DATA(value_datum) = CS ptr;
361 EXIM_DATUM_SIZE(value_datum) = length;
362 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
363 }
364
365
366
367 /*************************************************
368 * Delete record from database file *
369 *************************************************/
370
371 /*
372 Arguments:
373 dbblock a pointer to an open database block
374 key the key of the record to be deleted
375
376 Returns: the yield of the underlying dbm or db "delete" function.
377 */
378
379 int
380 dbfn_delete(open_db *dbblock, const uschar *key)
381 {
382 int klen = Ustrlen(key) + 1;
383 uschar * key_copy = store_get(klen);
384
385 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_delete: key=%s\n", key);
386
387 memcpy(key_copy, key, klen);
388 EXIM_DATUM key_datum;
389 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require clearing */
390 EXIM_DATUM_DATA(key_datum) = CS key_copy;
391 EXIM_DATUM_SIZE(key_datum) = klen;
392 return EXIM_DBDEL(dbblock->dbptr, key_datum);
393 }
394
395
396
397 /*************************************************
398 * Scan the keys of a database file *
399 *************************************************/
400
401 /*
402 Arguments:
403 dbblock a pointer to an open database block
404 start TRUE if starting a new scan
405 FALSE if continuing with the current scan
406 cursor a pointer to a pointer to a cursor anchor, for those dbm libraries
407 that use the notion of a cursor
408
409 Returns: the next record from the file, or
410 NULL if there are no more
411 */
412
413 uschar *
414 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
415 {
416 EXIM_DATUM key_datum, value_datum;
417 uschar *yield;
418 value_datum = value_datum; /* dummy; not all db libraries use this */
419
420 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_scan\n");
421
422 /* Some dbm require an initialization */
423
424 if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
425
426 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
427 EXIM_DATUM_INIT(value_datum); /* to be cleared before use. */
428
429 yield = (EXIM_DBSCAN(dbblock->dbptr, key_datum, value_datum, start, *cursor))?
430 US EXIM_DATUM_DATA(key_datum) : NULL;
431
432 /* Some dbm require a termination */
433
434 if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
435 return yield;
436 }
437
438
439
440 /*************************************************
441 **************************************************
442 * Stand-alone test program *
443 **************************************************
444 *************************************************/
445
446 #ifdef STAND_ALONE
447
448 int
449 main(int argc, char **cargv)
450 {
451 open_db dbblock[8];
452 int max_db = sizeof(dbblock)/sizeof(open_db);
453 int current = -1;
454 int showtime = 0;
455 int i;
456 dbdata_wait *dbwait = NULL;
457 uschar **argv = USS cargv;
458 uschar buffer[256];
459 uschar structbuffer[1024];
460
461 if (argc != 2)
462 {
463 printf("Usage: test_dbfn directory\n");
464 printf("The subdirectory called \"db\" in the given directory is used for\n");
465 printf("the files used in this test program.\n");
466 return 1;
467 }
468
469 /* Initialize */
470
471 spool_directory = argv[1];
472 debug_selector = D_all - D_memory;
473 debug_file = stderr;
474 big_buffer = malloc(big_buffer_size);
475
476 for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
477
478 printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
479 printf("DBM library: ");
480
481 #ifdef DB_VERSION_STRING
482 printf("Berkeley DB: %s\n", DB_VERSION_STRING);
483 #elif defined(BTREEVERSION) && defined(HASHVERSION)
484 #ifdef USE_DB
485 printf("probably Berkeley DB version 1.8x (native mode)\n");
486 #else
487 printf("probably Berkeley DB version 1.8x (compatibility mode)\n");
488 #endif
489 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
490 printf("probably ndbm\n");
491 #elif defined(USE_TDB)
492 printf("using tdb\n");
493 #else
494 #ifdef USE_GDBM
495 printf("probably GDBM (native mode)\n");
496 #else
497 printf("probably GDBM (compatibility mode)\n");
498 #endif
499 #endif
500
501 /* Test the functions */
502
503 printf("\nTest the functions\n> ");
504
505 while (Ufgets(buffer, 256, stdin) != NULL)
506 {
507 int len = Ustrlen(buffer);
508 int count = 1;
509 clock_t start = 1;
510 clock_t stop = 0;
511 uschar *cmd = buffer;
512 while (len > 0 && isspace((uschar)buffer[len-1])) len--;
513 buffer[len] = 0;
514
515 if (isdigit((uschar)*cmd))
516 {
517 count = Uatoi(cmd);
518 while (isdigit((uschar)*cmd)) cmd++;
519 while (isspace((uschar)*cmd)) cmd++;
520 }
521
522 if (Ustrncmp(cmd, "open", 4) == 0)
523 {
524 int i;
525 open_db *odb;
526 uschar *s = cmd + 4;
527 while (isspace((uschar)*s)) s++;
528
529 for (i = 0; i < max_db; i++)
530 if (dbblock[i].dbptr == NULL) break;
531
532 if (i >= max_db)
533 {
534 printf("Too many open databases\n> ");
535 continue;
536 }
537
538 start = clock();
539 odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE);
540 stop = clock();
541
542 if (odb)
543 {
544 current = i;
545 printf("opened %d\n", current);
546 }
547 /* Other error cases will have written messages */
548 else if (errno == ENOENT)
549 {
550 printf("open failed: %s%s\n", strerror(errno),
551 #ifdef USE_DB
552 " (or other Berkeley DB error)"
553 #else
554 ""
555 #endif
556 );
557 }
558 }
559
560 else if (Ustrncmp(cmd, "write", 5) == 0)
561 {
562 int rc = 0;
563 uschar *key = cmd + 5;
564 uschar *data;
565
566 if (current < 0)
567 {
568 printf("No current database\n");
569 continue;
570 }
571
572 while (isspace((uschar)*key)) key++;
573 data = key;
574 while (*data != 0 && !isspace((uschar)*data)) data++;
575 *data++ = 0;
576 while (isspace((uschar)*data)) data++;
577
578 dbwait = (dbdata_wait *)(&structbuffer);
579 Ustrcpy(dbwait->text, data);
580
581 start = clock();
582 while (count-- > 0)
583 rc = dbfn_write(dbblock + current, key, dbwait,
584 Ustrlen(data) + sizeof(dbdata_wait));
585 stop = clock();
586 if (rc != 0) printf("Failed: %s\n", strerror(errno));
587 }
588
589 else if (Ustrncmp(cmd, "read", 4) == 0)
590 {
591 uschar *key = cmd + 4;
592 if (current < 0)
593 {
594 printf("No current database\n");
595 continue;
596 }
597 while (isspace((uschar)*key)) key++;
598 start = clock();
599 while (count-- > 0)
600 dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock+ current, key, NULL);
601 stop = clock();
602 printf("%s\n", (dbwait == NULL)? "<not found>" : CS dbwait->text);
603 }
604
605 else if (Ustrncmp(cmd, "delete", 6) == 0)
606 {
607 uschar *key = cmd + 6;
608 if (current < 0)
609 {
610 printf("No current database\n");
611 continue;
612 }
613 while (isspace((uschar)*key)) key++;
614 dbfn_delete(dbblock + current, key);
615 }
616
617 else if (Ustrncmp(cmd, "scan", 4) == 0)
618 {
619 EXIM_CURSOR *cursor;
620 BOOL startflag = TRUE;
621 uschar *key;
622 uschar keybuffer[256];
623 if (current < 0)
624 {
625 printf("No current database\n");
626 continue;
627 }
628 start = clock();
629 while ((key = dbfn_scan(dbblock + current, startflag, &cursor)) != NULL)
630 {
631 startflag = FALSE;
632 Ustrcpy(keybuffer, key);
633 dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock + current,
634 keybuffer, NULL);
635 printf("%s: %s\n", keybuffer, dbwait->text);
636 }
637 stop = clock();
638 printf("End of scan\n");
639 }
640
641 else if (Ustrncmp(cmd, "close", 5) == 0)
642 {
643 uschar *s = cmd + 5;
644 while (isspace((uschar)*s)) s++;
645 i = Uatoi(s);
646 if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n"); else
647 {
648 start = clock();
649 dbfn_close(dbblock + i);
650 stop = clock();
651 dbblock[i].dbptr = NULL;
652 if (i == current) current = -1;
653 }
654 }
655
656 else if (Ustrncmp(cmd, "file", 4) == 0)
657 {
658 uschar *s = cmd + 4;
659 while (isspace((uschar)*s)) s++;
660 i = Uatoi(s);
661 if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n");
662 else current = i;
663 }
664
665 else if (Ustrncmp(cmd, "time", 4) == 0)
666 {
667 showtime = ~showtime;
668 printf("Timing %s\n", showtime? "on" : "off");
669 }
670
671 else if (Ustrcmp(cmd, "q") == 0 || Ustrncmp(cmd, "quit", 4) == 0) break;
672
673 else if (Ustrncmp(cmd, "help", 4) == 0)
674 {
675 printf("close [<number>] close file [<number>]\n");
676 printf("delete <key> remove record from current file\n");
677 printf("file <number> make file <number> current\n");
678 printf("open <name> open db file\n");
679 printf("q[uit] exit program\n");
680 printf("read <key> read record from current file\n");
681 printf("scan scan current file\n");
682 printf("time time display on/off\n");
683 printf("write <key> <rest-of-line> write record to current file\n");
684 }
685
686 else printf("Eh?\n");
687
688 if (showtime && stop >= start)
689 printf("start=%d stop=%d difference=%d\n", (int)start, (int)stop,
690 (int)(stop - start));
691
692 printf("> ");
693 }
694
695 for (i = 0; i < max_db; i++)
696 {
697 if (dbblock[i].dbptr != NULL)
698 {
699 printf("\nClosing %d", i);
700 dbfn_close(dbblock + i);
701 }
702 }
703
704 printf("\n");
705 return 0;
706 }
707
708 #endif
709
710 /* End of dbfn.c */