1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
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. */
10 /* This single source file is used to compile three utility programs for
11 maintaining Exim hints databases.
13 exim_dumpdb dumps out the contents
14 exim_fixdb patches the database (really for Exim maintenance/testing)
15 exim_tidydb removed obsolete data
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:
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 tls: TLS session resumption cache
26 There are a number of common subroutines, followed by three main programs,
27 whose inclusion is controlled by -D on the compilation command. */
33 /* Identifiers for the different database types. */
38 #define type_callout 4
39 #define type_ratelimit 5
43 /* This is used by our cut-down dbfn_open(). */
45 uschar *spool_directory;
48 /******************************************************************************/
49 /* dummies needed by Solaris build */
54 readconf_printtime(int t)
57 string_vformat_trc(gstring * g, const uschar * func, unsigned line,
58 unsigned size_limit, unsigned flags, const char *format, va_list ap)
61 string_sprintf_trc(const char * fmt, const uschar * func, unsigned line, ...)
64 string_format_trc(uschar * buf, int len, const uschar * func, unsigned line,
65 const char * fmt, ...)
68 struct global_flags f;
69 unsigned int log_selector[1];
71 BOOL split_spool_directory;
72 /******************************************************************************/
75 /*************************************************
76 * Berkeley DB error callback *
77 *************************************************/
79 /* For Berkeley DB >= 2, we can define a function to be called in case of DB
80 errors. This should help with debugging strange DB problems, e.g. getting "File
81 exists" when you try to open a db file. The API changed at release 4.3. */
83 #if defined(USE_DB) && defined(DB_VERSION_STRING)
85 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
86 dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
90 dbfn_bdb_error_callback(const char *pfx, char *msg)
94 printf("Berkeley DB error: %s\n", msg);
100 /*************************************************
102 *************************************************/
104 SIGNAL_BOOL sigalrm_seen;
107 sigalrm_handler(int sig)
114 /*************************************************
115 * Output usage message and exit *
116 *************************************************/
119 usage(uschar *name, uschar *options)
121 printf("Usage: exim_%s%s <spool-directory> <database-name>\n", name, options);
122 printf(" <database-name> = retry | misc | wait-<transport-name> | callout | ratelimit | tls\n");
128 /*************************************************
129 * Sort out the command arguments *
130 *************************************************/
132 /* This function checks that there are exactly 2 arguments, and checks the
133 second of them to be sure it is a known database name. */
136 check_args(int argc, uschar **argv, uschar *name, uschar *options)
140 if (Ustrcmp(argv[2], "retry") == 0) return type_retry;
141 if (Ustrcmp(argv[2], "misc") == 0) return type_misc;
142 if (Ustrncmp(argv[2], "wait-", 5) == 0) return type_wait;
143 if (Ustrcmp(argv[2], "callout") == 0) return type_callout;
144 if (Ustrcmp(argv[2], "ratelimit") == 0) return type_ratelimit;
145 if (Ustrcmp(argv[2], "tls") == 0) return type_tls;
147 usage(name, options);
148 return -1; /* Never obeyed */
153 /*************************************************
154 * Handle attempts to write the log *
155 *************************************************/
157 /* The message gets written to stderr when log_write() is called from a
158 utility. The message always gets '\n' added on the end of it. These calls come
159 from modules such as store.c when things go drastically wrong (e.g. malloc()
160 failing). In normal use they won't get obeyed.
163 selector not relevant when running a utility
164 flags not relevant when running a utility
165 format a printf() format
166 ... arguments for format
172 log_write(unsigned int selector, int flags, const char *format, ...)
175 va_start(ap, format);
176 vfprintf(stderr, format, ap);
177 fprintf(stderr, "\n");
183 /*************************************************
184 * Format a time value for printing *
185 *************************************************/
187 static uschar time_buffer[sizeof("09-xxx-1999 hh:mm:ss ")];
192 struct tm *tmstr = localtime(&t);
193 Ustrftime(time_buffer, sizeof(time_buffer), "%d-%b-%Y %H:%M:%S", tmstr);
199 /*************************************************
200 * Format a cache value for printing *
201 *************************************************/
204 print_cache(int value)
206 return (value == ccache_accept)? US"accept" :
207 (value == ccache_reject)? US"reject" :
213 /*************************************************
215 *************************************************/
222 time_t now = time(NULL);
223 struct tm *tm = localtime(&now);
228 for (uschar * t = s + Ustrlen(s) - 1; t >= s; t--)
230 if (*t == ':') continue;
231 if (!isdigit((uschar)*t)) return -1;
236 if (!isdigit((uschar)*t)) return -1;
237 value = value + (*t - '0')*10;
242 case 0: tm->tm_min = value; break;
243 case 1: tm->tm_hour = value; break;
244 case 2: tm->tm_mday = value; break;
245 case 3: tm->tm_mon = value - 1; break;
246 case 4: tm->tm_year = (value < 90)? value + 100 : value; break;
253 #endif /* EXIM_FIXDB */
257 /*************************************************
258 * Open and lock a database file *
259 *************************************************/
261 /* This is a cut-down version from the function in dbfn.h that Exim itself
262 uses. We assume the database exists, and therefore give up if we cannot open
266 name The single-component name of one of Exim's database files.
267 flags O_RDONLY or O_RDWR
268 dbblock Points to an open_db block to be filled in.
272 Returns: NULL if the open failed, or the locking failed.
273 On success, dbblock is returned. This contains the dbm pointer and
274 the fd of the locked lock file.
278 dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof, BOOL panic)
281 struct flock lock_data;
282 BOOL read_only = flags == O_RDONLY;
283 uschar * dirname, * filename;
285 /* The first thing to do is to open a separate file on which to lock. This
286 ensures that Exim has exclusive use of the database before it even tries to
287 open it. If there is a database, there should be a lock file in existence. */
289 #ifdef COMPILE_UTILITY
290 if ( asprintf(CSS &dirname, "%s/db", spool_directory) < 0
291 || asprintf(CSS &filename, "%s/%s.lockfile", dirname, name) < 0)
294 dirname = string_sprintf("%s/db", spool_directory);
295 filename = string_sprintf("%s/%s.lockfile", dirname, name);
298 dbblock->lockfd = Uopen(filename, flags, 0);
299 if (dbblock->lockfd < 0)
301 printf("** Failed to open database lock file %s: %s\n", filename,
306 /* Now we must get a lock on the opened lock file; do this with a blocking
307 lock that times out. */
309 lock_data.l_type = read_only ? F_RDLCK : F_WRLCK;
310 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
312 sigalrm_seen = FALSE;
313 os_non_restarting_signal(SIGALRM, sigalrm_handler);
314 ALARM(EXIMDB_LOCK_TIMEOUT);
315 rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
318 if (sigalrm_seen) errno = ETIMEDOUT;
321 printf("** Failed to get %s lock for %s: %s",
322 flags & O_WRONLY ? "write" : "read",
324 errno == ETIMEDOUT ? "timed out" : strerror(errno));
325 (void)close(dbblock->lockfd);
329 /* At this point we have an opened and locked separate lock file, that is,
330 exclusive access to the database, so we can go ahead and open it. */
332 #ifdef COMPILE_UTILITY
333 if (asprintf(CSS &filename, "%s/%s", dirname, name) < 0) return NULL;
335 filename = string_sprintf("%s/%s", dirname, name);
337 EXIM_DBOPEN(filename, dirname, flags, 0, &dbblock->dbptr);
341 printf("** Failed to open DBM file %s for %s:\n %s%s\n", filename,
342 read_only? "reading" : "writing", strerror(errno),
344 " (or Berkeley DB error while opening)"
349 (void)close(dbblock->lockfd);
359 /*************************************************
360 * Unlock and close a database file *
361 *************************************************/
363 /* Closing a file automatically unlocks it, so after closing the database, just
366 Argument: a pointer to an open database block
371 dbfn_close(open_db *dbblock)
373 EXIM_DBCLOSE(dbblock->dbptr);
374 (void)close(dbblock->lockfd);
380 /*************************************************
381 * Read from database file *
382 *************************************************/
384 /* Passing back the pointer unchanged is useless, because there is no guarantee
385 of alignment. Since all the records used by Exim need to be properly aligned to
386 pick out the timestamps, etc., do the copying centrally here.
389 dbblock a pointer to an open database block
390 key the key of the record to be read
391 length where to put the length (or NULL if length not wanted). Includes overhead.
393 Returns: a pointer to the retrieved record, or
394 NULL if the record is not found
398 dbfn_read_with_length(open_db *dbblock, const uschar *key, int *length)
401 EXIM_DATUM key_datum, result_datum;
402 int klen = Ustrlen(key) + 1;
403 uschar * key_copy = store_get(klen, is_tainted(key));
405 memcpy(key_copy, key, klen);
407 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
408 EXIM_DATUM_INIT(result_datum); /* to be cleared before use. */
409 EXIM_DATUM_DATA(key_datum) = CS key_copy;
410 EXIM_DATUM_SIZE(key_datum) = klen;
412 if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
414 /* Assume for now that anything stored could have been tainted. Properly
415 we should store the taint status along with the data. */
417 yield = store_get(EXIM_DATUM_SIZE(result_datum), TRUE);
418 memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
419 if (length) *length = EXIM_DATUM_SIZE(result_datum);
421 EXIM_DATUM_FREE(result_datum); /* Some DBM libs require freeing */
427 #if defined(EXIM_TIDYDB) || defined(EXIM_FIXDB)
429 /*************************************************
430 * Write to database file *
431 *************************************************/
435 dbblock a pointer to an open database block
436 key the key of the record to be written
437 ptr a pointer to the record to be written
438 length the length of the record to be written
440 Returns: the yield of the underlying dbm or db "write" function. If this
441 is dbm, the value is zero for OK.
445 dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
447 EXIM_DATUM key_datum, value_datum;
448 dbdata_generic *gptr = (dbdata_generic *)ptr;
449 int klen = Ustrlen(key) + 1;
450 uschar * key_copy = store_get(klen, is_tainted(key));
452 memcpy(key_copy, key, klen);
453 gptr->time_stamp = time(NULL);
455 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
456 EXIM_DATUM_INIT(value_datum); /* to be cleared before use. */
457 EXIM_DATUM_DATA(key_datum) = CS key_copy;
458 EXIM_DATUM_SIZE(key_datum) = klen;
459 EXIM_DATUM_DATA(value_datum) = CS ptr;
460 EXIM_DATUM_SIZE(value_datum) = length;
461 return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
466 /*************************************************
467 * Delete record from database file *
468 *************************************************/
472 dbblock a pointer to an open database block
473 key the key of the record to be deleted
475 Returns: the yield of the underlying dbm or db "delete" function.
479 dbfn_delete(open_db *dbblock, const uschar *key)
481 int klen = Ustrlen(key) + 1;
482 uschar * key_copy = store_get(klen, is_tainted(key));
484 memcpy(key_copy, key, klen);
485 EXIM_DATUM key_datum;
486 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require clearing */
487 EXIM_DATUM_DATA(key_datum) = CS key_copy;
488 EXIM_DATUM_SIZE(key_datum) = klen;
489 return EXIM_DBDEL(dbblock->dbptr, key_datum);
492 #endif /* EXIM_TIDYDB || EXIM_FIXDB */
496 #if defined(EXIM_DUMPDB) || defined(EXIM_TIDYDB)
497 /*************************************************
498 * Scan the keys of a database file *
499 *************************************************/
503 dbblock a pointer to an open database block
504 start TRUE if starting a new scan
505 FALSE if continuing with the current scan
506 cursor a pointer to a pointer to a cursor anchor, for those dbm libraries
507 that use the notion of a cursor
509 Returns: the next record from the file, or
510 NULL if there are no more
514 dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
516 EXIM_DATUM key_datum, value_datum;
519 /* Some dbm require an initialization */
521 if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
523 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries require the datum */
524 EXIM_DATUM_INIT(value_datum); /* to be cleared before use. */
526 yield = (EXIM_DBSCAN(dbblock->dbptr, key_datum, value_datum, start, *cursor))?
527 US EXIM_DATUM_DATA(key_datum) : NULL;
529 /* Some dbm require a termination */
531 if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
534 #endif /* EXIM_DUMPDB || EXIM_TIDYDB */
539 /*************************************************
540 * The exim_dumpdb main program *
541 *************************************************/
544 main(int argc, char **cargv)
551 uschar **argv = USS cargv;
552 uschar keybuffer[1024];
556 /* Check the arguments, and open the database */
558 dbdata_type = check_args(argc, argv, US"dumpdb", US"");
559 spool_directory = argv[1];
560 if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
563 /* Scan the file, formatting the information for each entry. Note
564 that data is returned in a malloc'ed block, in order that it be
565 correctly aligned. */
567 for (uschar * key = dbfn_scan(dbm, TRUE, &cursor);
569 key = dbfn_scan(dbm, FALSE, &cursor))
573 dbdata_callout_cache *callout;
574 dbdata_ratelimit *ratelimit;
575 dbdata_ratelimit_unique *rate_unique;
576 dbdata_tls_session *session;
580 uschar name[MESSAGE_ID_LENGTH + 1];
582 rmark reset_point = store_mark();
584 /* Keep a copy of the key separate, as in some DBM's the pointer is into data
585 which might change. */
587 if (Ustrlen(key) > sizeof(keybuffer) - 1)
589 printf("**** Overlong key encountered: %s\n", key);
592 Ustrcpy(keybuffer, key);
594 if (!(value = dbfn_read_with_length(dbm, keybuffer, &length)))
595 fprintf(stderr, "**** Entry \"%s\" was in the key scan, but the record "
596 "was not found in the file - something is wrong!\n",
600 /* Note: don't use print_time more than once in one statement, since
601 it uses a single buffer. */
606 retry = (dbdata_retry *)value;
607 printf(" %s %d %d %s\n%s ", keybuffer, retry->basic_errno,
608 retry->more_errno, retry->text,
609 print_time(retry->first_failed));
610 printf("%s ", print_time(retry->last_try));
611 printf("%s %s\n", print_time(retry->next_try),
612 (retry->expired)? "*" : "");
616 wait = (dbdata_wait *)value;
617 printf("%s ", keybuffer);
619 name[MESSAGE_ID_LENGTH] = 0;
621 /* Leave corrupt records alone */
622 if (wait->count > WAIT_NAME_MAX)
625 "**** Data for %s corrupted\n count=%d=0x%x max=%d\n",
626 CS keybuffer, wait->count, wait->count, WAIT_NAME_MAX);
627 wait->count = WAIT_NAME_MAX;
628 yield = count_bad = 1;
630 for (int i = 1; i <= wait->count; i++)
632 Ustrncpy(name, t, MESSAGE_ID_LENGTH);
633 if (count_bad && name[0] == 0) break;
634 if (Ustrlen(name) != MESSAGE_ID_LENGTH ||
635 Ustrspn(name, "0123456789"
636 "abcdefghijklmnopqrstuvwxyz"
637 "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
640 "**** Data for %s corrupted: bad character in message id\n",
642 for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
643 fprintf(stderr, "%02x ", name[j]);
644 fprintf(stderr, "\n");
649 t += MESSAGE_ID_LENGTH;
655 printf("%s %s\n", print_time(((dbdata_generic *)value)->time_stamp),
660 callout = (dbdata_callout_cache *)value;
662 /* New-style address record */
664 if (length == sizeof(dbdata_callout_cache_address))
666 printf("%s %s callout=%s\n",
667 print_time(((dbdata_generic *)value)->time_stamp),
669 print_cache(callout->result));
672 /* New-style domain record */
674 else if (length == sizeof(dbdata_callout_cache))
676 printf("%s %s callout=%s postmaster=%s",
677 print_time(((dbdata_generic *)value)->time_stamp),
679 print_cache(callout->result),
680 print_cache(callout->postmaster_result));
681 if (callout->postmaster_result != ccache_unknown)
682 printf(" (%s)", print_time(callout->postmaster_stamp));
683 printf(" random=%s", print_cache(callout->random_result));
684 if (callout->random_result != ccache_unknown)
685 printf(" (%s)", print_time(callout->random_stamp));
692 if (Ustrstr(key, "/unique/") != NULL && length >= sizeof(*rate_unique))
694 ratelimit = (dbdata_ratelimit *)value;
695 rate_unique = (dbdata_ratelimit_unique *)value;
696 printf("%s.%06d rate: %10.3f epoch: %s size: %u key: %s\n",
697 print_time(ratelimit->time_stamp),
698 ratelimit->time_usec, ratelimit->rate,
699 print_time(rate_unique->bloom_epoch), rate_unique->bloom_size,
704 ratelimit = (dbdata_ratelimit *)value;
705 printf("%s.%06d rate: %10.3f key: %s\n",
706 print_time(ratelimit->time_stamp),
707 ratelimit->time_usec, ratelimit->rate,
713 session = (dbdata_tls_session *)value;
714 printf(" %s %.*s\n", keybuffer, length, session->session);
718 store_reset(reset_point);
725 #endif /* EXIM_DUMPDB */
731 /*************************************************
732 * The exim_fixdb main program *
733 *************************************************/
735 /* In order not to hold the database lock any longer than is necessary, each
736 operation on the database uses a separate open/close call. This is expensive,
737 but then using this utility is not expected to be very common. Its main use is
738 to provide a way of patching up hints databases in order to run tests.
743 This causes the data from the given record to be displayed, or "not found"
744 to be output. Note that in the retry database, destination names are
745 preceded by R: or T: for router or transport retry info.
748 This causes the given record to be deleted or "not found" to be output.
750 (3) <record name> <field number> <value>
751 This sets the given value into the given field, identified by a number
752 which is output by the display command. Not all types of record can
756 This exits from exim_fixdb.
758 If the record name is omitted from (2) or (3), the previously used record name
762 int main(int argc, char **cargv)
765 uschar **argv = USS cargv;
771 name[0] = 0; /* No name set */
773 /* Sort out the database type, verify what we are working on and then process
776 dbdata_type = check_args(argc, argv, US"fixdb", US"");
777 printf("Modifying Exim hints database %s/db/%s\n", argv[1], argv[2]);
779 for(; (reset_point = store_mark()); store_reset(reset_point))
786 dbdata_callout_cache *callout;
787 dbdata_ratelimit *ratelimit;
788 dbdata_ratelimit_unique *rate_unique;
789 dbdata_tls_session *session;
792 uschar field[256], value[256];
795 if (Ufgets(buffer, 256, stdin) == NULL) break;
797 buffer[Ustrlen(buffer)-1] = 0;
798 field[0] = value[0] = 0;
800 /* If the buffer contains just one digit, or just consists of "d", use the
801 previous name for an update. */
803 if ((isdigit((uschar)buffer[0]) && (buffer[1] == ' ' || buffer[1] == '\0'))
804 || Ustrcmp(buffer, "d") == 0)
808 printf("No previous record name is set\n");
811 (void)sscanf(CS buffer, "%s %s", field, value);
816 (void)sscanf(CS buffer, "%s %s %s", name, field, value);
819 /* Handle an update request */
824 spool_directory = argv[1];
826 if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
829 if (Ustrcmp(field, "d") == 0)
831 if (value[0] != 0) printf("unexpected value after \"d\"\n");
832 else printf("%s\n", (dbfn_delete(dbm, name) < 0)?
833 "not found" : "deleted");
838 else if (isdigit((uschar)field[0]))
840 int fieldno = Uatoi(field);
843 printf("value missing\n");
849 record = dbfn_read_with_length(dbm, name, &oldlength);
850 if (record == NULL) printf("not found\n"); else
853 /*int length = 0; Stops compiler warning */
858 retry = (dbdata_retry *)record;
859 /* length = sizeof(dbdata_retry) + Ustrlen(retry->text); */
863 case 0: retry->basic_errno = Uatoi(value);
865 case 1: retry->more_errno = Uatoi(value);
867 case 2: if ((tt = read_time(value)) > 0) retry->first_failed = tt;
868 else printf("bad time value\n");
870 case 3: if ((tt = read_time(value)) > 0) retry->last_try = tt;
871 else printf("bad time value\n");
873 case 4: if ((tt = read_time(value)) > 0) retry->next_try = tt;
874 else printf("bad time value\n");
876 case 5: if (Ustrcmp(value, "yes") == 0) retry->expired = TRUE;
877 else if (Ustrcmp(value, "no") == 0) retry->expired = FALSE;
878 else printf("\"yes\" or \"no\" expected=n");
880 default: printf("unknown field number\n");
887 printf("Can't change contents of wait database record\n");
891 printf("Can't change contents of misc database record\n");
895 callout = (dbdata_callout_cache *)record;
896 /* length = sizeof(dbdata_callout_cache); */
899 case 0: callout->result = Uatoi(value);
901 case 1: callout->postmaster_result = Uatoi(value);
903 case 2: callout->random_result = Uatoi(value);
905 default: printf("unknown field number\n");
912 ratelimit = (dbdata_ratelimit *)record;
915 case 0: if ((tt = read_time(value)) > 0) ratelimit->time_stamp = tt;
916 else printf("bad time value\n");
918 case 1: ratelimit->time_usec = Uatoi(value);
920 case 2: ratelimit->rate = Ustrtod(value, NULL);
922 case 3: if (Ustrstr(name, "/unique/") != NULL
923 && oldlength >= sizeof(dbdata_ratelimit_unique))
925 rate_unique = (dbdata_ratelimit_unique *)record;
926 if ((tt = read_time(value)) > 0) rate_unique->bloom_epoch = tt;
927 else printf("bad time value\n");
930 /* else fall through */
932 case 5: if (Ustrstr(name, "/unique/") != NULL
933 && oldlength >= sizeof(dbdata_ratelimit_unique))
941 md5_end(&md5info, value, Ustrlen(value), md5sum);
942 hash = md5sum[0] << 0 | md5sum[1] << 8
943 | md5sum[2] << 16 | md5sum[3] << 24;
944 hinc = md5sum[4] << 0 | md5sum[5] << 8
945 | md5sum[6] << 16 | md5sum[7] << 24;
946 rate_unique = (dbdata_ratelimit_unique *)record;
948 for (unsigned n = 0; n < 8; n++, hash += hinc)
950 int bit = 1 << (hash % 8);
951 int byte = (hash / 8) % rate_unique->bloom_size;
952 if ((rate_unique->bloom[byte] & bit) == 0)
955 if (fieldno == 5) rate_unique->bloom[byte] |= bit;
959 seen ? "seen" : fieldno == 5 ? "added" : "unseen", value);
962 /* else fall through */
963 default: printf("unknown field number\n");
970 printf("Can't change contents of tls database record\n");
974 dbfn_write(dbm, name, record, oldlength);
981 printf("field number or d expected\n");
986 if (!verify) continue;
989 /* The "name" q causes an exit */
991 else if (Ustrcmp(name, "q") == 0) return 0;
993 /* Handle a read request, or verify after an update. */
995 spool_directory = argv[1];
996 if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
999 if (!(record = dbfn_read_with_length(dbm, name, &oldlength)))
1001 printf("record %s not found\n", name);
1007 printf("%s\n", CS print_time(((dbdata_generic *)record)->time_stamp));
1011 retry = (dbdata_retry *)record;
1012 printf("0 error number: %d %s\n", retry->basic_errno, retry->text);
1013 printf("1 extra data: %d\n", retry->more_errno);
1014 printf("2 first failed: %s\n", print_time(retry->first_failed));
1015 printf("3 last try: %s\n", print_time(retry->last_try));
1016 printf("4 next try: %s\n", print_time(retry->next_try));
1017 printf("5 expired: %s\n", (retry->expired)? "yes" : "no");
1021 wait = (dbdata_wait *)record;
1023 printf("Sequence: %d\n", wait->sequence);
1024 if (wait->count > WAIT_NAME_MAX)
1026 printf("**** Data corrupted: count=%d=0x%x max=%d ****\n", wait->count,
1027 wait->count, WAIT_NAME_MAX);
1028 wait->count = WAIT_NAME_MAX;
1031 for (int i = 1; i <= wait->count; i++)
1033 Ustrncpy(value, t, MESSAGE_ID_LENGTH);
1034 value[MESSAGE_ID_LENGTH] = 0;
1035 if (count_bad && value[0] == 0) break;
1036 if (Ustrlen(value) != MESSAGE_ID_LENGTH ||
1037 Ustrspn(value, "0123456789"
1038 "abcdefghijklmnopqrstuvwxyz"
1039 "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
1041 printf("\n**** Data corrupted: bad character in message id ****\n");
1042 for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
1043 printf("%02x ", value[j]);
1047 printf("%s ", value);
1048 t += MESSAGE_ID_LENGTH;
1057 callout = (dbdata_callout_cache *)record;
1058 printf("0 callout: %s (%d)\n", print_cache(callout->result),
1060 if (oldlength > sizeof(dbdata_callout_cache_address))
1062 printf("1 postmaster: %s (%d)\n", print_cache(callout->postmaster_result),
1063 callout->postmaster_result);
1064 printf("2 random: %s (%d)\n", print_cache(callout->random_result),
1065 callout->random_result);
1069 case type_ratelimit:
1070 ratelimit = (dbdata_ratelimit *)record;
1071 printf("0 time stamp: %s\n", print_time(ratelimit->time_stamp));
1072 printf("1 fract. time: .%06d\n", ratelimit->time_usec);
1073 printf("2 sender rate: % .3f\n", ratelimit->rate);
1074 if (Ustrstr(name, "/unique/") != NULL
1075 && oldlength >= sizeof(dbdata_ratelimit_unique))
1077 rate_unique = (dbdata_ratelimit_unique *)record;
1078 printf("3 filter epoch: %s\n", print_time(rate_unique->bloom_epoch));
1079 printf("4 test filter membership\n");
1080 printf("5 add element to filter\n");
1085 session = (dbdata_tls_session *)value;
1086 printf("0 time stamp: %s\n", print_time(session->time_stamp));
1087 printf("1 session: .%s\n", session->session);
1092 /* The database is closed after each request */
1101 #endif /* EXIM_FIXDB */
1106 /*************************************************
1107 * The exim_tidydb main program *
1108 *************************************************/
1111 /* Utility program to tidy the contents of an exim database file. There is one
1114 -t <time> expiry time for old records - default 30 days
1116 For backwards compatibility, an -f option is recognized and ignored. (It used
1117 to request a "full" tidy. This version always does the whole job.) */
1120 typedef struct key_item {
1121 struct key_item *next;
1126 int main(int argc, char **cargv)
1128 struct stat statbuf;
1129 int maxkeep = 30 * 24 * 60 * 60;
1130 int dbdata_type, i, oldest, path_len;
1131 key_item *keychain = NULL;
1135 EXIM_CURSOR *cursor;
1136 uschar **argv = USS cargv;
1142 /* Scan the options */
1144 for (i = 1; i < argc; i++)
1146 if (argv[i][0] != '-') break;
1147 if (Ustrcmp(argv[i], "-f") == 0) continue;
1148 if (Ustrcmp(argv[i], "-t") == 0)
1156 if (!isdigit(*s)) usage(US"tidydb", US" [-t <time>]");
1157 (void)sscanf(CS s, "%d%n", &value, &count);
1161 case 'w': value *= 7;
1162 case 'd': value *= 24;
1163 case 'h': value *= 60;
1164 case 'm': value *= 60;
1167 default: usage(US"tidydb", US" [-t <time>]");
1172 else usage(US"tidydb", US" [-t <time>]");
1175 /* Adjust argument values and process arguments */
1180 dbdata_type = check_args(argc, argv, US"tidydb", US" [-t <time>]");
1182 /* Compute the oldest keep time, verify what we are doing, and open the
1185 oldest = time(NULL) - maxkeep;
1186 printf("Tidying Exim hints database %s/db/%s\n", argv[1], argv[2]);
1188 spool_directory = argv[1];
1189 if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
1192 /* Prepare for building file names */
1194 sprintf(CS buffer, "%s/input/", argv[1]);
1195 path_len = Ustrlen(buffer);
1198 /* It appears, by experiment, that it is a bad idea to make changes
1199 to the file while scanning it. Pity the man page doesn't warn you about that.
1200 Therefore, we scan and build a list of all the keys. Then we use that to
1201 read the records and possibly update them. */
1203 for (key = dbfn_scan(dbm, TRUE, &cursor);
1205 key = dbfn_scan(dbm, FALSE, &cursor))
1207 key_item *k = store_get(sizeof(key_item) + Ustrlen(key), is_tainted(key));
1210 Ustrcpy(k->key, key);
1213 /* Now scan the collected keys and operate on the records, resetting
1214 the store each time round. */
1216 for (; keychain && (reset_point = store_mark()); store_reset(reset_point))
1218 dbdata_generic *value;
1220 key = keychain->key;
1221 keychain = keychain->next;
1222 value = dbfn_read_with_length(dbm, key, NULL);
1224 /* A continuation record may have been deleted or renamed already, so
1225 non-existence is not serious. */
1227 if (!value) continue;
1229 /* Delete if too old */
1231 if (value->time_stamp < oldest)
1233 printf("deleted %s (too old)\n", key);
1234 dbfn_delete(dbm, key);
1238 /* Do database-specific tidying for wait databases, and message-
1239 specific tidying for the retry database. */
1241 if (dbdata_type == type_wait)
1243 dbdata_wait *wait = (dbdata_wait *)value;
1244 BOOL update = FALSE;
1246 /* Leave corrupt records alone */
1248 if (wait->time_stamp > time(NULL))
1250 printf("**** Data for '%s' corrupted\n time in future: %s\n",
1251 key, print_time(((dbdata_generic *)value)->time_stamp));
1254 if (wait->count > WAIT_NAME_MAX)
1256 printf("**** Data for '%s' corrupted\n count=%d=0x%x max=%d\n",
1257 key, wait->count, wait->count, WAIT_NAME_MAX);
1260 if (wait->sequence > WAIT_CONT_MAX)
1262 printf("**** Data for '%s' corrupted\n sequence=%d=0x%x max=%d\n",
1263 key, wait->sequence, wait->sequence, WAIT_CONT_MAX);
1267 /* Record over 1 year old; just remove it */
1269 if (wait->time_stamp < time(NULL) - 365*24*60*60)
1271 dbfn_delete(dbm, key);
1272 printf("deleted %s (too old)\n", key);
1276 /* Loop for renamed continuation records. For each message id,
1277 check to see if the message exists, and if not, remove its entry
1278 from the record. Because of the possibility of split input directories,
1279 we must look in both possible places for a -D file. */
1283 int length = wait->count * MESSAGE_ID_LENGTH;
1285 for (int offset = length - MESSAGE_ID_LENGTH;
1286 offset >= 0; offset -= MESSAGE_ID_LENGTH)
1288 Ustrncpy(buffer+path_len, wait->text + offset, MESSAGE_ID_LENGTH);
1289 sprintf(CS(buffer+path_len + MESSAGE_ID_LENGTH), "-D");
1291 if (Ustat(buffer, &statbuf) != 0)
1293 buffer[path_len] = wait->text[offset+5];
1294 buffer[path_len+1] = '/';
1295 Ustrncpy(buffer+path_len+2, wait->text + offset, MESSAGE_ID_LENGTH);
1296 sprintf(CS(buffer+path_len+2 + MESSAGE_ID_LENGTH), "-D");
1298 if (Ustat(buffer, &statbuf) != 0)
1300 int left = length - offset - MESSAGE_ID_LENGTH;
1301 if (left > 0) Ustrncpy(wait->text + offset,
1302 wait->text + offset + MESSAGE_ID_LENGTH, left);
1304 length -= MESSAGE_ID_LENGTH;
1310 /* If record is empty and the main record, either delete it or rename
1311 the next continuation, repeating if that is also empty. */
1313 if (wait->count == 0 && Ustrchr(key, ':') == NULL)
1315 while (wait->count == 0 && wait->sequence > 0)
1318 dbdata_generic *newvalue;
1319 sprintf(CS newkey, "%s:%d", key, wait->sequence - 1);
1320 newvalue = dbfn_read_with_length(dbm, newkey, NULL);
1321 if (newvalue != NULL)
1324 wait = (dbdata_wait *)newvalue;
1325 dbfn_delete(dbm, newkey);
1326 printf("renamed %s\n", newkey);
1329 else wait->sequence--;
1332 /* If we have ended up with an empty main record, delete it
1333 and break the loop. Otherwise the new record will be scanned. */
1335 if (wait->count == 0 && wait->sequence == 0)
1337 dbfn_delete(dbm, key);
1338 printf("deleted %s (empty)\n", key);
1344 /* If not an empty main record, break the loop */
1349 /* Re-write the record if required */
1353 printf("updated %s\n", key);
1354 dbfn_write(dbm, key, wait, sizeof(dbdata_wait) +
1355 wait->count * MESSAGE_ID_LENGTH);
1359 /* If a retry record's key ends with a message-id, check that that message
1360 still exists; if not, remove this record. */
1362 else if (dbdata_type == type_retry)
1365 int len = Ustrlen(key);
1367 if (len < MESSAGE_ID_LENGTH + 1) continue;
1368 id = key + len - MESSAGE_ID_LENGTH - 1;
1369 if (*id++ != ':') continue;
1371 for (i = 0; i < MESSAGE_ID_LENGTH; i++)
1372 if (i == 6 || i == 13)
1373 { if (id[i] != '-') break; }
1375 { if (!isalnum(id[i])) break; }
1376 if (i < MESSAGE_ID_LENGTH) continue;
1378 Ustrncpy(buffer + path_len, id, MESSAGE_ID_LENGTH);
1379 sprintf(CS(buffer + path_len + MESSAGE_ID_LENGTH), "-D");
1381 if (Ustat(buffer, &statbuf) != 0)
1383 sprintf(CS(buffer + path_len), "%c/%s-D", id[5], id);
1384 if (Ustat(buffer, &statbuf) != 0)
1386 dbfn_delete(dbm, key);
1387 printf("deleted %s (no message)\n", key);
1394 printf("Tidying complete\n");
1398 #endif /* EXIM_TIDYDB */
1400 /* End of exim_dbutil.c */