6b2027aa9fefa2b561ce4aafa78e9a0124c4a726
[exim.git] / src / src / dbfn.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2024 */
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 */
9
10
11 #include "exim.h"
12
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> */
16 #define PATHLEN 256
17
18
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 inlinable functions from an included file.
24
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.
28
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
31 sequentially.
32
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.
39
40 API:
41   dbfn_open
42   dbfn_close
43   dbfn_read_with_length
44   dbfn_read_enforce_length
45   dbfn_write
46   dbfn_delete
47   dbfn_scan                             unused; ifdeffout out
48
49 Users:
50   ACL ratelimit & seen conditions
51   delivery retry handling
52   delivery serialization
53   TLS session resumption
54   peer capability cache
55   callout & quota cache
56 */
57
58
59
60 /*************************************************
61 *          Open and lock a database file         *
62 *************************************************/
63
64 /* Used for accessing Exim's hints databases.
65
66 Arguments:
67   name     The single-component name of one of Exim's database files.
68   flags    Either O_RDONLY or O_RDWR, indicating the type of open required;
69              O_RDWR implies "create if necessary"
70   dbblock  Points to an open_db block to be filled in.
71   lof      If TRUE, write to the log for actual open failures (locking failures
72            are always logged).
73   panic    If TRUE, panic on failure to create the db directory
74
75 Returns:   NULL if the open failed, or the locking failed. After locking
76            failures, errno is zero.
77
78            On success, dbblock is returned. This contains the dbm pointer and
79            the fd of the locked lock file.
80
81 There are some calls that use O_RDWR|O_CREAT for the flags. Having discovered
82 this in December 2005, I'm not sure if this is correct or not, but for the
83 moment I haven't changed them.
84 */
85
86 open_db *
87 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof, BOOL panic)
88 {
89 int rc, save_errno;
90 BOOL read_only = flags == O_RDONLY;
91 flock_t lock_data;
92 uschar dirname[PATHLEN], filename[PATHLEN];
93
94 DEBUG(D_hints_lookup) acl_level++;
95
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. */
108
109 snprintf(CS dirname, sizeof(dirname), "%s/db", spool_directory);
110 snprintf(CS filename, sizeof(filename), "%s/%s.lockfile", dirname, name);
111
112 priv_drop_temp(exim_uid, exim_gid);
113 if ((dbblock->lockfd = Uopen(filename, O_RDWR, EXIMDB_LOCKFILE_MODE)) < 0)
114   {
115   (void)directory_make(spool_directory, US"db", EXIMDB_DIRECTORY_MODE, panic);
116   dbblock->lockfd = Uopen(filename, O_RDWR|O_CREAT, EXIMDB_LOCKFILE_MODE);
117   }
118 priv_restore();
119
120 if (dbblock->lockfd < 0)
121   {
122   log_write(0, LOG_MAIN, "%s",
123     string_open_failed("database lock file %s", filename));
124   errno = 0;      /* Indicates locking failure */
125   DEBUG(D_hints_lookup) acl_level--;
126   return NULL;
127   }
128
129 /* Now we must get a lock on the opened lock file; do this with a blocking
130 lock that times out. */
131
132 lock_data.l_type = read_only? F_RDLCK : F_WRLCK;
133 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
134
135 DEBUG(D_hints_lookup|D_retry|D_route|D_deliver)
136   debug_printf_indent("locking %s\n", filename);
137
138 sigalrm_seen = FALSE;
139 ALARM(EXIMDB_LOCK_TIMEOUT);
140 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
141 ALARM_CLR(0);
142
143 if (sigalrm_seen) errno = ETIMEDOUT;
144 if (rc < 0)
145   {
146   log_write(0, LOG_MAIN|LOG_PANIC, "Failed to get %s lock for %s: %s",
147     read_only ? "read" : "write", filename,
148     errno == ETIMEDOUT ? "timed out" : strerror(errno));
149   (void)close(dbblock->lockfd);
150   errno = 0;       /* Indicates locking failure */
151   DEBUG(D_hints_lookup) acl_level--;
152   return NULL;
153   }
154
155 DEBUG(D_hints_lookup) debug_printf_indent("locked  %s\n", filename);
156
157 /* At this point we have an opened and locked separate lock file, that is,
158 exclusive access to the database, so we can go ahead and open it. If we are
159 expected to create it, don't do so at first, again so that we can detect
160 whether we need to change its ownership (see comments about the lock file
161 above.) There have been regular reports of crashes while opening hints
162 databases - often this is caused by non-matching db.h and the library. To make
163 it easy to pin this down, there are now debug statements on either side of the
164 open call. */
165
166 snprintf(CS filename, sizeof(filename), "%s/%s", dirname, name);
167
168 priv_drop_temp(exim_uid, exim_gid);
169 dbblock->dbptr = exim_dbopen(filename, dirname, flags, EXIMDB_MODE);
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   dbblock->dbptr = exim_dbopen(filename, dirname, flags|O_CREAT, EXIMDB_MODE);
175   }
176 save_errno = errno;
177 priv_restore();
178
179 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
180 log the event - also for debugging - but debug only if the file just doesn't
181 exist. */
182
183 if (!dbblock->dbptr)
184   {
185   errno = save_errno;
186   if (lof && save_errno != ENOENT)
187     log_write(0, LOG_MAIN, "%s", string_open_failed("DB file %s",
188         filename));
189   else
190     DEBUG(D_hints_lookup)
191       debug_printf_indent("%s\n", CS string_open_failed("DB file %s",
192           filename));
193   (void)close(dbblock->lockfd);
194   errno = save_errno;
195   DEBUG(D_hints_lookup) acl_level--;
196   return NULL;
197   }
198
199 DEBUG(D_hints_lookup)
200   debug_printf_indent("opened hints database %s: flags=%s\n", filename,
201     flags == O_RDONLY ? "O_RDONLY"
202     : flags == O_RDWR ? "O_RDWR"
203     : flags == (O_RDWR|O_CREAT) ? "O_RDWR|O_CREAT"
204     : "??");
205
206 /* Pass back the block containing the opened database handle and the open fd
207 for the lock. */
208
209 return dbblock;
210 }
211
212
213
214
215 /*************************************************
216 *         Unlock and close a database file       *
217 *************************************************/
218
219 /* Closing a file automatically unlocks it, so after closing the database, just
220 close the lock file.
221
222 Argument: a pointer to an open database block
223 Returns:  nothing
224 */
225
226 void
227 dbfn_close(open_db *dbblock)
228 {
229 exim_dbclose(dbblock->dbptr);
230 (void)close(dbblock->lockfd);
231 DEBUG(D_hints_lookup)
232   { debug_printf_indent("closed hints database and lockfile\n"); acl_level--; }
233 }
234
235
236
237
238 /*************************************************
239 *             Read from database file            *
240 *************************************************/
241
242 /* Passing back the pointer unchanged is useless, because there is
243 no guarantee of alignment. Since all the records used by Exim need
244 to be properly aligned to pick out the timestamps, etc., we might as
245 well do the copying centrally here.
246
247 Most calls don't need the length, so there is a macro called dbfn_read which
248 has two arguments; it calls this function adding NULL as the third.
249
250 Arguments:
251   dbblock   a pointer to an open database block
252   key       the key of the record to be read
253   length    a pointer to an int into which to return the length, if not NULL
254
255 Returns: a pointer to the retrieved record, or
256          NULL if the record is not found
257 */
258
259 void *
260 dbfn_read_with_length(open_db * dbblock, const uschar * key, int * length)
261 {
262 void * yield;
263 EXIM_DATUM key_datum, result_datum;
264 int klen = Ustrlen(key) + 1;
265 uschar * key_copy = store_get(klen, key);
266 unsigned dlen;
267
268 memcpy(key_copy, key, klen);
269
270 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_read: key=%s\n", key);
271
272 exim_datum_init(&key_datum);         /* Some DBM libraries require the datum */
273 exim_datum_init(&result_datum);      /* to be cleared before use. */
274 exim_datum_data_set(&key_datum, key_copy);
275 exim_datum_size_set(&key_datum, klen);
276
277 if (!exim_dbget(dbblock->dbptr, &key_datum, &result_datum))
278   {
279   DEBUG(D_hints_lookup) debug_printf_indent("dbfn_read: null return\n");
280   return NULL;
281   }
282
283 /* Assume the data store could have been tainted.  Properly, we should
284 store the taint status with the data. */
285
286 dlen = exim_datum_size_get(&result_datum);
287 yield = store_get(dlen, GET_TAINTED);
288 memcpy(yield, exim_datum_data_get(&result_datum), dlen);
289 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_read: size %u return\n", dlen);
290 if (length) *length = dlen;
291
292 exim_datum_free(&result_datum);    /* Some DBM libs require freeing */
293 return yield;
294 }
295
296
297 /* Read a record.  If the length is not as expected then delete it, write
298 an error log line, delete the record and return NULL.
299 Use this for fixed-size records (so not retry or wait records).
300
301 Arguments:
302   dbblock   a pointer to an open database block
303   key       the key of the record to be read
304   length    the expected record length
305
306 Returns: a pointer to the retrieved record, or
307          NULL if the record is not found/bad
308 */
309
310 void *
311 dbfn_read_enforce_length(open_db * dbblock, const uschar * key, size_t length)
312 {
313 int rlen;
314 void * yield = dbfn_read_with_length(dbblock, key, &rlen);
315
316 if (yield)
317   {
318   if (rlen == length) return yield;
319   log_write(0, LOG_MAIN|LOG_PANIC, "Bad db record size for '%s'", key);
320   dbfn_delete(dbblock, key);
321   }
322 return NULL;
323 }
324
325
326 /*************************************************
327 *             Write to database file             *
328 *************************************************/
329
330 /*
331 Arguments:
332   dbblock   a pointer to an open database block
333   key       the key of the record to be written
334   ptr       a pointer to the record to be written
335   length    the length of the record to be written
336
337 Returns:    the yield of the underlying dbm or db "write" function. If this
338             is dbm, the value is zero for OK.
339 */
340
341 int
342 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
343 {
344 EXIM_DATUM key_datum, value_datum;
345 dbdata_generic *gptr = (dbdata_generic *)ptr;
346 int klen = Ustrlen(key) + 1;
347 uschar * key_copy = store_get(klen, key);
348
349 memcpy(key_copy, key, klen);
350 gptr->time_stamp = time(NULL);
351
352 DEBUG(D_hints_lookup)
353   debug_printf_indent("dbfn_write: key=%s datalen %d\n", key, length);
354
355 exim_datum_init(&key_datum);         /* Some DBM libraries require the datum */
356 exim_datum_init(&value_datum);       /* to be cleared before use. */
357 exim_datum_data_set(&key_datum, key_copy);
358 exim_datum_size_set(&key_datum, klen);
359 exim_datum_data_set(&value_datum, ptr);
360 exim_datum_size_set(&value_datum, length);
361 return exim_dbput(dbblock->dbptr, &key_datum, &value_datum);
362 }
363
364
365
366 /*************************************************
367 *           Delete record from database file     *
368 *************************************************/
369
370 /*
371 Arguments:
372   dbblock    a pointer to an open database block
373   key        the key of the record to be deleted
374
375 Returns: the yield of the underlying dbm or db "delete" function.
376 */
377
378 int
379 dbfn_delete(open_db *dbblock, const uschar *key)
380 {
381 int klen = Ustrlen(key) + 1;
382 uschar * key_copy = store_get(klen, key);
383 EXIM_DATUM key_datum;
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_init(&key_datum);         /* Some DBM libraries require clearing */
389 exim_datum_data_set(&key_datum, key_copy);
390 exim_datum_size_set(&key_datum, klen);
391 return exim_dbdel(dbblock->dbptr, &key_datum);
392 }
393
394
395
396 #ifdef notdef
397 /* XXX This appears to be unused.  There's a separate implementation
398 in dbutils.c for dumpdb and fixdb, using the same underlying support.
399 */
400
401 /*************************************************
402 *         Scan the keys of a database file       *
403 *************************************************/
404
405 /*
406 Arguments:
407   dbblock  a pointer to an open database block
408   start    TRUE if starting a new scan
409            FALSE if continuing with the current scan
410   cursor   a pointer to a pointer to a cursor anchor, for those dbm libraries
411            that use the notion of a cursor
412
413 Returns:   the next record from the file, or
414            NULL if there are no more
415 */
416
417 uschar *
418 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
419 {
420 EXIM_DATUM key_datum, value_datum;
421 uschar *yield;
422
423 DEBUG(D_hints_lookup) debug_printf_indent("dbfn_scan\n");
424
425 /* Some dbm require an initialization */
426
427 if (start) *cursor = exim_dbcreate_cursor(dbblock->dbptr);
428
429 exim_datum_init(&key_datum);         /* Some DBM libraries require the datum */
430 exim_datum_init(&value_datum);       /* to be cleared before use. */
431
432 yield = exim_dbscan(dbblock->dbptr, &key_datum, &value_datum, start, *cursor)
433   ? US exim_datum_data_get(&key_datum) : NULL;
434
435 /* Some dbm require a termination */
436
437 if (!yield) exim_dbdelete_cursor(*cursor);
438 return yield;
439 }
440 #endif
441
442
443
444 /*************************************************
445 **************************************************
446 *             Stand-alone test program           *
447 **************************************************
448 *************************************************/
449
450 #ifdef STAND_ALONE
451
452 int
453 main(int argc, char **cargv)
454 {
455 open_db dbblock[8];
456 int max_db = sizeof(dbblock)/sizeof(open_db);
457 int current = -1;
458 int showtime = 0;
459 int i;
460 dbdata_wait *dbwait = NULL;
461 uschar **argv = USS cargv;
462 uschar buffer[256];
463 uschar structbuffer[1024];
464
465 if (argc != 2)
466   {
467   printf("Usage: test_dbfn directory\n");
468   printf("The subdirectory called \"db\" in the given directory is used for\n");
469   printf("the files used in this test program.\n");
470   return 1;
471   }
472
473 /* Initialize */
474
475 spool_directory = argv[1];
476 debug_selector = D_all - D_memory;
477 debug_file = stderr;
478 big_buffer = malloc(big_buffer_size);
479
480 for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
481
482 printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
483 printf("DBM library: ");
484
485 #ifdef DB_VERSION_STRING
486 printf("Berkeley DB: %s\n", DB_VERSION_STRING);
487 #elif defined(BTREEVERSION) && defined(HASHVERSION)
488   #ifdef USE_DB
489   printf("probably Berkeley DB version 1.8x (native mode)\n");
490   #else
491   printf("probably Berkeley DB version 1.8x (compatibility mode)\n");
492   #endif
493 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
494 printf("probably ndbm\n");
495 #elif defined(USE_TDB)
496 printf("using tdb\n");
497 #else
498   #ifdef USE_GDBM
499   printf("probably GDBM (native mode)\n");
500   #else
501   printf("probably GDBM (compatibility mode)\n");
502   #endif
503 #endif
504
505 /* Test the functions */
506
507 printf("\nTest the functions\n> ");
508
509 while (Ufgets(buffer, 256, stdin) != NULL)
510   {
511   int len = Ustrlen(buffer);
512   int count = 1;
513   clock_t start = 1;
514   clock_t stop = 0;
515   uschar *cmd = buffer;
516   while (len > 0 && isspace((uschar)buffer[len-1])) len--;
517   buffer[len] = 0;
518
519   if (isdigit((uschar)*cmd))
520     {
521     count = Uatoi(cmd);
522     while (isdigit((uschar)*cmd)) cmd++;
523     Uskip_whitespace(&cmd);
524     }
525
526   if (Ustrncmp(cmd, "open", 4) == 0)
527     {
528     int i;
529     open_db *odb;
530     uschar *s = cmd + 4;
531     Uskip_whitespace(&s);
532
533     for (i = 0; i < max_db; i++)
534       if (dbblock[i].dbptr == NULL) break;
535
536     if (i >= max_db)
537       {
538       printf("Too many open databases\n> ");
539       continue;
540       }
541
542     start = clock();
543     odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE, TRUE);
544     stop = clock();
545
546     if (odb)
547       {
548       current = i;
549       printf("opened %d\n", current);
550       }
551     /* Other error cases will have written messages */
552     else if (errno == ENOENT)
553       {
554       printf("open failed: %s%s\n", strerror(errno),
555         #ifdef USE_DB
556         " (or other Berkeley DB error)"
557         #else
558         ""
559         #endif
560         );
561       }
562     }
563
564   else if (Ustrncmp(cmd, "write", 5) == 0)
565     {
566     int rc = 0;
567     uschar * key = cmd + 5, * data;
568
569     if (current < 0)
570       {
571       printf("No current database\n");
572       continue;
573       }
574
575     Uskip_whitespace(&key);
576     data = key;
577     Uskip_nonwhite(&data);
578     *data++ = '\0';
579     Uskip_whitespace(&data);
580
581     dbwait = (dbdata_wait *)(&structbuffer);
582     Ustrcpy(dbwait->text, data);
583
584     start = clock();
585     while (count-- > 0)
586       rc = dbfn_write(dbblock + current, key, dbwait,
587         Ustrlen(data) + sizeof(dbdata_wait));
588     stop = clock();
589     if (rc != 0) printf("Failed: %s\n", strerror(errno));
590     }
591
592   else if (Ustrncmp(cmd, "read", 4) == 0)
593     {
594     uschar * key = cmd + 4;
595     if (current < 0)
596       {
597       printf("No current database\n");
598       continue;
599       }
600     Uskip_whitespace(&key);
601     start = clock();
602     while (count-- > 0)
603       dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock+ current, key, NULL);
604     stop = clock();
605     printf("%s\n", (dbwait == NULL)? "<not found>" : CS dbwait->text);
606     }
607
608   else if (Ustrncmp(cmd, "delete", 6) == 0)
609     {
610     uschar * key = cmd + 6;
611     if (current < 0)
612       {
613       printf("No current database\n");
614       continue;
615       }
616     Uskip_whitespace(&key);
617     dbfn_delete(dbblock + current, key);
618     }
619
620   else if (Ustrncmp(cmd, "scan", 4) == 0)
621     {
622     EXIM_CURSOR *cursor;
623     BOOL startflag = TRUE;
624     uschar *key;
625     uschar keybuffer[256];
626     if (current < 0)
627       {
628       printf("No current database\n");
629       continue;
630       }
631     start = clock();
632     while ((key = dbfn_scan(dbblock + current, startflag, &cursor)) != NULL)
633       {
634       startflag = FALSE;
635       Ustrcpy(keybuffer, key);
636       dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock + current,
637         keybuffer, NULL);
638       printf("%s: %s\n", keybuffer, dbwait->text);
639       }
640     stop = clock();
641     printf("End of scan\n");
642     }
643
644   else if (Ustrncmp(cmd, "close", 5) == 0)
645     {
646     uschar * s = cmd + 5;
647     Uskip_whitespace(&s);
648     i = Uatoi(s);
649     if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n"); else
650       {
651       start = clock();
652       dbfn_close(dbblock + i);
653       stop = clock();
654       dbblock[i].dbptr = NULL;
655       if (i == current) current = -1;
656       }
657     }
658
659   else if (Ustrncmp(cmd, "file", 4) == 0)
660     {
661     uschar * s = cmd + 4;
662     Uskip_whitespace(&s);
663     i = Uatoi(s);
664     if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n");
665       else current = i;
666     }
667
668   else if (Ustrncmp(cmd, "time", 4) == 0)
669     {
670     showtime = ~showtime;
671     printf("Timing %s\n", showtime? "on" : "off");
672     }
673
674   else if (Ustrcmp(cmd, "q") == 0 || Ustrncmp(cmd, "quit", 4) == 0) break;
675
676   else if (Ustrncmp(cmd, "help", 4) == 0)
677     {
678     printf("close  [<number>]              close file [<number>]\n");
679     printf("delete <key>                   remove record from current file\n");
680     printf("file   <number>                make file <number> current\n");
681     printf("open   <name>                  open db file\n");
682     printf("q[uit]                         exit program\n");
683     printf("read   <key>                   read record from current file\n");
684     printf("scan                           scan current file\n");
685     printf("time                           time display on/off\n");
686     printf("write  <key> <rest-of-line>    write record to current file\n");
687     }
688
689   else printf("Eh?\n");
690
691   if (showtime && stop >= start)
692     printf("start=%d stop=%d difference=%d\n", (int)start, (int)stop,
693      (int)(stop - start));
694
695   printf("> ");
696   }
697
698 for (i = 0; i < max_db; i++)
699   {
700   if (dbblock[i].dbptr != NULL)
701     {
702     printf("\nClosing %d", i);
703     dbfn_close(dbblock + i);
704     }
705   }
706
707 printf("\n");
708 return 0;
709 }
710
711 #endif
712
713 /* End of dbfn.c */
714 /* vi: aw ai sw=2
715 */