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)
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 != NULL) *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];
554 /* Check the arguments, and open the database */
556 dbdata_type = check_args(argc, argv, US"dumpdb", US"");
557 spool_directory = argv[1];
558 if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
561 /* Scan the file, formatting the information for each entry. Note
562 that data is returned in a malloc'ed block, in order that it be
563 correctly aligned. */
565 for (uschar * key = dbfn_scan(dbm, TRUE, &cursor);
567 key = dbfn_scan(dbm, FALSE, &cursor))
571 dbdata_callout_cache *callout;
572 dbdata_ratelimit *ratelimit;
573 dbdata_ratelimit_unique *rate_unique;
574 dbdata_tls_session *session;
578 uschar name[MESSAGE_ID_LENGTH + 1];
580 rmark reset_point = store_mark();
582 /* Keep a copy of the key separate, as in some DBM's the pointer is into data
583 which might change. */
585 if (Ustrlen(key) > sizeof(keybuffer) - 1)
587 printf("**** Overlong key encountered: %s\n", key);
590 Ustrcpy(keybuffer, key);
592 if (!(value = dbfn_read_with_length(dbm, keybuffer, &length)))
593 fprintf(stderr, "**** Entry \"%s\" was in the key scan, but the record "
594 "was not found in the file - something is wrong!\n",
598 /* Note: don't use print_time more than once in one statement, since
599 it uses a single buffer. */
604 retry = (dbdata_retry *)value;
605 printf(" %s %d %d %s\n%s ", keybuffer, retry->basic_errno,
606 retry->more_errno, retry->text,
607 print_time(retry->first_failed));
608 printf("%s ", print_time(retry->last_try));
609 printf("%s %s\n", print_time(retry->next_try),
610 (retry->expired)? "*" : "");
614 wait = (dbdata_wait *)value;
615 printf("%s ", keybuffer);
617 name[MESSAGE_ID_LENGTH] = 0;
619 if (wait->count > WAIT_NAME_MAX)
622 "**** Data for %s corrupted\n count=%d=0x%x max=%d\n",
623 CS keybuffer, wait->count, wait->count, WAIT_NAME_MAX);
624 wait->count = WAIT_NAME_MAX;
625 yield = count_bad = 1;
627 for (int i = 1; i <= wait->count; i++)
629 Ustrncpy(name, t, MESSAGE_ID_LENGTH);
630 if (count_bad && name[0] == 0) break;
631 if (Ustrlen(name) != MESSAGE_ID_LENGTH ||
632 Ustrspn(name, "0123456789"
633 "abcdefghijklmnopqrstuvwxyz"
634 "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
637 "**** Data for %s corrupted: bad character in message id\n",
639 for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
640 fprintf(stderr, "%02x ", name[j]);
641 fprintf(stderr, "\n");
646 t += MESSAGE_ID_LENGTH;
652 printf("%s %s\n", print_time(((dbdata_generic *)value)->time_stamp),
657 callout = (dbdata_callout_cache *)value;
659 /* New-style address record */
661 if (length == sizeof(dbdata_callout_cache_address))
663 printf("%s %s callout=%s\n",
664 print_time(((dbdata_generic *)value)->time_stamp),
666 print_cache(callout->result));
669 /* New-style domain record */
671 else if (length == sizeof(dbdata_callout_cache))
673 printf("%s %s callout=%s postmaster=%s",
674 print_time(((dbdata_generic *)value)->time_stamp),
676 print_cache(callout->result),
677 print_cache(callout->postmaster_result));
678 if (callout->postmaster_result != ccache_unknown)
679 printf(" (%s)", print_time(callout->postmaster_stamp));
680 printf(" random=%s", print_cache(callout->random_result));
681 if (callout->random_result != ccache_unknown)
682 printf(" (%s)", print_time(callout->random_stamp));
689 if (Ustrstr(key, "/unique/") != NULL && length >= sizeof(*rate_unique))
691 ratelimit = (dbdata_ratelimit *)value;
692 rate_unique = (dbdata_ratelimit_unique *)value;
693 printf("%s.%06d rate: %10.3f epoch: %s size: %u key: %s\n",
694 print_time(ratelimit->time_stamp),
695 ratelimit->time_usec, ratelimit->rate,
696 print_time(rate_unique->bloom_epoch), rate_unique->bloom_size,
701 ratelimit = (dbdata_ratelimit *)value;
702 printf("%s.%06d rate: %10.3f key: %s\n",
703 print_time(ratelimit->time_stamp),
704 ratelimit->time_usec, ratelimit->rate,
710 session = (dbdata_tls_session *)value;
711 printf(" %s %.*s\n", keybuffer, length, session->session);
715 store_reset(reset_point);
722 #endif /* EXIM_DUMPDB */
728 /*************************************************
729 * The exim_fixdb main program *
730 *************************************************/
732 /* In order not to hold the database lock any longer than is necessary, each
733 operation on the database uses a separate open/close call. This is expensive,
734 but then using this utility is not expected to be very common. Its main use is
735 to provide a way of patching up hints databases in order to run tests.
740 This causes the data from the given record to be displayed, or "not found"
741 to be output. Note that in the retry database, destination names are
742 preceded by R: or T: for router or transport retry info.
745 This causes the given record to be deleted or "not found" to be output.
747 (3) <record name> <field number> <value>
748 This sets the given value into the given field, identified by a number
749 which is output by the display command. Not all types of record can
753 This exits from exim_fixdb.
755 If the record name is omitted from (2) or (3), the previously used record name
759 int main(int argc, char **cargv)
762 uschar **argv = USS cargv;
767 name[0] = 0; /* No name set */
769 /* Sort out the database type, verify what we are working on and then process
772 dbdata_type = check_args(argc, argv, US"fixdb", US"");
773 printf("Modifying Exim hints database %s/db/%s\n", argv[1], argv[2]);
775 for(; (reset_point = store_mark()); store_reset(reset_point))
782 dbdata_callout_cache *callout;
783 dbdata_ratelimit *ratelimit;
784 dbdata_ratelimit_unique *rate_unique;
785 dbdata_tls_session *session;
788 uschar field[256], value[256];
791 if (Ufgets(buffer, 256, stdin) == NULL) break;
793 buffer[Ustrlen(buffer)-1] = 0;
794 field[0] = value[0] = 0;
796 /* If the buffer contains just one digit, or just consists of "d", use the
797 previous name for an update. */
799 if ((isdigit((uschar)buffer[0]) && (buffer[1] == ' ' || buffer[1] == '\0'))
800 || Ustrcmp(buffer, "d") == 0)
804 printf("No previous record name is set\n");
807 (void)sscanf(CS buffer, "%s %s", field, value);
812 (void)sscanf(CS buffer, "%s %s %s", name, field, value);
815 /* Handle an update request */
820 spool_directory = argv[1];
822 if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
825 if (Ustrcmp(field, "d") == 0)
827 if (value[0] != 0) printf("unexpected value after \"d\"\n");
828 else printf("%s\n", (dbfn_delete(dbm, name) < 0)?
829 "not found" : "deleted");
834 else if (isdigit((uschar)field[0]))
836 int fieldno = Uatoi(field);
839 printf("value missing\n");
845 record = dbfn_read_with_length(dbm, name, &oldlength);
846 if (record == NULL) printf("not found\n"); else
849 /*int length = 0; Stops compiler warning */
854 retry = (dbdata_retry *)record;
855 /* length = sizeof(dbdata_retry) + Ustrlen(retry->text); */
859 case 0: retry->basic_errno = Uatoi(value);
861 case 1: retry->more_errno = Uatoi(value);
863 case 2: if ((tt = read_time(value)) > 0) retry->first_failed = tt;
864 else printf("bad time value\n");
866 case 3: if ((tt = read_time(value)) > 0) retry->last_try = tt;
867 else printf("bad time value\n");
869 case 4: if ((tt = read_time(value)) > 0) retry->next_try = tt;
870 else printf("bad time value\n");
872 case 5: if (Ustrcmp(value, "yes") == 0) retry->expired = TRUE;
873 else if (Ustrcmp(value, "no") == 0) retry->expired = FALSE;
874 else printf("\"yes\" or \"no\" expected=n");
876 default: printf("unknown field number\n");
883 printf("Can't change contents of wait database record\n");
887 printf("Can't change contents of misc database record\n");
891 callout = (dbdata_callout_cache *)record;
892 /* length = sizeof(dbdata_callout_cache); */
895 case 0: callout->result = Uatoi(value);
897 case 1: callout->postmaster_result = Uatoi(value);
899 case 2: callout->random_result = Uatoi(value);
901 default: printf("unknown field number\n");
908 ratelimit = (dbdata_ratelimit *)record;
911 case 0: if ((tt = read_time(value)) > 0) ratelimit->time_stamp = tt;
912 else printf("bad time value\n");
914 case 1: ratelimit->time_usec = Uatoi(value);
916 case 2: ratelimit->rate = Ustrtod(value, NULL);
918 case 3: if (Ustrstr(name, "/unique/") != NULL
919 && oldlength >= sizeof(dbdata_ratelimit_unique))
921 rate_unique = (dbdata_ratelimit_unique *)record;
922 if ((tt = read_time(value)) > 0) rate_unique->bloom_epoch = tt;
923 else printf("bad time value\n");
926 /* else fall through */
928 case 5: if (Ustrstr(name, "/unique/") != NULL
929 && oldlength >= sizeof(dbdata_ratelimit_unique))
937 md5_end(&md5info, value, Ustrlen(value), md5sum);
938 hash = md5sum[0] << 0 | md5sum[1] << 8
939 | md5sum[2] << 16 | md5sum[3] << 24;
940 hinc = md5sum[4] << 0 | md5sum[5] << 8
941 | md5sum[6] << 16 | md5sum[7] << 24;
942 rate_unique = (dbdata_ratelimit_unique *)record;
944 for (unsigned n = 0; n < 8; n++, hash += hinc)
946 int bit = 1 << (hash % 8);
947 int byte = (hash / 8) % rate_unique->bloom_size;
948 if ((rate_unique->bloom[byte] & bit) == 0)
951 if (fieldno == 5) rate_unique->bloom[byte] |= bit;
955 seen ? "seen" : fieldno == 5 ? "added" : "unseen", value);
958 /* else fall through */
959 default: printf("unknown field number\n");
966 printf("Can't change contents of tls database record\n");
970 dbfn_write(dbm, name, record, oldlength);
977 printf("field number or d expected\n");
982 if (!verify) continue;
985 /* The "name" q causes an exit */
987 else if (Ustrcmp(name, "q") == 0) return 0;
989 /* Handle a read request, or verify after an update. */
991 spool_directory = argv[1];
992 if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
995 if (!(record = dbfn_read_with_length(dbm, name, &oldlength)))
997 printf("record %s not found\n", name);
1003 printf("%s\n", CS print_time(((dbdata_generic *)record)->time_stamp));
1007 retry = (dbdata_retry *)record;
1008 printf("0 error number: %d %s\n", retry->basic_errno, retry->text);
1009 printf("1 extra data: %d\n", retry->more_errno);
1010 printf("2 first failed: %s\n", print_time(retry->first_failed));
1011 printf("3 last try: %s\n", print_time(retry->last_try));
1012 printf("4 next try: %s\n", print_time(retry->next_try));
1013 printf("5 expired: %s\n", (retry->expired)? "yes" : "no");
1017 wait = (dbdata_wait *)record;
1019 printf("Sequence: %d\n", wait->sequence);
1020 if (wait->count > WAIT_NAME_MAX)
1022 printf("**** Data corrupted: count=%d=0x%x max=%d ****\n", wait->count,
1023 wait->count, WAIT_NAME_MAX);
1024 wait->count = WAIT_NAME_MAX;
1027 for (int i = 1; i <= wait->count; i++)
1029 Ustrncpy(value, t, MESSAGE_ID_LENGTH);
1030 value[MESSAGE_ID_LENGTH] = 0;
1031 if (count_bad && value[0] == 0) break;
1032 if (Ustrlen(value) != MESSAGE_ID_LENGTH ||
1033 Ustrspn(value, "0123456789"
1034 "abcdefghijklmnopqrstuvwxyz"
1035 "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
1037 printf("\n**** Data corrupted: bad character in message id ****\n");
1038 for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
1039 printf("%02x ", value[j]);
1043 printf("%s ", value);
1044 t += MESSAGE_ID_LENGTH;
1053 callout = (dbdata_callout_cache *)record;
1054 printf("0 callout: %s (%d)\n", print_cache(callout->result),
1056 if (oldlength > sizeof(dbdata_callout_cache_address))
1058 printf("1 postmaster: %s (%d)\n", print_cache(callout->postmaster_result),
1059 callout->postmaster_result);
1060 printf("2 random: %s (%d)\n", print_cache(callout->random_result),
1061 callout->random_result);
1065 case type_ratelimit:
1066 ratelimit = (dbdata_ratelimit *)record;
1067 printf("0 time stamp: %s\n", print_time(ratelimit->time_stamp));
1068 printf("1 fract. time: .%06d\n", ratelimit->time_usec);
1069 printf("2 sender rate: % .3f\n", ratelimit->rate);
1070 if (Ustrstr(name, "/unique/") != NULL
1071 && oldlength >= sizeof(dbdata_ratelimit_unique))
1073 rate_unique = (dbdata_ratelimit_unique *)record;
1074 printf("3 filter epoch: %s\n", print_time(rate_unique->bloom_epoch));
1075 printf("4 test filter membership\n");
1076 printf("5 add element to filter\n");
1081 session = (dbdata_tls_session *)value;
1082 printf("0 time stamp: %s\n", print_time(session->time_stamp));
1083 printf("1 session: .%s\n", session->session);
1088 /* The database is closed after each request */
1097 #endif /* EXIM_FIXDB */
1102 /*************************************************
1103 * The exim_tidydb main program *
1104 *************************************************/
1107 /* Utility program to tidy the contents of an exim database file. There is one
1110 -t <time> expiry time for old records - default 30 days
1112 For backwards compatibility, an -f option is recognized and ignored. (It used
1113 to request a "full" tidy. This version always does the whole job.) */
1116 typedef struct key_item {
1117 struct key_item *next;
1122 int main(int argc, char **cargv)
1124 struct stat statbuf;
1125 int maxkeep = 30 * 24 * 60 * 60;
1126 int dbdata_type, i, oldest, path_len;
1127 key_item *keychain = NULL;
1131 EXIM_CURSOR *cursor;
1132 uschar **argv = USS cargv;
1136 /* Scan the options */
1138 for (i = 1; i < argc; i++)
1140 if (argv[i][0] != '-') break;
1141 if (Ustrcmp(argv[i], "-f") == 0) continue;
1142 if (Ustrcmp(argv[i], "-t") == 0)
1150 if (!isdigit(*s)) usage(US"tidydb", US" [-t <time>]");
1151 (void)sscanf(CS s, "%d%n", &value, &count);
1155 case 'w': value *= 7;
1156 case 'd': value *= 24;
1157 case 'h': value *= 60;
1158 case 'm': value *= 60;
1161 default: usage(US"tidydb", US" [-t <time>]");
1166 else usage(US"tidydb", US" [-t <time>]");
1169 /* Adjust argument values and process arguments */
1174 dbdata_type = check_args(argc, argv, US"tidydb", US" [-t <time>]");
1176 /* Compute the oldest keep time, verify what we are doing, and open the
1179 oldest = time(NULL) - maxkeep;
1180 printf("Tidying Exim hints database %s/db/%s\n", argv[1], argv[2]);
1182 spool_directory = argv[1];
1183 if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
1186 /* Prepare for building file names */
1188 sprintf(CS buffer, "%s/input/", argv[1]);
1189 path_len = Ustrlen(buffer);
1192 /* It appears, by experiment, that it is a bad idea to make changes
1193 to the file while scanning it. Pity the man page doesn't warn you about that.
1194 Therefore, we scan and build a list of all the keys. Then we use that to
1195 read the records and possibly update them. */
1197 for (key = dbfn_scan(dbm, TRUE, &cursor);
1199 key = dbfn_scan(dbm, FALSE, &cursor))
1201 key_item *k = store_get(sizeof(key_item) + Ustrlen(key), is_tainted(key));
1204 Ustrcpy(k->key, key);
1207 /* Now scan the collected keys and operate on the records, resetting
1208 the store each time round. */
1210 for (; keychain && (reset_point = store_mark()); store_reset(reset_point))
1212 dbdata_generic *value;
1214 key = keychain->key;
1215 keychain = keychain->next;
1216 value = dbfn_read_with_length(dbm, key, NULL);
1218 /* A continuation record may have been deleted or renamed already, so
1219 non-existence is not serious. */
1221 if (value == NULL) continue;
1223 /* Delete if too old */
1225 if (value->time_stamp < oldest)
1227 printf("deleted %s (too old)\n", key);
1228 dbfn_delete(dbm, key);
1232 /* Do database-specific tidying for wait databases, and message-
1233 specific tidying for the retry database. */
1235 if (dbdata_type == type_wait)
1237 dbdata_wait *wait = (dbdata_wait *)value;
1238 BOOL update = FALSE;
1240 /* Leave corrupt records alone */
1242 if (wait->count > WAIT_NAME_MAX)
1244 printf("**** Data for %s corrupted\n count=%d=0x%x max=%d\n",
1245 key, wait->count, wait->count, WAIT_NAME_MAX);
1249 /* Loop for renamed continuation records. For each message id,
1250 check to see if the message exists, and if not, remove its entry
1251 from the record. Because of the possibility of split input directories,
1252 we must look in both possible places for a -D file. */
1256 int length = wait->count * MESSAGE_ID_LENGTH;
1258 for (int offset = length - MESSAGE_ID_LENGTH;
1259 offset >= 0; offset -= MESSAGE_ID_LENGTH)
1261 Ustrncpy(buffer+path_len, wait->text + offset, MESSAGE_ID_LENGTH);
1262 sprintf(CS(buffer+path_len + MESSAGE_ID_LENGTH), "-D");
1264 if (Ustat(buffer, &statbuf) != 0)
1266 buffer[path_len] = wait->text[offset+5];
1267 buffer[path_len+1] = '/';
1268 Ustrncpy(buffer+path_len+2, wait->text + offset, MESSAGE_ID_LENGTH);
1269 sprintf(CS(buffer+path_len+2 + MESSAGE_ID_LENGTH), "-D");
1271 if (Ustat(buffer, &statbuf) != 0)
1273 int left = length - offset - MESSAGE_ID_LENGTH;
1274 if (left > 0) Ustrncpy(wait->text + offset,
1275 wait->text + offset + MESSAGE_ID_LENGTH, left);
1277 length -= MESSAGE_ID_LENGTH;
1283 /* If record is empty and the main record, either delete it or rename
1284 the next continuation, repeating if that is also empty. */
1286 if (wait->count == 0 && Ustrchr(key, ':') == NULL)
1288 while (wait->count == 0 && wait->sequence > 0)
1291 dbdata_generic *newvalue;
1292 sprintf(CS newkey, "%s:%d", key, wait->sequence - 1);
1293 newvalue = dbfn_read_with_length(dbm, newkey, NULL);
1294 if (newvalue != NULL)
1297 wait = (dbdata_wait *)newvalue;
1298 dbfn_delete(dbm, newkey);
1299 printf("renamed %s\n", newkey);
1302 else wait->sequence--;
1305 /* If we have ended up with an empty main record, delete it
1306 and break the loop. Otherwise the new record will be scanned. */
1308 if (wait->count == 0 && wait->sequence == 0)
1310 dbfn_delete(dbm, key);
1311 printf("deleted %s (empty)\n", key);
1317 /* If not an empty main record, break the loop */
1322 /* Re-write the record if required */
1326 printf("updated %s\n", key);
1327 dbfn_write(dbm, key, wait, sizeof(dbdata_wait) +
1328 wait->count * MESSAGE_ID_LENGTH);
1332 /* If a retry record's key ends with a message-id, check that that message
1333 still exists; if not, remove this record. */
1335 else if (dbdata_type == type_retry)
1338 int len = Ustrlen(key);
1340 if (len < MESSAGE_ID_LENGTH + 1) continue;
1341 id = key + len - MESSAGE_ID_LENGTH - 1;
1342 if (*id++ != ':') continue;
1344 for (i = 0; i < MESSAGE_ID_LENGTH; i++)
1345 if (i == 6 || i == 13)
1346 { if (id[i] != '-') break; }
1348 { if (!isalnum(id[i])) break; }
1349 if (i < MESSAGE_ID_LENGTH) continue;
1351 Ustrncpy(buffer + path_len, id, MESSAGE_ID_LENGTH);
1352 sprintf(CS(buffer + path_len + MESSAGE_ID_LENGTH), "-D");
1354 if (Ustat(buffer, &statbuf) != 0)
1356 sprintf(CS(buffer + path_len), "%c/%s-D", id[5], id);
1357 if (Ustat(buffer, &statbuf) != 0)
1359 dbfn_delete(dbm, key);
1360 printf("deleted %s (no message)\n", key);
1367 printf("Tidying complete\n");
1371 #endif /* EXIM_TIDYDB */
1373 /* End of exim_dbutil.c */