Panic-die if .include specifies a non-absolute path.
[users/jgh/exim.git] / src / src / dbfn.c
1 /* $Cambridge: exim/src/src/dbfn.c,v 1.8 2006/02/07 11:19:00 ph10 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2006 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10
11 #include "exim.h"
12
13
14 /* Functions for accessing Exim's hints database, which consists of a number of
15 different DBM files. This module does not contain code for reading DBM files
16 for (e.g.) alias expansion. That is all contained within the general search
17 functions. As Exim now has support for several DBM interfaces, all the relevant
18 functions are called as macros.
19
20 All the data in Exim's database is in the nature of *hints*. Therefore it
21 doesn't matter if it gets destroyed by accident. These functions are not
22 supposed to implement a "safe" database.
23
24 Keys are passed in as C strings, and the terminating zero *is* used when
25 building the dbm files. This just makes life easier when scanning the files
26 sequentially.
27
28 Synchronization is required on the database files, and this is achieved by
29 means of locking on independent lock files. (Earlier attempts to lock on the
30 DBM files themselves were never completely successful.) Since callers may in
31 general want to do more than one read or write while holding the lock, there
32 are separate open and close functions. However, the calling modules should
33 arrange to hold the locks for the bare minimum of time. */
34
35
36
37 /*************************************************
38 *         Berkeley DB error callback             *
39 *************************************************/
40
41 /* For Berkeley DB >= 2, we can define a function to be called in case of DB
42 errors. This should help with debugging strange DB problems, e.g. getting "File
43 exists" when you try to open a db file. The API for this function was changed
44 at DB release 4.3. */
45
46 #if defined(USE_DB) && defined(DB_VERSION_STRING)
47 void
48 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
49 dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
50 {
51 dbenv = dbenv;
52 #else
53 dbfn_bdb_error_callback(const char *pfx, char *msg)
54 {
55 #endif
56 pfx = pfx;
57 log_write(0, LOG_MAIN, "Berkeley DB error: %s", msg);
58 }
59 #endif
60
61
62
63
64 /*************************************************
65 *          Open and lock a database file         *
66 *************************************************/
67
68 /* Used for accessing Exim's hints databases.
69
70 Arguments:
71   name     The single-component name of one of Exim's database files.
72   flags    Either O_RDONLY or O_RDWR, indicating the type of open required;
73              O_RDWR implies "create if necessary"
74   dbblock  Points to an open_db block to be filled in.
75   lof      If TRUE, write to the log for actual open failures (locking failures
76            are always logged).
77
78 Returns:   NULL if the open failed, or the locking failed. After locking
79            failures, errno is zero.
80
81            On success, dbblock is returned. This contains the dbm pointer and
82            the fd of the locked lock file.
83
84 There are some calls that use O_RDWR|O_CREAT for the flags. Having discovered
85 this in December 2005, I'm not sure if this is correct or not, but for the
86 moment I haven't changed them.
87 */
88
89 open_db *
90 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof)
91 {
92 int rc, save_errno;
93 BOOL read_only = flags == O_RDONLY;
94 BOOL created = FALSE;
95 flock_t lock_data;
96 uschar buffer[256];
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 sprintf(CS buffer, "%s/db/%s.lockfile", spool_directory, name);
112
113 if ((dbblock->lockfd = Uopen(buffer, O_RDWR, EXIMDB_LOCKFILE_MODE)) < 0)
114   {
115   created = TRUE;
116   (void)directory_make(spool_directory, US"db", EXIMDB_DIRECTORY_MODE, TRUE);
117   dbblock->lockfd = Uopen(buffer, O_RDWR|O_CREAT, EXIMDB_LOCKFILE_MODE);
118   }
119
120 if (dbblock->lockfd < 0)
121   {
122   log_write(0, LOG_MAIN, "%s",
123     string_open_failed(errno, "database lock file %s", buffer));
124   errno = 0;      /* Indicates locking failure */
125   return NULL;
126   }
127
128 /* Now we must get a lock on the opened lock file; do this with a blocking
129 lock that times out. */
130
131 lock_data.l_type = read_only? F_RDLCK : F_WRLCK;
132 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
133
134 DEBUG(D_hints_lookup|D_retry|D_route|D_deliver)
135   debug_printf("locking %s\n", buffer);
136
137 sigalrm_seen = FALSE;
138 alarm(EXIMDB_LOCK_TIMEOUT);
139 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
140 alarm(0);
141
142 if (sigalrm_seen) errno = ETIMEDOUT;
143 if (rc < 0)
144   {
145   log_write(0, LOG_MAIN, "Failed to get %s lock for %s: %s",
146     ((flags & O_RDONLY) != 0)? "read" : "write", buffer,
147     (errno == ETIMEDOUT)? "timed out" : strerror(errno));
148   (void)close(dbblock->lockfd);
149   errno = 0;       /* Indicates locking failure */
150   return NULL;
151   }
152
153 DEBUG(D_hints_lookup) debug_printf("locked %s\n", buffer);
154
155 /* At this point we have an opened and locked separate lock file, that is,
156 exclusive access to the database, so we can go ahead and open it. If we are
157 expected to create it, don't do so at first, again so that we can detect
158 whether we need to change its ownership (see comments about the lock file
159 above.) There have been regular reports of crashes while opening hints
160 databases - often this is caused by non-matching db.h and the library. To make
161 it easy to pin this down, there are now debug statements on either side of the
162 open call. */
163
164 sprintf(CS buffer, "%s/db/%s", spool_directory, name);
165 DEBUG(D_hints_lookup) debug_printf("EXIM_DBOPEN(%s)\n", buffer);
166 EXIM_DBOPEN(buffer, flags, EXIMDB_MODE, &(dbblock->dbptr));
167 DEBUG(D_hints_lookup) debug_printf("returned from EXIM_DBOPEN\n");
168
169 if (dbblock->dbptr == NULL && errno == ENOENT && flags == O_RDWR)
170   {
171   DEBUG(D_hints_lookup)
172     debug_printf("%s appears not to exist: trying to create\n", buffer);
173   created = TRUE;
174   EXIM_DBOPEN(buffer, flags|O_CREAT, EXIMDB_MODE, &(dbblock->dbptr));
175   DEBUG(D_hints_lookup) debug_printf("returned from EXIM_DBOPEN\n");
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(buffer, '/') + 1;
199   int namelen = Ustrlen(name);
200
201   *lastname = 0;
202   dd = opendir(CS buffer);
203
204   while ((ent = readdir(dd)) != NULL)
205     {
206     if (Ustrncmp(ent->d_name, name, namelen) == 0)
207       {
208       struct stat statbuf;
209       Ustrcpy(lastname, ent->d_name);
210       if (Ustat(buffer, &statbuf) >= 0 && statbuf.st_uid != exim_uid)
211         {
212         DEBUG(D_hints_lookup) debug_printf("ensuring %s is owned by exim\n", buffer);
213         (void)Uchown(buffer, exim_uid, exim_gid);
214         }
215       }
216     }
217
218   closedir(dd);
219   }
220
221 /* If the open has failed, return NULL, leaving errno set. If lof is TRUE,
222 log the event - also for debugging - but not if the file just doesn't exist. */
223
224 if (dbblock->dbptr == NULL)
225   {
226   if (save_errno != ENOENT)
227     {
228     if (lof)
229       log_write(0, LOG_MAIN, "%s", string_open_failed(save_errno, "DB file %s",
230         buffer));
231     else
232       DEBUG(D_hints_lookup)
233         debug_printf("%s", CS string_open_failed(save_errno, "DB file %s\n",
234           buffer));
235     }
236   (void)close(dbblock->lockfd);
237   errno = save_errno;
238   return NULL;
239   }
240
241 DEBUG(D_hints_lookup)
242   debug_printf("opened hints database %s: flags=%s\n", buffer,
243     (flags == O_RDONLY)? "O_RDONLY" : (flags == O_RDWR)? "O_RDWR" :
244     (flags == (O_RDWR|O_CREAT))? "O_RDWR|O_CREAT" : "??");
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 }
272
273
274
275
276 /*************************************************
277 *             Read from database file            *
278 *************************************************/
279
280 /* Passing back the pointer unchanged is useless, because there is
281 no guarantee of alignment. Since all the records used by Exim need
282 to be properly aligned to pick out the timestamps, etc., we might as
283 well do the copying centrally here.
284
285 Most calls don't need the length, so there is a macro called dbfn_read which
286 has two arguments; it calls this function adding NULL as the third.
287
288 Arguments:
289   dbblock   a pointer to an open database block
290   key       the key of the record to be read
291   length    a pointer to an int into which to return the length, if not NULL
292
293 Returns: a pointer to the retrieved record, or
294          NULL if the record is not found
295 */
296
297 void *
298 dbfn_read_with_length(open_db *dbblock, uschar *key, int *length)
299 {
300 void *yield;
301 EXIM_DATUM key_datum, result_datum;
302
303 DEBUG(D_hints_lookup) debug_printf("dbfn_read: key=%s\n", key);
304
305 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
306 EXIM_DATUM_INIT(result_datum);      /* to be cleared before use. */
307 EXIM_DATUM_DATA(key_datum) = CS key;
308 EXIM_DATUM_SIZE(key_datum) = Ustrlen(key) + 1;
309
310 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
311
312 yield = store_get(EXIM_DATUM_SIZE(result_datum));
313 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
314 if (length != NULL) *length = EXIM_DATUM_SIZE(result_datum);
315
316 EXIM_DATUM_FREE(result_datum);    /* Some DBM libs require freeing */
317 return yield;
318 }
319
320
321
322 /*************************************************
323 *             Write to database file             *
324 *************************************************/
325
326 /*
327 Arguments:
328   dbblock   a pointer to an open database block
329   key       the key of the record to be written
330   ptr       a pointer to the record to be written
331   length    the length of the record to be written
332
333 Returns:    the yield of the underlying dbm or db "write" function. If this
334             is dbm, the value is zero for OK.
335 */
336
337 int
338 dbfn_write(open_db *dbblock, uschar *key, void *ptr, int length)
339 {
340 EXIM_DATUM key_datum, value_datum;
341 dbdata_generic *gptr = (dbdata_generic *)ptr;
342 gptr->time_stamp = time(NULL);
343
344 DEBUG(D_hints_lookup) debug_printf("dbfn_write: key=%s\n", key);
345
346 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
347 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
348 EXIM_DATUM_DATA(key_datum) = CS key;
349 EXIM_DATUM_SIZE(key_datum) = Ustrlen(key) + 1;
350 EXIM_DATUM_DATA(value_datum) = CS ptr;
351 EXIM_DATUM_SIZE(value_datum) = length;
352 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
353 }
354
355
356
357 /*************************************************
358 *           Delete record from database file     *
359 *************************************************/
360
361 /*
362 Arguments:
363   dbblock    a pointer to an open database block
364   key        the key of the record to be deleted
365
366 Returns: the yield of the underlying dbm or db "delete" function.
367 */
368
369 int
370 dbfn_delete(open_db *dbblock, uschar *key)
371 {
372 EXIM_DATUM key_datum;
373 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require clearing */
374 EXIM_DATUM_DATA(key_datum) = CS key;
375 EXIM_DATUM_SIZE(key_datum) = Ustrlen(key) + 1;
376 return EXIM_DBDEL(dbblock->dbptr, key_datum);
377 }
378
379
380
381 /*************************************************
382 *         Scan the keys of a database file       *
383 *************************************************/
384
385 /*
386 Arguments:
387   dbblock  a pointer to an open database block
388   start    TRUE if starting a new scan
389            FALSE if continuing with the current scan
390   cursor   a pointer to a pointer to a cursor anchor, for those dbm libraries
391            that use the notion of a cursor
392
393 Returns:   the next record from the file, or
394            NULL if there are no more
395 */
396
397 uschar *
398 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
399 {
400 EXIM_DATUM key_datum, value_datum;
401 uschar *yield;
402 value_datum = value_datum;    /* dummy; not all db libraries use this */
403
404 /* Some dbm require an initialization */
405
406 if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
407
408 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
409 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
410
411 yield = (EXIM_DBSCAN(dbblock->dbptr, key_datum, value_datum, start, *cursor))?
412   US EXIM_DATUM_DATA(key_datum) : NULL;
413
414 /* Some dbm require a termination */
415
416 if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
417 return yield;
418 }
419
420
421
422 /*************************************************
423 **************************************************
424 *             Stand-alone test program           *
425 **************************************************
426 *************************************************/
427
428 #ifdef STAND_ALONE
429
430 int
431 main(int argc, char **cargv)
432 {
433 open_db dbblock[8];
434 int max_db = sizeof(dbblock)/sizeof(open_db);
435 int current = -1;
436 int showtime = 0;
437 int i;
438 dbdata_wait *dbwait = NULL;
439 uschar **argv = USS cargv;
440 uschar buffer[256];
441 uschar structbuffer[1024];
442
443 if (argc != 2)
444   {
445   printf("Usage: test_dbfn directory\n");
446   printf("The subdirectory called \"db\" in the given directory is used for\n");
447   printf("the files used in this test program.\n");
448   return 1;
449   }
450
451 /* Initialize */
452
453 spool_directory = argv[1];
454 debug_selector = D_all - D_memory;
455 debug_file = stderr;
456 big_buffer = malloc(big_buffer_size);
457
458 for (i = 0; i < max_db; i++) dbblock[i].dbptr = NULL;
459
460 printf("\nExim's db functions tester: interface type is %s\n", EXIM_DBTYPE);
461 printf("DBM library: ");
462
463 #ifdef DB_VERSION_STRING
464 printf("Berkeley DB: %s\n", DB_VERSION_STRING);
465 #elif defined(BTREEVERSION) && defined(HASHVERSION)
466   #ifdef USE_DB
467   printf("probably Berkeley DB version 1.8x (native mode)\n");
468   #else
469   printf("probably Berkeley DB version 1.8x (compatibility mode)\n");
470   #endif
471 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
472 printf("probably ndbm\n");
473 #elif defined(USE_TDB)
474 printf("using tdb\n");
475 #else
476   #ifdef USE_GDBM
477   printf("probably GDBM (native mode)\n");
478   #else
479   printf("probably GDBM (compatibility mode)\n");
480   #endif
481 #endif
482
483 /* Test the functions */
484
485 printf("\nTest the functions\n> ");
486
487 while (Ufgets(buffer, 256, stdin) != NULL)
488   {
489   int len = Ustrlen(buffer);
490   int count = 1;
491   clock_t start = 1;
492   clock_t stop = 0;
493   uschar *cmd = buffer;
494   while (len > 0 && isspace((uschar)buffer[len-1])) len--;
495   buffer[len] = 0;
496
497   if (isdigit((uschar)*cmd))
498     {
499     count = Uatoi(cmd);
500     while (isdigit((uschar)*cmd)) cmd++;
501     while (isspace((uschar)*cmd)) cmd++;
502     }
503
504   if (Ustrncmp(cmd, "open", 4) == 0)
505     {
506     int i;
507     open_db *odb;
508     uschar *s = cmd + 4;
509     while (isspace((uschar)*s)) s++;
510
511     for (i = 0; i < max_db; i++)
512       if (dbblock[i].dbptr == NULL) break;
513
514     if (i >= max_db)
515       {
516       printf("Too many open databases\n> ");
517       continue;
518       }
519
520     start = clock();
521     odb = dbfn_open(s, O_RDWR, dbblock + i, TRUE);
522     stop = clock();
523
524     if (odb != NULL)
525       {
526       current = i;
527       printf("opened %d\n", current);
528       }
529     /* Other error cases will have written messages */
530     else if (errno == ENOENT)
531       {
532       printf("open failed: %s%s\n", strerror(errno),
533         #ifdef USE_DB
534         " (or other Berkeley DB error)"
535         #else
536         ""
537         #endif
538         );
539       }
540     }
541
542   else if (Ustrncmp(cmd, "write", 5) == 0)
543     {
544     int rc = 0;
545     uschar *key = cmd + 5;
546     uschar *data;
547
548     if (current < 0)
549       {
550       printf("No current database\n");
551       continue;
552       }
553
554     while (isspace((uschar)*key)) key++;
555     data = key;
556     while (*data != 0 && !isspace((uschar)*data)) data++;
557     *data++ = 0;
558     while (isspace((uschar)*data)) data++;
559
560     dbwait = (dbdata_wait *)(&structbuffer);
561     Ustrcpy(dbwait->text, data);
562
563     start = clock();
564     while (count-- > 0)
565       rc = dbfn_write(dbblock + current, key, dbwait,
566         Ustrlen(data) + sizeof(dbdata_wait));
567     stop = clock();
568     if (rc != 0) printf("Failed: %s\n", strerror(errno));
569     }
570
571   else if (Ustrncmp(cmd, "read", 4) == 0)
572     {
573     uschar *key = cmd + 4;
574     if (current < 0)
575       {
576       printf("No current database\n");
577       continue;
578       }
579     while (isspace((uschar)*key)) key++;
580     start = clock();
581     while (count-- > 0)
582       dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock+ current, key, NULL);
583     stop = clock();
584     printf("%s\n", (dbwait == NULL)? "<not found>" : CS dbwait->text);
585     }
586
587   else if (Ustrncmp(cmd, "delete", 6) == 0)
588     {
589     uschar *key = cmd + 6;
590     if (current < 0)
591       {
592       printf("No current database\n");
593       continue;
594       }
595     while (isspace((uschar)*key)) key++;
596     dbfn_delete(dbblock + current, key);
597     }
598
599   else if (Ustrncmp(cmd, "scan", 4) == 0)
600     {
601     EXIM_CURSOR *cursor;
602     BOOL startflag = TRUE;
603     uschar *key;
604     uschar keybuffer[256];
605     if (current < 0)
606       {
607       printf("No current database\n");
608       continue;
609       }
610     start = clock();
611     while ((key = dbfn_scan(dbblock + current, startflag, &cursor)) != NULL)
612       {
613       startflag = FALSE;
614       Ustrcpy(keybuffer, key);
615       dbwait = (dbdata_wait *)dbfn_read_with_length(dbblock + current,
616         keybuffer, NULL);
617       printf("%s: %s\n", keybuffer, dbwait->text);
618       }
619     stop = clock();
620     printf("End of scan\n");
621     }
622
623   else if (Ustrncmp(cmd, "close", 5) == 0)
624     {
625     uschar *s = cmd + 5;
626     while (isspace((uschar)*s)) s++;
627     i = Uatoi(s);
628     if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n"); else
629       {
630       start = clock();
631       dbfn_close(dbblock + i);
632       stop = clock();
633       dbblock[i].dbptr = NULL;
634       if (i == current) current = -1;
635       }
636     }
637
638   else if (Ustrncmp(cmd, "file", 4) == 0)
639     {
640     uschar *s = cmd + 4;
641     while (isspace((uschar)*s)) s++;
642     i = Uatoi(s);
643     if (i >= max_db || dbblock[i].dbptr == NULL) printf("Not open\n");
644       else current = i;
645     }
646
647   else if (Ustrncmp(cmd, "time", 4) == 0)
648     {
649     showtime = ~showtime;
650     printf("Timing %s\n", showtime? "on" : "off");
651     }
652
653   else if (Ustrcmp(cmd, "q") == 0 || Ustrncmp(cmd, "quit", 4) == 0) break;
654
655   else if (Ustrncmp(cmd, "help", 4) == 0)
656     {
657     printf("close  [<number>]              close file [<number>]\n");
658     printf("delete <key>                   remove record from current file\n");
659     printf("file   <number>                make file <number> current\n");
660     printf("open   <name>                  open db file\n");
661     printf("q[uit]                         exit program\n");
662     printf("read   <key>                   read record from current file\n");
663     printf("scan                           scan current file\n");
664     printf("time                           time display on/off\n");
665     printf("write  <key> <rest-of-line>    write record to current file\n");
666     }
667
668   else printf("Eh?\n");
669
670   if (showtime && stop >= start)
671     printf("start=%d stop=%d difference=%d\n", (int)start, (int)stop,
672      (int)(stop - start));
673
674   printf("> ");
675   }
676
677 for (i = 0; i < max_db; i++)
678   {
679   if (dbblock[i].dbptr != NULL)
680     {
681     printf("\nClosing %d", i);
682     dbfn_close(dbblock + i);
683     }
684   }
685
686 printf("\n");
687 return 0;
688 }
689
690 #endif
691
692 /* End of dbfn.c */