Adding upstream version 4.94.2.upstream/4.94.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1399 insertions, 0 deletions

diff --git a/src/exim_dbutil.c b/src/exim_dbutil.c
new file mode 100644
index 0000000..bd7b538
--- /dev/null
+++ b/src/exim_dbutil.c
@@ -0,0 +1,1399 @@
+/*************************************************
+*     Exim - an Internet mail transport agent    *
+*************************************************/
+
+/* Copyright (c) University of Cambridge 1995 - 2018 */
+/* Copyright (c) The Exim Maintainers 2020 */
+/* See the file NOTICE for conditions of use and distribution. */
+
+
+/* This single source file is used to compile three utility programs for
+maintaining Exim hints databases.
+
+  exim_dumpdb     dumps out the contents
+  exim_fixdb      patches the database (really for Exim maintenance/testing)
+  exim_tidydb     removed obsolete data
+
+In all cases, the first argument is the name of the spool directory. The second
+argument is the name of the database file. The available names are:
+
+  retry:      retry delivery information
+  misc:       miscellaneous hints data
+  wait-<t>:   message waiting information; <t> is a transport name
+  callout:    callout verification cache
+  tls:	      TLS session resumption cache
+
+There are a number of common subroutines, followed by three main programs,
+whose inclusion is controlled by -D on the compilation command. */
+
+
+#include "exim.h"
+
+
+/* Identifiers for the different database types. */
+
+#define type_retry     1
+#define type_wait      2
+#define type_misc      3
+#define type_callout   4
+#define type_ratelimit 5
+#define type_tls       6
+
+
+/* This is used by our cut-down dbfn_open(). */
+
+uschar *spool_directory;
+
+
+/******************************************************************************/
+      /* dummies needed by Solaris build */
+void
+millisleep(int msec)
+{}
+uschar *
+readconf_printtime(int t)
+{ return NULL; }
+gstring *
+string_vformat_trc(gstring * g, const uschar * func, unsigned line,
+  unsigned size_limit, unsigned flags, const char *format, va_list ap)
+{ return NULL; }
+uschar *
+string_sprintf_trc(const char * fmt, const uschar * func, unsigned line, ...)
+{ return NULL; }
+BOOL
+string_format_trc(uschar * buf, int len, const uschar * func, unsigned line,
+  const char * fmt, ...)
+{ return FALSE; }
+
+struct global_flags	f;
+unsigned int		log_selector[1];
+uschar *		queue_name;
+BOOL			split_spool_directory;
+/******************************************************************************/
+
+
+/*************************************************
+*         Berkeley DB error callback             *
+*************************************************/
+
+/* For Berkeley DB >= 2, we can define a function to be called in case of DB
+errors. This should help with debugging strange DB problems, e.g. getting "File
+exists" when you try to open a db file. The API changed at release 4.3. */
+
+#if defined(USE_DB) && defined(DB_VERSION_STRING)
+void
+#if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
+dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
+{
+dbenv = dbenv;
+#else
+dbfn_bdb_error_callback(const char *pfx, char *msg)
+{
+#endif
+pfx = pfx;
+printf("Berkeley DB error: %s\n", msg);
+}
+#endif
+
+
+
+/*************************************************
+*              SIGALRM handler                   *
+*************************************************/
+
+SIGNAL_BOOL sigalrm_seen;
+
+void
+sigalrm_handler(int sig)
+{
+sig = sig;            /* Keep picky compilers happy */
+sigalrm_seen = 1;
+}
+
+
+
+/*************************************************
+*        Output usage message and exit           *
+*************************************************/
+
+static void
+usage(uschar *name, uschar *options)
+{
+printf("Usage: exim_%s%s  <spool-directory> <database-name>\n", name, options);
+printf("  <database-name> = retry | misc | wait-<transport-name> | callout | ratelimit | tls\n");
+exit(1);
+}
+
+
+
+/*************************************************
+*           Sort out the command arguments       *
+*************************************************/
+
+/* This function checks that there are exactly 2 arguments, and checks the
+second of them to be sure it is a known database name. */
+
+static int
+check_args(int argc, uschar **argv, uschar *name, uschar *options)
+{
+if (argc == 3)
+  {
+  if (Ustrcmp(argv[2], "retry") == 0) return type_retry;
+  if (Ustrcmp(argv[2], "misc") == 0) return type_misc;
+  if (Ustrncmp(argv[2], "wait-", 5) == 0) return type_wait;
+  if (Ustrcmp(argv[2], "callout") == 0) return type_callout;
+  if (Ustrcmp(argv[2], "ratelimit") == 0) return type_ratelimit;
+  if (Ustrcmp(argv[2], "tls") == 0) return type_tls;
+  }
+usage(name, options);
+return -1;              /* Never obeyed */
+}
+
+
+
+/*************************************************
+*         Handle attempts to write the log       *
+*************************************************/
+
+/* The message gets written to stderr when log_write() is called from a
+utility. The message always gets '\n' added on the end of it. These calls come
+from modules such as store.c when things go drastically wrong (e.g. malloc()
+failing). In normal use they won't get obeyed.
+
+Arguments:
+  selector  not relevant when running a utility
+  flags     not relevant when running a utility
+  format    a printf() format
+  ...       arguments for format
+
+Returns:    nothing
+*/
+
+void
+log_write(unsigned int selector, int flags, const char *format, ...)
+{
+va_list ap;
+va_start(ap, format);
+vfprintf(stderr, format, ap);
+fprintf(stderr, "\n");
+va_end(ap);
+selector = selector;     /* Keep picky compilers happy */
+flags = flags;
+}
+
+
+
+/*************************************************
+*        Format a time value for printing        *
+*************************************************/
+
+static uschar time_buffer[sizeof("09-xxx-1999 hh:mm:ss  ")];
+
+uschar *
+print_time(time_t t)
+{
+struct tm *tmstr = localtime(&t);
+Ustrftime(time_buffer, sizeof(time_buffer), "%d-%b-%Y %H:%M:%S", tmstr);
+return time_buffer;
+}
+
+
+
+/*************************************************
+*        Format a cache value for printing       *
+*************************************************/
+
+uschar *
+print_cache(int value)
+{
+return (value == ccache_accept)? US"accept" :
+       (value == ccache_reject)? US"reject" :
+       US"unknown";
+}
+
+
+#ifdef EXIM_FIXDB
+/*************************************************
+*                Read time value                 *
+*************************************************/
+
+static time_t
+read_time(uschar *s)
+{
+int field = 0;
+int value;
+time_t now = time(NULL);
+struct tm *tm = localtime(&now);
+
+tm->tm_sec = 0;
+tm->tm_isdst = -1;
+
+for (uschar * t = s + Ustrlen(s) - 1; t >= s; t--)
+  {
+  if (*t == ':') continue;
+  if (!isdigit((uschar)*t)) return -1;
+
+  value = *t - '0';
+  if (--t >= s)
+    {
+    if (!isdigit((uschar)*t)) return -1;
+    value = value + (*t - '0')*10;
+    }
+
+  switch (field++)
+    {
+    case 0: tm->tm_min = value; break;
+    case 1: tm->tm_hour = value; break;
+    case 2: tm->tm_mday = value; break;
+    case 3: tm->tm_mon = value - 1; break;
+    case 4: tm->tm_year = (value < 90)? value + 100 : value; break;
+    default: return -1;
+    }
+  }
+
+return mktime(tm);
+}
+#endif  /* EXIM_FIXDB */
+
+
+
+/*************************************************
+*       Open and lock a database file            *
+*************************************************/
+
+/* This is a cut-down version from the function in dbfn.h that Exim itself
+uses. We assume the database exists, and therefore give up if we cannot open
+the lock file.
+
+Arguments:
+  name     The single-component name of one of Exim's database files.
+  flags    O_RDONLY or O_RDWR
+  dbblock  Points to an open_db block to be filled in.
+  lof      Unused.
+  panic	   Unused
+
+Returns:   NULL if the open failed, or the locking failed.
+           On success, dbblock is returned. This contains the dbm pointer and
+           the fd of the locked lock file.
+*/
+
+open_db *
+dbfn_open(uschar *name, int flags, open_db *dbblock, BOOL lof, BOOL panic)
+{
+int rc;
+struct flock lock_data;
+BOOL read_only = flags == O_RDONLY;
+uschar * dirname, * filename;
+
+/* The first thing to do is to open a separate file on which to lock. This
+ensures that Exim has exclusive use of the database before it even tries to
+open it. If there is a database, there should be a lock file in existence. */
+
+#ifdef COMPILE_UTILITY
+if (  asprintf(CSS &dirname, "%s/db", spool_directory) < 0
+   || asprintf(CSS &filename, "%s/%s.lockfile", dirname, name) < 0)
+  return NULL;
+#else
+dirname = string_sprintf("%s/db", spool_directory);
+filename = string_sprintf("%s/%s.lockfile", dirname, name);
+#endif
+
+dbblock->lockfd = Uopen(filename, flags, 0);
+if (dbblock->lockfd < 0)
+  {
+  printf("** Failed to open database lock file %s: %s\n", filename,
+    strerror(errno));
+  return NULL;
+  }
+
+/* Now we must get a lock on the opened lock file; do this with a blocking
+lock that times out. */
+
+lock_data.l_type = read_only ? F_RDLCK : F_WRLCK;
+lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
+
+sigalrm_seen = FALSE;
+os_non_restarting_signal(SIGALRM, sigalrm_handler);
+ALARM(EXIMDB_LOCK_TIMEOUT);
+rc = fcntl(dbblock->lockfd, F_SETLKW, &lock_data);
+ALARM_CLR(0);
+
+if (sigalrm_seen) errno = ETIMEDOUT;
+if (rc < 0)
+  {
+  printf("** Failed to get %s lock for %s: %s",
+    flags & O_WRONLY ? "write" : "read",
+    filename,
+    errno == ETIMEDOUT ? "timed out" : strerror(errno));
+  (void)close(dbblock->lockfd);
+  return NULL;
+  }
+
+/* At this point we have an opened and locked separate lock file, that is,
+exclusive access to the database, so we can go ahead and open it. */
+
+#ifdef COMPILE_UTILITY
+if (asprintf(CSS &filename, "%s/%s", dirname, name) < 0) return NULL;
+#else
+filename = string_sprintf("%s/%s", dirname, name);
+#endif
+EXIM_DBOPEN(filename, dirname, flags, 0, &dbblock->dbptr);
+
+if (!dbblock->dbptr)
+  {
+  printf("** Failed to open DBM file %s for %s:\n   %s%s\n", filename,
+    read_only? "reading" : "writing", strerror(errno),
+    #ifdef USE_DB
+    " (or Berkeley DB error while opening)"
+    #else
+    ""
+    #endif
+    );
+  (void)close(dbblock->lockfd);
+  return NULL;
+  }
+
+return dbblock;
+}
+
+
+
+
+/*************************************************
+*         Unlock and close a database file       *
+*************************************************/
+
+/* Closing a file automatically unlocks it, so after closing the database, just
+close the lock file.
+
+Argument: a pointer to an open database block
+Returns:  nothing
+*/
+
+void
+dbfn_close(open_db *dbblock)
+{
+EXIM_DBCLOSE(dbblock->dbptr);
+(void)close(dbblock->lockfd);
+}
+
+
+
+
+/*************************************************
+*             Read from database file            *
+*************************************************/
+
+/* Passing back the pointer unchanged is useless, because there is no guarantee
+of alignment. Since all the records used by Exim need to be properly aligned to
+pick out the timestamps, etc., do the copying centrally here.
+
+Arguments:
+  dbblock   a pointer to an open database block
+  key       the key of the record to be read
+  length    where to put the length (or NULL if length not wanted). Includes overhead.
+
+Returns: a pointer to the retrieved record, or
+         NULL if the record is not found
+*/
+
+void *
+dbfn_read_with_length(open_db *dbblock, const uschar *key, int *length)
+{
+void *yield;
+EXIM_DATUM key_datum, result_datum;
+int klen = Ustrlen(key) + 1;
+uschar * key_copy = store_get(klen, is_tainted(key));
+
+memcpy(key_copy, key, klen);
+
+EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
+EXIM_DATUM_INIT(result_datum);      /* to be cleared before use. */
+EXIM_DATUM_DATA(key_datum) = CS key_copy;
+EXIM_DATUM_SIZE(key_datum) = klen;
+
+if (!EXIM_DBGET(dbblock->dbptr, key_datum, result_datum)) return NULL;
+
+/* Assume for now that anything stored could have been tainted. Properly
+we should store the taint status along with the data. */
+
+yield = store_get(EXIM_DATUM_SIZE(result_datum), TRUE);
+memcpy(yield, EXIM_DATUM_DATA(result_datum), EXIM_DATUM_SIZE(result_datum));
+if (length) *length = EXIM_DATUM_SIZE(result_datum);
+
+EXIM_DATUM_FREE(result_datum);    /* Some DBM libs require freeing */
+return yield;
+}
+
+
+
+#if defined(EXIM_TIDYDB) || defined(EXIM_FIXDB)
+
+/*************************************************
+*             Write to database file             *
+*************************************************/
+
+/*
+Arguments:
+  dbblock   a pointer to an open database block
+  key       the key of the record to be written
+  ptr       a pointer to the record to be written
+  length    the length of the record to be written
+
+Returns:    the yield of the underlying dbm or db "write" function. If this
+            is dbm, the value is zero for OK.
+*/
+
+int
+dbfn_write(open_db *dbblock, const uschar *key, void *ptr, int length)
+{
+EXIM_DATUM key_datum, value_datum;
+dbdata_generic *gptr = (dbdata_generic *)ptr;
+int klen = Ustrlen(key) + 1;
+uschar * key_copy = store_get(klen, is_tainted(key));
+
+memcpy(key_copy, key, klen);
+gptr->time_stamp = time(NULL);
+
+EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
+EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
+EXIM_DATUM_DATA(key_datum) = CS key_copy;
+EXIM_DATUM_SIZE(key_datum) = klen;
+EXIM_DATUM_DATA(value_datum) = CS ptr;
+EXIM_DATUM_SIZE(value_datum) = length;
+return EXIM_DBPUT(dbblock->dbptr, key_datum, value_datum);
+}
+
+
+
+/*************************************************
+*           Delete record from database file     *
+*************************************************/
+
+/*
+Arguments:
+  dbblock    a pointer to an open database block
+  key        the key of the record to be deleted
+
+Returns: the yield of the underlying dbm or db "delete" function.
+*/
+
+int
+dbfn_delete(open_db *dbblock, const uschar *key)
+{
+int klen = Ustrlen(key) + 1;
+uschar * key_copy = store_get(klen, is_tainted(key));
+
+memcpy(key_copy, key, klen);
+EXIM_DATUM key_datum;
+EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require clearing */
+EXIM_DATUM_DATA(key_datum) = CS key_copy;
+EXIM_DATUM_SIZE(key_datum) = klen;
+return EXIM_DBDEL(dbblock->dbptr, key_datum);
+}
+
+#endif  /* EXIM_TIDYDB || EXIM_FIXDB */
+
+
+
+#if defined(EXIM_DUMPDB) || defined(EXIM_TIDYDB)
+/*************************************************
+*         Scan the keys of a database file       *
+*************************************************/
+
+/*
+Arguments:
+  dbblock  a pointer to an open database block
+  start    TRUE if starting a new scan
+           FALSE if continuing with the current scan
+  cursor   a pointer to a pointer to a cursor anchor, for those dbm libraries
+           that use the notion of a cursor
+
+Returns:   the next record from the file, or
+           NULL if there are no more
+*/
+
+uschar *
+dbfn_scan(open_db *dbblock, BOOL start, EXIM_CURSOR **cursor)
+{
+EXIM_DATUM key_datum, value_datum;
+uschar *yield;
+value_datum = value_datum;    /* dummy; not all db libraries use this */
+
+/* Some dbm require an initialization */
+
+if (start) EXIM_DBCREATE_CURSOR(dbblock->dbptr, cursor);
+
+EXIM_DATUM_INIT(key_datum);         /* Some DBM libraries require the datum */
+EXIM_DATUM_INIT(value_datum);       /* to be cleared before use. */
+
+yield = (EXIM_DBSCAN(dbblock->dbptr, key_datum, value_datum, start, *cursor))?
+  US EXIM_DATUM_DATA(key_datum) : NULL;
+
+/* Some dbm require a termination */
+
+if (!yield) EXIM_DBDELETE_CURSOR(*cursor);
+return yield;
+}
+#endif  /* EXIM_DUMPDB || EXIM_TIDYDB */
+
+
+
+#ifdef EXIM_DUMPDB
+/*************************************************
+*           The exim_dumpdb main program         *
+*************************************************/
+
+int
+main(int argc, char **cargv)
+{
+int dbdata_type = 0;
+int yield = 0;
+open_db dbblock;
+open_db *dbm;
+EXIM_CURSOR *cursor;
+uschar **argv = USS cargv;
+uschar keybuffer[1024];
+
+/* Check the arguments, and open the database */
+
+dbdata_type = check_args(argc, argv, US"dumpdb", US"");
+spool_directory = argv[1];
+if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
+  exit(1);
+
+/* Scan the file, formatting the information for each entry. Note
+that data is returned in a malloc'ed block, in order that it be
+correctly aligned. */
+
+for (uschar * key = dbfn_scan(dbm, TRUE, &cursor);
+     key;
+     key = dbfn_scan(dbm, FALSE, &cursor))
+  {
+  dbdata_retry *retry;
+  dbdata_wait *wait;
+  dbdata_callout_cache *callout;
+  dbdata_ratelimit *ratelimit;
+  dbdata_ratelimit_unique *rate_unique;
+  dbdata_tls_session *session;
+  int count_bad = 0;
+  int length;
+  uschar *t;
+  uschar name[MESSAGE_ID_LENGTH + 1];
+  void *value;
+  rmark reset_point = store_mark();
+
+  /* Keep a copy of the key separate, as in some DBM's the pointer is into data
+  which might change. */
+
+  if (Ustrlen(key) > sizeof(keybuffer) - 1)
+    {
+    printf("**** Overlong key encountered: %s\n", key);
+    return 1;
+    }
+  Ustrcpy(keybuffer, key);
+
+  if (!(value = dbfn_read_with_length(dbm, keybuffer, &length)))
+    fprintf(stderr, "**** Entry \"%s\" was in the key scan, but the record "
+                    "was not found in the file - something is wrong!\n",
+      CS keybuffer);
+  else
+    {
+    /* Note: don't use print_time more than once in one statement, since
+    it uses a single buffer. */
+
+    switch(dbdata_type)
+      {
+      case type_retry:
+	retry = (dbdata_retry *)value;
+	printf("  %s %d %d %s\n%s  ", keybuffer, retry->basic_errno,
+	  retry->more_errno, retry->text,
+	  print_time(retry->first_failed));
+	printf("%s  ", print_time(retry->last_try));
+	printf("%s %s\n", print_time(retry->next_try),
+	  (retry->expired)? "*" : "");
+	break;
+
+      case type_wait:
+	wait = (dbdata_wait *)value;
+	printf("%s ", keybuffer);
+	t = wait->text;
+	name[MESSAGE_ID_LENGTH] = 0;
+
+    /* Leave corrupt records alone */
+	if (wait->count > WAIT_NAME_MAX)
+	  {
+	  fprintf(stderr,
+	    "**** Data for %s corrupted\n  count=%d=0x%x max=%d\n",
+	    CS keybuffer, wait->count, wait->count, WAIT_NAME_MAX);
+	  wait->count = WAIT_NAME_MAX;
+	  yield = count_bad = 1;
+	  }
+	for (int i = 1; i <= wait->count; i++)
+	  {
+	  Ustrncpy(name, t, MESSAGE_ID_LENGTH);
+	  if (count_bad && name[0] == 0) break;
+	  if (Ustrlen(name) != MESSAGE_ID_LENGTH ||
+	      Ustrspn(name, "0123456789"
+			    "abcdefghijklmnopqrstuvwxyz"
+			    "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
+	    {
+	    fprintf(stderr,
+	      "**** Data for %s corrupted: bad character in message id\n",
+	      CS keybuffer);
+	    for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
+	      fprintf(stderr, "%02x ", name[j]);
+	    fprintf(stderr, "\n");
+	    yield = 1;
+	    break;
+	    }
+	  printf("%s ", name);
+	  t += MESSAGE_ID_LENGTH;
+	  }
+	printf("\n");
+	break;
+
+      case type_misc:
+	printf("%s %s\n", print_time(((dbdata_generic *)value)->time_stamp),
+	  keybuffer);
+	break;
+
+      case type_callout:
+	callout = (dbdata_callout_cache *)value;
+
+	/* New-style address record */
+
+	if (length == sizeof(dbdata_callout_cache_address))
+	  {
+	  printf("%s %s callout=%s\n",
+	    print_time(((dbdata_generic *)value)->time_stamp),
+	    keybuffer,
+	    print_cache(callout->result));
+	  }
+
+	/* New-style domain record */
+
+	else if (length == sizeof(dbdata_callout_cache))
+	  {
+	  printf("%s %s callout=%s postmaster=%s",
+	    print_time(((dbdata_generic *)value)->time_stamp),
+	    keybuffer,
+	    print_cache(callout->result),
+	    print_cache(callout->postmaster_result));
+	  if (callout->postmaster_result != ccache_unknown)
+	    printf(" (%s)", print_time(callout->postmaster_stamp));
+	  printf(" random=%s", print_cache(callout->random_result));
+	  if (callout->random_result != ccache_unknown)
+	    printf(" (%s)", print_time(callout->random_stamp));
+	  printf("\n");
+	  }
+
+	break;
+
+      case type_ratelimit:
+	if (Ustrstr(key, "/unique/") != NULL && length >= sizeof(*rate_unique))
+	  {
+	  ratelimit = (dbdata_ratelimit *)value;
+	  rate_unique = (dbdata_ratelimit_unique *)value;
+	  printf("%s.%06d rate: %10.3f epoch: %s size: %u key: %s\n",
+	    print_time(ratelimit->time_stamp),
+	    ratelimit->time_usec, ratelimit->rate,
+	    print_time(rate_unique->bloom_epoch), rate_unique->bloom_size,
+	    keybuffer);
+	  }
+	else
+	  {
+	  ratelimit = (dbdata_ratelimit *)value;
+	  printf("%s.%06d rate: %10.3f key: %s\n",
+	    print_time(ratelimit->time_stamp),
+	    ratelimit->time_usec, ratelimit->rate,
+	    keybuffer);
+	  }
+	break;
+
+      case type_tls:
+	session = (dbdata_tls_session *)value;
+	printf("  %s %.*s\n", keybuffer, length, session->session);
+	break;
+      }
+    }
+  store_reset(reset_point);
+  }
+
+dbfn_close(dbm);
+return yield;
+}
+
+#endif  /* EXIM_DUMPDB */
+
+
+
+
+#ifdef EXIM_FIXDB
+/*************************************************
+*           The exim_fixdb main program          *
+*************************************************/
+
+/* In order not to hold the database lock any longer than is necessary, each
+operation on the database uses a separate open/close call. This is expensive,
+but then using this utility is not expected to be very common. Its main use is
+to provide a way of patching up hints databases in order to run tests.
+
+Syntax of commands:
+
+(1) <record name>
+    This causes the data from the given record to be displayed, or "not found"
+    to be output. Note that in the retry database, destination names are
+    preceded by R: or T: for router or transport retry info.
+
+(2) <record name> d
+    This causes the given record to be deleted or "not found" to be output.
+
+(3) <record name> <field number> <value>
+    This sets the given value into the given field, identified by a number
+    which is output by the display command. Not all types of record can
+    be changed.
+
+(4) q
+    This exits from exim_fixdb.
+
+If the record name is omitted from (2) or (3), the previously used record name
+is re-used. */
+
+
+int main(int argc, char **cargv)
+{
+int dbdata_type;
+uschar **argv = USS cargv;
+uschar buffer[256];
+uschar name[256];
+rmark reset_point;
+
+name[0] = 0;  /* No name set */
+
+/* Sort out the database type, verify what we are working on and then process
+user requests */
+
+dbdata_type = check_args(argc, argv, US"fixdb", US"");
+printf("Modifying Exim hints database %s/db/%s\n", argv[1], argv[2]);
+
+for(; (reset_point = store_mark()); store_reset(reset_point))
+  {
+  open_db dbblock;
+  open_db *dbm;
+  void *record;
+  dbdata_retry *retry;
+  dbdata_wait *wait;
+  dbdata_callout_cache *callout;
+  dbdata_ratelimit *ratelimit;
+  dbdata_ratelimit_unique *rate_unique;
+  dbdata_tls_session *session;
+  int oldlength;
+  uschar *t;
+  uschar field[256], value[256];
+
+  printf("> ");
+  if (Ufgets(buffer, 256, stdin) == NULL) break;
+
+  buffer[Ustrlen(buffer)-1] = 0;
+  field[0] = value[0] = 0;
+
+  /* If the buffer contains just one digit, or just consists of "d", use the
+  previous name for an update. */
+
+  if ((isdigit((uschar)buffer[0]) && (buffer[1] == ' ' || buffer[1] == '\0'))
+       || Ustrcmp(buffer, "d") == 0)
+    {
+    if (name[0] == 0)
+      {
+      printf("No previous record name is set\n");
+      continue;
+      }
+    (void)sscanf(CS buffer, "%s %s", field, value);
+    }
+  else
+    {
+    name[0] = 0;
+    (void)sscanf(CS buffer, "%s %s %s", name, field, value);
+    }
+
+  /* Handle an update request */
+
+  if (field[0] != 0)
+    {
+    int verify = 1;
+    spool_directory = argv[1];
+
+    if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
+      continue;
+
+    if (Ustrcmp(field, "d") == 0)
+      {
+      if (value[0] != 0) printf("unexpected value after \"d\"\n");
+        else printf("%s\n", (dbfn_delete(dbm, name) < 0)?
+          "not found" : "deleted");
+      dbfn_close(dbm);
+      continue;
+      }
+
+    else if (isdigit((uschar)field[0]))
+      {
+      int fieldno = Uatoi(field);
+      if (value[0] == 0)
+        {
+        printf("value missing\n");
+        dbfn_close(dbm);
+        continue;
+        }
+      else
+        {
+        record = dbfn_read_with_length(dbm, name, &oldlength);
+        if (record == NULL) printf("not found\n"); else
+          {
+          time_t tt;
+          /*int length = 0;      Stops compiler warning */
+
+          switch(dbdata_type)
+            {
+            case type_retry:
+	      retry = (dbdata_retry *)record;
+	      /* length = sizeof(dbdata_retry) + Ustrlen(retry->text); */
+
+	      switch(fieldno)
+		{
+		case 0: retry->basic_errno = Uatoi(value);
+			break;
+		case 1: retry->more_errno = Uatoi(value);
+			break;
+		case 2: if ((tt = read_time(value)) > 0) retry->first_failed = tt;
+			else printf("bad time value\n");
+			break;
+		case 3: if ((tt = read_time(value)) > 0) retry->last_try = tt;
+			else printf("bad time value\n");
+			break;
+		case 4: if ((tt = read_time(value)) > 0) retry->next_try = tt;
+			else printf("bad time value\n");
+			break;
+		case 5: if (Ustrcmp(value, "yes") == 0) retry->expired = TRUE;
+			else if (Ustrcmp(value, "no") == 0) retry->expired = FALSE;
+			else printf("\"yes\" or \"no\" expected=n");
+			break;
+		default: printf("unknown field number\n");
+			 verify = 0;
+			 break;
+		}
+	      break;
+
+            case type_wait:
+	      printf("Can't change contents of wait database record\n");
+	      break;
+
+            case type_misc:
+	      printf("Can't change contents of misc database record\n");
+	      break;
+
+            case type_callout:
+	      callout = (dbdata_callout_cache *)record;
+	      /* length = sizeof(dbdata_callout_cache); */
+	      switch(fieldno)
+		{
+		case 0: callout->result = Uatoi(value);
+			break;
+		case 1: callout->postmaster_result = Uatoi(value);
+			break;
+		case 2: callout->random_result = Uatoi(value);
+			break;
+		default: printf("unknown field number\n");
+			 verify = 0;
+			 break;
+		}
+		break;
+
+            case type_ratelimit:
+	      ratelimit = (dbdata_ratelimit *)record;
+	      switch(fieldno)
+		{
+		case 0: if ((tt = read_time(value)) > 0) ratelimit->time_stamp = tt;
+			else printf("bad time value\n");
+			break;
+		case 1: ratelimit->time_usec = Uatoi(value);
+			break;
+		case 2: ratelimit->rate = Ustrtod(value, NULL);
+			break;
+		case 3: if (Ustrstr(name, "/unique/") != NULL
+			    && oldlength >= sizeof(dbdata_ratelimit_unique))
+			  {
+			  rate_unique = (dbdata_ratelimit_unique *)record;
+			  if ((tt = read_time(value)) > 0) rate_unique->bloom_epoch = tt;
+			    else printf("bad time value\n");
+			  break;
+			  }
+			/* else fall through */
+		case 4:
+		case 5: if (Ustrstr(name, "/unique/") != NULL
+			    && oldlength >= sizeof(dbdata_ratelimit_unique))
+			  {
+			  /* see acl.c */
+			  BOOL seen;
+			  unsigned hash, hinc;
+			  uschar md5sum[16];
+			  md5 md5info;
+			  md5_start(&md5info);
+			  md5_end(&md5info, value, Ustrlen(value), md5sum);
+			  hash = md5sum[0] <<  0 | md5sum[1] <<  8
+			       | md5sum[2] << 16 | md5sum[3] << 24;
+			  hinc = md5sum[4] <<  0 | md5sum[5] <<  8
+			       | md5sum[6] << 16 | md5sum[7] << 24;
+			  rate_unique = (dbdata_ratelimit_unique *)record;
+			  seen = TRUE;
+			  for (unsigned n = 0; n < 8; n++, hash += hinc)
+			    {
+			    int bit = 1 << (hash % 8);
+			    int byte = (hash / 8) % rate_unique->bloom_size;
+			    if ((rate_unique->bloom[byte] & bit) == 0)
+			      {
+			      seen = FALSE;
+			      if (fieldno == 5) rate_unique->bloom[byte] |= bit;
+			      }
+			    }
+			  printf("%s %s\n",
+			    seen ? "seen" : fieldno == 5 ? "added" : "unseen", value);
+			  break;
+			  }
+			/* else fall through */
+		default: printf("unknown field number\n");
+			 verify = 0;
+			 break;
+		}
+	      break;
+
+            case type_tls:
+	      printf("Can't change contents of tls database record\n");
+	      break;
+            }
+
+          dbfn_write(dbm, name, record, oldlength);
+          }
+        }
+      }
+
+    else
+      {
+      printf("field number or d expected\n");
+      verify = 0;
+      }
+
+    dbfn_close(dbm);
+    if (!verify) continue;
+    }
+
+  /* The "name" q causes an exit */
+
+  else if (Ustrcmp(name, "q") == 0) return 0;
+
+  /* Handle a read request, or verify after an update. */
+
+  spool_directory = argv[1];
+  if (!(dbm = dbfn_open(argv[2], O_RDONLY, &dbblock, FALSE, TRUE)))
+    continue;
+
+  if (!(record = dbfn_read_with_length(dbm, name, &oldlength)))
+    {
+    printf("record %s not found\n", name);
+    name[0] = 0;
+    }
+  else
+    {
+    int count_bad = 0;
+    printf("%s\n", CS print_time(((dbdata_generic *)record)->time_stamp));
+    switch(dbdata_type)
+      {
+      case type_retry:
+	retry = (dbdata_retry *)record;
+	printf("0 error number: %d %s\n", retry->basic_errno, retry->text);
+	printf("1 extra data:   %d\n", retry->more_errno);
+	printf("2 first failed: %s\n", print_time(retry->first_failed));
+	printf("3 last try:     %s\n", print_time(retry->last_try));
+	printf("4 next try:     %s\n", print_time(retry->next_try));
+	printf("5 expired:      %s\n", (retry->expired)? "yes" : "no");
+	break;
+
+      case type_wait:
+	wait = (dbdata_wait *)record;
+	t = wait->text;
+	printf("Sequence: %d\n", wait->sequence);
+	if (wait->count > WAIT_NAME_MAX)
+	  {
+	  printf("**** Data corrupted: count=%d=0x%x max=%d ****\n", wait->count,
+	    wait->count, WAIT_NAME_MAX);
+	  wait->count = WAIT_NAME_MAX;
+	  count_bad = 1;
+	  }
+	for (int i = 1; i <= wait->count; i++)
+	  {
+	  Ustrncpy(value, t, MESSAGE_ID_LENGTH);
+	  value[MESSAGE_ID_LENGTH] = 0;
+	  if (count_bad && value[0] == 0) break;
+	  if (Ustrlen(value) != MESSAGE_ID_LENGTH ||
+	      Ustrspn(value, "0123456789"
+			    "abcdefghijklmnopqrstuvwxyz"
+			    "ABCDEFGHIJKLMNOPQRSTUVWXYZ-") != MESSAGE_ID_LENGTH)
+	    {
+	    printf("\n**** Data corrupted: bad character in message id ****\n");
+	    for (int j = 0; j < MESSAGE_ID_LENGTH; j++)
+	      printf("%02x ", value[j]);
+	    printf("\n");
+	    break;
+	    }
+	  printf("%s ", value);
+	  t += MESSAGE_ID_LENGTH;
+	  }
+	printf("\n");
+	break;
+
+      case type_misc:
+	break;
+
+      case type_callout:
+	callout = (dbdata_callout_cache *)record;
+	printf("0 callout:    %s (%d)\n", print_cache(callout->result),
+	    callout->result);
+	if (oldlength > sizeof(dbdata_callout_cache_address))
+	  {
+	  printf("1 postmaster: %s (%d)\n", print_cache(callout->postmaster_result),
+	      callout->postmaster_result);
+	  printf("2 random:     %s (%d)\n", print_cache(callout->random_result),
+	      callout->random_result);
+	  }
+	break;
+
+      case type_ratelimit:
+	ratelimit = (dbdata_ratelimit *)record;
+	printf("0 time stamp:  %s\n", print_time(ratelimit->time_stamp));
+	printf("1 fract. time: .%06d\n", ratelimit->time_usec);
+	printf("2 sender rate: % .3f\n", ratelimit->rate);
+	if (Ustrstr(name, "/unique/") != NULL
+	 && oldlength >= sizeof(dbdata_ratelimit_unique))
+	 {
+	 rate_unique = (dbdata_ratelimit_unique *)record;
+	 printf("3 filter epoch: %s\n", print_time(rate_unique->bloom_epoch));
+	 printf("4 test filter membership\n");
+	 printf("5 add element to filter\n");
+	 }
+	break;
+
+      case type_tls:
+	session = (dbdata_tls_session *)value;
+	printf("0 time stamp:  %s\n", print_time(session->time_stamp));
+	printf("1 session: .%s\n", session->session);
+	break;
+      }
+    }
+
+  /* The database is closed after each request */
+
+  dbfn_close(dbm);
+  }
+
+printf("\n");
+return 0;
+}
+
+#endif  /* EXIM_FIXDB */
+
+
+
+#ifdef EXIM_TIDYDB
+/*************************************************
+*           The exim_tidydb main program         *
+*************************************************/
+
+
+/* Utility program to tidy the contents of an exim database file. There is one
+option:
+
+   -t <time>  expiry time for old records - default 30 days
+
+For backwards compatibility, an -f option is recognized and ignored. (It used
+to request a "full" tidy. This version always does the whole job.) */
+
+
+typedef struct key_item {
+  struct key_item *next;
+  uschar key[1];
+} key_item;
+
+
+int main(int argc, char **cargv)
+{
+struct stat statbuf;
+int maxkeep = 30 * 24 * 60 * 60;
+int dbdata_type, i, oldest, path_len;
+key_item *keychain = NULL;
+rmark reset_point;
+open_db dbblock;
+open_db *dbm;
+EXIM_CURSOR *cursor;
+uschar **argv = USS cargv;
+uschar buffer[256];
+uschar *key;
+
+/* Scan the options */
+
+for (i = 1; i < argc; i++)
+  {
+  if (argv[i][0] != '-') break;
+  if (Ustrcmp(argv[i], "-f") == 0) continue;
+  if (Ustrcmp(argv[i], "-t") == 0)
+    {
+    uschar *s;
+    s = argv[++i];
+    maxkeep = 0;
+    while (*s != 0)
+      {
+      int value, count;
+      if (!isdigit(*s)) usage(US"tidydb", US" [-t <time>]");
+      (void)sscanf(CS s, "%d%n", &value, &count);
+      s += count;
+      switch (*s)
+        {
+        case 'w': value *= 7;
+        case 'd': value *= 24;
+        case 'h': value *= 60;
+        case 'm': value *= 60;
+        case 's': s++;
+        break;
+        default: usage(US"tidydb", US" [-t <time>]");
+        }
+      maxkeep += value;
+      }
+    }
+  else usage(US"tidydb", US" [-t <time>]");
+  }
+
+/* Adjust argument values and process arguments */
+
+argc -= --i;
+argv += i;
+
+dbdata_type = check_args(argc, argv, US"tidydb", US" [-t <time>]");
+
+/* Compute the oldest keep time, verify what we are doing, and open the
+database */
+
+oldest = time(NULL) - maxkeep;
+printf("Tidying Exim hints database %s/db/%s\n", argv[1], argv[2]);
+
+spool_directory = argv[1];
+if (!(dbm = dbfn_open(argv[2], O_RDWR, &dbblock, FALSE, TRUE)))
+  exit(1);
+
+/* Prepare for building file names */
+
+sprintf(CS buffer, "%s/input/", argv[1]);
+path_len = Ustrlen(buffer);
+
+
+/* It appears, by experiment, that it is a bad idea to make changes
+to the file while scanning it. Pity the man page doesn't warn you about that.
+Therefore, we scan and build a list of all the keys. Then we use that to
+read the records and possibly update them. */
+
+for (key = dbfn_scan(dbm, TRUE, &cursor);
+     key;
+     key = dbfn_scan(dbm, FALSE, &cursor))
+  {
+  key_item *k = store_get(sizeof(key_item) + Ustrlen(key), is_tainted(key));
+  k->next = keychain;
+  keychain = k;
+  Ustrcpy(k->key, key);
+  }
+
+/* Now scan the collected keys and operate on the records, resetting
+the store each time round. */
+
+for (; keychain && (reset_point = store_mark()); store_reset(reset_point))
+  {
+  dbdata_generic *value;
+
+  key = keychain->key;
+  keychain = keychain->next;
+  value = dbfn_read_with_length(dbm, key, NULL);
+
+  /* A continuation record may have been deleted or renamed already, so
+  non-existence is not serious. */
+
+  if (!value) continue;
+
+  /* Delete if too old */
+
+  if (value->time_stamp < oldest)
+    {
+    printf("deleted %s (too old)\n", key);
+    dbfn_delete(dbm, key);
+    continue;
+    }
+
+  /* Do database-specific tidying for wait databases, and message-
+  specific tidying for the retry database. */
+
+  if (dbdata_type == type_wait)
+    {
+    dbdata_wait *wait = (dbdata_wait *)value;
+    BOOL update = FALSE;
+
+    /* Leave corrupt records alone */
+
+    if (wait->time_stamp > time(NULL))
+      {
+      printf("**** Data for '%s' corrupted\n  time in future: %s\n",
+        key, print_time(((dbdata_generic *)value)->time_stamp));
+      continue;
+      }
+    if (wait->count > WAIT_NAME_MAX)
+      {
+      printf("**** Data for '%s' corrupted\n  count=%d=0x%x max=%d\n",
+        key, wait->count, wait->count, WAIT_NAME_MAX);
+      continue;
+      }
+    if (wait->sequence > WAIT_CONT_MAX)
+      {
+      printf("**** Data for '%s' corrupted\n  sequence=%d=0x%x max=%d\n",
+        key, wait->sequence, wait->sequence, WAIT_CONT_MAX);
+      continue;
+      }
+
+    /* Record over 1 year old; just remove it */
+
+    if (wait->time_stamp < time(NULL) - 365*24*60*60)
+      {
+      dbfn_delete(dbm, key);
+      printf("deleted %s (too old)\n", key);
+      continue;
+      }
+
+    /* Loop for renamed continuation records. For each message id,
+    check to see if the message exists, and if not, remove its entry
+    from the record. Because of the possibility of split input directories,
+    we must look in both possible places for a -D file. */
+
+    for (;;)
+      {
+      int length = wait->count * MESSAGE_ID_LENGTH;
+
+      for (int offset = length - MESSAGE_ID_LENGTH;
+           offset >= 0; offset -= MESSAGE_ID_LENGTH)
+        {
+        Ustrncpy(buffer+path_len, wait->text + offset, MESSAGE_ID_LENGTH);
+        sprintf(CS(buffer+path_len + MESSAGE_ID_LENGTH), "-D");
+
+        if (Ustat(buffer, &statbuf) != 0)
+          {
+          buffer[path_len] = wait->text[offset+5];
+          buffer[path_len+1] = '/';
+          Ustrncpy(buffer+path_len+2, wait->text + offset, MESSAGE_ID_LENGTH);
+          sprintf(CS(buffer+path_len+2 + MESSAGE_ID_LENGTH), "-D");
+
+          if (Ustat(buffer, &statbuf) != 0)
+            {
+            int left = length - offset - MESSAGE_ID_LENGTH;
+            if (left > 0) Ustrncpy(wait->text + offset,
+              wait->text + offset + MESSAGE_ID_LENGTH, left);
+            wait->count--;
+            length -= MESSAGE_ID_LENGTH;
+            update = TRUE;
+            }
+          }
+        }
+
+      /* If record is empty and the main record, either delete it or rename
+      the next continuation, repeating if that is also empty. */
+
+      if (wait->count == 0 && Ustrchr(key, ':') == NULL)
+        {
+        while (wait->count == 0 && wait->sequence > 0)
+          {
+          uschar newkey[256];
+          dbdata_generic *newvalue;
+          sprintf(CS newkey, "%s:%d", key, wait->sequence - 1);
+          newvalue = dbfn_read_with_length(dbm, newkey, NULL);
+          if (newvalue != NULL)
+            {
+            value = newvalue;
+            wait = (dbdata_wait *)newvalue;
+            dbfn_delete(dbm, newkey);
+            printf("renamed %s\n", newkey);
+            update = TRUE;
+            }
+          else wait->sequence--;
+          }
+
+        /* If we have ended up with an empty main record, delete it
+        and break the loop. Otherwise the new record will be scanned. */
+
+        if (wait->count == 0 && wait->sequence == 0)
+          {
+          dbfn_delete(dbm, key);
+          printf("deleted %s (empty)\n", key);
+          update = FALSE;
+          break;
+          }
+        }
+
+      /* If not an empty main record, break the loop */
+
+      else break;
+      }
+
+    /* Re-write the record if required */
+
+    if (update)
+      {
+      printf("updated %s\n", key);
+      dbfn_write(dbm, key, wait, sizeof(dbdata_wait) +
+        wait->count * MESSAGE_ID_LENGTH);
+      }
+    }
+
+  /* If a retry record's key ends with a message-id, check that that message
+  still exists; if not, remove this record. */
+
+  else if (dbdata_type == type_retry)
+    {
+    uschar *id;
+    int len = Ustrlen(key);
+
+    if (len < MESSAGE_ID_LENGTH + 1) continue;
+    id = key + len - MESSAGE_ID_LENGTH - 1;
+    if (*id++ != ':') continue;
+
+    for (i = 0; i < MESSAGE_ID_LENGTH; i++)
+      if (i == 6 || i == 13)
+        { if (id[i] != '-') break; }
+      else
+        { if (!isalnum(id[i])) break; }
+    if (i < MESSAGE_ID_LENGTH) continue;
+
+    Ustrncpy(buffer + path_len, id, MESSAGE_ID_LENGTH);
+    sprintf(CS(buffer + path_len + MESSAGE_ID_LENGTH), "-D");
+
+    if (Ustat(buffer, &statbuf) != 0)
+      {
+      sprintf(CS(buffer + path_len), "%c/%s-D", id[5], id);
+      if (Ustat(buffer, &statbuf) != 0)
+        {
+        dbfn_delete(dbm, key);
+        printf("deleted %s (no message)\n", key);
+        }
+      }
+    }
+  }
+
+dbfn_close(dbm);
+printf("Tidying complete\n");
+return 0;
+}
+
+#endif  /* EXIM_TIDYDB */
+
+/* End of exim_dbutil.c */