45b778fc0aacc8039efa97b3ec22fcad392ff64f
[exim.git] / src / src / exim_dbutil.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9
10 /* This single source file is used to compile three utility programs for
11 maintaining Exim hints databases.
12
13   exim_dumpdb     dumps out the contents
14   exim_fixdb      patches the database (really for Exim maintenance/testing)
15   exim_tidydb     removed obsolete data
16
17 In all cases, the first argument is the name of the spool directory. The second
18 argument is the name of the database file. The available names are:
19
20   retry:      retry delivery information
21   misc:       miscellaneous hints data
22   wait-<t>:   message waiting information; <t> is a transport name
23   callout:    callout verification cache
24   ratelimit:  ACL 'ratelimit' condition
25   tls:        TLS session resumption cache
26   seen:       ACL 'seen' condition
27
28 There are a number of common subroutines, followed by three main programs,
29 whose inclusion is controlled by -D on the compilation command. */
30
31
32 #include "exim.h"
33
34
35 /* Identifiers for the different database types. */
36
37 #define type_retry     1
38 #define type_wait      2
39 #define type_misc      3
40 #define type_callout   4
41 #define type_ratelimit 5
42 #define type_tls       6
43 #define type_seen      7
44
45
46 /* This is used by our cut-down dbfn_open(). */
47
48 uschar *spool_directory;
49
50
51 /******************************************************************************/
52       /* dummies needed by Solaris build */
53 void
54 millisleep(int msec)
55 {}
56 uschar *
57 readconf_printtime(int t)
58 { return NULL; }
59 gstring *
60 string_vformat_trc(gstring * g, const uschar * func, unsigned line,
61   unsigned size_limit, unsigned flags, const char *format, va_list ap)
62 { return NULL; }
63 uschar *
64 string_sprintf_trc(const char * fmt, const uschar * func, unsigned line, ...)
65 { return NULL; }
66 BOOL
67 string_format_trc(uschar * buf, int len, const uschar * func, unsigned line,
68   const char * fmt, ...)
69 { return FALSE; }
70
71 struct global_flags     f;
72 unsigned int            log_selector[1];
73 uschar *                queue_name;
74 BOOL                    split_spool_directory;
75
76
77 /* These introduced by the taintwarn handling */
78 #ifdef ALLOW_INSECURE_TAINTED_DATA
79 BOOL    allow_insecure_tainted_data;
80 #endif
81
82 /******************************************************************************/
83
84
85 /*************************************************
86 *         Berkeley DB error callback             *
87 *************************************************/
88
89 /* For Berkeley DB >= 2, we can define a function to be called in case of DB
90 errors. This should help with debugging strange DB problems, e.g. getting "File
91 exists" when you try to open a db file. The API changed at release 4.3. */
92
93 #if defined(USE_DB) && defined(DB_VERSION_STRING)
94 void
95 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
96 dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
97 {
98 dbenv = dbenv;
99 #else
100 dbfn_bdb_error_callback(const char *pfx, char *msg)
101 {
102 #endif
103 pfx = pfx;
104 printf("Berkeley DB error: %s\n", msg);
105 }
106 #endif
107
108
109
110 /*************************************************
111 *              SIGALRM handler                   *
112 *************************************************/
113
114 SIGNAL_BOOL sigalrm_seen;
115
116 void
117 sigalrm_handler(int sig)
118 {
119 sigalrm_seen = 1;
120 }
121
122
123
124 /*************************************************
125 *        Output usage message and exit           *
126 *************************************************/
127
128 static void
129 usage(uschar *name, uschar *options)
130 {
131 printf("Usage: exim_%s%s  <spool-directory> <database-name>\n", name, options);
132 printf("  <database-name> = retry | misc | wait-<transport-name> | callout | ratelimit | tls | seen\n");
133 exit(1);
134 }
135
136
137
138 /*************************************************
139 *           Sort out the command arguments       *
140 *************************************************/
141
142 /* This function checks that there are exactly 2 arguments, and checks the
143 second of them to be sure it is a known database name. */
144
145 static int
146 check_args(int argc, uschar **argv, uschar *name, uschar *options)
147 {
148 if (argc == 3)
149   {
150   if (Ustrcmp(argv[2], "retry") == 0) return type_retry;
151   if (Ustrcmp(argv[2], "misc") == 0) return type_misc;
152   if (Ustrncmp(argv[2], "wait-", 5) == 0) return type_wait;
153   if (Ustrcmp(argv[2], "callout") == 0) return type_callout;
154   if (Ustrcmp(argv[2], "ratelimit") == 0) return type_ratelimit;
155   if (Ustrcmp(argv[2], "tls") == 0) return type_tls;
156   if (Ustrcmp(argv[2], "seen") == 0) return type_seen;
157   }
158 usage(name, options);
159 return -1;              /* Never obeyed */
160 }
161
162
163
164 /*************************************************
165 *         Handle attempts to write the log       *
166 *************************************************/
167
168 /* The message gets written to stderr when log_write() is called from a
169 utility. The message always gets '\n' added on the end of it. These calls come
170 from modules such as store.c when things go drastically wrong (e.g. malloc()
171 failing). In normal use they won't get obeyed.
172
173 Arguments:
174   selector  not relevant when running a utility
175   flags     not relevant when running a utility
176   format    a printf() format
177   ...       arguments for format
178
179 Returns:    nothing
180 */
181
182 void
183 log_write(unsigned int selector, int flags, const char *format, ...)
184 {
185 va_list ap;
186 va_start(ap, format);
187 vfprintf(stderr, format, ap);
188 fprintf(stderr, "\n");
189 va_end(ap);
190 }
191
192
193
194 /*************************************************
195 *        Format a time value for printing        *
196 *************************************************/
197
198 static uschar time_buffer[sizeof("09-xxx-1999 hh:mm:ss  ")];
199
200 uschar *
201 print_time(time_t t)
202 {
203 struct tm *tmstr = localtime(&t);
204 Ustrftime(time_buffer, sizeof(time_buffer), "%d-%b-%Y %H:%M:%S", tmstr);
205 return time_buffer;
206 }
207
208
209
210 /*************************************************
211 *        Format a cache value for printing       *
212 *************************************************/
213
214 uschar *
215 print_cache(int value)
216 {
217 return (value == ccache_accept)? US"accept" :
218        (value == ccache_reject)? US"reject" :
219        US"unknown";
220 }
221
222
223 #ifdef EXIM_FIXDB
224 /*************************************************
225 *                Read time value                 *
226 *************************************************/
227
228 static time_t
229 read_time(uschar *s)
230 {
231 int field = 0;
232 int value;
233 time_t now = time(NULL);
234 struct tm *tm = localtime(&now);
235
236 tm->tm_sec = 0;
237 tm->tm_isdst = -1;
238
239 for (uschar * t = s + Ustrlen(s) - 1; t >= s; t--)
240   {
241   if (*t == ':') continue;
242   if (!isdigit((uschar)*t)) return -1;
243
244   value = *t - '0';
245   if (--t >= s)
246     {
247     if (!isdigit((uschar)*t)) return -1;
248     value = value + (*t - '0')*10;
249     }
250
251   switch (field++)
252     {
253     case 0: tm->tm_min = value; break;
254     case 1: tm->tm_hour = value; break;
255     case 2: tm->tm_mday = value; break;
256     case 3: tm->tm_mon = value - 1; break;
257     case 4: tm->tm_year = (value < 90)? value + 100 : value; break;
258     default: return -1;
259     }
260   }
261
262 return mktime(tm);
263 }
264 #endif  /* EXIM_FIXDB */
265
266
267
268 /*************************************************
269 *       Open and lock a database file            *
270 *************************************************/
271
272 /* This is a cut-down version from the function in dbfn.h that Exim itself
273 uses. We assume the database exists, and therefore give up if we cannot open
274 the lock file.
275
276 Arguments:
277   name     The single-component name of one of Exim's database files.
278   flags    O_RDONLY or O_RDWR
279   dbblock  Points to an open_db block to be filled in.
280   lof      Unused.
281   panic    Unused
282
283 Returns:   NULL if the open failed, or the locking failed.
284            On success, dbblock is returned. This contains the dbm pointer and
285            the fd of the locked lock file.
286 */
287
288 open_db *
289 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof, BOOL panic)
290 {
291 int rc;
292 struct flock lock_data;
293 BOOL read_only = flags == O_RDONLY;
294 uschar * dirname, * filename;
295
296 /* The first thing to do is to open a separate file on which to lock. This
297 ensures that Exim has exclusive use of the database before it even tries to
298 open it. If there is a database, there should be a lock file in existence. */
299
300 #ifdef COMPILE_UTILITY
301 if (  asprintf(CSS &dirname, "%s/db", spool_directory) < 0
302    || asprintf(CSS &filename, "%s/%s.lockfile", dirname, name) < 0)
303   return NULL;
304 #else
305 dirname = string_sprintf("%s/db", spool_directory);
306 filename = string_sprintf("%s/%s.lockfile", dirname, name);
307 #endif
308
309 dbblock->lockfd = Uopen(filename, flags, 0);
310 if (dbblock->lockfd < 0)
311   {
312   printf("** Failed to open database lock file %s: %s\n", filename,
313     strerror(errno));
314   return NULL;
315   }
316
317 /* Now we must get a lock on the opened lock file; do this with a blocking
318 lock that times out. */
319
320 lock_data.l_type = read_only ? F_RDLCK : F_WRLCK;
321 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
322
323 sigalrm_seen = FALSE;
324 os_non_restarting_signal(SIGALRM, sigalrm_handler);
325 ALARM(EXIMDB_LOCK_TIMEOUT);
326 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
327 ALARM_CLR(0);
328
329 if (sigalrm_seen) errno = ETIMEDOUT;
330 if (rc < 0)
331   {
332   printf("** Failed to get %s lock for %s: %s",
333     flags & O_WRONLY ? "write" : "read",
334     filename,
335     errno == ETIMEDOUT ? "timed out" : strerror(errno));
336   (void)close(dbblock->lockfd);
337   return NULL;
338   }
339
340 /* At this point we have an opened and locked separate lock file, that is,
341 exclusive access to the database, so we can go ahead and open it. */
342
343 #ifdef COMPILE_UTILITY
344 if (asprintf(CSS &filename, "%s/%s", dirname, name) < 0) return NULL;
345 #else
346 filename = string_sprintf("%s/%s", dirname, name);
347 #endif
348 EXIM_DBOPEN(filename, dirname, flags, 0, &dbblock->dbptr);
349
350 if (!dbblock->dbptr)
351   {
352   printf("** Failed to open DBM file %s for %s:\n   %s%s\n", filename,
353     read_only? "reading" : "writing", strerror(errno),
354     #ifdef USE_DB
355     " (or Berkeley DB error while opening)"
356     #else
357     ""
358     #endif
359     );
360   (void)close(dbblock->lockfd);
361   return NULL;
362   }
363
364 return dbblock;
365 }
366
367
368
369
370 /*************************************************
371 *         Unlock and close a database file       *
372 *************************************************/
373
374 /* Closing a file automatically unlocks it, so after closing the database, just
375 close the lock file.
376
377 Argument: a pointer to an open database block
378 Returns:  nothing
379 */
380
381 void
382 dbfn_close(open_db *dbblock)
383 {
384 EXIM_DBCLOSE(dbblock->dbptr);
385 (void)close(dbblock->lockfd);
386 }
387
388
389
390
391 /*************************************************
392 *             Read from database file            *
393 *************************************************/
394
395 /* Passing back the pointer unchanged is useless, because there is no guarantee
396 of alignment. Since all the records used by Exim need to be properly aligned to
397 pick out the timestamps, etc., do the copying centrally here.
398
399 Arguments:
400   dbblock   a pointer to an open database block
401   key       the key of the record to be read
402   length    where to put the length (or NULL if length not wanted). Includes overhead.
403
404 Returns: a pointer to the retrieved record, or
405          NULL if the record is not found
406 */
407
408 void *
409 dbfn_read_with_length(open_db *dbblock, const uschar *key, int *length)
410 {
411 void *yield;
412 EXIM_DATUM key_datum, result_datum;
413 int klen = Ustrlen(key) + 1;
414 uschar * key_copy = store_get(klen, is_tainted(key));
415
416 memcpy(key_copy, key, klen);
417
418 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
419 EXIM_DATUM_INIT(result_datum);      /* to be cleared before use. */
420 EXIM_DATUM_DATA(key_datum) = CS key_copy;
421 EXIM_DATUM_SIZE(key_datum) = klen;
422
423 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
424
425 /* Assume for now that anything stored could have been tainted. Properly
426 we should store the taint status along with the data. */
427
428 yield = store_get(EXIM_DATUM_SIZE(result_datum), TRUE);
429 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
430 if (length) *length = EXIM_DATUM_SIZE(result_datum);
431
432 EXIM_DATUM_FREE(result_datum);    /* Some DBM libs require freeing */
433 return yield;
434 }
435
436
437
438 #if defined(EXIM_TIDYDB) || defined(EXIM_FIXDB)
439
440 /*************************************************
441 *             Write to database file             *
442 *************************************************/
443
444 /*
445 Arguments:
446   dbblock   a pointer to an open database block
447   key       the key of the record to be written
448   ptr       a pointer to the record to be written
449   length    the length of the record to be written
450
451 Returns:    the yield of the underlying dbm or db "write" function. If this
452             is dbm, the value is zero for OK.
453 */
454
455 int
456 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
457 {
458 EXIM_DATUM key_datum, value_datum;
459 dbdata_generic *gptr = (dbdata_generic *)ptr;
460 int klen = Ustrlen(key) + 1;
461 uschar * key_copy = store_get(klen, is_tainted(key));
462
463 memcpy(key_copy, key, klen);
464 gptr->time_stamp = time(NULL);
465
466 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
467 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
468 EXIM_DATUM_DATA(key_datum) = CS key_copy;
469 EXIM_DATUM_SIZE(key_datum) = klen;
470 EXIM_DATUM_DATA(value_datum) = CS ptr;
471 EXIM_DATUM_SIZE(value_datum) = length;
472 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
473 }
474
475
476
477 /*************************************************
478 *           Delete record from database file     *
479 *************************************************/
480
481 /*
482 Arguments:
483   dbblock    a pointer to an open database block
484   key        the key of the record to be deleted
485
486 Returns: the yield of the underlying dbm or db "delete" function.
487 */
488
489 int
490 dbfn_delete(open_db *dbblock, const uschar *key)
491 {
492 int klen = Ustrlen(key) + 1;
493 uschar * key_copy = store_get(klen, is_tainted(key));
494
495 memcpy(key_copy, key, klen);
496 EXIM_DATUM key_datum;
497 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require clearing */
498 EXIM_DATUM_DATA(key_datum) = CS key_copy;
499 EXIM_DATUM_SIZE(key_datum) = klen;
500 return EXIM_DBDEL(dbblock->dbptr, key_datum);
501 }
502
503 #endif  /* EXIM_TIDYDB || EXIM_FIXDB */
504
505
506
507 #if defined(EXIM_DUMPDB) || defined(EXIM_TIDYDB)
508 /*************************************************
509 *         Scan the keys of a database file       *
510 *************************************************/
511
512 /*
513 Arguments:
514   dbblock  a pointer to an open database block
515   start    TRUE if starting a new scan
516            FALSE if continuing with the current scan
517   cursor   a pointer to a pointer to a cursor anchor, for those dbm libraries
518            that use the notion of a cursor
519
520 Returns:   the next record from the file, or
521            NULL if there are no more
522 */
523
524 uschar *
525 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
526 {
527 EXIM_DATUM key_datum, value_datum;
528 uschar *yield;
529
530 /* Some dbm require an initialization */
531
532 if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
533
534 EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
535 EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
536
537 yield = (EXIM_DBSCAN(dbblock->dbptr, key_datum, value_datum, start, *cursor))?
538   US EXIM_DATUM_DATA(key_datum) : NULL;
539
540 /* Some dbm require a termination */
541
542 if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
543 return yield;
544 }
545 #endif  /* EXIM_DUMPDB || EXIM_TIDYDB */
546
547
548
549 #ifdef EXIM_DUMPDB
550 /*************************************************
551 *           The exim_dumpdb main program         *
552 *************************************************/
553
554 int
555 main(int argc, char **cargv)
556 {
557 int dbdata_type = 0;
558 int yield = 0;
559 open_db dbblock;
560 open_db *dbm;
561 EXIM_CURSOR *cursor;
562 uschar **argv = USS cargv;
563 uschar keybuffer[1024];
564
565 store_init();
566
567 /* Check the arguments, and open the database */
568
569 dbdata_type = check_args(argc, argv, US"dumpdb", US"");
570 spool_directory = argv[1];
571 if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
572   exit(1);
573
574 /* Scan the file, formatting the information for each entry. Note
575 that data is returned in a malloc'ed block, in order that it be
576 correctly aligned. */
577
578 for (uschar * key = dbfn_scan(dbm, TRUE, &cursor);
579      key;
580      key = dbfn_scan(dbm, FALSE, &cursor))
581   {
582   dbdata_retry *retry;
583   dbdata_wait *wait;
584   dbdata_callout_cache *callout;
585   dbdata_ratelimit *ratelimit;
586   dbdata_ratelimit_unique *rate_unique;
587   dbdata_tls_session *session;
588   dbdata_seen *seen;
589   int count_bad = 0;
590   int length;
591   uschar *t;
592   uschar name[MESSAGE_ID_LENGTH + 1];
593   void *value;
594   rmark reset_point = store_mark();
595
596   /* Keep a copy of the key separate, as in some DBM's the pointer is into data
597   which might change. */
598
599   if (Ustrlen(key) > sizeof(keybuffer) - 1)
600     {
601     printf("**** Overlong key encountered: %s\n", key);
602     return 1;
603     }
604   Ustrcpy(keybuffer, key);
605
606   if (!(value = dbfn_read_with_length(dbm, keybuffer, &length)))
607     fprintf(stderr, "**** Entry \"%s\" was in the key scan, but the record "
608                     "was not found in the file - something is wrong!\n",
609       CS keybuffer);
610   else
611     {
612     /* Note: don't use print_time more than once in one statement, since
613     it uses a single buffer. */
614
615     switch(dbdata_type)
616       {
617       case type_retry:
618         retry = (dbdata_retry *)value;
619         printf("  %s %d %d %s\n%s  ", keybuffer, retry->basic_errno,
620           retry->more_errno, retry->text,
621           print_time(retry->first_failed));
622         printf("%s  ", print_time(retry->last_try));
623         printf("%s %s\n", print_time(retry->next_try),
624           (retry->expired)? "*" : "");
625         break;
626
627       case type_wait:
628         wait = (dbdata_wait *)value;
629         printf("%s ", keybuffer);
630         t = wait->text;
631         name[MESSAGE_ID_LENGTH] = 0;
632
633     /* Leave corrupt records alone */
634         if (wait->count > WAIT_NAME_MAX)
635           {
636           fprintf(stderr,
637             "**** Data for %s corrupted\n  count=%d=0x%x max=%d\n",
638             CS keybuffer, wait->count, wait->count, WAIT_NAME_MAX);
639           wait->count = WAIT_NAME_MAX;
640           yield = count_bad = 1;
641           }
642         for (int i = 1; i <= wait->count; i++)
643           {
644           Ustrncpy(name, t, MESSAGE_ID_LENGTH);
645           if (count_bad && name[0] == 0) break;
646           if (Ustrlen(name) != MESSAGE_ID_LENGTH ||
647               Ustrspn(name, "0123456789"
648                             "abcdefghijklmnopqrstuvwxyz"
649                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
650             {
651             fprintf(stderr,
652               "**** Data for %s corrupted: bad character in message id\n",
653               CS keybuffer);
654             for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
655               fprintf(stderr, "%02x ", name[j]);
656             fprintf(stderr, "\n");
657             yield = 1;
658             break;
659             }
660           printf("%s ", name);
661           t += MESSAGE_ID_LENGTH;
662           }
663         printf("\n");
664         break;
665
666       case type_misc:
667         printf("%s %s\n", print_time(((dbdata_generic *)value)->time_stamp),
668           keybuffer);
669         break;
670
671       case type_callout:
672         callout = (dbdata_callout_cache *)value;
673
674         /* New-style address record */
675
676         if (length == sizeof(dbdata_callout_cache_address))
677           {
678           printf("%s %s callout=%s\n",
679             print_time(((dbdata_generic *)value)->time_stamp),
680             keybuffer,
681             print_cache(callout->result));
682           }
683
684         /* New-style domain record */
685
686         else if (length == sizeof(dbdata_callout_cache))
687           {
688           printf("%s %s callout=%s postmaster=%s",
689             print_time(((dbdata_generic *)value)->time_stamp),
690             keybuffer,
691             print_cache(callout->result),
692             print_cache(callout->postmaster_result));
693           if (callout->postmaster_result != ccache_unknown)
694             printf(" (%s)", print_time(callout->postmaster_stamp));
695           printf(" random=%s", print_cache(callout->random_result));
696           if (callout->random_result != ccache_unknown)
697             printf(" (%s)", print_time(callout->random_stamp));
698           printf("\n");
699           }
700
701         break;
702
703       case type_ratelimit:
704         if (Ustrstr(key, "/unique/") != NULL && length >= sizeof(*rate_unique))
705           {
706           ratelimit = (dbdata_ratelimit *)value;
707           rate_unique = (dbdata_ratelimit_unique *)value;
708           printf("%s.%06d rate: %10.3f epoch: %s size: %u key: %s\n",
709             print_time(ratelimit->time_stamp),
710             ratelimit->time_usec, ratelimit->rate,
711             print_time(rate_unique->bloom_epoch), rate_unique->bloom_size,
712             keybuffer);
713           }
714         else
715           {
716           ratelimit = (dbdata_ratelimit *)value;
717           printf("%s.%06d rate: %10.3f key: %s\n",
718             print_time(ratelimit->time_stamp),
719             ratelimit->time_usec, ratelimit->rate,
720             keybuffer);
721           }
722         break;
723
724       case type_tls:
725         session = (dbdata_tls_session *)value;
726         printf("  %s %.*s\n", keybuffer, length, session->session);
727         break;
728
729       case type_seen:
730         seen = (dbdata_seen *)value;
731         printf("%s\t%s\n", keybuffer, print_time(seen->time_stamp));
732         break;
733       }
734     }
735   store_reset(reset_point);
736   }
737
738 dbfn_close(dbm);
739 return yield;
740 }
741
742 #endif  /* EXIM_DUMPDB */
743
744
745
746
747 #ifdef EXIM_FIXDB
748 /*************************************************
749 *           The exim_fixdb main program          *
750 *************************************************/
751
752 /* In order not to hold the database lock any longer than is necessary, each
753 operation on the database uses a separate open/close call. This is expensive,
754 but then using this utility is not expected to be very common. Its main use is
755 to provide a way of patching up hints databases in order to run tests.
756
757 Syntax of commands:
758
759 (1) <record name>
760     This causes the data from the given record to be displayed, or "not found"
761     to be output. Note that in the retry database, destination names are
762     preceded by R: or T: for router or transport retry info.
763
764 (2) <record name> d
765     This causes the given record to be deleted or "not found" to be output.
766
767 (3) <record name> <field number> <value>
768     This sets the given value into the given field, identified by a number
769     which is output by the display command. Not all types of record can
770     be changed.
771
772 (4) q
773     This exits from exim_fixdb.
774
775 If the record name is omitted from (2) or (3), the previously used record name
776 is re-used. */
777
778
779 int main(int argc, char **cargv)
780 {
781 int dbdata_type;
782 uschar **argv = USS cargv;
783 uschar buffer[256];
784 uschar name[256];
785 rmark reset_point;
786
787 store_init();
788 name[0] = 0;  /* No name set */
789
790 /* Sort out the database type, verify what we are working on and then process
791 user requests */
792
793 dbdata_type = check_args(argc, argv, US"fixdb", US"");
794 printf("Modifying Exim hints database %s/db/%s\n", argv[1], argv[2]);
795
796 for(; (reset_point = store_mark()); store_reset(reset_point))
797   {
798   open_db dbblock;
799   open_db *dbm;
800   void *record;
801   dbdata_retry *retry;
802   dbdata_wait *wait;
803   dbdata_callout_cache *callout;
804   dbdata_ratelimit *ratelimit;
805   dbdata_ratelimit_unique *rate_unique;
806   dbdata_tls_session *session;
807   int oldlength;
808   uschar *t;
809   uschar field[256], value[256];
810
811   printf("> ");
812   if (Ufgets(buffer, 256, stdin) == NULL) break;
813
814   buffer[Ustrlen(buffer)-1] = 0;
815   field[0] = value[0] = 0;
816
817   /* If the buffer contains just one digit, or just consists of "d", use the
818   previous name for an update. */
819
820   if ((isdigit((uschar)buffer[0]) && (buffer[1] == ' ' || buffer[1] == '\0'))
821        || Ustrcmp(buffer, "d") == 0)
822     {
823     if (name[0] == 0)
824       {
825       printf("No previous record name is set\n");
826       continue;
827       }
828     (void)sscanf(CS buffer, "%s %s", field, value);
829     }
830   else
831     {
832     name[0] = 0;
833     (void)sscanf(CS buffer, "%s %s %s", name, field, value);
834     }
835
836   /* Handle an update request */
837
838   if (field[0] != 0)
839     {
840     int verify = 1;
841     spool_directory = argv[1];
842
843     if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
844       continue;
845
846     if (Ustrcmp(field, "d") == 0)
847       {
848       if (value[0] != 0) printf("unexpected value after \"d\"\n");
849         else printf("%s\n", (dbfn_delete(dbm, name) < 0)?
850           "not found" : "deleted");
851       dbfn_close(dbm);
852       continue;
853       }
854
855     else if (isdigit((uschar)field[0]))
856       {
857       int fieldno = Uatoi(field);
858       if (value[0] == 0)
859         {
860         printf("value missing\n");
861         dbfn_close(dbm);
862         continue;
863         }
864       else
865         {
866         record = dbfn_read_with_length(dbm, name, &oldlength);
867         if (record == NULL) printf("not found\n"); else
868           {
869           time_t tt;
870           /*int length = 0;      Stops compiler warning */
871
872           switch(dbdata_type)
873             {
874             case type_retry:
875               retry = (dbdata_retry *)record;
876               /* length = sizeof(dbdata_retry) + Ustrlen(retry->text); */
877
878               switch(fieldno)
879                 {
880                 case 0: retry->basic_errno = Uatoi(value);
881                         break;
882                 case 1: retry->more_errno = Uatoi(value);
883                         break;
884                 case 2: if ((tt = read_time(value)) > 0) retry->first_failed = tt;
885                         else printf("bad time value\n");
886                         break;
887                 case 3: if ((tt = read_time(value)) > 0) retry->last_try = tt;
888                         else printf("bad time value\n");
889                         break;
890                 case 4: if ((tt = read_time(value)) > 0) retry->next_try = tt;
891                         else printf("bad time value\n");
892                         break;
893                 case 5: if (Ustrcmp(value, "yes") == 0) retry->expired = TRUE;
894                         else if (Ustrcmp(value, "no") == 0) retry->expired = FALSE;
895                         else printf("\"yes\" or \"no\" expected=n");
896                         break;
897                 default: printf("unknown field number\n");
898                          verify = 0;
899                          break;
900                 }
901               break;
902
903             case type_wait:
904               printf("Can't change contents of wait database record\n");
905               break;
906
907             case type_misc:
908               printf("Can't change contents of misc database record\n");
909               break;
910
911             case type_callout:
912               callout = (dbdata_callout_cache *)record;
913               /* length = sizeof(dbdata_callout_cache); */
914               switch(fieldno)
915                 {
916                 case 0: callout->result = Uatoi(value);
917                         break;
918                 case 1: callout->postmaster_result = Uatoi(value);
919                         break;
920                 case 2: callout->random_result = Uatoi(value);
921                         break;
922                 default: printf("unknown field number\n");
923                          verify = 0;
924                          break;
925                 }
926                 break;
927
928             case type_ratelimit:
929               ratelimit = (dbdata_ratelimit *)record;
930               switch(fieldno)
931                 {
932                 case 0: if ((tt = read_time(value)) > 0) ratelimit->time_stamp = tt;
933                         else printf("bad time value\n");
934                         break;
935                 case 1: ratelimit->time_usec = Uatoi(value);
936                         break;
937                 case 2: ratelimit->rate = Ustrtod(value, NULL);
938                         break;
939                 case 3: if (Ustrstr(name, "/unique/") != NULL
940                             && oldlength >= sizeof(dbdata_ratelimit_unique))
941                           {
942                           rate_unique = (dbdata_ratelimit_unique *)record;
943                           if ((tt = read_time(value)) > 0) rate_unique->bloom_epoch = tt;
944                             else printf("bad time value\n");
945                           break;
946                           }
947                         /* else fall through */
948                 case 4:
949                 case 5: if (Ustrstr(name, "/unique/") != NULL
950                             && oldlength >= sizeof(dbdata_ratelimit_unique))
951                           {
952                           /* see acl.c */
953                           BOOL seen;
954                           unsigned hash, hinc;
955                           uschar md5sum[16];
956                           md5 md5info;
957                           md5_start(&md5info);
958                           md5_end(&md5info, value, Ustrlen(value), md5sum);
959                           hash = md5sum[0] <<  0 | md5sum[1] <<  8
960                                | md5sum[2] << 16 | md5sum[3] << 24;
961                           hinc = md5sum[4] <<  0 | md5sum[5] <<  8
962                                | md5sum[6] << 16 | md5sum[7] << 24;
963                           rate_unique = (dbdata_ratelimit_unique *)record;
964                           seen = TRUE;
965                           for (unsigned n = 0; n < 8; n++, hash += hinc)
966                             {
967                             int bit = 1 << (hash % 8);
968                             int byte = (hash / 8) % rate_unique->bloom_size;
969                             if ((rate_unique->bloom[byte] & bit) == 0)
970                               {
971                               seen = FALSE;
972                               if (fieldno == 5) rate_unique->bloom[byte] |= bit;
973                               }
974                             }
975                           printf("%s %s\n",
976                             seen ? "seen" : fieldno == 5 ? "added" : "unseen", value);
977                           break;
978                           }
979                         /* else fall through */
980                 default: printf("unknown field number\n");
981                          verify = 0;
982                          break;
983                 }
984               break;
985
986             case type_tls:
987               printf("Can't change contents of tls database record\n");
988               break;
989             }
990
991           dbfn_write(dbm, name, record, oldlength);
992           }
993         }
994       }
995
996     else
997       {
998       printf("field number or d expected\n");
999       verify = 0;
1000       }
1001
1002     dbfn_close(dbm);
1003     if (!verify) continue;
1004     }
1005
1006   /* The "name" q causes an exit */
1007
1008   else if (Ustrcmp(name, "q") == 0) return 0;
1009
1010   /* Handle a read request, or verify after an update. */
1011
1012   spool_directory = argv[1];
1013   if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
1014     continue;
1015
1016   if (!(record = dbfn_read_with_length(dbm, name, &oldlength)))
1017     {
1018     printf("record %s not found\n", name);
1019     name[0] = 0;
1020     }
1021   else
1022     {
1023     int count_bad = 0;
1024     printf("%s\n", CS print_time(((dbdata_generic *)record)->time_stamp));
1025     switch(dbdata_type)
1026       {
1027       case type_retry:
1028         retry = (dbdata_retry *)record;
1029         printf("0 error number: %d %s\n", retry->basic_errno, retry->text);
1030         printf("1 extra data:   %d\n", retry->more_errno);
1031         printf("2 first failed: %s\n", print_time(retry->first_failed));
1032         printf("3 last try:     %s\n", print_time(retry->last_try));
1033         printf("4 next try:     %s\n", print_time(retry->next_try));
1034         printf("5 expired:      %s\n", (retry->expired)? "yes" : "no");
1035         break;
1036
1037       case type_wait:
1038         wait = (dbdata_wait *)record;
1039         t = wait->text;
1040         printf("Sequence: %d\n", wait->sequence);
1041         if (wait->count > WAIT_NAME_MAX)
1042           {
1043           printf("**** Data corrupted: count=%d=0x%x max=%d ****\n", wait->count,
1044             wait->count, WAIT_NAME_MAX);
1045           wait->count = WAIT_NAME_MAX;
1046           count_bad = 1;
1047           }
1048         for (int i = 1; i <= wait->count; i++)
1049           {
1050           Ustrncpy(value, t, MESSAGE_ID_LENGTH);
1051           value[MESSAGE_ID_LENGTH] = 0;
1052           if (count_bad && value[0] == 0) break;
1053           if (Ustrlen(value) != MESSAGE_ID_LENGTH ||
1054               Ustrspn(value, "0123456789"
1055                             "abcdefghijklmnopqrstuvwxyz"
1056                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
1057             {
1058             printf("\n**** Data corrupted: bad character in message id ****\n");
1059             for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
1060               printf("%02x ", value[j]);
1061             printf("\n");
1062             break;
1063             }
1064           printf("%s ", value);
1065           t += MESSAGE_ID_LENGTH;
1066           }
1067         printf("\n");
1068         break;
1069
1070       case type_misc:
1071         break;
1072
1073       case type_callout:
1074         callout = (dbdata_callout_cache *)record;
1075         printf("0 callout:    %s (%d)\n", print_cache(callout->result),
1076             callout->result);
1077         if (oldlength > sizeof(dbdata_callout_cache_address))
1078           {
1079           printf("1 postmaster: %s (%d)\n", print_cache(callout->postmaster_result),
1080               callout->postmaster_result);
1081           printf("2 random:     %s (%d)\n", print_cache(callout->random_result),
1082               callout->random_result);
1083           }
1084         break;
1085
1086       case type_ratelimit:
1087         ratelimit = (dbdata_ratelimit *)record;
1088         printf("0 time stamp:  %s\n", print_time(ratelimit->time_stamp));
1089         printf("1 fract. time: .%06d\n", ratelimit->time_usec);
1090         printf("2 sender rate: % .3f\n", ratelimit->rate);
1091         if (Ustrstr(name, "/unique/") != NULL
1092          && oldlength >= sizeof(dbdata_ratelimit_unique))
1093          {
1094          rate_unique = (dbdata_ratelimit_unique *)record;
1095          printf("3 filter epoch: %s\n", print_time(rate_unique->bloom_epoch));
1096          printf("4 test filter membership\n");
1097          printf("5 add element to filter\n");
1098          }
1099         break;
1100
1101       case type_tls:
1102         session = (dbdata_tls_session *)value;
1103         printf("0 time stamp:  %s\n", print_time(session->time_stamp));
1104         printf("1 session: .%s\n", session->session);
1105         break;
1106       }
1107     }
1108
1109   /* The database is closed after each request */
1110
1111   dbfn_close(dbm);
1112   }
1113
1114 printf("\n");
1115 return 0;
1116 }
1117
1118 #endif  /* EXIM_FIXDB */
1119
1120
1121
1122 #ifdef EXIM_TIDYDB
1123 /*************************************************
1124 *           The exim_tidydb main program         *
1125 *************************************************/
1126
1127
1128 /* Utility program to tidy the contents of an exim database file. There is one
1129 option:
1130
1131    -t <time>  expiry time for old records - default 30 days
1132
1133 For backwards compatibility, an -f option is recognized and ignored. (It used
1134 to request a "full" tidy. This version always does the whole job.) */
1135
1136
1137 typedef struct key_item {
1138   struct key_item *next;
1139   uschar key[1];
1140 } key_item;
1141
1142
1143 int main(int argc, char **cargv)
1144 {
1145 struct stat statbuf;
1146 int maxkeep = 30 * 24 * 60 * 60;
1147 int dbdata_type, i, oldest, path_len;
1148 key_item *keychain = NULL;
1149 rmark reset_point;
1150 open_db dbblock;
1151 open_db *dbm;
1152 EXIM_CURSOR *cursor;
1153 uschar **argv = USS cargv;
1154 uschar buffer[256];
1155 uschar *key;
1156
1157 store_init();
1158
1159 /* Scan the options */
1160
1161 for (i = 1; i < argc; i++)
1162   {
1163   if (argv[i][0] != '-') break;
1164   if (Ustrcmp(argv[i], "-f") == 0) continue;
1165   if (Ustrcmp(argv[i], "-t") == 0)
1166     {
1167     uschar *s;
1168     s = argv[++i];
1169     maxkeep = 0;
1170     while (*s != 0)
1171       {
1172       int value, count;
1173       if (!isdigit(*s)) usage(US"tidydb", US" [-t <time>]");
1174       (void)sscanf(CS s, "%d%n", &value, &count);
1175       s += count;
1176       switch (*s)
1177         {
1178         case 'w': value *= 7;
1179         case 'd': value *= 24;
1180         case 'h': value *= 60;
1181         case 'm': value *= 60;
1182         case 's': s++;
1183         break;
1184         default: usage(US"tidydb", US" [-t <time>]");
1185         }
1186       maxkeep += value;
1187       }
1188     }
1189   else usage(US"tidydb", US" [-t <time>]");
1190   }
1191
1192 /* Adjust argument values and process arguments */
1193
1194 argc -= --i;
1195 argv += i;
1196
1197 dbdata_type = check_args(argc, argv, US"tidydb", US" [-t <time>]");
1198
1199 /* Compute the oldest keep time, verify what we are doing, and open the
1200 database */
1201
1202 oldest = time(NULL) - maxkeep;
1203 printf("Tidying Exim hints database %s/db/%s\n", argv[1], argv[2]);
1204
1205 spool_directory = argv[1];
1206 if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
1207   exit(1);
1208
1209 /* Prepare for building file names */
1210
1211 sprintf(CS buffer, "%s/input/", argv[1]);
1212 path_len = Ustrlen(buffer);
1213
1214
1215 /* It appears, by experiment, that it is a bad idea to make changes
1216 to the file while scanning it. Pity the man page doesn't warn you about that.
1217 Therefore, we scan and build a list of all the keys. Then we use that to
1218 read the records and possibly update them. */
1219
1220 for (key = dbfn_scan(dbm, TRUE, &cursor);
1221      key;
1222      key = dbfn_scan(dbm, FALSE, &cursor))
1223   {
1224   key_item *k = store_get(sizeof(key_item) + Ustrlen(key), is_tainted(key));
1225   k->next = keychain;
1226   keychain = k;
1227   Ustrcpy(k->key, key);
1228   }
1229
1230 /* Now scan the collected keys and operate on the records, resetting
1231 the store each time round. */
1232
1233 for (; keychain && (reset_point = store_mark()); store_reset(reset_point))
1234   {
1235   dbdata_generic *value;
1236
1237   key = keychain->key;
1238   keychain = keychain->next;
1239   value = dbfn_read_with_length(dbm, key, NULL);
1240
1241   /* A continuation record may have been deleted or renamed already, so
1242   non-existence is not serious. */
1243
1244   if (!value) continue;
1245
1246   /* Delete if too old */
1247
1248   if (value->time_stamp < oldest)
1249     {
1250     printf("deleted %s (too old)\n", key);
1251     dbfn_delete(dbm, key);
1252     continue;
1253     }
1254
1255   /* Do database-specific tidying for wait databases, and message-
1256   specific tidying for the retry database. */
1257
1258   if (dbdata_type == type_wait)
1259     {
1260     dbdata_wait *wait = (dbdata_wait *)value;
1261     BOOL update = FALSE;
1262
1263     /* Leave corrupt records alone */
1264
1265     if (wait->time_stamp > time(NULL))
1266       {
1267       printf("**** Data for '%s' corrupted\n  time in future: %s\n",
1268         key, print_time(((dbdata_generic *)value)->time_stamp));
1269       continue;
1270       }
1271     if (wait->count > WAIT_NAME_MAX)
1272       {
1273       printf("**** Data for '%s' corrupted\n  count=%d=0x%x max=%d\n",
1274         key, wait->count, wait->count, WAIT_NAME_MAX);
1275       continue;
1276       }
1277     if (wait->sequence > WAIT_CONT_MAX)
1278       {
1279       printf("**** Data for '%s' corrupted\n  sequence=%d=0x%x max=%d\n",
1280         key, wait->sequence, wait->sequence, WAIT_CONT_MAX);
1281       continue;
1282       }
1283
1284     /* Record over 1 year old; just remove it */
1285
1286     if (wait->time_stamp < time(NULL) - 365*24*60*60)
1287       {
1288       dbfn_delete(dbm, key);
1289       printf("deleted %s (too old)\n", key);
1290       continue;
1291       }
1292
1293     /* Loop for renamed continuation records. For each message id,
1294     check to see if the message exists, and if not, remove its entry
1295     from the record. Because of the possibility of split input directories,
1296     we must look in both possible places for a -D file. */
1297
1298     for (;;)
1299       {
1300       int length = wait->count * MESSAGE_ID_LENGTH;
1301
1302       for (int offset = length - MESSAGE_ID_LENGTH;
1303            offset >= 0; offset -= MESSAGE_ID_LENGTH)
1304         {
1305         Ustrncpy(buffer+path_len, wait->text + offset, MESSAGE_ID_LENGTH);
1306         sprintf(CS(buffer+path_len + MESSAGE_ID_LENGTH), "-D");
1307
1308         if (Ustat(buffer, &statbuf) != 0)
1309           {
1310           buffer[path_len] = wait->text[offset+5];
1311           buffer[path_len+1] = '/';
1312           Ustrncpy(buffer+path_len+2, wait->text + offset, MESSAGE_ID_LENGTH);
1313           sprintf(CS(buffer+path_len+2 + MESSAGE_ID_LENGTH), "-D");
1314
1315           if (Ustat(buffer, &statbuf) != 0)
1316             {
1317             int left = length - offset - MESSAGE_ID_LENGTH;
1318             if (left > 0) Ustrncpy(wait->text + offset,
1319               wait->text + offset + MESSAGE_ID_LENGTH, left);
1320             wait->count--;
1321             length -= MESSAGE_ID_LENGTH;
1322             update = TRUE;
1323             }
1324           }
1325         }
1326
1327       /* If record is empty and the main record, either delete it or rename
1328       the next continuation, repeating if that is also empty. */
1329
1330       if (wait->count == 0 && Ustrchr(key, ':') == NULL)
1331         {
1332         while (wait->count == 0 && wait->sequence > 0)
1333           {
1334           uschar newkey[256];
1335           dbdata_generic *newvalue;
1336           sprintf(CS newkey, "%s:%d", key, wait->sequence - 1);
1337           newvalue = dbfn_read_with_length(dbm, newkey, NULL);
1338           if (newvalue != NULL)
1339             {
1340             value = newvalue;
1341             wait = (dbdata_wait *)newvalue;
1342             dbfn_delete(dbm, newkey);
1343             printf("renamed %s\n", newkey);
1344             update = TRUE;
1345             }
1346           else wait->sequence--;
1347           }
1348
1349         /* If we have ended up with an empty main record, delete it
1350         and break the loop. Otherwise the new record will be scanned. */
1351
1352         if (wait->count == 0 && wait->sequence == 0)
1353           {
1354           dbfn_delete(dbm, key);
1355           printf("deleted %s (empty)\n", key);
1356           update = FALSE;
1357           break;
1358           }
1359         }
1360
1361       /* If not an empty main record, break the loop */
1362
1363       else break;
1364       }
1365
1366     /* Re-write the record if required */
1367
1368     if (update)
1369       {
1370       printf("updated %s\n", key);
1371       dbfn_write(dbm, key, wait, sizeof(dbdata_wait) +
1372         wait->count * MESSAGE_ID_LENGTH);
1373       }
1374     }
1375
1376   /* If a retry record's key ends with a message-id, check that that message
1377   still exists; if not, remove this record. */
1378
1379   else if (dbdata_type == type_retry)
1380     {
1381     uschar *id;
1382     int len = Ustrlen(key);
1383
1384     if (len < MESSAGE_ID_LENGTH + 1) continue;
1385     id = key + len - MESSAGE_ID_LENGTH - 1;
1386     if (*id++ != ':') continue;
1387
1388     for (i = 0; i < MESSAGE_ID_LENGTH; i++)
1389       if (i == 6 || i == 13)
1390         { if (id[i] != '-') break; }
1391       else
1392         { if (!isalnum(id[i])) break; }
1393     if (i < MESSAGE_ID_LENGTH) continue;
1394
1395     Ustrncpy(buffer + path_len, id, MESSAGE_ID_LENGTH);
1396     sprintf(CS(buffer + path_len + MESSAGE_ID_LENGTH), "-D");
1397
1398     if (Ustat(buffer, &statbuf) != 0)
1399       {
1400       sprintf(CS(buffer + path_len), "%c/%s-D", id[5], id);
1401       if (Ustat(buffer, &statbuf) != 0)
1402         {
1403         dbfn_delete(dbm, key);
1404         printf("deleted %s (no message)\n", key);
1405         }
1406       }
1407     }
1408   }
1409
1410 dbfn_close(dbm);
1411 printf("Tidying complete\n");
1412 return 0;
1413 }
1414
1415 #endif  /* EXIM_TIDYDB */
1416
1417 /* End of exim_dbutil.c */