cppcheck silencing

[exim.git] / src / src / exim.c

diff --git a/src/src/exim.c b/src/src/exim.c
index 517b5435ebc675fb6ac6ef5a746a5870faea749b..201bf6e8e5cb92d17a601cf45bab882c0c5592c3 100644 (file)
--- a/src/src/exim.c
+++ b/src/src/exim.c
@@ -2,8 +2,10 @@
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 

-/* Copyright (c) University of Cambridge 1995 - 2014 */
+/* Copyright (c) The Exim Maintainers 2020 - 2024 */
+/* Copyright (c) University of Cambridge 1995 - 2018 */

 /* See the file NOTICE for conditions of use and distribution. */
 /* See the file NOTICE for conditions of use and distribution. */

+/* SPDX-License-Identifier: GPL-2.0-or-later */

 
 
 /* The main function: entry point, initialization, and high-level control.
 
 
 /* The main function: entry point, initialization, and high-level control.


@@ -12,7 +14,26 @@ Also a few functions that don't naturally fit elsewhere. */
 
 #include "exim.h"
 
 
 #include "exim.h"
 

+#if defined(__GLIBC__) && !defined(__UCLIBC__)
+# include <gnu/libc-version.h>
+#endif
+
+#ifndef _TIME_H
+# include <time.h>
+#endif
+#ifndef NO_EXECINFO
+# include <execinfo.h>
+#endif
+
+#ifdef USE_GNUTLS
+# include <gnutls/gnutls.h>
+# if GNUTLS_VERSION_NUMBER < 0x030103 && !defined(DISABLE_OCSP)
+#  define DISABLE_OCSP
+# endif
+#endif
+

 extern void init_lookup_list(void);
 extern void init_lookup_list(void);

+extern void init_misc_mod_list(void);

 
 
 
 
 
 


@@ -24,29 +45,36 @@ extern void init_lookup_list(void);
 for store allocation via Exim's store manager. The normal calls are actually
 macros that pass over location information to make tracing easier. These
 functions just interface to the standard macro calls. A good compiler will
 for store allocation via Exim's store manager. The normal calls are actually
 macros that pass over location information to make tracing easier. These
 functions just interface to the standard macro calls. A good compiler will

-optimize out the tail recursion and so not make them too expensive. There
-are two sets of functions; one for use when we want to retain the compiled
-regular expression for a long time; the other for short-term use. */
+optimize out the tail recursion and so not make them too expensive. */

 
 static void *
 
 static void *

-function_store_get(size_t size)
+function_store_malloc(PCRE2_SIZE size, void * tag)

 {
 {

-return store_get((int)size);
+if (size > INT_MAX)
+  log_write(0, LOG_MAIN|LOG_PANIC_DIE, "excessive memory alloc request");
+return store_malloc((int)size);

 }
 
 static void
 }
 
 static void

-function_dummy_free(void *block) { block = block; }
+function_store_free(void * block, void * tag)
+{
+/* At least some version of pcre2 pass a null pointer */
+if (block) store_free(block);
+}
+

 
 static void *
 
 static void *

-function_store_malloc(size_t size)
+function_store_get(PCRE2_SIZE size, void * tag)

 {
 {

-return store_malloc((int)size);
+if (size > INT_MAX)
+  log_write(0, LOG_MAIN|LOG_PANIC_DIE, "excessive memory alloc request");
+return store_get((int)size, GET_UNTAINTED);    /* loses track of taint */

 }
 
 static void
 }
 
 static void

-function_store_free(void *block)
+function_store_nullfree(void * block, void * tag)

 {
 {

-store_free(block);
+/* We cannot free memory allocated using store_get() */

 }
 
 
 }
 
 


@@ -62,44 +90,16 @@ enum commandline_info { CMDINFO_NONE=0,
 
 
 
 
 
 

-/*************************************************
-*  Compile regular expression and panic on fail  *
-*************************************************/
-
-/* This function is called when failure to compile a regular expression leads
-to a panic exit. In other cases, pcre_compile() is called directly. In many
-cases where this function is used, the results of the compilation are to be
-placed in long-lived store, so we temporarily reset the store management
-functions that PCRE uses if the use_malloc flag is set.
-
-Argument:
-  pattern     the pattern to compile
-  caseless    TRUE if caseless matching is required
-  use_malloc  TRUE if compile into malloc store
+static void
+pcre_init(void)
+{
+pcre_mlc_ctx = pcre2_general_context_create(function_store_malloc, function_store_free, NULL);
+pcre_gen_ctx = pcre2_general_context_create(function_store_get, function_store_nullfree, NULL);

 
 

-Returns:      pointer to the compiled pattern
-*/
+pcre_mlc_cmp_ctx = pcre2_compile_context_create(pcre_mlc_ctx);
+pcre_gen_cmp_ctx = pcre2_compile_context_create(pcre_gen_ctx);

 
 

-const pcre *
-regex_must_compile(uschar *pattern, BOOL caseless, BOOL use_malloc)
-{
-int offset;
-int options = PCRE_COPT;
-const pcre *yield;
-const uschar *error;
-if (use_malloc)
-  {
-  pcre_malloc = function_store_malloc;
-  pcre_free = function_store_free;
-  }
-if (caseless) options |= PCRE_CASELESS;
-yield = pcre_compile(CS pattern, options, (const char **)&error, &offset, NULL);
-pcre_malloc = function_store_get;
-pcre_free = function_dummy_free;
-if (yield == NULL)
-  log_write(0, LOG_MAIN|LOG_PANIC_DIE, "regular expression error: "
-    "%s at offset %d while compiling %s", error, offset, pattern);
-return yield;
+pcre_gen_mtc_ctx = pcre2_match_context_create(pcre_gen_ctx);

 }
 
 
 }
 
 


@@ -110,7 +110,10 @@ return yield;
 *************************************************/
 
 /* This function runs a regular expression match, and sets up the pointers to
 *************************************************/
 
 /* This function runs a regular expression match, and sets up the pointers to

-the matched substrings.
+the matched substrings.  The matched strings are copied so the lifetime of
+the subject is not a problem.  Matched strings will have the same taint status
+as the subject string (this is not a de-taint method, and must not be made so
+given the support for wildcards in REs).

 
 Arguments:
   re          the compiled expression
 
 Arguments:
   re          the compiled expression


@@ -120,32 +123,78 @@ Arguments:
               if >= 0 setup from setup+1 onwards,
                 excluding the full matched string
 
               if >= 0 setup from setup+1 onwards,
                 excluding the full matched string
 

-Returns:      TRUE or FALSE
+Returns:      TRUE if matched, or FALSE

 */
 
 BOOL
 */
 
 BOOL

-regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
+regex_match_and_setup(const pcre2_code * re, const uschar * subject, int options, int setup)

 {
 {

-int ovector[3*(EXPAND_MAXN+1)];
-int n = pcre_exec(re, NULL, CS subject, Ustrlen(subject), 0,
-  PCRE_EOPT | options, ovector, sizeof(ovector)/sizeof(int));
-BOOL yield = n >= 0;
-if (n == 0) n = EXPAND_MAXN + 1;
-if (yield)
+pcre2_match_data * md = pcre2_match_data_create_from_pattern(re, pcre_gen_ctx);
+int res = pcre2_match(re, (PCRE2_SPTR)subject, PCRE2_ZERO_TERMINATED, 0,
+                       PCRE_EOPT | options, md, pcre_gen_mtc_ctx);
+BOOL yield;
+
+if ((yield = (res >= 0)))

   {
   {

-  int nn;
-  expand_nmax = (setup < 0)? 0 : setup + 1;
-  for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
+  PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
+  res = pcre2_get_ovector_count(md);
+  expand_nmax = setup < 0 ? 0 : setup + 1;
+  for (int matchnum = setup < 0 ? 0 : 1; matchnum < res; matchnum++)

     {
     {

-    expand_nstring[expand_nmax] = subject + ovector[nn];
-    expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
+    /* Although PCRE2 has a pcre2_substring_get_bynumber() conveneience, it
+    seems to return a bad pointer when a capture group had no data, eg. (.*)
+    matching zero letters.  So use the underlying ovec and hope (!) that the
+    offsets are sane (including that case).  Should we go further and range-
+    check each one vs. the subject string length? */
+    int off = matchnum * 2;
+    int len = ovec[off + 1] - ovec[off];
+    expand_nstring[expand_nmax] = string_copyn(subject + ovec[off], len);
+    expand_nlength[expand_nmax++] = len;

     }
   expand_nmax--;
   }
     }
   expand_nmax--;
   }

+else if (res != PCRE2_ERROR_NOMATCH) DEBUG(D_any)
+  {
+  uschar errbuf[128];
+  pcre2_get_error_message(res, errbuf, sizeof(errbuf));
+  debug_printf_indent("pcre2: %s\n", errbuf);
+  }
+/* pcre2_match_data_free(md);  gen ctx needs no free */

 return yield;
 }
 
 
 return yield;
 }
 
 

+/* Check just for match with regex.  Uses the common memory-handling.
+
+Arguments:
+       re      compiled regex
+       subject string to be checked
+       slen    length of subject; -1 for nul-terminated
+       rptr    pointer for matched string, copied, or NULL
+
+Return: TRUE for a match.
+*/
+
+BOOL
+regex_match(const pcre2_code * re, const uschar * subject, int slen, uschar ** rptr)
+{
+pcre2_match_data * md = pcre2_match_data_create(1, pcre_gen_ctx);
+int rc = pcre2_match(re, (PCRE2_SPTR)subject,
+                     slen >= 0 ? slen : PCRE2_ZERO_TERMINATED,
+                     0, PCRE_EOPT, md, pcre_gen_mtc_ctx);
+PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
+BOOL ret = FALSE;
+
+if (rc >= 0)
+  {
+  if (rptr)
+    *rptr = string_copyn(subject + ovec[0], ovec[1] - ovec[0]);
+  ret = TRUE;
+  }
+/* pcre2_match_data_free(md);  gen ctx needs no free */
+return ret;
+}
+

 
 
 /*************************************************
 
 
 /*************************************************


@@ -160,24 +209,116 @@ Returns:   nothing
 */
 
 void
 */
 
 void

-set_process_info(const char *format, ...)
+set_process_info(const char * format, ...)

 {
 {

+gstring gs = { .size = PROCESS_INFO_SIZE - 2, .ptr = 0, .s = process_info };
+gstring * g;

 int len;
 int len;

+uschar * s;

 va_list ap;
 va_list ap;

-sprintf(CS process_info, "%5d ", (int)getpid());
-len = Ustrlen(process_info);
+
+g = string_fmt_append(&gs, "%5d ", (int)getpid());
+len = gstring_length(g);

 va_start(ap, format);
 va_start(ap, format);

-if (!string_vformat(process_info + len, PROCESS_INFO_SIZE - len - 2, format, ap))
-  Ustrcpy(process_info + len, "**** string overflowed buffer ****");
-len = Ustrlen(process_info);
-process_info[len+0] = '\n';
-process_info[len+1] = '\0';
-process_info_len = len + 1;
+if (!string_vformat(g, 0, format, ap))
+  {
+  gs.ptr = len;
+  g = string_cat(&gs, US"**** string overflowed buffer ****");
+  }
+g = string_catn(g, US"\n", 1);
+process_info_len = len_string_from_gstring(g, &s);

 DEBUG(D_process_info) debug_printf("set_process_info: %s", process_info);
 va_end(ap);
 }
 
 DEBUG(D_process_info) debug_printf("set_process_info: %s", process_info);
 va_end(ap);
 }
 

+/***********************************************
+*            Handler for SIGTERM               *
+***********************************************/
+
+static void
+term_handler(int sig)
+{
+exim_exit(EXIT_FAILURE);
+}
+
+
+/***********************************************
+*            Handler for SIGSEGV               *
+***********************************************/
+
+#define STACKDUMP_MAX 24
+void
+stackdump(void)
+{
+#ifndef NO_EXECINFO
+void * buf[STACKDUMP_MAX];
+char ** ss;
+int nptrs = backtrace(buf, STACKDUMP_MAX);
+
+log_write(0, LOG_MAIN|LOG_PANIC, "backtrace");
+log_write(0, LOG_MAIN|LOG_PANIC, "---");
+
+/* This function is officially not callable from a signal handler, as it
+calls malloc() for the returned data. However, it seems to work - and we
+know we're going on to crash anyway - so just hold our noses and do it.
+A alternative might be backtrace_symbols_fd(). */
+
+if ((ss = backtrace_symbols(buf, nptrs)))
+  {
+  for (int i = 0; i < nptrs; i++)
+    log_write(0, LOG_MAIN|LOG_PANIC, "\t%s", ss[i]);
+  free(ss);
+  }
+else
+  log_write(0, LOG_MAIN|LOG_PANIC, "backtrace_symbols: %s", strerror(errno));
+log_write(0, LOG_MAIN|LOG_PANIC, "---");
+#endif
+}
+#undef STACKDUMP_MAX
+
+
+static void
+#ifdef SA_SIGINFO
+segv_handler(int sig, siginfo_t * info, void * uctx)
+{
+if (!panic_coredump)
+  {
+  log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (fault address: %p)", info->si_addr);
+  # if defined(SEGV_MAPERR) && defined(SEGV_ACCERR) && defined(SEGV_BNDERR) && defined(SEGV_PKUERR)
+  switch (info->si_code)
+    {
+    case SEGV_MAPERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_MAPERR"); break;
+    case SEGV_ACCERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_ACCERR"); break;
+    case SEGV_BNDERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_BNDERR"); break;
+    case SEGV_PKUERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_PKUERR"); break;
+    }
+  # endif
+  }
+if (panic_coredump)
+  log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (deliberate trap)");
+else if (US info->si_addr < US 4096)
+  log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (null pointer indirection)");
+else
+  log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (maybe attempt to write to immutable memory)");
+if (process_info_len > 0)
+  log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (%s: %.*s)",
+    process_purpose, process_info_len, process_info);
+stackdump();
+signal(SIGSEGV, SIG_DFL);
+kill(getpid(), sig);
+}

 
 

+#else
+segv_handler(int sig)
+{
+log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (maybe attempt to write to immutable memory)");
+if (process_info_len > 0)
+  log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (%.*s)", process_info_len, process_info);
+stackdump();
+signal(SIGSEGV, SIG_DFL);
+kill(getpid(), sig);
+}
+#endif

 
 
 /*************************************************
 
 
 /*************************************************


@@ -202,19 +343,8 @@ int fd;
 
 os_restarting_signal(sig, usr1_handler);
 
 
 os_restarting_signal(sig, usr1_handler);
 

-fd = Uopen(process_log_path, O_APPEND|O_WRONLY, LOG_MODE);
-if (fd < 0)
-  {
-  /* If we are already running as the Exim user, try to create it in the
-  current process (assuming spool_directory exists). Otherwise, if we are
-  root, do the creation in an exim:exim subprocess. */
-
-  int euid = geteuid();
-  if (euid == exim_uid)
-    fd = Uopen(process_log_path, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
-  else if (euid == root_uid)
-    fd = log_create_as_exim(process_log_path);
-  }
+if (!process_log_path) return;
+fd = log_open_as_exim(process_log_path);

 
 /* If we are neither exim nor root, or if we failed to create the log file,
 give up. There is not much useful we can do with errors, since we don't want
 
 /* If we are neither exim nor root, or if we failed to create the log file,
 give up. There is not much useful we can do with errors, since we don't want


@@ -222,7 +352,7 @@ to disrupt whatever is going on outside the signal handler. */
 
 if (fd < 0) return;
 
 
 if (fd < 0) return;
 

-{int dummy = write(fd, process_info, process_info_len); dummy = dummy; }
+if (write(fd, process_info, process_info_len) != 0) ;

 (void)close(fd);
 }
 
 (void)close(fd);
 }
 


@@ -249,7 +379,6 @@ Returns:  nothing
 void
 sigalrm_handler(int sig)
 {
 void
 sigalrm_handler(int sig)
 {

-sig = sig;      /* Keep picky compilers happy */

 sigalrm_seen = TRUE;
 os_non_restarting_signal(SIGALRM, sigalrm_handler);
 }
 sigalrm_seen = TRUE;
 os_non_restarting_signal(SIGALRM, sigalrm_handler);
 }


@@ -267,6 +396,10 @@ will wait for ever, so we panic in this instance. (There was a case of this
 when a bug in a function that calls milliwait() caused it to pass invalid data.
 That's when I added the check. :-)
 
 when a bug in a function that calls milliwait() caused it to pass invalid data.
 That's when I added the check. :-)
 

+We assume it to be not worth sleeping for under 50us; this value will
+require revisiting as hardware advances.  This avoids the issue of
+a zero-valued timer setting meaning "never fire".
+

 Argument:  an itimerval structure containing the interval
 Returns:   nothing
 */
 Argument:  an itimerval structure containing the interval
 Returns:   nothing
 */


@@ -276,6 +409,10 @@ milliwait(struct itimerval *itval)
 {
 sigset_t sigmask;
 sigset_t old_sigmask;
 {
 sigset_t sigmask;
 sigset_t old_sigmask;

+int save_errno = errno;
+
+if (itval->it_value.tv_usec < 50 && itval->it_value.tv_sec == 0)
+  return;

 (void)sigemptyset(&sigmask);                           /* Empty mask */
 (void)sigaddset(&sigmask, SIGALRM);                    /* Add SIGALRM */
 (void)sigprocmask(SIG_BLOCK, &sigmask, &old_sigmask);  /* Block SIGALRM */
 (void)sigemptyset(&sigmask);                           /* Empty mask */
 (void)sigaddset(&sigmask, SIGALRM);                    /* Add SIGALRM */
 (void)sigprocmask(SIG_BLOCK, &sigmask, &old_sigmask);  /* Block SIGALRM */


@@ -286,6 +423,8 @@ if (setitimer(ITIMER_REAL, itval, NULL) < 0)           /* Start timer */
 (void)sigdelset(&sigmask, SIGALRM);                    /* Remove SIGALRM */
 (void)sigsuspend(&sigmask);                            /* Until SIGALRM */
 (void)sigprocmask(SIG_SETMASK, &old_sigmask, NULL);    /* Restore mask */
 (void)sigdelset(&sigmask, SIGALRM);                    /* Remove SIGALRM */
 (void)sigsuspend(&sigmask);                            /* Until SIGALRM */
 (void)sigprocmask(SIG_SETMASK, &old_sigmask, NULL);    /* Restore mask */

+errno = save_errno;
+sigalrm_seen = FALSE;

 }
 
 
 }
 
 


@@ -306,11 +445,9 @@ Returns:     nothing
 void
 millisleep(int msec)
 {
 void
 millisleep(int msec)
 {

-struct itimerval itval;
-itval.it_interval.tv_sec = 0;
-itval.it_interval.tv_usec = 0;
-itval.it_value.tv_sec = msec/1000;
-itval.it_value.tv_usec = (msec % 1000) * 1000;
+struct itimerval itval = {.it_interval = {.tv_sec = 0, .tv_usec = 0},
+                         .it_value = {.tv_sec = msec/1000,
+                                      .tv_usec = (msec % 1000) * 1000}};

 milliwait(&itval);
 }
 
 milliwait(&itval);
 }
 


@@ -328,7 +465,7 @@ Arguments:
 Returns:      -1, 0, or +1
 */
 
 Returns:      -1, 0, or +1
 */
 

-int
+static int

 exim_tvcmp(struct timeval *t1, struct timeval *t2)
 {
 if (t1->tv_sec > t2->tv_sec) return +1;
 exim_tvcmp(struct timeval *t1, struct timeval *t2)
 {
 if (t1->tv_sec > t2->tv_sec) return +1;


@@ -345,10 +482,58 @@ return 0;
 *          Clock tick wait function              *
 *************************************************/
 
 *          Clock tick wait function              *
 *************************************************/
 

+#ifdef _POSIX_MONOTONIC_CLOCK
+# ifdef CLOCK_BOOTTIME
+#  define EXIM_CLOCKTYPE CLOCK_BOOTTIME
+# else
+#  define EXIM_CLOCKTYPE CLOCK_MONOTONIC
+# endif
+
+/* Amount EXIM_CLOCK is behind realtime, at startup. */
+static struct timespec offset_ts;
+
+static void
+exim_clock_init(void)
+{
+struct timeval tv;
+if (clock_gettime(EXIM_CLOCKTYPE, &offset_ts) != 0) return;
+(void)gettimeofday(&tv, NULL);
+offset_ts.tv_sec = tv.tv_sec - offset_ts.tv_sec;
+offset_ts.tv_nsec = tv.tv_usec * 1000 - offset_ts.tv_nsec;
+if (offset_ts.tv_nsec >= 0) return;
+offset_ts.tv_sec--;
+offset_ts.tv_nsec += 1000*1000*1000;
+}
+#endif
+
+
+void
+exim_gettime(struct timeval * tv)
+{
+#ifdef _POSIX_MONOTONIC_CLOCK
+struct timespec now_ts;
+
+if (clock_gettime(EXIM_CLOCKTYPE, &now_ts) == 0)
+  {
+  now_ts.tv_sec += offset_ts.tv_sec;
+  if ((now_ts.tv_nsec += offset_ts.tv_nsec) >= 1000*1000*1000)
+    {
+    now_ts.tv_sec++;
+    now_ts.tv_nsec -= 1000*1000*1000;
+    }
+  tv->tv_sec = now_ts.tv_sec;
+  tv->tv_usec = now_ts.tv_nsec / 1000;
+  }
+else
+#endif
+  (void)gettimeofday(tv, NULL);
+}
+
+

 /* Exim uses a time + a pid to generate a unique identifier in two places: its
 message IDs, and in file names for maildir deliveries. Because some OS now
 re-use pids within the same second, sub-second times are now being used.
 /* Exim uses a time + a pid to generate a unique identifier in two places: its
 message IDs, and in file names for maildir deliveries. Because some OS now
 re-use pids within the same second, sub-second times are now being used.

-However, for absolute certaintly, we must ensure the clock has ticked before
+However, for absolute certainty, we must ensure the clock has ticked before

 allowing the relevant process to complete. At the time of implementation of
 this code (February 2003), the speed of processors is such that the clock will
 invariably have ticked already by the time a process has done its job. This
 allowing the relevant process to complete. At the time of implementation of
 this code (February 2003), the speed of processors is such that the clock will
 invariably have ticked already by the time a process has done its job. This


@@ -356,9 +541,10 @@ function prepares for the time when things are faster - and it also copes with
 clocks that go backwards.
 
 Arguments:
 clocks that go backwards.
 
 Arguments:

-  then_tv      A timeval which was used to create uniqueness; its usec field
+  prev_tv      A timeval which was used to create uniqueness; its usec field

                  has been rounded down to the value of the resolution.
                  We want to be sure the current time is greater than this.
                  has been rounded down to the value of the resolution.
                  We want to be sure the current time is greater than this.

+                On return, updated to current (rounded down).

   resolution   The resolution that was used to divide the microseconds
                  (1 for maildir, larger for message ids)
 
   resolution   The resolution that was used to divide the microseconds
                  (1 for maildir, larger for message ids)
 


@@ -366,26 +552,26 @@ Returns:       nothing
 */
 
 void
 */
 
 void

-exim_wait_tick(struct timeval *then_tv, int resolution)
+exim_wait_tick(struct timeval * prev_tv, int resolution)

 {
 struct timeval now_tv;
 long int now_true_usec;
 
 {
 struct timeval now_tv;
 long int now_true_usec;
 

-(void)gettimeofday(&now_tv, NULL);
+exim_gettime(&now_tv);

 now_true_usec = now_tv.tv_usec;
 now_tv.tv_usec = (now_true_usec/resolution) * resolution;
 
 now_true_usec = now_tv.tv_usec;
 now_tv.tv_usec = (now_true_usec/resolution) * resolution;
 

-if (exim_tvcmp(&now_tv, then_tv) <= 0)
+while (exim_tvcmp(&now_tv, prev_tv) <= 0)

   {
   struct itimerval itval;
   itval.it_interval.tv_sec = 0;
   itval.it_interval.tv_usec = 0;
   {
   struct itimerval itval;
   itval.it_interval.tv_sec = 0;
   itval.it_interval.tv_usec = 0;

-  itval.it_value.tv_sec = then_tv->tv_sec - now_tv.tv_sec;
-  itval.it_value.tv_usec = then_tv->tv_usec + resolution - now_true_usec;
+  itval.it_value.tv_sec = prev_tv->tv_sec - now_tv.tv_sec;
+  itval.it_value.tv_usec = prev_tv->tv_usec + resolution - now_true_usec;

 
   /* We know that, overall, "now" is less than or equal to "then". Therefore, a
   negative value for the microseconds is possible only in the case when "now"
 
   /* We know that, overall, "now" is less than or equal to "then". Therefore, a
   negative value for the microseconds is possible only in the case when "now"

-  is more than a second less than "then". That means that itval.it_value.tv_sec
+  is more than a second less than "tgt". That means that itval.it_value.tv_sec

   is greater than zero. The following correction is therefore safe. */
 
   if (itval.it_value.tv_usec < 0)
   is greater than zero. The following correction is therefore safe. */
 
   if (itval.it_value.tv_usec < 0)


@@ -396,18 +582,26 @@ if (exim_tvcmp(&now_tv, then_tv) <= 0)
 
   DEBUG(D_transport|D_receive)
     {
 
   DEBUG(D_transport|D_receive)
     {

-    if (!running_in_test_harness)
+    if (!f.running_in_test_harness)

       {
       {

-      debug_printf("tick check: %lu.%06lu %lu.%06lu\n",
-        then_tv->tv_sec, (long) then_tv->tv_usec,
+      debug_printf("tick check: " TIME_T_FMT ".%06lu " TIME_T_FMT ".%06lu\n",
+        prev_tv->tv_sec, (long) prev_tv->tv_usec,

                now_tv.tv_sec, (long) now_tv.tv_usec);
                now_tv.tv_sec, (long) now_tv.tv_usec);

-      debug_printf("waiting %lu.%06lu\n", itval.it_value.tv_sec,
-        (long) itval.it_value.tv_usec);
+      debug_printf("waiting " TIME_T_FMT ".%06lu sec\n",
+        itval.it_value.tv_sec, (long) itval.it_value.tv_usec);

       }
     }
 
   milliwait(&itval);
       }
     }
 
   milliwait(&itval);

+
+  /* Be prapared to go around if the kernel does not implement subtick
+  granularity (GNU Hurd) */
+
+  exim_gettime(&now_tv);
+  now_true_usec = now_tv.tv_usec;
+  now_tv.tv_usec = (now_true_usec/resolution) * resolution;

   }
   }

+*prev_tv = now_tv;

 }
 
 
 }
 
 


@@ -443,8 +637,6 @@ return f;
 }
 
 
 }
 
 

-
-

 /*************************************************
 *   Ensure stdin, stdout, and stderr exist       *
 *************************************************/
 /*************************************************
 *   Ensure stdin, stdout, and stderr exist       *
 *************************************************/


@@ -466,16 +658,15 @@ Returns:    Nothing
 void
 exim_nullstd(void)
 {
 void
 exim_nullstd(void)
 {

-int i;

 int devnull = -1;
 struct stat statbuf;
 int devnull = -1;
 struct stat statbuf;

-for (i = 0; i <= 2; i++)
+for (int i = 0; i <= 2; i++)

   {
   if (fstat(i, &statbuf) < 0 && errno == EBADF)
     {
     if (devnull < 0) devnull = open("/dev/null", O_RDWR);
     if (devnull < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
   {
   if (fstat(i, &statbuf) < 0 && errno == EBADF)
     {
     if (devnull < 0) devnull = open("/dev/null", O_RDWR);
     if (devnull < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",

-      string_open_failed(errno, "/dev/null"));
+      string_open_failed("/dev/null", NULL));

     if (devnull != i) (void)dup2(devnull, i);
     }
   }
     if (devnull != i) (void)dup2(devnull, i);
     }
   }


@@ -526,9 +717,9 @@ close_unwanted(void)
 {
 if (smtp_input)
   {
 {
 if (smtp_input)
   {

-  #ifdef SUPPORT_TLS
-  tls_close(TRUE, FALSE);      /* Shut down the TLS library */
-  #endif
+#ifndef DISABLE_TLS
+  tls_close(NULL, TLS_NO_SHUTDOWN);      /* Shut down the TLS library */
+#endif

   (void)close(fileno(smtp_in));
   (void)close(fileno(smtp_out));
   smtp_in = NULL;
   (void)close(fileno(smtp_in));
   (void)close(fileno(smtp_out));
   smtp_in = NULL;


@@ -539,7 +730,7 @@ else
   if ((debug_selector & D_resolver) == 0) (void)close(1);  /* stdout */
   if (debug_selector == 0)                                 /* stderr */
     {
   if ((debug_selector & D_resolver) == 0) (void)close(1);  /* stdout */
   if (debug_selector == 0)                                 /* stderr */
     {

-    if (!synchronous_delivery)
+    if (!f.synchronous_delivery)

       {
       (void)close(2);
       log_stderr = NULL;
       {
       (void)close(2);
       log_stderr = NULL;


@@ -572,7 +763,7 @@ Returns:     nothing; bombs out on failure
 */
 
 void
 */
 
 void

-exim_setugid(uid_t uid, gid_t gid, BOOL igflag, uschar *msg)
+exim_setugid(uid_t uid, gid_t gid, BOOL igflag, const uschar * msg)

 {
 uid_t euid = geteuid();
 gid_t egid = getegid();
 {
 uid_t euid = geteuid();
 gid_t egid = getegid();


@@ -585,21 +776,18 @@ if (euid == root_uid || euid != uid || egid != gid || igflag)
   if (igflag)
     {
     struct passwd *pw = getpwuid(uid);
   if (igflag)
     {
     struct passwd *pw = getpwuid(uid);

-    if (pw != NULL)
-      {
-      if (initgroups(pw->pw_name, gid) != 0)
-        log_write(0,LOG_MAIN|LOG_PANIC_DIE,"initgroups failed for uid=%ld: %s",
-          (long int)uid, strerror(errno));
-      }
-    else log_write(0, LOG_MAIN|LOG_PANIC_DIE, "cannot run initgroups(): "
-      "no passwd entry for uid=%ld", (long int)uid);
+    if (!pw)
+      log_write(0, LOG_MAIN|LOG_PANIC_DIE, "cannot run initgroups(): "
+       "no passwd entry for uid=%ld", (long int)uid);
+
+    if (initgroups(pw->pw_name, gid) != 0)
+      log_write(0,LOG_MAIN|LOG_PANIC_DIE,"initgroups failed for uid=%ld: %s",
+       (long int)uid, strerror(errno));

     }
 
   if (setgid(gid) < 0 || setuid(uid) < 0)
     }
 
   if (setgid(gid) < 0 || setuid(uid) < 0)

-    {

     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to set gid=%ld or uid=%ld "
       "(euid=%ld): %s", (long int)gid, (long int)uid, (long int)euid, msg);
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to set gid=%ld or uid=%ld "
       "(euid=%ld): %s", (long int)gid, (long int)uid, (long int)euid, msg);

-    }

   }
 
 /* Debugging output included uid/gid and all groups */
   }
 
 /* Debugging output included uid/gid and all groups */


@@ -607,17 +795,14 @@ if (euid == root_uid || euid != uid || egid != gid || igflag)
 DEBUG(D_uid)
   {
   int group_count, save_errno;
 DEBUG(D_uid)
   {
   int group_count, save_errno;

-  gid_t group_list[NGROUPS_MAX];
+  gid_t group_list[EXIM_GROUPLIST_SIZE];

   debug_printf("changed uid/gid: %s\n  uid=%ld gid=%ld pid=%ld\n", msg,
     (long int)geteuid(), (long int)getegid(), (long int)getpid());
   debug_printf("changed uid/gid: %s\n  uid=%ld gid=%ld pid=%ld\n", msg,
     (long int)geteuid(), (long int)getegid(), (long int)getpid());

-  group_count = getgroups(NGROUPS_MAX, group_list);
+  group_count = getgroups(nelem(group_list), group_list);

   save_errno = errno;
   debug_printf("  auxiliary group list:");
   if (group_count > 0)
   save_errno = errno;
   debug_printf("  auxiliary group list:");
   if (group_count > 0)

-    {
-    int i;
-    for (i = 0; i < group_count; i++) debug_printf(" %d", (int)group_list[i]);
-    }
+    for (int i = 0; i < group_count; i++) debug_printf(" %d", (int)group_list[i]);

   else if (group_count < 0)
     debug_printf(" <error: %s>", strerror(save_errno));
   else debug_printf(" <none>");
   else if (group_count < 0)
     debug_printf(" <error: %s>", strerror(save_errno));
   else debug_printf(" <none>");


@@ -645,13 +830,110 @@ void
 exim_exit(int rc)
 {
 search_tidyup();
 exim_exit(int rc)
 {
 search_tidyup();

+store_exit();

 DEBUG(D_any)
 DEBUG(D_any)

-  debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d terminating with rc=%d "
-    ">>>>>>>>>>>>>>>>\n", (int)getpid(), rc);
+  debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d (%s) terminating with rc=%d "
+    ">>>>>>>>>>>>>>>>\n",
+    (int)getpid(), process_purpose, rc);

 exit(rc);
 }
 
 
 exit(rc);
 }
 
 

+void
+exim_underbar_exit(int rc)
+{
+store_exit();
+DEBUG(D_any)
+  debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d (%s) terminating with rc=%d "
+    ">>>>>>>>>>>>>>>>\n",
+    (int)getpid(), process_purpose, rc);
+_exit(rc);
+}
+
+
+
+/* Print error string, then die */
+static void
+exim_fail(const char * fmt, ...)
+{
+va_list ap;
+va_start(ap, fmt);
+vfprintf(stderr, fmt, ap);
+va_end(ap);
+exit(EXIT_FAILURE);
+}
+
+/* fail if a length is too long */
+static inline void
+exim_len_fail_toolong(int itemlen, int maxlen, const char * description)
+{
+if (itemlen <= maxlen)
+  return;
+fprintf(stderr, "exim: length limit exceeded (%d > %d) for: %s\n",
+        itemlen, maxlen, description);
+exit(EXIT_FAILURE);
+}
+
+/* only pass through the string item back to the caller if it's short enough */
+static inline const uschar *
+exim_str_fail_toolong(const uschar * item, int maxlen, const char * description)
+{
+if (!item)
+  exim_fail("exim: bad item for: %s\n", description);
+exim_len_fail_toolong(Ustrlen(item), maxlen, description);
+return item;
+}
+
+/* as above, copying as tainted */
+static inline const uschar *
+exim_arg_copy(const uschar * item, int maxlen, const char * description)
+{
+return string_copy_taint(exim_str_fail_toolong(item, maxlen, description),
+                       GET_TAINTED);
+}
+
+/* exim_chown_failure() called from exim_chown()/exim_fchown() on failure
+of chown()/fchown().  See src/functions.h for more explanation */
+int
+exim_chown_failure(int fd, const uschar *name, uid_t owner, gid_t group)
+{
+int saved_errno = errno;  /* from the preceeding chown call */
+#if 1
+log_write(0, LOG_MAIN|LOG_PANIC,
+  __FILE__ ":%d: chown(%s, %d:%d) failed (%s)."
+  " Please contact the authors and refer to https://bugs.exim.org/show_bug.cgi?id=2391",
+  __LINE__, name?name:US"<unknown>", owner, group, strerror(errno));
+#else
+/* I leave this here, commented, in case the "bug"(?) comes up again.
+   It is not an Exim bug, but we can provide a workaround.
+   See Bug 2391
+   HS 2019-04-18 */
+
+struct stat buf;
+
+if (0 == (fd < 0 ? stat(name, &buf) : fstat(fd, &buf)))
+  {
+  if (buf.st_uid == owner && buf.st_gid == group) return 0;
+  log_write(0, LOG_MAIN|LOG_PANIC, "Wrong ownership on %s", name);
+  }
+else log_write(0, LOG_MAIN|LOG_PANIC, "Stat failed on %s: %s", name, strerror(errno));
+
+#endif
+errno = saved_errno;
+return -1;
+}
+
+
+/* Bump the index for argv, checking for overflow,
+and return the argument. */
+
+static const uschar *
+next_argv(const uschar ** argv, int * pi, int argc, const uschar * where)
+{
+int i = *pi;
+if (++i >= argc) exim_fail("exim: bad item for: %s\n", where);
+return argv[*pi = i];
+}

 
 
 /*************************************************
 
 
 /*************************************************


@@ -674,10 +956,7 @@ check_port(uschar *address)
 {
 int port = host_address_extract_port(address);
 if (string_is_ip_address(address, NULL) == 0)
 {
 int port = host_address_extract_port(address);
 if (string_is_ip_address(address, NULL) == 0)

-  {
-  fprintf(stderr, "exim abandoned: \"%s\" is not an IP address\n", address);
-  exit(EXIT_FAILURE);
-  }
+  exim_fail("exim abandoned: \"%s\" is not an IP address\n", address);

 return port;
 }
 
 return port;
 }
 


@@ -706,7 +985,7 @@ int start, end, domain;
 uschar *parse_error = NULL;
 uschar *address = parse_extract_address(s, &parse_error, &start, &end, &domain,
   FALSE);
 uschar *parse_error = NULL;
 uschar *address = parse_extract_address(s, &parse_error, &start, &end, &domain,
   FALSE);

-if (address == NULL)
+if (!address)

   {
   fprintf(stdout, "syntax error: %s\n", parse_error);
   *exit_value = 2;
   {
   fprintf(stdout, "syntax error: %s\n", parse_error);
   *exit_value = 2;


@@ -716,7 +995,7 @@ else
   int rc = verify_address(deliver_make_addr(address,TRUE), stdout, flags, -1,
     -1, -1, NULL, NULL, NULL);
   if (rc == FAIL) *exit_value = 2;
   int rc = verify_address(deliver_make_addr(address,TRUE), stdout, flags, -1,
     -1, -1, NULL, NULL, NULL);
   if (rc == FAIL) *exit_value = 2;

-    else if (rc == DEFER && *exit_value == 0) *exit_value = 1;
+  else if (rc == DEFER && *exit_value == 0) *exit_value = 1;

   }
 }
 
   }
 }
 


@@ -726,326 +1005,470 @@ else
 *          Show supported features               *
 *************************************************/
 
 *          Show supported features               *
 *************************************************/
 

-/* This function is called for -bV/--version and for -d to output the optional
-features of the current Exim binary.
-
-Arguments:  a FILE for printing
-Returns:    nothing
-*/
-

 static void
 static void

-show_whats_supported(FILE *f)
+show_string(BOOL is_stdout, gstring * g)

 {
 {

-  auth_info *authi;
+const uschar * s = string_from_gstring(g);
+if (s)
+  if (is_stdout) fputs(CCS s, stdout);
+  else debug_printf("%s", s);
+}
+

 
 

+static gstring *
+show_db_version(gstring * g)
+{
+g = string_cat(g, US"Hints DB:\n");

 #ifdef DB_VERSION_STRING
 #ifdef DB_VERSION_STRING

-fprintf(f, "Berkeley DB: %s\n", DB_VERSION_STRING);
+DEBUG(D_any)
+  {
+  g = string_fmt_append(g, " Library version: BDB: Compile: %s\n", DB_VERSION_STRING);
+  g = string_fmt_append(g, "                       Runtime: %s\n",
+    db_version(NULL, NULL, NULL));
+  }
+else
+  g = string_fmt_append(g, " Berkeley DB: %s\n", DB_VERSION_STRING);
+

 #elif defined(BTREEVERSION) && defined(HASHVERSION)
 #elif defined(BTREEVERSION) && defined(HASHVERSION)

-  #ifdef USE_DB
-  fprintf(f, "Probably Berkeley DB version 1.8x (native mode)\n");
-  #else
-  fprintf(f, "Probably Berkeley DB version 1.8x (compatibility mode)\n");
-  #endif
+# ifdef USE_DB
+  g = string_cat(g, US" Probably Berkeley DB version 1.8x (native mode)\n");
+# else
+  g = string_cat(g, US" Probably Berkeley DB version 1.8x (compatibility mode)\n");
+# endif
+

 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)

-fprintf(f, "Probably ndbm\n");
+g = string_cat(g, US" Probably ndbm\n");
+#elif defined(USE_SQLITE)
+g = string_cat(g, US" Using sqlite3\n");

 #elif defined(USE_TDB)
 #elif defined(USE_TDB)

-fprintf(f, "Using tdb\n");
+g = string_cat(g, US" Using tdb\n");

 #else
 #else

-  #ifdef USE_GDBM
-  fprintf(f, "Probably GDBM (native mode)\n");
-  #else
-  fprintf(f, "Probably GDBM (compatibility mode)\n");
-  #endif
+# ifdef USE_GDBM
+g = string_cat(g, US" Probably GDBM (native mode)\n");
+# else
+g = string_cat(g, US" Probably GDBM (compatibility mode)\n");
+# endif

 #endif
 #endif

+return g;
+}

 
 

-fprintf(f, "Support for:");
-#ifdef SUPPORT_CRYPTEQ
-  fprintf(f, " crypteq");
+
+static gstring *
+lookup_show_supported(gstring * g)
+{
+gstring * b = NULL, * d = NULL;
+
+#ifdef LOOKUP_LSEARCH
+# if LOOKUP_LSEARCH!=2
+  b = string_cat(b, US" lsearch wildlsearch nwildlsearch iplsearch");
+# else
+  d = string_cat(d, US" lsearch wildlsearch nwildlsearch iplsearch");
+# endif

 #endif
 #endif

-#if HAVE_ICONV
-  fprintf(f, " iconv()");
+#ifdef LOOKUP_CDB
+# if LOOKUP_CDB!=2
+  b = string_cat(b, US" cdb");
+# else
+  d = string_cat(d, US" cdb");
+# endif

 #endif
 #endif

-#if HAVE_IPV6
-  fprintf(f, " IPv6");
+#ifdef LOOKUP_DBM
+# if LOOKUP_DBM!=2
+  b = string_cat(b, US" dbm dbmjz dbmnz");
+# else
+  d = string_cat(d, US" dbm dbmjz dbmnz");
+# endif

 #endif
 #endif

-#ifdef HAVE_SETCLASSRESOURCES
-  fprintf(f, " use_setclassresources");
+#ifdef LOOKUP_DNSDB
+# if LOOKUP_DNSDB!=2
+  b = string_cat(b, US" dnsdb");
+# else
+  d = string_cat(d, US" dnsdb");
+# endif

 #endif
 #endif

-#ifdef SUPPORT_PAM
-  fprintf(f, " PAM");
+#ifdef LOOKUP_DSEARCH
+# if LOOKUP_DSEARCH!=2
+  b = string_cat(b, US" dsearch");
+# else
+  d = string_cat(d, US" dsearch");
+# endif

 #endif
 #endif

-#ifdef EXIM_PERL
-  fprintf(f, " Perl");
+#ifdef LOOKUP_IBASE
+# if LOOKUP_IBASE!=2
+  b = string_cat(b, US" ibase");
+# else
+  d = string_cat(d, US" ibase");
+# endif

 #endif
 #endif

-#ifdef EXPAND_DLFUNC
-  fprintf(f, " Expand_dlfunc");
+#ifdef LOOKUP_JSON
+# if LOOKUP_JSON!=2
+  b = string_cat(b, US" json");
+# else
+  d = string_cat(d, US" json");
+# endif

 #endif
 #endif

-#ifdef USE_TCP_WRAPPERS
-  fprintf(f, " TCPwrappers");
+#ifdef LOOKUP_LDAP
+# if LOOKUP_LDAP!=2
+  b = string_cat(b, US" ldap ldapdn ldapm");
+# else
+  d = string_cat(d, US" ldap ldapdn ldapm");
+# endif

 #endif
 #endif

-#ifdef SUPPORT_TLS
-  #ifdef USE_GNUTLS
-  fprintf(f, " GnuTLS");
-  #else
-  fprintf(f, " OpenSSL");
-  #endif
+#ifdef LOOKUP_LMDB
+# if LOOKUP_LMDB!=2
+  b = string_cat(b, US" lmdb");
+# else
+  d = string_cat(d, US" lmdb");
+# endif

 #endif
 #endif

-#ifdef SUPPORT_TRANSLATE_IP_ADDRESS
-  fprintf(f, " translate_ip_address");
+#ifdef LOOKUP_MYSQL
+# if LOOKUP_MYSQL!=2
+  b = string_cat(b, US" mysql");
+# else
+  d = string_cat(d, US" mysql");
+# endif

 #endif
 #endif

-#ifdef SUPPORT_MOVE_FROZEN_MESSAGES
-  fprintf(f, " move_frozen_messages");
+#ifdef LOOKUP_NIS
+# if LOOKUP_NIS!=2
+  b = string_cat(b, US" nis nis0");
+# else
+  d = string_cat(d, US" nis nis0");
+# endif

 #endif
 #endif

-#ifdef WITH_CONTENT_SCAN
-  fprintf(f, " Content_Scanning");
+#ifdef LOOKUP_NISPLUS
+# if LOOKUP_NISPLUS!=2
+  b = string_cat(b, US" nisplus");
+# else
+  d = string_cat(d, US" nisplus");
+# endif

 #endif
 #endif

-#ifndef DISABLE_DKIM
-  fprintf(f, " DKIM");
+#ifdef LOOKUP_ORACLE
+# if LOOKUP_ORACLE!=2
+  b = string_cat(b, US" oracle");
+# else
+  d = string_cat(d, US" oracle");
+# endif

 #endif
 #endif

-#ifdef WITH_OLD_DEMIME
-  fprintf(f, " Old_Demime");
+#ifdef LOOKUP_PASSWD
+# if LOOKUP_PASSWD!=2
+  b = string_cat(b, US" passwd");
+# else
+  d = string_cat(d, US" passwd");
+# endif

 #endif
 #endif

-#ifndef DISABLE_PRDR
-  fprintf(f, " PRDR");
+#ifdef LOOKUP_PGSQL
+# if LOOKUP_PGSQL!=2
+  b = string_cat(b, US" pgsql");
+# else
+  d = string_cat(d, US" pgsql");
+# endif

 #endif
 #endif

-#ifndef DISABLE_OCSP
-  fprintf(f, " OCSP");
+#ifdef LOOKUP_REDIS
+# if LOOKUP_REDIS!=2
+  b = string_cat(b, US" redis");
+# else
+  d = string_cat(d, US" redis");
+# endif

 #endif
 #endif

-#ifdef EXPERIMENTAL_SPF
-  fprintf(f, " Experimental_SPF");
+#ifdef SUPPORT_SPF
+# if SUPPORT_SPF!=2
+  b = string_cat(b, US" spf");
+# else
+  d = string_cat(d, US" spf");
+# endif

 #endif
 #endif

-#ifdef EXPERIMENTAL_SRS
-  fprintf(f, " Experimental_SRS");
+#ifdef LOOKUP_SQLITE
+# if LOOKUP_SQLITE!=2
+  b = string_cat(b, US" sqlite");
+# else
+  d = string_cat(d, US" sqlite");
+# endif

 #endif
 #endif

-#ifdef EXPERIMENTAL_BRIGHTMAIL
-  fprintf(f, " Experimental_Brightmail");
+#ifdef LOOKUP_TESTDB
+# if LOOKUP_TESTDB!=2
+  b = string_cat(b, US" testdb");
+# else
+  d = string_cat(d, US" testdb");
+# endif

 #endif
 #endif

-#ifdef EXPERIMENTAL_DCC
-  fprintf(f, " Experimental_DCC");
+#ifdef LOOKUP_WHOSON
+# if LOOKUP_WHOSON!=2
+  b = string_cat(b, US" whoson");
+# else
+  d = string_cat(d, US" whoson");
+# endif

 #endif
 #endif

-#ifdef EXPERIMENTAL_DMARC
-  fprintf(f, " Experimental_DMARC");
+
+if (b) g = string_fmt_append(g, "Lookups (built-in):%Y\n", b);
+if (d) g = string_fmt_append(g, "Lookups (dynamic): %Y\n", d);
+return g;
+}
+
+
+static void
+lookup_version_report_cb(uschar * name, uschar * ptr, void * ctx)
+{
+const lookup_info * li = (lookup_info *)ptr;
+gstring ** gp = ctx;
+
+if (li->version_report)
+  *gp = li->version_report(*gp);
+}
+
+
+/* This function is called for -bV/--version and for -d to output the optional
+features of the current Exim binary.
+
+Arguments:  BOOL, true for stdout else debug channel
+Returns:    nothing
+*/
+
+static void
+show_whats_supported(BOOL is_stdout)
+{
+rmark reset_point = store_mark();
+gstring * g = NULL;
+
+DEBUG(D_any) {} else g = show_db_version(g);
+
+g = string_cat(g, US"Support for:");
+#ifdef WITH_CONTENT_SCAN
+  g = string_cat(g, US" Content_Scanning");

 #endif
 #endif

-#ifdef EXPERIMENTAL_PROXY
-  fprintf(f, " Experimental_Proxy");
+#ifndef DISABLE_EXIM_FILTER
+  g = string_cat(g, US" Exim_filter");

 #endif
 #endif

-#ifdef EXPERIMENTAL_TPDA
-  fprintf(f, " Experimental_TPDA");
+#ifndef DISABLE_SIEVE_FILTER
+  g = string_cat(g, US" Sieve_filter");

 #endif
 #endif

-#ifdef EXPERIMENTAL_REDIS
-  fprintf(f, " Experimental_Redis");
+#ifdef SUPPORT_CRYPTEQ
+  g = string_cat(g, US" crypteq");

 #endif
 #endif

-#ifdef EXPERIMENTAL_CERTNAMES
-  fprintf(f, " Experimental_Certnames");
+#ifdef EXPAND_DLFUNC
+  g = string_cat(g, US" Expand_dlfunc");

 #endif
 #endif

-#ifdef EXPERIMENTAL_DSN
-  fprintf(f, " Experimental_DSN");
+#if HAVE_ICONV
+  g = string_cat(g, US" iconv()");

 #endif
 #endif

-fprintf(f, "\n");
-
-fprintf(f, "Lookups (built-in):");
-#if defined(LOOKUP_LSEARCH) && LOOKUP_LSEARCH!=2
-  fprintf(f, " lsearch wildlsearch nwildlsearch iplsearch");
+#if HAVE_IPV6
+  g = string_cat(g, US" IPv6");
+#endif
+#ifdef SUPPORT_PAM
+  g = string_cat(g, US" PAM");

 #endif
 #endif

-#if defined(LOOKUP_CDB) && LOOKUP_CDB!=2
-  fprintf(f, " cdb");
+#ifdef EXIM_PERL
+  g = string_cat(g, US" Perl");

 #endif
 #endif

-#if defined(LOOKUP_DBM) && LOOKUP_DBM!=2
-  fprintf(f, " dbm dbmjz dbmnz");
+#ifdef USE_GNUTLS
+  g = string_cat(g, US" GnuTLS");

 #endif
 #endif

-#if defined(LOOKUP_DNSDB) && LOOKUP_DNSDB!=2
-  fprintf(f, " dnsdb");
+#ifdef SUPPORT_MOVE_FROZEN_MESSAGES
+  g = string_cat(g, US" move_frozen_messages");

 #endif
 #endif

-#if defined(LOOKUP_DSEARCH) && LOOKUP_DSEARCH!=2
-  fprintf(f, " dsearch");
+#ifdef USE_OPENSSL
+  g = string_cat(g, US" OpenSSL");

 #endif
 #endif

-#if defined(LOOKUP_IBASE) && LOOKUP_IBASE!=2
-  fprintf(f, " ibase");
+#if defined(CYRUS_PWCHECK_SOCKET)
+  g = string_cat(g, US" pwcheck");

 #endif
 #endif

-#if defined(LOOKUP_LDAP) && LOOKUP_LDAP!=2
-  fprintf(f, " ldap ldapdn ldapm");
+#if defined(RADIUS_CONFIG_FILE)
+  g = string_cat(g, US" radius");

 #endif
 #endif

-#if defined(LOOKUP_MYSQL) && LOOKUP_MYSQL!=2
-  fprintf(f, " mysql");
+#ifndef DISABLE_TLS_RESUME
+  g = string_cat(g, US" TLS_resume");

 #endif
 #endif

-#if defined(LOOKUP_NIS) && LOOKUP_NIS!=2
-  fprintf(f, " nis nis0");
+#ifdef SUPPORT_TRANSLATE_IP_ADDRESS
+  g = string_cat(g, US" translate_ip_address");

 #endif
 #endif

-#if defined(LOOKUP_NISPLUS) && LOOKUP_NISPLUS!=2
-  fprintf(f, " nisplus");
+#ifdef USE_TCP_WRAPPERS
+  g = string_cat(g, US" TCPwrappers");

 #endif
 #endif

-#if defined(LOOKUP_ORACLE) && LOOKUP_ORACLE!=2
-  fprintf(f, " oracle");
+#ifdef HAVE_SETCLASSRESOURCES
+  g = string_cat(g, US" use_setclassresources");

 #endif
 #endif

-#if defined(LOOKUP_PASSWD) && LOOKUP_PASSWD!=2
-  fprintf(f, " passwd");
+#ifdef SUPPORT_DANE
+  g = string_cat(g, US" DANE");

 #endif
 #endif

-#if defined(LOOKUP_PGSQL) && LOOKUP_PGSQL!=2
-  fprintf(f, " pgsql");
+#ifndef DISABLE_DKIM
+  g = string_cat(g, US" DKIM");

 #endif
 #endif

-#if defined(LOOKUP_SQLITE) && LOOKUP_SQLITE!=2
-  fprintf(f, " sqlite");
+#ifdef SUPPORT_DMARC
+  g = string_cat(g, US" DMARC");

 #endif
 #endif

-#if defined(LOOKUP_TESTDB) && LOOKUP_TESTDB!=2
-  fprintf(f, " testdb");
+#ifndef DISABLE_DNSSEC
+  g = string_cat(g, US" DNSSEC");

 #endif
 #endif

-#if defined(LOOKUP_WHOSON) && LOOKUP_WHOSON!=2
-  fprintf(f, " whoson");
+#ifndef DISABLE_ESMTP_LIMITS
+  g = string_cat(g, US" ESMTP_Limits");

 #endif
 #endif

-fprintf(f, "\n");
-
-fprintf(f, "Authenticators:");
-#ifdef AUTH_CRAM_MD5
-  fprintf(f, " cram_md5");
+#ifndef DISABLE_WELLKNOWN
+  g = string_cat(g, US" ESMTP_Wellknown");

 #endif
 #endif

-#ifdef AUTH_CYRUS_SASL
-  fprintf(f, " cyrus_sasl");
+#ifndef DISABLE_EVENT
+  g = string_cat(g, US" Event");

 #endif
 #endif

-#ifdef AUTH_DOVECOT
-  fprintf(f, " dovecot");
+#ifdef SUPPORT_I18N
+  g = string_cat(g, US" I18N");

 #endif
 #endif

-#ifdef AUTH_GSASL
-  fprintf(f, " gsasl");
+#ifndef DISABLE_OCSP
+  g = string_cat(g, US" OCSP");

 #endif
 #endif

-#ifdef AUTH_HEIMDAL_GSSAPI
-  fprintf(f, " heimdal_gssapi");
+#ifndef DISABLE_PIPE_CONNECT
+  g = string_cat(g, US" PIPECONNECT");

 #endif
 #endif

-#ifdef AUTH_PLAINTEXT
-  fprintf(f, " plaintext");
+#ifndef DISABLE_PRDR
+  g = string_cat(g, US" PRDR");

 #endif
 #endif

-#ifdef AUTH_SPA
-  fprintf(f, " spa");
+#ifdef SUPPORT_PROXY
+  g = string_cat(g, US" PROXY");

 #endif
 #endif

-fprintf(f, "\n");
-
-fprintf(f, "Routers:");
-#ifdef ROUTER_ACCEPT
-  fprintf(f, " accept");
+#ifndef DISABLE_QUEUE_RAMP
+  g = string_cat(g, US" Queue_Ramp");

 #endif
 #endif

-#ifdef ROUTER_DNSLOOKUP
-  fprintf(f, " dnslookup");
+#ifdef SUPPORT_SOCKS
+  g = string_cat(g, US" SOCKS");

 #endif
 #endif

-#ifdef ROUTER_IPLITERAL
-  fprintf(f, " ipliteral");
+#ifdef SUPPORT_SPF
+  g = string_cat(g, US" SPF");

 #endif
 #endif

-#ifdef ROUTER_IPLOOKUP
-  fprintf(f, " iplookup");
+#if defined(SUPPORT_SRS)
+  g = string_cat(g, US" SRS");

 #endif
 #endif

-#ifdef ROUTER_MANUALROUTE
-  fprintf(f, " manualroute");
+#ifdef TCP_FASTOPEN
+  tcp_init();
+  if (f.tcp_fastopen_ok) g = string_cat(g, US" TCP_Fast_Open");

 #endif
 #endif

-#ifdef ROUTER_QUERYPROGRAM
-  fprintf(f, " queryprogram");
+#ifdef EXPERIMENTAL_ARC
+  g = string_cat(g, US" Experimental_ARC");

 #endif
 #endif

-#ifdef ROUTER_REDIRECT
-  fprintf(f, " redirect");
+#ifdef EXPERIMENTAL_BRIGHTMAIL
+  g = string_cat(g, US" Experimental_Brightmail");

 #endif
 #endif

-fprintf(f, "\n");
-
-fprintf(f, "Transports:");
-#ifdef TRANSPORT_APPENDFILE
-  fprintf(f, " appendfile");
-  #ifdef SUPPORT_MAILDIR
-    fprintf(f, "/maildir");
-  #endif
-  #ifdef SUPPORT_MAILSTORE
-    fprintf(f, "/mailstore");
-  #endif
-  #ifdef SUPPORT_MBX
-    fprintf(f, "/mbx");
-  #endif
+#ifdef EXPERIMENTAL_DCC
+  g = string_cat(g, US" Experimental_DCC");

 #endif
 #endif

-#ifdef TRANSPORT_AUTOREPLY
-  fprintf(f, " autoreply");
+#ifdef EXPERIMENTAL_DSN_INFO
+  g = string_cat(g, US" Experimental_DSN_info");

 #endif
 #endif

-#ifdef TRANSPORT_LMTP
-  fprintf(f, " lmtp");
+#ifdef EXPERIMENTAL_QUEUEFILE
+  g = string_cat(g, US" Experimental_QUEUEFILE");

 #endif
 #endif

-#ifdef TRANSPORT_PIPE
-  fprintf(f, " pipe");
+#ifdef EXPERIMENTAL_XCLIENT
+  g = string_cat(g, US" Experimental_XCLIENT");

 #endif
 #endif

-#ifdef TRANSPORT_SMTP
-  fprintf(f, " smtp");
+g = string_cat(g, US"\n");
+
+g = lookup_show_supported(g);
+g = auth_show_supported(g);
+g = route_show_supported(g);
+g = transport_show_supported(g);
+
+#ifdef WITH_CONTENT_SCAN
+g = malware_show_supported(g);

 #endif
 #endif

-fprintf(f, "\n");
+show_string(is_stdout, g); g = NULL;

 
 if (fixed_never_users[0] > 0)
   {
   int i;
 
 if (fixed_never_users[0] > 0)
   {
   int i;

-  fprintf(f, "Fixed never_users: ");
+  g = string_cat(g, US"Fixed never_users: ");

   for (i = 1; i <= (int)fixed_never_users[0] - 1; i++)
   for (i = 1; i <= (int)fixed_never_users[0] - 1; i++)

-    fprintf(f, "%d:", (unsigned int)fixed_never_users[i]);
-  fprintf(f, "%d\n", (unsigned int)fixed_never_users[i]);
+    string_fmt_append(g, "%u:", (unsigned)fixed_never_users[i]);
+  g = string_fmt_append(g, "%u\n", (unsigned)fixed_never_users[i]);

   }
 
   }
 

-fprintf(f, "Size of off_t: " SIZE_T_FMT "\n", sizeof(off_t));
+g = string_fmt_append(g, "Configure owner: %d:%d\n", config_uid, config_gid);
+
+g = string_fmt_append(g, "Size of off_t: " SIZE_T_FMT "\n", sizeof(off_t));

 
 /* Everything else is details which are only worth reporting when debugging.
 Perhaps the tls_version_report should move into this too. */
 
 /* Everything else is details which are only worth reporting when debugging.
 Perhaps the tls_version_report should move into this too. */

-DEBUG(D_any) do {
-
-  int i;
+DEBUG(D_any)
+  {

 
 /* clang defines __GNUC__ (at least, for me) so test for it first */
 #if defined(__clang__)
 
 /* clang defines __GNUC__ (at least, for me) so test for it first */
 #if defined(__clang__)

-  fprintf(f, "Compiler: CLang [%s]\n", __clang_version__);
+  g = string_fmt_append(g, "Compiler: CLang [%s]\n", __clang_version__);

 #elif defined(__GNUC__)
 #elif defined(__GNUC__)

-  fprintf(f, "Compiler: GCC [%s]\n",

 # ifdef __VERSION__
 # ifdef __VERSION__

-      __VERSION__
+  g = string_fmt_append(g, "Compiler: GCC [%s]\n", __VERSION__);

 # else
 # else

-      "? unknown version ?"
+  g = string_fmt_append(g, "Compiler: GCC [%s]\n", "? unknown version ?");

 # endif
 # endif

-      );

 #else
 #else

-  fprintf(f, "Compiler: <unknown>\n");
+  g = string_cat(g, US"Compiler: <unknown>\n");

 #endif
 
 #endif
 

-#ifdef SUPPORT_TLS
-  tls_version_report(f);
+#if defined(__GLIBC__) && !defined(__UCLIBC__)
+  g = string_fmt_append(g, "Library version: Glibc: Compile: %d.%d\n",
+               __GLIBC__, __GLIBC_MINOR__);
+  if (__GLIBC_PREREQ(2, 1))
+    g = string_fmt_append(g, "                        Runtime: %s\n",
+               gnu_get_libc_version());

 #endif
 
 #endif
 

-  for (authi = auths_available; *authi->driver_name != '\0'; ++authi) {
-    if (authi->version_report) {
-      (*authi->version_report)(f);
-    }
-  }
+  g = show_db_version(g);
+
+#ifndef DISABLE_TLS
+  g = tls_version_report(g);
+#endif
+#ifdef SUPPORT_I18N
+  g = utf8_version_report(g);
+#endif
+
+/*XXX do we need a "show misc-mods version-report" ?
+Currently they are output in misc_mod_add() */
+
+  show_string(is_stdout, g);
+  g = NULL;
+
+  for (auth_info * ai = auths_available; ai; ai = (auth_info *)ai->drinfo.next)
+    if (ai->version_report)
+      g = (*ai->version_report)(g);

 
   /* PCRE_PRERELEASE is either defined and empty or a bare sequence of
   characters; unless it's an ancient version of PCRE in which case it
   is not defined. */
 #ifndef PCRE_PRERELEASE
 
   /* PCRE_PRERELEASE is either defined and empty or a bare sequence of
   characters; unless it's an ancient version of PCRE in which case it
   is not defined. */
 #ifndef PCRE_PRERELEASE

-#define PCRE_PRERELEASE
+# define PCRE_PRERELEASE

 #endif
 #define QUOTE(X) #X
 #define EXPAND_AND_QUOTE(X) QUOTE(X)
 #endif
 #define QUOTE(X) #X
 #define EXPAND_AND_QUOTE(X) QUOTE(X)

-  fprintf(f, "Library version: PCRE: Compile: %d.%d%s\n"
-             "                       Runtime: %s\n",
-          PCRE_MAJOR, PCRE_MINOR,
-          EXPAND_AND_QUOTE(PCRE_PRERELEASE) "",
-          pcre_version());
+    {
+    uschar buf[24];
+    pcre2_config(PCRE2_CONFIG_VERSION, buf);
+    g = string_fmt_append(g, "Library version: PCRE2: Compile: %d.%d%s\n"
+               "                        Runtime: %s\n",
+           PCRE2_MAJOR, PCRE2_MINOR,
+           EXPAND_AND_QUOTE(PCRE2_PRERELEASE) "",
+           buf);
+    }

 #undef QUOTE
 #undef EXPAND_AND_QUOTE
 
 #undef QUOTE
 #undef EXPAND_AND_QUOTE
 

+  show_string(is_stdout, g);
+  g = NULL;
+

   init_lookup_list();
   init_lookup_list();

-  for (i = 0; i < lookup_list_count; i++)
-    {
-    if (lookup_list[i]->version_report)
-      lookup_list[i]->version_report(f);
-    }
+  tree_walk(lookups_tree, lookup_version_report_cb, &g);
+  show_string(is_stdout, g);
+  g = NULL;
+  init_misc_mod_list();

 
 #ifdef WHITELIST_D_MACROS
 
 #ifdef WHITELIST_D_MACROS

-  fprintf(f, "WHITELIST_D_MACROS: \"%s\"\n", WHITELIST_D_MACROS);
+  g = string_fmt_append(g, "WHITELIST_D_MACROS: \"%s\"\n", WHITELIST_D_MACROS);

 #else
 #else

-  fprintf(f, "WHITELIST_D_MACROS unset\n");
+  g = string_cat(g, US"WHITELIST_D_MACROS unset\n");

 #endif
 #ifdef TRUSTED_CONFIG_LIST
 #endif
 #ifdef TRUSTED_CONFIG_LIST

-  fprintf(f, "TRUSTED_CONFIG_LIST: \"%s\"\n", TRUSTED_CONFIG_LIST);
+  g = string_fmt_append(g, "TRUSTED_CONFIG_LIST: \"%s\"\n", TRUSTED_CONFIG_LIST);

 #else
 #else

-  fprintf(f, "TRUSTED_CONFIG_LIST unset\n");
+  g = string_cat(g, US"TRUSTED_CONFIG_LIST unset\n");

 #endif
 #endif

+  }

 
 

-} while (0);
+show_string(is_stdout, g);
+store_reset(reset_point);

 }
 
 
 }
 
 


@@ -1056,8 +1479,6 @@ DEBUG(D_any) do {
 static void
 show_exim_information(enum commandline_info request, FILE *stream)
 {
 static void
 show_exim_information(enum commandline_info request, FILE *stream)
 {

-const uschar **pp;
-

 switch(request)
   {
   case CMDINFO_NONE:
 switch(request)
   {
   case CMDINFO_NONE:


@@ -1069,13 +1490,19 @@ switch(request)
 "If the string is not recognised, you'll get this help (on stderr).\n"
 "\n"
 "  exim -bI:help    this information\n"
 "If the string is not recognised, you'll get this help (on stderr).\n"
 "\n"
 "  exim -bI:help    this information\n"

-"  exim -bI:dscp    dscp value keywords known\n"
-"  exim -bI:sieve   list of supported sieve extensions, one per line.\n"
+"  exim -bI:dscp    list of known dscp value keywords\n"
+"  exim -bI:sieve   list of supported sieve extensions\n"

 );
     return;
   case CMDINFO_SIEVE:
 );
     return;
   case CMDINFO_SIEVE:

-    for (pp = exim_sieve_extension_list; *pp; ++pp)
-      fprintf(stream, "%s\n", *pp);
+    {
+    const misc_module_info * mi;
+    typedef void (*fn_t)(FILE *);
+    if ((mi = misc_mod_find(US"sieve_filter", NULL)))
+      (((fn_t *) mi->functions)[SIEVE_EXTENSIONS]) (stream);
+    else
+      fprintf(stream, "Sieve filtering not available\n");
+    }

     return;
   case CMDINFO_DSCP:
     dscp_list_to_stream(stream);
     return;
   case CMDINFO_DSCP:
     dscp_list_to_stream(stream);


@@ -1096,42 +1523,36 @@ Argument:    the local part
 Returns:     the local part, quoted if necessary
 */
 
 Returns:     the local part, quoted if necessary
 */
 

-uschar *
-local_part_quote(uschar *lpart)
+const uschar *
+local_part_quote(const uschar * lpart)

 {
 BOOL needs_quote = FALSE;
 {
 BOOL needs_quote = FALSE;

-int size, ptr;
-uschar *yield;
-uschar *t;
+gstring * g;

 
 

-for (t = lpart; !needs_quote && *t != 0; t++)
-  {
+for (const uschar * t = lpart; !needs_quote && *t; t++)

   needs_quote = !isalnum(*t) && strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
     (*t != '.' || t == lpart || t[1] == 0);
   needs_quote = !isalnum(*t) && strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
     (*t != '.' || t == lpart || t[1] == 0);

-  }

 
 if (!needs_quote) return lpart;
 
 
 if (!needs_quote) return lpart;
 

-size = ptr = 0;
-yield = string_cat(NULL, &size, &ptr, US"\"", 1);
+g = string_catn(NULL, US"\"", 1);

 
 for (;;)
   {
 
 for (;;)
   {

-  uschar *nq = US Ustrpbrk(lpart, "\\\"");
-  if (nq == NULL)
+  uschar * nq = US Ustrpbrk(lpart, "\\\"");
+  if (!nq)

     {
     {

-    yield = string_cat(yield, &size, &ptr, lpart, Ustrlen(lpart));
+    g = string_cat(g, lpart);

     break;
     }
     break;
     }

-  yield = string_cat(yield, &size, &ptr, lpart, nq - lpart);
-  yield = string_cat(yield, &size, &ptr, US"\\", 1);
-  yield = string_cat(yield, &size, &ptr, nq, 1);
+  g = string_catn(g, lpart, nq - lpart);
+  g = string_catn(g, US"\\", 1);
+  g = string_catn(g, nq, 1);

   lpart = nq + 1;
   }
 
   lpart = nq + 1;
   }
 

-yield = string_cat(yield, &size, &ptr, US"\"", 1);
-yield[ptr] = 0;
-return yield;
+g = string_catn(g, US"\"", 1);
+return string_from_gstring(g);

 }
 
 
 }
 
 


@@ -1162,9 +1583,9 @@ void *dlhandle;
 void *dlhandle_curses = dlopen("libcurses." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_LAZY);
 
 dlhandle = dlopen("libreadline." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_NOW);
 void *dlhandle_curses = dlopen("libcurses." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_LAZY);
 
 dlhandle = dlopen("libreadline." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_NOW);

-if (dlhandle_curses != NULL) dlclose(dlhandle_curses);
+if (dlhandle_curses) dlclose(dlhandle_curses);

 
 

-if (dlhandle != NULL)
+if (dlhandle)

   {
   /* Checked manual pages; at least in GNU Readline 6.1, the prototypes are:
    *   char * readline (const char *prompt);
   {
   /* Checked manual pages; at least in GNU Readline 6.1, the prototypes are:
    *   char * readline (const char *prompt);


@@ -1174,9 +1595,7 @@ if (dlhandle != NULL)
   *fn_addhist_ptr = (void(*)(const char*))dlsym(dlhandle, "add_history");
   }
 else
   *fn_addhist_ptr = (void(*)(const char*))dlsym(dlhandle, "add_history");
   }
 else

-  {

   DEBUG(D_any) debug_printf("failed to load readline: %s\n", dlerror());
   DEBUG(D_any) debug_printf("failed to load readline: %s\n", dlerror());

-  }

 
 return dlhandle;
 }
 
 return dlhandle;
 }


@@ -1203,62 +1622,59 @@ Returns:        pointer to dynamic memory, or NULL at end of file
 static uschar *
 get_stdinput(char *(*fn_readline)(const char *), void(*fn_addhist)(const char *))
 {
 static uschar *
 get_stdinput(char *(*fn_readline)(const char *), void(*fn_addhist)(const char *))
 {

-int i;
-int size = 0;
-int ptr = 0;
-uschar *yield = NULL;
+gstring * g = NULL;
+BOOL had_input = FALSE;

 
 

-if (fn_readline == NULL) { printf("> "); fflush(stdout); }
+if (!fn_readline) { printf("> "); fflush(stdout); }

 
 

-for (i = 0;; i++)
+for (int i = 0;; i++)

   {
   uschar buffer[1024];
   {
   uschar buffer[1024];

-  uschar *p, *ss;
+  uschar * p, * ss;

 
 

-  #ifdef USE_READLINE
+#ifdef USE_READLINE

   char *readline_line = NULL;
   char *readline_line = NULL;

-  if (fn_readline != NULL)
+  if (fn_readline)

     {
     {

-    if ((readline_line = fn_readline((i > 0)? "":"> ")) == NULL) break;
-    if (*readline_line != 0 && fn_addhist != NULL) fn_addhist(readline_line);
+    if (!(readline_line = fn_readline((i > 0)? "":"> "))) break;
+    if (*readline_line && fn_addhist) fn_addhist(readline_line);

     p = US readline_line;
     }
   else
     p = US readline_line;
     }
   else

-  #endif
+#endif

 
   /* readline() not in use */
 
     {
 
   /* readline() not in use */
 
     {

-    if (Ufgets(buffer, sizeof(buffer), stdin) == NULL) break;
+    if (Ufgets(buffer, sizeof(buffer), stdin) == NULL) break;  /*EOF*/

     p = buffer;
     }
 
   /* Handle the line */
 
     p = buffer;
     }
 
   /* Handle the line */
 

-  ss = p + (int)Ustrlen(p);
-  while (ss > p && isspace(ss[-1])) ss--;
+  had_input = TRUE;
+  ss = p + Ustrlen(p);
+  while (ss > p && isspace(ss[-1])) ss--; /* strip trailing newline (and spaces) */

 
   if (i > 0)
 
   if (i > 0)

-    {
-    while (p < ss && isspace(*p)) p++;   /* leading space after cont */
-    }
+    while (p < ss && isspace(*p)) p++;   /* strip leading space after cont */

 
 

-  yield = string_cat(yield, &size, &ptr, p, ss - p);
+  g = string_catn(g, p, ss - p);

 
 

-  #ifdef USE_READLINE
-  if (fn_readline != NULL) free(readline_line);
-  #endif
+#ifdef USE_READLINE
+  if (fn_readline) free(readline_line);
+#endif

 
 

-  if (ss == p || yield[ptr-1] != '\\')
-    {
-    yield[ptr] = 0;
+  /* g can only be NULL if ss==p */
+  if (ss == p || gstring_last_char(g) != '\\') /* not continuation; done */

     break;
     break;

-    }
-  yield[--ptr] = 0;
+
+  gstring_trim(g, 1);                          /* drop the \ */

   }
 
   }
 

-if (yield == NULL) printf("\n");
-return yield;
+if (had_input) return g ? string_from_gstring(g) : US"";
+printf("\n");
+return NULL;

 }
 
 
 }
 
 


@@ -1277,25 +1693,20 @@ Returns:        DOES NOT RETURN
 */
 
 static void
 */
 
 static void

-exim_usage(uschar *progname)
+exim_usage(const uschar * progname)

 {
 
 {
 

-/* Handle specific program invocation varients */
+/* Handle specific program invocation variants */

 if (Ustrcmp(progname, US"-mailq") == 0)
 if (Ustrcmp(progname, US"-mailq") == 0)

-  {
-  fprintf(stderr,
+  exim_fail(

     "mailq - list the contents of the mail queue\n\n"
     "For a list of options, see the Exim documentation.\n");
     "mailq - list the contents of the mail queue\n\n"
     "For a list of options, see the Exim documentation.\n");

-  exit(EXIT_FAILURE);
-  }

 
 /* Generic usage - we output this whatever happens */
 
 /* Generic usage - we output this whatever happens */

-fprintf(stderr,
+exim_fail(

   "Exim is a Mail Transfer Agent. It is normally called by Mail User Agents,\n"
   "not directly from a shell command line. Options and/or arguments control\n"
   "what it does when called. For a list of options, see the Exim documentation.\n");
   "Exim is a Mail Transfer Agent. It is normally called by Mail User Agents,\n"
   "not directly from a shell command line. Options and/or arguments control\n"
   "what it does when called. For a list of options, see the Exim documentation.\n");

-
-exit(EXIT_FAILURE);

 }
 
 
 }
 
 


@@ -1307,22 +1718,21 @@ exit(EXIT_FAILURE);
 /* Typically, Exim will drop privileges if macros are supplied.  In some
 cases, we want to not do so.
 
 /* Typically, Exim will drop privileges if macros are supplied.  In some
 cases, we want to not do so.
 

-Arguments:    none (macros is a global)
+Arguments:    opt_D_used - true if the commandline had a "-D" option

 Returns:      true if trusted, false otherwise
 */
 
 static BOOL
 Returns:      true if trusted, false otherwise
 */
 
 static BOOL

-macros_trusted(void)
+macros_trusted(BOOL opt_D_used)

 {
 #ifdef WHITELIST_D_MACROS
 {
 #ifdef WHITELIST_D_MACROS

-macro_item *m;
-uschar *whitelisted, *end, *p, **whites, **w;
+uschar *whitelisted, *end, *p, **whites;

 int white_count, i, n;
 size_t len;
 BOOL prev_char_item, found;
 #endif
 
 int white_count, i, n;
 size_t len;
 BOOL prev_char_item, found;
 #endif
 

-if (macros == NULL)
+if (!opt_D_used)

   return TRUE;
 #ifndef WHITELIST_D_MACROS
 return FALSE;
   return TRUE;
 #ifndef WHITELIST_D_MACROS
 return FALSE;


@@ -1344,7 +1754,7 @@ if ( ! ((real_uid == root_uid)
   }
 
 /* Get a list of macros which are whitelisted */
   }
 
 /* Get a list of macros which are whitelisted */

-whitelisted = string_copy_malloc(US WHITELIST_D_MACROS);
+whitelisted = string_copy_perm(US WHITELIST_D_MACROS, FALSE);

 prev_char_item = FALSE;
 white_count = 0;
 for (p = whitelisted; *p != '\0'; ++p)
 prev_char_item = FALSE;
 white_count = 0;
 for (p = whitelisted; *p != '\0'; ++p)


@@ -1379,11 +1789,12 @@ for (p = whitelisted, i = 0; (p != end) && (i < white_count); ++p)
   }
 whites[i] = NULL;
 
   }
 whites[i] = NULL;
 

-/* The list of macros should be very short.  Accept the N*M complexity. */
-for (m = macros; m != NULL; m = m->next)
+/* The list of commandline macros should be very short.
+Accept the N*M complexity. */
+for (macro_item * m = macros_user; m; m = m->next) if (m->command_line)

   {
   found = FALSE;
   {
   found = FALSE;

-  for (w = whites; *w; ++w)
+  for (uschar ** w = whites; *w; ++w)

     if (Ustrcmp(*w, m->name) == 0)
       {
       found = TRUE;
     if (Ustrcmp(*w, m->name) == 0)
       {
       found = TRUE;


@@ -1391,19 +1802,12 @@ for (m = macros; m != NULL; m = m->next)
       }
   if (!found)
     return FALSE;
       }
   if (!found)
     return FALSE;

-  if (m->replacement == NULL)
+  if (!m->replacement)

     continue;
     continue;

-  len = Ustrlen(m->replacement);
-  if (len == 0)
+  if ((len = m->replen) == 0)

     continue;
     continue;

-  n = pcre_exec(regex_whitelisted_macro, NULL, CS m->replacement, len,
-   0, PCRE_EOPT, NULL, 0);
-  if (n < 0)
-    {
-    if (n != PCRE_ERROR_NOMATCH)
-      debug_printf("macros_trusted checking %s returned %d\n", m->name, n);
+  if (!regex_match(regex_whitelisted_macro, m->replacement, len, NULL))

     return FALSE;
     return FALSE;

-    }

   }
 DEBUG(D_any) debug_printf("macros_trusted overridden to true by whitelisting\n");
 return TRUE;
   }
 DEBUG(D_any) debug_printf("macros_trusted overridden to true by whitelisting\n");
 return TRUE;


@@ -1411,6 +1815,77 @@ return TRUE;
 }
 
 
 }
 
 

+/*************************************************
+*          Expansion testing                    *
+*************************************************/
+
+/* Expand and print one item, doing macro-processing.
+
+Arguments:
+  item         line for expansion
+*/
+
+static void
+expansion_test_line(const uschar * line)
+{
+int len;
+BOOL dummy_macexp;
+uschar * s;
+
+Ustrncpy(big_buffer, line, big_buffer_size);
+big_buffer[big_buffer_size-1] = '\0';
+len = Ustrlen(big_buffer);
+
+(void) macros_expand(0, &len, &dummy_macexp);
+
+#ifdef LOOKUP_MODULE_DIR
+//mod_load_check(big_buffer);
+#endif
+
+if (isupper(big_buffer[0]))
+  {
+  if (macro_read_assignment(big_buffer))
+    printf("Defined macro '%s'\n", mlast->name);
+  }
+else if (Ustrncmp(big_buffer, "set,t ", 6) == 0)
+  printf("%s\n", acl_standalone_setvar(big_buffer+6, TRUE));
+else if (Ustrncmp(big_buffer, "set ", 4) == 0)
+  printf("%s\n", acl_standalone_setvar(big_buffer+4, FALSE));
+else
+  if ((s = expand_string(big_buffer))) printf("%s\n", CS s);
+  else printf("Failed: %s\n", expand_string_message);
+}
+
+
+
+/*************************************************
+*          Queue-runner operations               *
+*************************************************/
+
+/* Prefix a new qrunner descriptor to the qrunners list */
+
+static qrunner *
+alloc_qrunner(void)
+{
+qrunner * q = qrunners;
+qrunners = store_get(sizeof(qrunner), GET_UNTAINTED);
+memset(qrunners, 0, sizeof(qrunner));          /* default queue, zero interval */
+qrunners->next = q;
+qrunners->next_tick = time(NULL);              /* run right away */
+return qrunners;
+}
+
+static qrunner *
+alloc_onetime_qrunner(void)
+{
+qrunners = store_get_perm(sizeof(qrunner), GET_UNTAINTED);
+memset(qrunners, 0, sizeof(qrunner));          /* default queue, zero interval */
+qrunners->next_tick = time(NULL);              /* run right away */
+qrunners->run_max = 1;
+return qrunners;
+}
+
+

 /*************************************************
 *          Entry point and high-level code       *
 *************************************************/
 /*************************************************
 *          Entry point and high-level code       *
 *************************************************/


@@ -1431,9 +1906,9 @@ Returns:    EXIT_SUCCESS if terminated successfully
 */
 
 int
 */
 
 int

-main(int argc, char **cargv)
+main(int argc, char ** cargv)

 {
 {

-uschar **argv = USS cargv;
+const uschar ** argv = CUSS cargv;

 int  arg_receive_timeout = -1;
 int  arg_smtp_receive_timeout = -1;
 int  arg_error_handling = error_handling;
 int  arg_receive_timeout = -1;
 int  arg_smtp_receive_timeout = -1;
 int  arg_error_handling = error_handling;


@@ -1441,10 +1916,10 @@ int  filter_sfd = -1;
 int  filter_ufd = -1;
 int  group_count;
 int  i, rv;
 int  filter_ufd = -1;
 int  group_count;
 int  i, rv;

-int  list_queue_option = 0;
+int  list_queue_option = QL_BASIC;

 int  msg_action = 0;
 int  msg_action_arg = -1;
 int  msg_action = 0;
 int  msg_action_arg = -1;

-int  namelen = (argv[0] == NULL)? 0 : Ustrlen(argv[0]);
+int  namelen = argv[0] ? Ustrlen(argv[0]) : 0;

 int  queue_only_reason = 0;
 #ifdef EXIM_PERL
 int  perl_start_option = 0;
 int  queue_only_reason = 0;
 #ifdef EXIM_PERL
 int  perl_start_option = 0;


@@ -1453,6 +1928,7 @@ int  recipients_arg = argc;
 int  sender_address_domain = 0;
 int  test_retry_arg = -1;
 int  test_rewrite_arg = -1;
 int  sender_address_domain = 0;
 int  test_retry_arg = -1;
 int  test_rewrite_arg = -1;

+gid_t original_egid;

 BOOL arg_queue_only = FALSE;
 BOOL bi_option = FALSE;
 BOOL checking = FALSE;
 BOOL arg_queue_only = FALSE;
 BOOL bi_option = FALSE;
 BOOL checking = FALSE;


@@ -1466,9 +1942,10 @@ BOOL f_end_dot = FALSE;
 BOOL deliver_give_up = FALSE;
 BOOL list_queue = FALSE;
 BOOL list_options = FALSE;
 BOOL deliver_give_up = FALSE;
 BOOL list_queue = FALSE;
 BOOL list_options = FALSE;

+BOOL list_config = FALSE;

 BOOL local_queue_only;
 BOOL local_queue_only;

-BOOL more = TRUE;

 BOOL one_msg_action = FALSE;
 BOOL one_msg_action = FALSE;

+BOOL opt_D_used = FALSE;

 BOOL queue_only_set = FALSE;
 BOOL receiving_message = TRUE;
 BOOL sender_ident_set = FALSE;
 BOOL queue_only_set = FALSE;
 BOOL receiving_message = TRUE;
 BOOL sender_ident_set = FALSE;


@@ -1478,28 +1955,29 @@ BOOL removed_privilege = FALSE;
 BOOL usage_wanted = FALSE;
 BOOL verify_address_mode = FALSE;
 BOOL verify_as_sender = FALSE;
 BOOL usage_wanted = FALSE;
 BOOL verify_address_mode = FALSE;
 BOOL verify_as_sender = FALSE;

+BOOL rcpt_verify_quota = FALSE;

 BOOL version_printed = FALSE;
 BOOL version_printed = FALSE;

-uschar *alias_arg = NULL;
-uschar *called_as = US"";
-uschar *cmdline_syslog_name = NULL;
-uschar *start_queue_run_id = NULL;
-uschar *stop_queue_run_id = NULL;
-uschar *expansion_test_message = NULL;
-uschar *ftest_domain = NULL;
-uschar *ftest_localpart = NULL;
-uschar *ftest_prefix = NULL;
-uschar *ftest_suffix = NULL;
-uschar *malware_test_file = NULL;
-uschar *real_sender_address;
-uschar *originator_home = US"/";
+const uschar * alias_arg = NULL;
+const uschar * called_as = US"";
+const uschar * cmdline_syslog_name = NULL;
+const uschar * start_queue_run_id = NULL;
+const uschar * stop_queue_run_id = NULL;
+const uschar * expansion_test_message = NULL;
+const uschar * ftest_domain = NULL;
+const uschar * ftest_localpart = NULL;
+const uschar * ftest_prefix = NULL;
+const uschar * ftest_suffix = NULL;
+uschar * log_oneline = NULL;
+const uschar * malware_test_file = NULL;
+const uschar * real_sender_address;
+uschar * originator_home = US"/";

 size_t sz;
 size_t sz;

-void *reset_point;

 
 struct passwd *pw;
 struct stat statbuf;
 pid_t passed_qr_pid = (pid_t)0;
 int passed_qr_pipe = -1;
 
 struct passwd *pw;
 struct stat statbuf;
 pid_t passed_qr_pid = (pid_t)0;
 int passed_qr_pipe = -1;

-gid_t group_list[NGROUPS_MAX];
+gid_t group_list[EXIM_GROUPLIST_SIZE];

 
 /* For the -bI: flag */
 enum commandline_info info_flag = CMDINFO_NONE;
 
 /* For the -bI: flag */
 enum commandline_info info_flag = CMDINFO_NONE;


@@ -1515,6 +1993,13 @@ because some OS define it in /usr/include/unistd.h. */
 
 extern char **environ;
 
 
 extern char **environ;
 

+#ifdef MEASURE_TIMING
+(void)gettimeofday(&timestamp_startup, NULL);
+#endif
+
+store_init();  /* Initialise the memory allocation susbsystem */
+pcre_init();   /* Set up memory handling for pcre */
+

 /* If the Exim user and/or group and/or the configuration file owner/group were
 defined by ref:name at build time, we must now find the actual uid/gid values.
 This is a feature to make the lives of binary distributors easier. */
 /* If the Exim user and/or group and/or the configuration file owner/group were
 defined by ref:name at build time, we must now find the actual uid/gid values.
 This is a feature to make the lives of binary distributors easier. */


@@ -1523,49 +2008,32 @@ This is a feature to make the lives of binary distributors easier. */
 if (route_finduser(US EXIM_USERNAME, &pw, &exim_uid))
   {
   if (exim_uid == 0)
 if (route_finduser(US EXIM_USERNAME, &pw, &exim_uid))
   {
   if (exim_uid == 0)

-    {
-    fprintf(stderr, "exim: refusing to run with uid 0 for \"%s\"\n",
-      EXIM_USERNAME);
-    exit(EXIT_FAILURE);
-    }
+    exim_fail("exim: refusing to run with uid 0 for \"%s\"\n", EXIM_USERNAME);
+

   /* If ref:name uses a number as the name, route_finduser() returns
   TRUE with exim_uid set and pw coerced to NULL. */
   if (pw)
     exim_gid = pw->pw_gid;
 #ifndef EXIM_GROUPNAME
   else
   /* If ref:name uses a number as the name, route_finduser() returns
   TRUE with exim_uid set and pw coerced to NULL. */
   if (pw)
     exim_gid = pw->pw_gid;
 #ifndef EXIM_GROUPNAME
   else

-    {
-    fprintf(stderr,
+    exim_fail(

         "exim: ref:name should specify a usercode, not a group.\n"
         "exim: can't let you get away with it unless you also specify a group.\n");
         "exim: ref:name should specify a usercode, not a group.\n"
         "exim: can't let you get away with it unless you also specify a group.\n");

-    exit(EXIT_FAILURE);
-    }

 #endif
   }
 else
 #endif
   }
 else

-  {
-  fprintf(stderr, "exim: failed to find uid for user name \"%s\"\n",
-    EXIM_USERNAME);
-  exit(EXIT_FAILURE);
-  }
+  exim_fail("exim: failed to find uid for user name \"%s\"\n", EXIM_USERNAME);

 #endif
 
 #ifdef EXIM_GROUPNAME
 if (!route_findgroup(US EXIM_GROUPNAME, &exim_gid))
 #endif
 
 #ifdef EXIM_GROUPNAME
 if (!route_findgroup(US EXIM_GROUPNAME, &exim_gid))

-  {
-  fprintf(stderr, "exim: failed to find gid for group name \"%s\"\n",
-    EXIM_GROUPNAME);
-  exit(EXIT_FAILURE);
-  }
+  exim_fail("exim: failed to find gid for group name \"%s\"\n", EXIM_GROUPNAME);

 #endif
 
 #ifdef CONFIGURE_OWNERNAME
 if (!route_finduser(US CONFIGURE_OWNERNAME, NULL, &config_uid))
 #endif
 
 #ifdef CONFIGURE_OWNERNAME
 if (!route_finduser(US CONFIGURE_OWNERNAME, NULL, &config_uid))

-  {
-  fprintf(stderr, "exim: failed to find uid for user name \"%s\"\n",
+  exim_fail("exim: failed to find uid for user name \"%s\"\n",

     CONFIGURE_OWNERNAME);
     CONFIGURE_OWNERNAME);

-  exit(EXIT_FAILURE);
-  }

 #endif
 
 /* We default the system_filter_user to be the Exim run-time user, as a
 #endif
 
 /* We default the system_filter_user to be the Exim run-time user, as a


@@ -1574,15 +2042,13 @@ system_filter_uid = exim_uid;
 
 #ifdef CONFIGURE_GROUPNAME
 if (!route_findgroup(US CONFIGURE_GROUPNAME, &config_gid))
 
 #ifdef CONFIGURE_GROUPNAME
 if (!route_findgroup(US CONFIGURE_GROUPNAME, &config_gid))

-  {
-  fprintf(stderr, "exim: failed to find gid for group name \"%s\"\n",
+  exim_fail("exim: failed to find gid for group name \"%s\"\n",

     CONFIGURE_GROUPNAME);
     CONFIGURE_GROUPNAME);

-  exit(EXIT_FAILURE);
-  }

 #endif
 
 #endif
 

-/* In the Cygwin environment, some initialization needs doing. It is fudged
-in by means of this macro. */
+/* In the Cygwin environment, some initialization used to need doing.
+It was fudged in by means of this macro; now no longer but we'll leave
+it in case of others. */

 
 #ifdef OS_INIT
 OS_INIT
 
 #ifdef OS_INIT
 OS_INIT


@@ -1591,8 +2057,14 @@ OS_INIT
 /* Check a field which is patched when we are running Exim within its
 testing harness; do a fast initial check, and then the whole thing. */
 
 /* Check a field which is patched when we are running Exim within its
 testing harness; do a fast initial check, and then the whole thing. */
 

-running_in_test_harness =
+f.running_in_test_harness =

   *running_status == '<' && Ustrcmp(running_status, "<<<testing>>>") == 0;
   *running_status == '<' && Ustrcmp(running_status, "<<<testing>>>") == 0;

+if (f.running_in_test_harness)
+  debug_store = TRUE;
+
+/* Protect against abusive argv[0] */
+if (!argv[0] || !argc) exim_fail("exim: executable name required\n");
+exim_str_fail_toolong(argv[0], PATH_MAX, "argv[0]");

 
 /* The C standard says that the equivalent of setlocale(LC_ALL, "C") is obeyed
 at the start of a program; however, it seems that some environments do not
 
 /* The C standard says that the equivalent of setlocale(LC_ALL, "C") is obeyed
 at the start of a program; however, it seems that some environments do not


@@ -1601,6 +2073,12 @@ make quite sure. */
 
 setlocale(LC_ALL, "C");
 
 
 setlocale(LC_ALL, "C");
 

+/* Get the offset between CLOCK_MONOTONIC/CLOCK_BOOTTIME and wallclock */
+
+#ifdef _POSIX_MONOTONIC_CLOCK
+exim_clock_init();
+#endif
+

 /* Set up the default handler for timing using alarm(). */
 
 os_non_restarting_signal(SIGALRM, sigalrm_handler);
 /* Set up the default handler for timing using alarm(). */
 
 os_non_restarting_signal(SIGALRM, sigalrm_handler);


@@ -1608,12 +2086,12 @@ os_non_restarting_signal(SIGALRM, sigalrm_handler);
 /* Ensure we have a buffer for constructing log entries. Use malloc directly,
 because store_malloc writes a log entry on failure. */
 
 /* Ensure we have a buffer for constructing log entries. Use malloc directly,
 because store_malloc writes a log entry on failure. */
 

-log_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
-if (log_buffer == NULL)
-  {
-  fprintf(stderr, "exim: failed to get store for log buffer\n");
-  exit(EXIT_FAILURE);
-  }
+if (!(log_buffer = US malloc(LOG_BUFFER_SIZE)))
+  exim_fail("exim: failed to get store for log buffer\n");
+
+/* Initialize the default log options. */
+
+bits_set(log_selector, log_selector_size, log_default);

 
 /* Set log_stderr to stderr, provided that stderr exists. This gets reset to
 NULL when the daemon is run and the file is closed. We have to use this
 
 /* Set log_stderr to stderr, provided that stderr exists. This gets reset to
 NULL when the daemon is run and the file is closed. We have to use this


@@ -1622,15 +2100,6 @@ indirection, because some systems don't allow writing to the variable "stderr".
 
 if (fstat(fileno(stderr), &statbuf) >= 0) log_stderr = stderr;
 
 
 if (fstat(fileno(stderr), &statbuf) >= 0) log_stderr = stderr;
 

-/* Arrange for the PCRE regex library to use our store functions. Note that
-the normal calls are actually macros that add additional arguments for
-debugging purposes so we have to assign specially constructed functions here.
-The default is to use store in the stacking pool, but this is overridden in the
-regex_must_compile() function. */
-
-pcre_malloc = function_store_get;
-pcre_free = function_dummy_free;
-

 /* Ensure there is a big buffer for temporary use in several places. It is put
 in malloc store so that it can be freed for enlargement if necessary. */
 
 /* Ensure there is a big buffer for temporary use in several places. It is put
 in malloc store so that it can be freed for enlargement if necessary. */
 


@@ -1639,8 +2108,22 @@ big_buffer = store_malloc(big_buffer_size);
 /* Set up the handler for the data request signal, and set the initial
 descriptive text. */
 
 /* Set up the handler for the data request signal, and set the initial
 descriptive text. */
 

+process_info = store_get(PROCESS_INFO_SIZE, GET_TAINTED);

 set_process_info("initializing");
 set_process_info("initializing");

-os_restarting_signal(SIGUSR1, usr1_handler);
+os_restarting_signal(SIGUSR1, usr1_handler);           /* exiwhat */
+#ifdef SA_SIGINFO
+  {
+  struct sigaction act = { .sa_sigaction = segv_handler, .sa_flags = SA_RESETHAND | SA_SIGINFO };
+  sigaction(SIGSEGV, &act, NULL);
+  }
+#else
+signal(SIGSEGV, segv_handler);                         /* log faults */
+#endif
+
+/* If running in a dockerized environment, the TERM signal is only
+delegated to the PID 1 if we request it by setting an signal handler */
+
+if (getpid() == 1) signal(SIGTERM, term_handler);

 
 /* SIGHUP is used to get the daemon to reconfigure. It gets set as appropriate
 in the daemon code. For the rest of Exim's uses, we ignore it. */
 
 /* SIGHUP is used to get the daemon to reconfigure. It gets set as appropriate
 in the daemon code. For the rest of Exim's uses, we ignore it. */


@@ -1707,7 +2190,14 @@ this here, because the -M options check their arguments for syntactic validity
 using mac_ismsgid, which uses this. */
 
 regex_ismsgid =
 using mac_ismsgid, which uses this. */
 
 regex_ismsgid =

-  regex_must_compile(US"^(?:[^\\W_]{6}-){2}[^\\W_]{2}$", FALSE, TRUE);
+  regex_must_compile(US"^(?:"
+         "[^\\W_]{" str(MESSAGE_ID_TIME_LEN) "}"
+         "-[^\\W_]{" str(MESSAGE_ID_PID_LEN) "}"
+         "-[^\\W_]{" str(MESSAGE_ID_SUBTIME_LEN) "}"
+       "|"
+         "(?:[^\\W_]{6}-){2}[^\\W_]{2}"                /* old ID format */
+       ")$",
+    MCS_NOFLAGS, TRUE);

 
 /* Precompile the regular expression that is used for matching an SMTP error
 code, possibly extended, at the start of an error message. Note that the
 
 /* Precompile the regular expression that is used for matching an SMTP error
 code, possibly extended, at the start of an error message. Note that the


@@ -1715,17 +2205,16 @@ terminating whitespace character is included. */
 
 regex_smtp_code =
   regex_must_compile(US"^\\d\\d\\d\\s(?:\\d\\.\\d\\d?\\d?\\.\\d\\d?\\d?\\s)?",
 
 regex_smtp_code =
   regex_must_compile(US"^\\d\\d\\d\\s(?:\\d\\.\\d\\d?\\d?\\.\\d\\d?\\d?\\s)?",

-    FALSE, TRUE);
+    MCS_NOFLAGS, TRUE);

 
 #ifdef WHITELIST_D_MACROS
 /* Precompile the regular expression used to filter the content of macros
 given to -D for permissibility. */
 
 regex_whitelisted_macro =
 
 #ifdef WHITELIST_D_MACROS
 /* Precompile the regular expression used to filter the content of macros
 given to -D for permissibility. */
 
 regex_whitelisted_macro =

-  regex_must_compile(US"^[A-Za-z0-9_/.-]*$", FALSE, TRUE);
+  regex_must_compile(US"^[A-Za-z0-9_/.-]*$", MCS_NOFLAGS, TRUE);

 #endif
 
 #endif
 

-

 /* If the program is called as "mailq" treat it as equivalent to "exim -bp";
 this seems to be a generally accepted convention, since one finds symbolic
 links called "mailq" in standard OS configurations. */
 /* If the program is called as "mailq" treat it as equivalent to "exim -bp";
 this seems to be a generally accepted convention, since one finds symbolic
 links called "mailq" in standard OS configurations. */


@@ -1747,7 +2236,7 @@ message has been sent). */
 if ((namelen == 5 && Ustrcmp(argv[0], "rmail") == 0) ||
     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rmail", 6) == 0))
   {
 if ((namelen == 5 && Ustrcmp(argv[0], "rmail") == 0) ||
     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rmail", 6) == 0))
   {

-  dot_ends = FALSE;
+  f.dot_ends = FALSE;

   called_as = US"-rmail";
   errors_sender_rc = EXIT_SUCCESS;
   }
   called_as = US"-rmail";
   errors_sender_rc = EXIT_SUCCESS;
   }


@@ -1768,7 +2257,7 @@ this is a smail convention. */
 if ((namelen == 4 && Ustrcmp(argv[0], "runq") == 0) ||
     (namelen  > 4 && Ustrncmp(argv[0] + namelen - 5, "/runq", 5) == 0))
   {
 if ((namelen == 4 && Ustrcmp(argv[0], "runq") == 0) ||
     (namelen  > 4 && Ustrncmp(argv[0] + namelen - 5, "/runq", 5) == 0))
   {

-  queue_interval = 0;
+  alloc_onetime_qrunner();

   receiving_message = FALSE;
   called_as = US"-runq";
   }
   receiving_message = FALSE;
   called_as = US"-runq";
   }


@@ -1788,6 +2277,7 @@ if ((namelen == 10 && Ustrcmp(argv[0], "newaliases") == 0) ||
 normally be root, but in some esoteric environments it may not be. */
 
 original_euid = geteuid();
 normally be root, but in some esoteric environments it may not be. */
 
 original_euid = geteuid();

+original_egid = getegid();

 
 /* Get the real uid and gid. If the caller is root, force the effective uid/gid
 to be the same as the real ones. This makes a difference only if Exim is setuid
 
 /* Get the real uid and gid. If the caller is root, force the effective uid/gid
 to be the same as the real ones. This makes a difference only if Exim is setuid


@@ -1799,20 +2289,12 @@ real_gid = getgid();
 
 if (real_uid == root_uid)
   {
 
 if (real_uid == root_uid)
   {

-  rv = setgid(real_gid);
-  if (rv)
-    {
-    fprintf(stderr, "exim: setgid(%ld) failed: %s\n",
+  if ((rv = setgid(real_gid)))
+    exim_fail("exim: setgid(%ld) failed: %s\n",

         (long int)real_gid, strerror(errno));
         (long int)real_gid, strerror(errno));

-    exit(EXIT_FAILURE);
-    }
-  rv = setuid(real_uid);
-  if (rv)
-    {
-    fprintf(stderr, "exim: setuid(%ld) failed: %s\n",
+  if ((rv = setuid(real_uid)))
+    exim_fail("exim: setuid(%ld) failed: %s\n",

         (long int)real_uid, strerror(errno));
         (long int)real_uid, strerror(errno));

-    exit(EXIT_FAILURE);
-    }

   }
 
 /* If neither the original real uid nor the original euid was root, Exim is
   }
 
 /* If neither the original real uid nor the original euid was root, Exim is


@@ -1820,16 +2302,21 @@ running in an unprivileged state. */
 
 unprivileged = (real_uid != root_uid && original_euid != root_uid);
 
 
 unprivileged = (real_uid != root_uid && original_euid != root_uid);
 

+/* For most of the args-parsing we need to use permanent pool memory */
+ {
+ int old_pool = store_pool;
+ store_pool = POOL_PERM;
+

 /* Scan the program's arguments. Some can be dealt with right away; others are
 simply recorded for checking and handling afterwards. Do a high-level switch
 on the second character (the one after '-'), to save some effort. */
 
 /* Scan the program's arguments. Some can be dealt with right away; others are
 simply recorded for checking and handling afterwards. Do a high-level switch
 on the second character (the one after '-'), to save some effort. */
 

-for (i = 1; i < argc; i++)
+ for (i = 1; i < argc; i++)

   {
   BOOL badarg = FALSE;
   {
   BOOL badarg = FALSE;

-  uschar *arg = argv[i];
-  uschar *argrest;
-  int switchchar;
+  const uschar * arg = argv[i];
+  const uschar * argrest;
+  uschar switchchar;

 
   /* An argument not starting with '-' is the start of a recipients list;
   break out of the options-scanning loop. */
 
   /* An argument not starting with '-' is the start of a recipients list;
   break out of the options-scanning loop. */


@@ -1840,7 +2327,7 @@ for (i = 1; i < argc; i++)
     break;
     }
 
     break;
     }
 

-  /* An option consistion of -- terminates the options */
+  /* An option consisting of -- terminates the options */

 
   if (Ustrcmp(arg, "--") == 0)
     {
 
   if (Ustrcmp(arg, "--") == 0)
     {


@@ -1869,7 +2356,7 @@ for (i = 1; i < argc; i++)
     {
     switchchar = arg[3];
     argrest += 2;
     {
     switchchar = arg[3];
     argrest += 2;

-    queue_2stage = TRUE;
+    f.queue_2stage = TRUE;

     }
 
   /* Make -r synonymous with -f, since it is a documented alias */
     }
 
   /* Make -r synonymous with -f, since it is a documented alias */


@@ -1907,387 +2394,412 @@ for (i = 1; i < argc; i++)
     /* sendmail uses -Ac and -Am to control which .cf file is used;
     we ignore them. */
     case 'A':
     /* sendmail uses -Ac and -Am to control which .cf file is used;
     we ignore them. */
     case 'A':

-    if (*argrest == '\0') { badarg = TRUE; break; }
-    else
-      {
-      BOOL ignore = FALSE;
-      switch (*argrest)
-        {
-        case 'c':
-        case 'm':
-          if (*(argrest + 1) == '\0')
-            ignore = TRUE;
-          break;
-        }
-      if (!ignore) { badarg = TRUE; break; }
-      }
-    break;
+      if (!*argrest) { badarg = TRUE; break; }
+      else
+       {
+       BOOL ignore = FALSE;
+       switch (*argrest)
+         {
+         case 'c':
+         case 'm':
+           if (*(argrest + 1) == '\0')
+             ignore = TRUE;
+           break;
+         }
+       if (!ignore) badarg = TRUE;
+       }
+      break;
+
+    /* -atrn <host> <domains> */
+    case 'a':
+      if (Ustrcmp(argrest, "trn") == 0)
+       if (i+2 < argc)
+         {
+         atrn_mode = US"C";    /* Customer mode */
+
+         /* The host could at this point have a port attached */
+         atrn_host = exim_arg_copy(argv[++i], EXIM_DOMAINNAME_MAX, "-atrn");
+         atrn_domains = exim_arg_copy(argv[++i], EXIM_DOMAINNAME_MAX*4,
+                                     "-atrn");
+         i++;
+         }
+       else
+         exim_fail("exim: host and domainlist expected after %s\n", argv[i]);
+      else badarg = TRUE;
+      break;

 
     /* -Btype is a sendmail option for 7bit/8bit setting. Exim is 8-bit clean
     so has no need of it. */
 
     case 'B':
 
     /* -Btype is a sendmail option for 7bit/8bit setting. Exim is 8-bit clean
     so has no need of it. */
 
     case 'B':

-    if (*argrest == 0) i++;       /* Skip over the type */
-    break;
+      if (!*argrest) i++;       /* Skip over the type */
+      break;

 
 
     case 'b':
 
 
     case 'b':

-    receiving_message = FALSE;    /* Reset TRUE for -bm, -bS, -bs below */
-
-    /* -bd:  Run in daemon mode, awaiting SMTP connections.
-       -bdf: Ditto, but in the foreground.
-    */
-
-    if (*argrest == 'd')

       {
       {

-      daemon_listen = TRUE;
-      if (*(++argrest) == 'f') background_daemon = FALSE;
-        else if (*argrest != 0) { badarg = TRUE; break; }
-      }
-
-    /* -be:  Run in expansion test mode
-       -bem: Ditto, but read a message from a file first
-    */
+      receiving_message = FALSE;    /* Reset TRUE for -bm, -bS, -bs below */
+
+      switch (*argrest++)
+       {
+       /* -bd:  Run in daemon mode, awaiting SMTP connections.
+          -bdf: Ditto, but in the foreground.
+       */
+       case 'd':
+         f.daemon_listen = f.daemon_scion = TRUE;
+         if (*argrest == 'f') f.background_daemon = FALSE;
+         else if (*argrest) badarg = TRUE;
+         break;
+
+       /* -be:  Run in expansion test mode
+          -bem: Ditto, but read a message from a file first
+       */
+       case 'e':
+         expansion_test = checking = TRUE;
+         if (*argrest == 'm')
+           {
+           if (++i >= argc) { badarg = TRUE; break; }
+           expansion_test_message = argv[i];
+           argrest++;
+           }
+         if (*argrest) badarg = TRUE;
+         break;
+
+       /* -bF:  Run system filter test */
+       case 'F':
+         filter_test |= checking = FTEST_SYSTEM;
+         if (*argrest) badarg = TRUE;
+         else if (++i < argc) filter_test_sfile = argv[i];
+         else exim_fail("exim: file name expected after %s\n", argv[i-1]);
+         break;
+
+       /* -bf:  Run user filter test
+          -bfd: Set domain for filter testing
+          -bfl: Set local part for filter testing
+          -bfp: Set prefix for filter testing
+          -bfs: Set suffix for filter testing
+       */
+       case 'f':
+         if (!*argrest)
+           {
+           filter_test |= checking = FTEST_USER;
+           if (++i < argc) filter_test_ufile = argv[i];
+           else exim_fail("exim: file name expected after %s\n", argv[i-1]);
+           }
+         else
+           {
+           if (++i >= argc)
+             exim_fail("exim: string expected after %s\n", arg);
+           if (Ustrcmp(argrest, "d") == 0) ftest_domain = exim_str_fail_toolong(argv[i], EXIM_DOMAINNAME_MAX, "-bfd");
+           else if (Ustrcmp(argrest, "l") == 0) ftest_localpart = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfl");
+           else if (Ustrcmp(argrest, "p") == 0) ftest_prefix = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfp");
+           else if (Ustrcmp(argrest, "s") == 0) ftest_suffix = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfs");
+           else badarg = TRUE;
+           }
+         break;
+
+       /* -bh: Host checking - an IP address must follow. */
+       case 'h':
+         if (  (!*argrest || Ustrcmp(argrest, "c") == 0)
+            && ++i < argc)
+           {
+           sender_host_address = string_copy_taint(
+                 exim_str_fail_toolong(argv[i], EXIM_IPADDR_MAX, "-bh"),
+                 GET_TAINTED);
+           host_checking = checking = f.log_testing_mode = TRUE;
+           f.host_checking_callout = *argrest == 'c';
+           message_logs = FALSE;
+           }
+         else
+           badarg = TRUE;
+         break;
+
+       /* -bi: This option is used by sendmail to initialize *the* alias file,
+       though it has the -oA option to specify a different file. Exim has no
+       concept of *the* alias file, but since Sun's YP make script calls
+       sendmail this way, some support must be provided. */
+       case 'i':
+         if (!*argrest) bi_option = TRUE;
+         else badarg = TRUE;
+         break;
+
+       /* -bI: provide information, of the type to follow after a colon.
+       This is an Exim flag. */
+       case 'I':
+         if (Ustrlen(argrest) >= 1 && *argrest == ':')
+           {
+           const uschar * p = argrest+1;
+           info_flag = CMDINFO_HELP;
+           if (Ustrlen(p))
+             if (strcmpic(p, CUS"sieve") == 0)
+               {
+               info_flag = CMDINFO_SIEVE;
+               info_stdout = TRUE;
+               }
+             else if (strcmpic(p, CUS"dscp") == 0)
+               {
+               info_flag = CMDINFO_DSCP;
+               info_stdout = TRUE;
+               }
+             else if (strcmpic(p, CUS"help") == 0)
+               info_stdout = TRUE;
+           }
+         else badarg = TRUE;
+         break;
+
+       /* -bm: Accept and deliver message - the default option. Reinstate
+       receiving_message, which got turned off for all -b options.
+          -bmalware: test the filename given for malware */
+       case 'm':
+         if (!*argrest) receiving_message = TRUE;
+         else if (Ustrcmp(argrest, "alware") == 0)
+           {
+           if (++i >= argc) { badarg = TRUE; break; }
+           checking = TRUE;
+           malware_test_file = argv[i];
+           }
+         else badarg = TRUE;
+         break;
+
+       /* -bnq: For locally originating messages, do not qualify unqualified
+       addresses. In the envelope, this causes errors; in header lines they
+       just get left. */
+       case 'n':
+         if (Ustrcmp(argrest, "q") == 0)
+           {
+           f.allow_unqualified_sender = FALSE;
+           f.allow_unqualified_recipient = FALSE;
+           }
+         else badarg = TRUE;
+         break;
+
+       /* -bpxx: List the contents of the mail queue, in various forms. If
+       the option is -bpc, just a queue count is needed. Otherwise, if the
+       first letter after p is r, then order is random. */
+       case 'p':
+         if (*argrest == 'c')
+           {
+           count_queue = TRUE;
+           if (*++argrest) badarg = TRUE;
+           break;
+           }

 
 

-    else if (*argrest == 'e')
-      {
-      expansion_test = checking = TRUE;
-      if (argrest[1] == 'm')
-        {
-        if (++i >= argc) { badarg = TRUE; break; }
-        expansion_test_message = argv[i];
-        argrest++;
-        }
-      if (argrest[1] != 0) { badarg = TRUE; break; }
-      }
+         if (*argrest == 'r')
+           list_queue_option = QL_UNSORTED, argrest++;
+         else
+           list_queue_option = QL_BASIC;

 
 

-    /* -bF:  Run system filter test */
+         list_queue = TRUE;

 
 

-    else if (*argrest == 'F')
-      {
-      filter_test |= FTEST_SYSTEM;
-      if (*(++argrest) != 0) { badarg = TRUE; break; }
-      if (++i < argc) filter_test_sfile = argv[i]; else
-        {
-        fprintf(stderr, "exim: file name expected after %s\n", argv[i-1]);
-        exit(EXIT_FAILURE);
-        }
-      }
+         /* -bp: List the contents of the mail queue, top-level only */

 
 

-    /* -bf:  Run user filter test
-       -bfd: Set domain for filter testing
-       -bfl: Set local part for filter testing
-       -bfp: Set prefix for filter testing
-       -bfs: Set suffix for filter testing
-    */
+         if (!*argrest) {}

 
 

-    else if (*argrest == 'f')
-      {
-      if (*(++argrest) == 0)
-        {
-        filter_test |= FTEST_USER;
-        if (++i < argc) filter_test_ufile = argv[i]; else
-          {
-          fprintf(stderr, "exim: file name expected after %s\n", argv[i-1]);
-          exit(EXIT_FAILURE);
-          }
-        }
-      else
-        {
-        if (++i >= argc)
-          {
-          fprintf(stderr, "exim: string expected after %s\n", arg);
-          exit(EXIT_FAILURE);
-          }
-        if (Ustrcmp(argrest, "d") == 0) ftest_domain = argv[i];
-        else if (Ustrcmp(argrest, "l") == 0) ftest_localpart = argv[i];
-        else if (Ustrcmp(argrest, "p") == 0) ftest_prefix = argv[i];
-        else if (Ustrcmp(argrest, "s") == 0) ftest_suffix = argv[i];
-        else { badarg = TRUE; break; }
-        }
-      }
+         /* -bpu: List the contents of the mail queue, top-level undelivered */

 
 

-    /* -bh: Host checking - an IP address must follow. */
+         else if (Ustrcmp(argrest, "u") == 0) list_queue_option |= QL_UNDELIVERED_ONLY;

 
 

-    else if (Ustrcmp(argrest, "h") == 0 || Ustrcmp(argrest, "hc") == 0)
-      {
-      if (++i >= argc) { badarg = TRUE; break; }
-      sender_host_address = argv[i];
-      host_checking = checking = log_testing_mode = TRUE;
-      host_checking_callout = argrest[1] == 'c';
-      }
+         /* -bpa: List the contents of the mail queue, including all delivered */

 
 

-    /* -bi: This option is used by sendmail to initialize *the* alias file,
-    though it has the -oA option to specify a different file. Exim has no
-    concept of *the* alias file, but since Sun's YP make script calls
-    sendmail this way, some support must be provided. */
+         else if (Ustrcmp(argrest, "a") == 0) list_queue_option |= QL_PLUS_GENERATED;

 
 

-    else if (Ustrcmp(argrest, "i") == 0) bi_option = TRUE;
+         /* -bpi: List only message IDs */

 
 

-    /* -bI: provide information, of the type to follow after a colon.
-    This is an Exim flag. */
+         else if (Ustrcmp(argrest, "i") == 0) list_queue_option |= QL_MSGID_ONLY;

 
 

-    else if (argrest[0] == 'I' && Ustrlen(argrest) >= 2 && argrest[1] == ':')
-      {
-      uschar *p = &argrest[2];
-      info_flag = CMDINFO_HELP;
-      if (Ustrlen(p))
-        {
-        if (strcmpic(p, CUS"sieve") == 0)
-          {
-          info_flag = CMDINFO_SIEVE;
-          info_stdout = TRUE;
-          }
-        else if (strcmpic(p, CUS"dscp") == 0)
-          {
-          info_flag = CMDINFO_DSCP;
-          info_stdout = TRUE;
-          }
-        else if (strcmpic(p, CUS"help") == 0)
-          {
-          info_stdout = TRUE;
-          }
-        }
-      }
+         /* Unknown after -bp[r] */

 
 

-    /* -bm: Accept and deliver message - the default option. Reinstate
-    receiving_message, which got turned off for all -b options. */
+         else badarg = TRUE;
+         break;

 
 

-    else if (Ustrcmp(argrest, "m") == 0) receiving_message = TRUE;

 
 

-    /* -bmalware: test the filename given for malware */
+       /* -bP: List the configuration variables given as the address list.
+       Force -v, so configuration errors get displayed. */
+       case 'P':

 
 

-    else if (Ustrcmp(argrest, "malware") == 0)
-      {
-      if (++i >= argc) { badarg = TRUE; break; }
-      malware_test_file = argv[i];
-      }
+         /* -bP config: we need to setup here, because later,
+         when list_options is checked, the config is read already */
+         if (*argrest)
+           badarg = TRUE;
+         else if (argv[i+1] && Ustrcmp(argv[i+1], "config") == 0)
+           {
+           list_config = TRUE;
+           readconf_save_config(version_string);
+           }
+         else
+           {
+           list_options = TRUE;
+           debug_selector |= D_v;
+           debug_file = stderr;
+           }
+         break;
+
+       /* -brt: Test retry configuration lookup */
+       case 'r':
+         if (Ustrcmp(argrest, "t") == 0)
+           {
+           checking = TRUE;
+           test_retry_arg = i + 1;
+           goto END_ARG;
+           }

 
 

-    /* -bnq: For locally originating messages, do not qualify unqualified
-    addresses. In the envelope, this causes errors; in header lines they
-    just get left. */
+         /* -brw: Test rewrite configuration */

 
 

-    else if (Ustrcmp(argrest, "nq") == 0)
-      {
-      allow_unqualified_sender = FALSE;
-      allow_unqualified_recipient = FALSE;
+         else if (Ustrcmp(argrest, "w") == 0)
+           {
+           checking = TRUE;
+           test_rewrite_arg = i + 1;
+           goto END_ARG;
+           }
+         else badarg = TRUE;
+         break;
+
+       /* -bS: Read SMTP commands on standard input, but produce no replies -
+       all errors are reported by sending messages. */
+       case 'S':
+         if (!*argrest)
+           smtp_input = smtp_batched_input = receiving_message = TRUE;
+         else badarg = TRUE;
+         break;
+
+       /* -bs: Read SMTP commands on standard input and produce SMTP replies
+       on standard output. */
+       case 's':
+         if (!*argrest) smtp_input = receiving_message = TRUE;
+         else badarg = TRUE;
+         break;
+
+       /* -bt: address testing mode */
+       case 't':
+         if (!*argrest)
+           f.address_test_mode = checking = f.log_testing_mode = TRUE;
+         else badarg = TRUE;
+         break;
+
+       /* -bv: verify addresses */
+       case 'v':
+         if (!*argrest)
+           verify_address_mode = checking = f.log_testing_mode = TRUE;
+
+       /* -bvs: verify sender addresses */
+
+         else if (Ustrcmp(argrest, "s") == 0)
+           {
+           verify_address_mode = checking = f.log_testing_mode = TRUE;
+           verify_as_sender = TRUE;
+           }
+         else badarg = TRUE;
+         break;
+
+       /* -bV: Print version string and support details */
+       case 'V':
+         if (!*argrest)
+           {
+           printf("Exim version %s #%s built %s\n", version_string,
+             version_cnumber, version_date);
+           printf("%s\n", CS version_copyright);
+           version_printed = TRUE;
+           show_whats_supported(TRUE);
+           f.log_testing_mode = TRUE;
+           }
+         else badarg = TRUE;
+         break;
+
+       /* -bw: inetd wait mode, accept a listening socket as stdin */
+       case 'w':
+         f.inetd_wait_mode = f.daemon_listen = f.daemon_scion = TRUE;
+         f.background_daemon = FALSE;
+         if (*argrest)
+           if ((inetd_wait_timeout = readconf_readtime(argrest, 0, FALSE)) <= 0)
+             exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
+         break;
+
+       default:
+         badarg = TRUE;
+         break;
+       }
+      break;

       }
 
       }
 

-    /* -bpxx: List the contents of the mail queue, in various forms. If
-    the option is -bpc, just a queue count is needed. Otherwise, if the
-    first letter after p is r, then order is random. */

 
 

-    else if (*argrest == 'p')
-      {
-      if (*(++argrest) == 'c')
-        {
-        count_queue = TRUE;
-        if (*(++argrest) != 0) badarg = TRUE;
-        break;
-        }
+    /* -C: change configuration file list; ignore if it isn't really
+    a change! Enforce a prefix check if required. */

 
 

-      if (*argrest == 'r')
+    case 'C':
+    if (!*argrest)
+      if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
+    if (Ustrcmp(config_main_filelist, argrest) != 0)
+      {
+      #ifdef ALT_CONFIG_PREFIX
+      int sep = 0;
+      int len = Ustrlen(ALT_CONFIG_PREFIX);
+      const uschar *list = argrest;
+      uschar *filename;
+      /* The argv is untainted, so big_buffer (also untainted) is ok to use */
+      while((filename = string_nextinlist(&list, &sep, big_buffer,
+             big_buffer_size)))
+        if (  (  Ustrlen(filename) < len
+             || Ustrncmp(filename, ALT_CONFIG_PREFIX, len) != 0
+             || Ustrstr(filename, "/../") != NULL
+             )
+          && (Ustrcmp(filename, "/dev/null") != 0 || real_uid != root_uid)
+          )
+          exim_fail("-C Permission denied\n");
+      #endif
+      if (real_uid != root_uid)

         {
         {

-        list_queue_option = 8;
-        argrest++;
-        }
-      else list_queue_option = 0;
-
-      list_queue = TRUE;
+        #ifdef TRUSTED_CONFIG_LIST

 
 

-      /* -bp: List the contents of the mail queue, top-level only */
+        if (real_uid != exim_uid
+            #ifdef CONFIGURE_OWNER
+            && real_uid != config_uid
+            #endif
+            )
+          f.trusted_config = FALSE;
+        else
+          {
+          FILE *trust_list = Ufopen(TRUSTED_CONFIG_LIST, "rb");
+          if (trust_list)
+            {
+            struct stat statbuf;

 
 

-      if (*argrest == 0) {}
-
-      /* -bpu: List the contents of the mail queue, top-level undelivered */
-
-      else if (Ustrcmp(argrest, "u") == 0) list_queue_option += 1;
-
-      /* -bpa: List the contents of the mail queue, including all delivered */
-
-      else if (Ustrcmp(argrest, "a") == 0) list_queue_option += 2;
-
-      /* Unknown after -bp[r] */
-
-      else
-        {
-        badarg = TRUE;
-        break;
-        }
-      }
-
-
-    /* -bP: List the configuration variables given as the address list.
-    Force -v, so configuration errors get displayed. */
-
-    else if (Ustrcmp(argrest, "P") == 0)
-      {
-      list_options = TRUE;
-      debug_selector |= D_v;
-      debug_file = stderr;
-      }
-
-    /* -brt: Test retry configuration lookup */
-
-    else if (Ustrcmp(argrest, "rt") == 0)
-      {
-      test_retry_arg = i + 1;
-      goto END_ARG;
-      }
-
-    /* -brw: Test rewrite configuration */
-
-    else if (Ustrcmp(argrest, "rw") == 0)
-      {
-      test_rewrite_arg = i + 1;
-      goto END_ARG;
-      }
-
-    /* -bS: Read SMTP commands on standard input, but produce no replies -
-    all errors are reported by sending messages. */
-
-    else if (Ustrcmp(argrest, "S") == 0)
-      smtp_input = smtp_batched_input = receiving_message = TRUE;
-
-    /* -bs: Read SMTP commands on standard input and produce SMTP replies
-    on standard output. */
-
-    else if (Ustrcmp(argrest, "s") == 0) smtp_input = receiving_message = TRUE;
-
-    /* -bt: address testing mode */
-
-    else if (Ustrcmp(argrest, "t") == 0)
-      address_test_mode = checking = log_testing_mode = TRUE;
-
-    /* -bv: verify addresses */
-
-    else if (Ustrcmp(argrest, "v") == 0)
-      verify_address_mode = checking = log_testing_mode = TRUE;
-
-    /* -bvs: verify sender addresses */
-
-    else if (Ustrcmp(argrest, "vs") == 0)
-      {
-      verify_address_mode = checking = log_testing_mode = TRUE;
-      verify_as_sender = TRUE;
-      }
-
-    /* -bV: Print version string and support details */
-
-    else if (Ustrcmp(argrest, "V") == 0)
-      {
-      printf("Exim version %s #%s built %s\n", version_string,
-        version_cnumber, version_date);
-      printf("%s\n", CS version_copyright);
-      version_printed = TRUE;
-      show_whats_supported(stdout);
-      }
-
-    /* -bw: inetd wait mode, accept a listening socket as stdin */
-
-    else if (*argrest == 'w')
-      {
-      inetd_wait_mode = TRUE;
-      background_daemon = FALSE;
-      daemon_listen = TRUE;
-      if (*(++argrest) != '\0')
-        {
-        inetd_wait_timeout = readconf_readtime(argrest, 0, FALSE);
-        if (inetd_wait_timeout <= 0)
-          {
-          fprintf(stderr, "exim: bad time value %s: abandoned\n", argv[i]);
-          exit(EXIT_FAILURE);
-          }
-        }
-      }
-
-    else badarg = TRUE;
-    break;
-
-
-    /* -C: change configuration file list; ignore if it isn't really
-    a change! Enforce a prefix check if required. */
-
-    case 'C':
-    if (*argrest == 0)
-      {
-      if(++i < argc) argrest = argv[i]; else
-        { badarg = TRUE; break; }
-      }
-    if (Ustrcmp(config_main_filelist, argrest) != 0)
-      {
-      #ifdef ALT_CONFIG_PREFIX
-      int sep = 0;
-      int len = Ustrlen(ALT_CONFIG_PREFIX);
-      uschar *list = argrest;
-      uschar *filename;
-      while((filename = string_nextinlist(&list, &sep, big_buffer,
-             big_buffer_size)) != NULL)
-        {
-        if ((Ustrlen(filename) < len ||
-             Ustrncmp(filename, ALT_CONFIG_PREFIX, len) != 0 ||
-             Ustrstr(filename, "/../") != NULL) &&
-             (Ustrcmp(filename, "/dev/null") != 0 || real_uid != root_uid))
-          {
-          fprintf(stderr, "-C Permission denied\n");
-          exit(EXIT_FAILURE);
-          }
-        }
-      #endif
-      if (real_uid != root_uid)
-        {
-        #ifdef TRUSTED_CONFIG_LIST
-
-        if (real_uid != exim_uid
-            #ifdef CONFIGURE_OWNER
-            && real_uid != config_uid
-            #endif
-            )
-          trusted_config = FALSE;
-        else
-          {
-          FILE *trust_list = Ufopen(TRUSTED_CONFIG_LIST, "rb");
-          if (trust_list)
-            {
-            struct stat statbuf;
-
-            if (fstat(fileno(trust_list), &statbuf) != 0 ||
-                (statbuf.st_uid != root_uid        /* owner not root */
-                 #ifdef CONFIGURE_OWNER
-                 && statbuf.st_uid != config_uid   /* owner not the special one */
-                 #endif
-                   ) ||                            /* or */
-                (statbuf.st_gid != root_gid        /* group not root */
-                 #ifdef CONFIGURE_GROUP
-                 && statbuf.st_gid != config_gid   /* group not the special one */
-                 #endif
-                 && (statbuf.st_mode & 020) != 0   /* group writeable */
-                   ) ||                            /* or */
-                (statbuf.st_mode & 2) != 0)        /* world writeable */
-              {
-              trusted_config = FALSE;
-              fclose(trust_list);
-              }
-           else
-              {
-              /* Well, the trust list at least is up to scratch... */
-              void *reset_point = store_get(0);
-              uschar *trusted_configs[32];
-              int nr_configs = 0;
-              int i = 0;
+            if (fstat(fileno(trust_list), &statbuf) != 0 ||
+                (statbuf.st_uid != root_uid        /* owner not root */
+                 #ifdef CONFIGURE_OWNER
+                 && statbuf.st_uid != config_uid   /* owner not the special one */
+                 #endif
+                   ) ||                            /* or */
+                (statbuf.st_gid != root_gid        /* group not root */
+                 #ifdef CONFIGURE_GROUP
+                 && statbuf.st_gid != config_gid   /* group not the special one */
+                 #endif
+                 && (statbuf.st_mode & 020) != 0   /* group writeable */
+                   ) ||                            /* or */
+                (statbuf.st_mode & 2) != 0)        /* world writeable */
+              {
+              f.trusted_config = FALSE;
+              fclose(trust_list);
+              }
+           else
+              {
+              /* Well, the trust list at least is up to scratch... */
+              rmark reset_point;
+              uschar *trusted_configs[32];
+              int nr_configs = 0;
+              int i = 0;
+             int old_pool = store_pool;
+             store_pool = POOL_MAIN;

 
 

+              reset_point = store_mark();

               while (Ufgets(big_buffer, big_buffer_size, trust_list))
                 {
               while (Ufgets(big_buffer, big_buffer_size, trust_list))
                 {

-                uschar *start = big_buffer, *nl;
-                while (*start && isspace(*start))
-                start++;
-                if (*start != '/')
+                uschar * start = big_buffer, * nl;
+                if (Uskip_whitespace(&start) != '/')

                   continue;
                   continue;

-                nl = Ustrchr(start, '\n');
-                if (nl)
-                  *nl = 0;
+                if ((nl = Ustrchr(start, '\n')))
+                  *nl = '\0';

                 trusted_configs[nr_configs++] = string_copy(start);
                 trusted_configs[nr_configs++] = string_copy(start);

-                if (nr_configs == 32)
+                if (nr_configs == nelem(trusted_configs))

                   break;
                 }
               fclose(trust_list);
                   break;
                 }
               fclose(trust_list);


@@ -2295,45 +2807,38 @@ for (i = 1; i < argc; i++)
               if (nr_configs)
                 {
                 int sep = 0;
               if (nr_configs)
                 {
                 int sep = 0;

-                uschar *list = argrest;
+                const uschar *list = argrest;

                 uschar *filename;
                 uschar *filename;

-                while (trusted_config && (filename = string_nextinlist(&list,
-                        &sep, big_buffer, big_buffer_size)) != NULL)
+                while (f.trusted_config && (filename = string_nextinlist(&list,
+                        &sep, big_buffer, big_buffer_size)))

                   {
                   for (i=0; i < nr_configs; i++)
                   {
                   for (i=0; i < nr_configs; i++)

-                    {

                     if (Ustrcmp(filename, trusted_configs[i]) == 0)
                       break;
                     if (Ustrcmp(filename, trusted_configs[i]) == 0)
                       break;

-                    }

                   if (i == nr_configs)
                     {
                   if (i == nr_configs)
                     {

-                    trusted_config = FALSE;
+                    f.trusted_config = FALSE;

                     break;
                     }
                   }
                     break;
                     }
                   }

-                store_reset(reset_point);
-                }
-              else
-                {
-                /* No valid prefixes found in trust_list file. */
-                trusted_config = FALSE;

                 }
                 }

+              else     /* No valid prefixes found in trust_list file. */
+                f.trusted_config = FALSE;
+              store_reset(reset_point);
+             store_pool = old_pool;

               }
            }
               }
            }

-          else
-            {
-            /* Could not open trust_list file. */
-            trusted_config = FALSE;
-            }
+          else         /* Could not open trust_list file. */
+            f.trusted_config = FALSE;

           }
       #else
         /* Not root; don't trust config */
           }
       #else
         /* Not root; don't trust config */

-        trusted_config = FALSE;
+        f.trusted_config = FALSE;

       #endif
         }
 
       config_main_filelist = argrest;
       #endif
         }
 
       config_main_filelist = argrest;

-      config_changed = TRUE;
+      f.config_changed = TRUE;

       }
     break;
 
       }
     break;
 


@@ -2341,25 +2846,21 @@ for (i = 1; i < argc; i++)
     /* -D: set up a macro definition */
 
     case 'D':
     /* -D: set up a macro definition */
 
     case 'D':

-    #ifdef DISABLE_D_OPTION
-    fprintf(stderr, "exim: -D is not available in this Exim binary\n");
-    exit(EXIT_FAILURE);
-    #else
+#ifdef DISABLE_D_OPTION
+      exim_fail("exim: -D is not available in this Exim binary\n");
+#else

       {
       int ptr = 0;
       {
       int ptr = 0;

-      macro_item *mlast = NULL;
-      macro_item *m;
+      macro_item * m;

       uschar name[24];
       uschar name[24];

-      uschar *s = argrest;
+      const uschar * s = argrest;

 
 

-      while (isspace(*s)) s++;
+      opt_D_used = TRUE;
+      Uskip_whitespace(&s);

 
       if (*s < 'A' || *s > 'Z')
 
       if (*s < 'A' || *s > 'Z')

-        {
-        fprintf(stderr, "exim: macro name set by -D must start with "
+        exim_fail("exim: macro name set by -D must start with "

           "an upper case letter\n");
           "an upper case letter\n");

-        exit(EXIT_FAILURE);
-        }

 
       while (isalnum(*s) || *s == '_')
         {
 
       while (isalnum(*s) || *s == '_')
         {


@@ -2368,67 +2869,67 @@ for (i = 1; i < argc; i++)
         }
       name[ptr] = 0;
       if (ptr == 0) { badarg = TRUE; break; }
         }
       name[ptr] = 0;
       if (ptr == 0) { badarg = TRUE; break; }

-      while (isspace(*s)) s++;
-      if (*s != 0)
+      if (Uskip_whitespace(&s))

         {
         if (*s++ != '=') { badarg = TRUE; break; }
         {
         if (*s++ != '=') { badarg = TRUE; break; }

-        while (isspace(*s)) s++;
+        Uskip_whitespace(&s);

         }
 
         }
 

-      for (m = macros; m != NULL; m = m->next)
-        {
+      for (m = macros_user; m; m = m->next)

         if (Ustrcmp(m->name, name) == 0)
         if (Ustrcmp(m->name, name) == 0)

-          {
-          fprintf(stderr, "exim: duplicated -D in command line\n");
-          exit(EXIT_FAILURE);
-          }
-        mlast = m;
-        }
+          exim_fail("exim: duplicated -D in command line\n");

 
 

-      m = store_get(sizeof(macro_item) + Ustrlen(name));
-      m->next = NULL;
-      m->command_line = TRUE;
-      if (mlast == NULL) macros = m; else mlast->next = m;
-      Ustrcpy(m->name, name);
-      m->replacement = string_copy(s);
+      m = macro_create(name, s, TRUE);

 
       if (clmacro_count >= MAX_CLMACROS)
 
       if (clmacro_count >= MAX_CLMACROS)

-        {
-        fprintf(stderr, "exim: too many -D options on command line\n");
-        exit(EXIT_FAILURE);
-        }
-      clmacros[clmacro_count++] = string_sprintf("-D%s=%s", m->name,
-        m->replacement);
+        exim_fail("exim: too many -D options on command line\n");
+      clmacros[clmacro_count++] =
+       string_sprintf("-D%s=%s", m->name, m->replacement);

       }
     #endif
     break;
 
       }
     #endif
     break;
 

-    /* -d: Set debug level (see also -v below) or set the drop_cr option.
-    The latter is now a no-op, retained for compatibility only. If -dd is used,
-    debugging subprocesses of the daemon is disabled. */
-

     case 'd':
     case 'd':

+
+    /* -dropcr: Set this option.  Now a no-op, retained for compatibility only. */
+

     if (Ustrcmp(argrest, "ropcr") == 0)
       {
       /* drop_cr = TRUE; */
       }
 
     if (Ustrcmp(argrest, "ropcr") == 0)
       {
       /* drop_cr = TRUE; */
       }
 

-    /* Use an intermediate variable so that we don't set debugging while
-    decoding the debugging bits. */
+    /* -dp: Set up a debug pretrigger buffer with given size. */
+
+    else if (Ustrcmp(argrest, "p") == 0)
+      if (++i >= argc)
+       badarg = TRUE;
+      else
+       debug_pretrigger_setup(argv[i]);
+
+    /* -dt: Set a debug trigger selector */
+
+    else if (Ustrncmp(argrest, "t=", 2) == 0)
+      dtrigger_selector = (unsigned int) Ustrtol(argrest + 2, NULL, 0);
+
+    /* -d: Set debug level (see also -v below).
+    If -dd is used, debugging subprocesses of the daemon is disabled. */

 
     else
       {
 
     else
       {

+      /* Use an intermediate variable so that we don't set debugging while
+      decoding the debugging bits. */
+

       unsigned int selector = D_default;
       debug_selector = 0;
       debug_file = NULL;
       if (*argrest == 'd')
         {
       unsigned int selector = D_default;
       debug_selector = 0;
       debug_file = NULL;
       if (*argrest == 'd')
         {

-        debug_daemon = TRUE;
+        f.debug_daemon = TRUE;

         argrest++;
         }
         argrest++;
         }

-      if (*argrest != 0)
-        decode_bits(&selector, NULL, D_memory, 0, argrest, debug_options,
-          debug_options_count, US"debug", 0);
+      if (*argrest)
+        decode_bits(&selector, 1, debug_notall, argrest,
+          debug_options, debug_options_count, US"debug", 0);

       debug_selector = selector;
       }
     break;
       debug_selector = selector;
       }
     break;


@@ -2442,7 +2943,7 @@ for (i = 1; i < argc; i++)
     message_reference at it, for logging. */
 
     case 'E':
     message_reference at it, for logging. */
 
     case 'E':

-    local_error_message = TRUE;
+    f.local_error_message = TRUE;

     if (mac_ismsgid(argrest)) message_reference = argrest;
     break;
 
     if (mac_ismsgid(argrest)) message_reference = argrest;
     break;
 


@@ -2473,13 +2974,12 @@ for (i = 1; i < argc; i++)
     the -F or be in the next argument. */
 
     case 'F':
     the -F or be in the next argument. */
 
     case 'F':

-    if (*argrest == 0)
-      {
-      if(++i < argc) argrest = argv[i]; else
-        { badarg = TRUE; break; }
-      }
-    originator_name = argrest;
-    sender_name_forced = TRUE;
+    if (!*argrest)
+      if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
+    originator_name = string_copy_taint(
+                 exim_str_fail_toolong(argrest, EXIM_HUMANNAME_MAX, "-F"),
+                 GET_TAINTED);
+    f.sender_name_forced = TRUE;

     break;
 
 
     break;
 
 


@@ -2500,35 +3000,40 @@ for (i = 1; i < argc; i++)
 
     case 'f':
       {
 
     case 'f':
       {

-      int start, end;
+      int dummy_start, dummy_end;

       uschar *errmess;
       uschar *errmess;

-      if (*argrest == 0)
-        {
-        if (i+1 < argc) argrest = argv[++i]; else
-          { badarg = TRUE; break; }
-        }
-      if (*argrest == 0)
-        {
-        sender_address = string_sprintf("");  /* Ensure writeable memory */
-        }
+      if (!*argrest)
+        if (i+1 < argc) argrest = argv[++i]; else { badarg = TRUE; break; }
+      (void) exim_str_fail_toolong(argrest, EXIM_DISPLAYMAIL_MAX, "-f");
+      if (!*argrest)
+       {
+        uschar * s = store_get(1, GET_UNTAINTED);      /* Ensure writeable memory */
+        *s = '\0';
+        sender_address = s;
+       }

       else
         {
       else
         {

-        uschar *temp = argrest + Ustrlen(argrest) - 1;
+        const uschar * temp = argrest + Ustrlen(argrest) - 1;

         while (temp >= argrest && isspace(*temp)) temp--;
         if (temp >= argrest && *temp == '.') f_end_dot = TRUE;
         allow_domain_literals = TRUE;
         strip_trailing_dot = TRUE;
         while (temp >= argrest && isspace(*temp)) temp--;
         if (temp >= argrest && *temp == '.') f_end_dot = TRUE;
         allow_domain_literals = TRUE;
         strip_trailing_dot = TRUE;

-        sender_address = parse_extract_address(argrest, &errmess, &start, &end,
-          &sender_address_domain, TRUE);
+#ifdef SUPPORT_I18N
+       allow_utf8_domains = TRUE;
+#endif
+        if (!(sender_address = parse_extract_address(argrest, &errmess,
+                 &dummy_start, &dummy_end, &sender_address_domain, TRUE)))
+          exim_fail("exim: bad -f address \"%s\": %s\n", argrest, errmess);
+
+       sender_address = string_copy_taint(sender_address, GET_TAINTED);
+#ifdef SUPPORT_I18N
+       message_smtputf8 =  string_is_utf8(sender_address);
+       allow_utf8_domains = FALSE;
+#endif

         allow_domain_literals = FALSE;
         strip_trailing_dot = FALSE;
         allow_domain_literals = FALSE;
         strip_trailing_dot = FALSE;

-        if (sender_address == NULL)
-          {
-          fprintf(stderr, "exim: bad -f address \"%s\": %s\n", argrest, errmess);
-          return EXIT_FAILURE;
-          }

         }
         }

-      sender_address_forced = TRUE;
+      f.sender_address_forced = TRUE;

       }
     break;
 
       }
     break;
 


@@ -2546,11 +3051,8 @@ for (i = 1; i < argc; i++)
     To put it in will require a change to the spool header file format. */
 
     case 'h':
     To put it in will require a change to the spool header file format. */
 
     case 'h':

-    if (*argrest == 0)
-      {
-      if(++i < argc) argrest = argv[i]; else
-        { badarg = TRUE; break; }
-      }
+    if (!*argrest)
+      if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }

     if (!isdigit(*argrest)) badarg = TRUE;
     break;
 
     if (!isdigit(*argrest)) badarg = TRUE;
     break;
 


@@ -2559,7 +3061,7 @@ for (i = 1; i < argc; i++)
     not to be documented for sendmail but mailx (at least) uses it) */
 
     case 'i':
     not to be documented for sendmail but mailx (at least) uses it) */
 
     case 'i':

-    if (*argrest == 0) dot_ends = FALSE; else badarg = TRUE;
+    if (!*argrest) f.dot_ends = FALSE; else badarg = TRUE;

     break;
 
 
     break;
 
 


@@ -2567,23 +3069,13 @@ for (i = 1; i < argc; i++)
     syslog_processname in the config file, but needs to be an admin option. */
 
     case 'L':
     syslog_processname in the config file, but needs to be an admin option. */
 
     case 'L':

-    if (*argrest == '\0')
-      {
-      if(++i < argc) argrest = argv[i]; else
-        { badarg = TRUE; break; }
-      }
-    sz = Ustrlen(argrest);
-    if (sz > 32)
-      {
-      fprintf(stderr, "exim: the -L syslog name is too long: \"%s\"\n", argrest);
-      return EXIT_FAILURE;
-      }
+    if (!*argrest)
+      if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
+    if ((sz = Ustrlen(argrest)) > 32)
+      exim_fail("exim: the -L syslog name is too long: \"%s\"\n", argrest);

     if (sz < 1)
     if (sz < 1)

-      {
-      fprintf(stderr, "exim: the -L syslog name is too short\n");
-      return EXIT_FAILURE;
-      }
-    cmdline_syslog_name = argrest;
+      exim_fail("exim: the -L syslog name is too short\n");
+    cmdline_syslog_name = string_copy_taint(argrest, GET_TAINTED);

     break;
 
     case 'M':
     break;
 
     case 'M':


@@ -2608,20 +3100,20 @@ for (i = 1; i < argc; i++)
       EXIM_SOCKLEN_T size = sizeof(interface_sock);
 
       if (argc != i + 6)
       EXIM_SOCKLEN_T size = sizeof(interface_sock);
 
       if (argc != i + 6)

-        {
-        fprintf(stderr, "exim: too many or too few arguments after -MC\n");
-        return EXIT_FAILURE;
-        }
+        exim_fail("exim: too many or too few arguments after -MC\n");

 
       if (msg_action_arg >= 0)
 
       if (msg_action_arg >= 0)

-        {
-        fprintf(stderr, "exim: incompatible arguments\n");
-        return EXIT_FAILURE;
-        }
-
-      continue_transport = argv[++i];
-      continue_hostname = argv[++i];
-      continue_host_address = argv[++i];
+        exim_fail("exim: incompatible arguments\n");
+
+      continue_transport = string_copy_taint(
+       exim_str_fail_toolong(argv[++i], EXIM_DRIVERNAME_MAX, "-C internal transport"),
+       GET_TAINTED);
+      continue_hostname = string_copy_taint(
+       exim_str_fail_toolong(argv[++i], EXIM_HOSTNAME_MAX, "-C internal hostname"),
+       GET_TAINTED);
+      continue_host_address = string_copy_taint(
+       exim_str_fail_toolong(argv[++i], EXIM_IPADDR_MAX, "-C internal hostaddr"),
+       GET_TAINTED);

       continue_sequence = Uatoi(argv[++i]);
       msg_action = MSG_DELIVER;
       msg_action_arg = ++i;
       continue_sequence = Uatoi(argv[++i]);
       msg_action = MSG_DELIVER;
       msg_action_arg = ++i;


@@ -2630,91 +3122,166 @@ for (i = 1; i < argc; i++)
       queue_run_pipe = passed_qr_pipe;
 
       if (!mac_ismsgid(argv[i]))
       queue_run_pipe = passed_qr_pipe;
 
       if (!mac_ismsgid(argv[i]))

-        {
-        fprintf(stderr, "exim: malformed message id %s after -MC option\n",
+        exim_fail("exim: malformed message id %s after -MC option\n",

           argv[i]);
           argv[i]);

-        return EXIT_FAILURE;
-        }

 
 

-      /* Set up $sending_ip_address and $sending_port */
+      /* Set up $sending_ip_address and $sending_port, unless proxied */

 
 

-      if (getsockname(fileno(stdin), (struct sockaddr *)(&interface_sock),
-          &size) == 0)
-        sending_ip_address = host_ntoa(-1, &interface_sock, NULL,
-          &sending_port);
-      else
-        {
-        fprintf(stderr, "exim: getsockname() failed after -MC option: %s\n",
-          strerror(errno));
-        return EXIT_FAILURE;
-        }
+      if (!continue_proxy_cipher)
+       if (getsockname(fileno(stdin), (struct sockaddr *)(&interface_sock),
+           &size) == 0)
+         sending_ip_address = host_ntoa(-1, &interface_sock, NULL,
+           &sending_port);
+       else
+         exim_fail("exim: getsockname() failed after -MC option: %s\n",
+           strerror(errno));

 
 

-      if (running_in_test_harness) millisleep(500);
+      testharness_pause_ms(500);

       break;
       }
 
       break;
       }
 

+    else if (*argrest == 'C' && argrest[1] && !argrest[2])
+      {
+      switch(argrest[1])
+       {

     /* -MCA: set the smtp_authenticated flag; this is useful only when it
     precedes -MC (see above). The flag indicates that the host to which
     Exim is connected has accepted an AUTH sequence. */
 
     /* -MCA: set the smtp_authenticated flag; this is useful only when it
     precedes -MC (see above). The flag indicates that the host to which
     Exim is connected has accepted an AUTH sequence. */
 

-    else if (Ustrcmp(argrest, "CA") == 0)
-      {
-      smtp_authenticated = TRUE;
-      break;
-      }
+       case 'A': f.smtp_authenticated = TRUE; break;

 
 

-    #ifdef EXPERIMENTAL_DSN

     /* -MCD: set the smtp_use_dsn flag; this indicates that the host
        that exim is connected to supports the esmtp extension DSN */
     /* -MCD: set the smtp_use_dsn flag; this indicates that the host
        that exim is connected to supports the esmtp extension DSN */

-    else if (strcmp(argrest, "CD") == 0)
-      {
-      smtp_use_dsn = TRUE;
-      break;
-      }
-    #endif
+
+       case 'D': smtp_peer_options |= OPTION_DSN; break;
+
+    /* -MCd: for debug, set a process-purpose string */
+
+       case 'd': if (++i < argc)
+                   process_purpose = string_copy_taint(
+                     exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-MCd"),
+                     GET_TAINTED);
+                 else badarg = TRUE;
+                 break;
+
+    /* -MCG: set the queue name, to a non-default value. Arguably, anything
+       from the commandline should be tainted - but we will need an untainted
+       value for the spoolfile when doing a -odi delivery process. */
+
+       case 'G': if (++i < argc) queue_name = string_copy_taint(
+                     exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-MCG"),
+                     GET_UNTAINTED);
+                 else badarg = TRUE;
+                 break;
+
+    /* -MCK: the peer offered CHUNKING.  Must precede -MC */
+
+       case 'K': smtp_peer_options |= OPTION_CHUNKING; break;
+
+#ifndef DISABLE_ESMTP_LIMITS
+    /* -MCL: peer used LIMITS RCPTMAX and/or RCPTDOMAINMAX */
+       case 'L': if (++i < argc) continue_limit_mail = Uatoi(argv[i]);
+                 else badarg = TRUE;
+                 if (++i < argc) continue_limit_rcpt = Uatoi(argv[i]);
+                 else badarg = TRUE;
+                 if (++i < argc) continue_limit_rcptdom = Uatoi(argv[i]);
+                 else badarg = TRUE;
+                 break;
+#endif

 
     /* -MCP: set the smtp_use_pipelining flag; this is useful only when
     it preceded -MC (see above) */
 
 
     /* -MCP: set the smtp_use_pipelining flag; this is useful only when
     it preceded -MC (see above) */
 

-    else if (Ustrcmp(argrest, "CP") == 0)
-      {
-      smtp_use_pipelining = TRUE;
-      break;
-      }
-
+       case 'P': smtp_peer_options |= OPTION_PIPE; break;
+
+#ifdef SUPPORT_SOCKS
+    /* -MCp: Socks proxy in use; nearside IP, port, external IP, port */
+       case 'p': proxy_session = TRUE;
+                 if (++i < argc)
+                   {
+                   proxy_local_address = string_copy_taint(argv[i], GET_TAINTED);
+                   if (++i < argc)
+                     {
+                     proxy_local_port = Uatoi(argv[i]);
+                     if (++i < argc)
+                       {
+                       proxy_external_address = string_copy_taint(argv[i], GET_TAINTED);
+                       if (++i < argc)
+                         {
+                         proxy_external_port = Uatoi(argv[i]);
+                         break;
+                   } } } }
+                 badarg = TRUE;
+                 break;
+#endif

     /* -MCQ: pass on the pid of the queue-running process that started
     this chain of deliveries and the fd of its synchronizing pipe; this
     is useful only when it precedes -MC (see above) */
 
     /* -MCQ: pass on the pid of the queue-running process that started
     this chain of deliveries and the fd of its synchronizing pipe; this
     is useful only when it precedes -MC (see above) */
 

-    else if (Ustrcmp(argrest, "CQ") == 0)
-      {
-      if(++i < argc) passed_qr_pid = (pid_t)(Uatol(argv[i]));
-        else badarg = TRUE;
-      if(++i < argc) passed_qr_pipe = (int)(Uatol(argv[i]));
-        else badarg = TRUE;
-      break;
-      }
+       case 'Q': if (++i < argc) passed_qr_pid = (pid_t)(Uatol(argv[i]));
+                 else badarg = TRUE;
+                 if (++i < argc) passed_qr_pipe = (int)(Uatol(argv[i]));
+                 else badarg = TRUE;
+                 break;
+
+    /* -MCq: do a quota check on the given recipient for the given size
+    of message.  Separate from -MC. */
+       case 'q': rcpt_verify_quota = TRUE;
+                 if (++i < argc) message_size = Uatoi(argv[i]);
+                 else badarg = TRUE;
+                 break;

 
     /* -MCS: set the smtp_use_size flag; this is useful only when it
     precedes -MC (see above) */
 
 
     /* -MCS: set the smtp_use_size flag; this is useful only when it
     precedes -MC (see above) */
 

-    else if (Ustrcmp(argrest, "CS") == 0)
-      {
-      smtp_use_size = TRUE;
-      break;
-      }
+       case 'S': smtp_peer_options |= OPTION_SIZE; break;
+
+#ifndef DISABLE_TLS
+    /* -MCs: used with -MCt; SNI was sent */
+    /* -MCr: ditto, DANE */
+
+       case 'r':
+       case 's': if (++i < argc)
+                   {
+                   continue_proxy_sni = string_copy_taint(
+                     exim_str_fail_toolong(argv[i], EXIM_HOSTNAME_MAX, "-MCr/-MCs"),
+                     GET_TAINTED);
+                   if (argrest[1] == 'r') continue_proxy_dane = TRUE;
+                   }
+                 else badarg = TRUE;
+                 break;
+
+    /* -MCt: similar to -MCT below but the connection is still open
+    via a proxy process which handles the TLS context and coding.
+    Require three arguments for the proxied local address and port,
+    and the TLS cipher. */
+
+       case 't': if (++i < argc)
+                   sending_ip_address = string_copy_taint(
+                     exim_str_fail_toolong(argv[i], EXIM_IPADDR_MAX, "-MCt IP"),
+                     GET_TAINTED);
+                 else badarg = TRUE;
+                 if (++i < argc)
+                   sending_port = (int)(Uatol(argv[i]));
+                 else badarg = TRUE;
+                 if (++i < argc)
+                   continue_proxy_cipher = string_copy_taint(
+                     exim_str_fail_toolong(argv[i], EXIM_CIPHERNAME_MAX, "-MCt cipher"),
+                     GET_TAINTED);
+                 else badarg = TRUE;
+                 /*FALLTHROUGH*/

 
     /* -MCT: set the tls_offered flag; this is useful only when it
     precedes -MC (see above). The flag indicates that the host to which
     Exim is connected has offered TLS support. */
 
 
     /* -MCT: set the tls_offered flag; this is useful only when it
     precedes -MC (see above). The flag indicates that the host to which
     Exim is connected has offered TLS support. */
 

-    #ifdef SUPPORT_TLS
-    else if (Ustrcmp(argrest, "CT") == 0)
-      {
-      tls_offered = TRUE;
+       case 'T': smtp_peer_options |= OPTION_TLS; break;
+#endif
+
+       default:  badarg = TRUE; break;
+       }

       break;
       }
       break;
       }

-    #endif

 
     /* -M[x]: various operations on the following list of message ids:
        -M    deliver the messages, ignoring next retry times and thawing
 
     /* -M[x]: various operations on the following list of message ids:
        -M    deliver the messages, ignoring next retry times and thawing


@@ -2727,6 +3294,7 @@ for (i = 1; i < argc; i++)
     following options which are followed by a single message id, and which
     act on that message. Some of them use the "recipient" addresses as well.
        -Mar  add recipient(s)
     following options which are followed by a single message id, and which
     act on that message. Some of them use the "recipient" addresses as well.
        -Mar  add recipient(s)

+       -MG   move to a different queue

        -Mmad mark all recipients delivered
        -Mmd  mark recipients(s) delivered
        -Mes  edit sender
        -Mmad mark all recipients delivered
        -Mmd  mark recipients(s) delivered
        -Mes  edit sender


@@ -2737,10 +3305,10 @@ for (i = 1; i < argc; i++)
        -Mvl  show log
     */
 
        -Mvl  show log
     */
 

-    else if (*argrest == 0)
+    else if (!*argrest)

       {
       msg_action = MSG_DELIVER;
       {
       msg_action = MSG_DELIVER;

-      forced_delivery = deliver_force_thaw = TRUE;
+      forced_delivery = f.deliver_force_thaw = TRUE;

       }
     else if (Ustrcmp(argrest, "ar") == 0)
       {
       }
     else if (Ustrcmp(argrest, "ar") == 0)
       {


@@ -2759,10 +3327,15 @@ for (i = 1; i < argc; i++)
       msg_action = MSG_DELIVER;
       deliver_give_up = TRUE;
       }
       msg_action = MSG_DELIVER;
       deliver_give_up = TRUE;
       }

-    else if (Ustrcmp(argrest, "mad") == 0)
+   else if (Ustrcmp(argrest, "G") == 0)

       {
       {

-      msg_action = MSG_MARK_ALL_DELIVERED;
+      msg_action = MSG_SETQUEUE;
+      queue_name_dest = string_copy_taint(
+       exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
+                             EXIM_DRIVERNAME_MAX, "-MG"),
+       GET_TAINTED);

       }
       }

+    else if (Ustrcmp(argrest, "mad") == 0) msg_action = MSG_MARK_ALL_DELIVERED;

     else if (Ustrcmp(argrest, "md") == 0)
       {
       msg_action = MSG_MARK_DELIVERED;
     else if (Ustrcmp(argrest, "md") == 0)
       {
       msg_action = MSG_MARK_DELIVERED;


@@ -2801,22 +3374,15 @@ for (i = 1; i < argc; i++)
 
     msg_action_arg = i + 1;
     if (msg_action_arg >= argc)
 
     msg_action_arg = i + 1;
     if (msg_action_arg >= argc)

-      {
-      fprintf(stderr, "exim: no message ids given after %s option\n", arg);
-      return EXIT_FAILURE;
-      }
+      exim_fail("exim: no message ids given after %s option\n", arg);

 
     /* Some require only message ids to follow */
 
     if (!one_msg_action)
       {
 
     /* Some require only message ids to follow */
 
     if (!one_msg_action)
       {

-      int j;
-      for (j = msg_action_arg; j < argc; j++) if (!mac_ismsgid(argv[j]))
-        {
-        fprintf(stderr, "exim: malformed message id %s after %s option\n",
+      for (int j = msg_action_arg; j < argc; j++) if (!mac_ismsgid(argv[j]))
+        exim_fail("exim: malformed message id %s after %s option\n",

           argv[j], arg);
           argv[j], arg);

-        return EXIT_FAILURE;
-        }

       goto END_ARG;   /* Remaining args are ids */
       }
 
       goto END_ARG;   /* Remaining args are ids */
       }
 


@@ -2826,11 +3392,8 @@ for (i = 1; i < argc; i++)
     else
       {
       if (!mac_ismsgid(argv[msg_action_arg]))
     else
       {
       if (!mac_ismsgid(argv[msg_action_arg]))

-        {
-        fprintf(stderr, "exim: malformed message id %s after %s option\n",
+        exim_fail("exim: malformed message id %s after %s option\n",

           argv[msg_action_arg], arg);
           argv[msg_action_arg], arg);

-        return EXIT_FAILURE;
-        }

       i++;
       }
     break;
       i++;
       }
     break;


@@ -2840,7 +3403,7 @@ for (i = 1; i < argc; i++)
     for sendmail it askes for "me too". Exim always does this. */
 
     case 'm':
     for sendmail it askes for "me too". Exim always does this. */
 
     case 'm':

-    if (*argrest != 0) badarg = TRUE;
+    if (*argrest) badarg = TRUE;

     break;
 
 
     break;
 
 


@@ -2848,9 +3411,9 @@ for (i = 1; i < argc; i++)
     their thing. It implies debugging at the D_v level. */
 
     case 'N':
     their thing. It implies debugging at the D_v level. */
 
     case 'N':

-    if (*argrest == 0)
+    if (!*argrest)

       {
       {

-      dont_deliver = TRUE;
+      f.dont_deliver = TRUE;

       debug_selector |= D_v;
       debug_file = stderr;
       }
       debug_selector |= D_v;
       debug_file = stderr;
       }


@@ -2871,226 +3434,265 @@ for (i = 1; i < argc; i++)
     -O option=value and -Ooption=value. */
 
     case 'O':
     -O option=value and -Ooption=value. */
 
     case 'O':

-    if (*argrest == 0)
-      {
+    if (!*argrest)

       if (++i >= argc)
       if (++i >= argc)

-        {
-        fprintf(stderr, "exim: string expected after -O\n");
-        exit(EXIT_FAILURE);
-        }
-      }
+        exim_fail("exim: string expected after -O\n");

     break;
 
     case 'o':
     break;
 
     case 'o':

-
-    /* -oA: Set an argument for the bi command (sendmail's "alternate alias
-    file" option). */
-
-    if (*argrest == 'A')
-      {
-      alias_arg = argrest + 1;
-      if (alias_arg[0] == 0)
-        {
-        if (i+1 < argc) alias_arg = argv[++i]; else
-          {
-          fprintf(stderr, "exim: string expected after -oA\n");
-          exit(EXIT_FAILURE);
-          }
-        }
-      }
-
-    /* -oB: Set a connection message max value for remote deliveries */
-
-    else if (*argrest == 'B')
-      {
-      uschar *p = argrest + 1;
-      if (p[0] == 0)
-        {
-        if (i+1 < argc && isdigit((argv[i+1][0]))) p = argv[++i]; else
-          {
-          connection_max_messages = 1;
-          p = NULL;
-          }
-        }
-
-      if (p != NULL)
-        {
-        if (!isdigit(*p))
-          {
-          fprintf(stderr, "exim: number expected after -oB\n");
-          exit(EXIT_FAILURE);
-          }
-        connection_max_messages = Uatoi(p);
-        }
-      }
-
-    /* -odb: background delivery */
-
-    else if (Ustrcmp(argrest, "db") == 0)
-      {
-      synchronous_delivery = FALSE;
-      arg_queue_only = FALSE;
-      queue_only_set = TRUE;
-      }
-
-    /* -odf: foreground delivery (smail-compatible option); same effect as
-       -odi: interactive (synchronous) delivery (sendmail-compatible option)
-    */
-
-    else if (Ustrcmp(argrest, "df") == 0 || Ustrcmp(argrest, "di") == 0)
-      {
-      synchronous_delivery = TRUE;
-      arg_queue_only = FALSE;
-      queue_only_set = TRUE;
-      }
-
-    /* -odq: queue only */
-
-    else if (Ustrcmp(argrest, "dq") == 0)
-      {
-      synchronous_delivery = FALSE;
-      arg_queue_only = TRUE;
-      queue_only_set = TRUE;
-      }
-
-    /* -odqs: queue SMTP only - do local deliveries and remote routing,
-    but no remote delivery */
-
-    else if (Ustrcmp(argrest, "dqs") == 0)
+    switch (*argrest++)

       {
       {

-      queue_smtp = TRUE;
-      arg_queue_only = FALSE;
-      queue_only_set = TRUE;
-      }
-
-    /* -oex: Sendmail error flags. As these are also accepted without the
-    leading -o prefix, for compatibility with vacation and other callers,
-    they are handled with -e above. */
-
-    /* -oi:     Set flag so dot doesn't end non-SMTP input (same as -i)
-       -oitrue: Another sendmail syntax for the same */
+      /* -oA: Set an argument for the bi command (sendmail's "alternate alias
+      file" option). */
+      case 'A':
+       if (!*(alias_arg = argrest))
+         if (i+1 < argc) alias_arg = argv[++i];
+         else exim_fail("exim: string expected after -oA\n");
+       break;
+
+      /* -oB: Set a connection message max value for remote deliveries */
+      case 'B':
+       {
+       const uschar * p = argrest;
+       if (!*p)
+         if (i+1 < argc && isdigit((argv[i+1][0])))
+           p = argv[++i];
+         else
+           {
+           connection_max_messages = 1;
+           p = NULL;
+           }

 
 

-    else if (Ustrcmp(argrest, "i") == 0 ||
-             Ustrcmp(argrest, "itrue") == 0)
-      dot_ends = FALSE;
+       if (p)
+         {
+         if (!isdigit(*p))
+           exim_fail("exim: number expected after -oB\n");
+         connection_max_messages = Uatoi(p);
+         }
+       }
+       break;
+
+      /* -odb: background delivery */
+
+      case 'd':
+       if (Ustrcmp(argrest, "b") == 0)
+         {
+         f.synchronous_delivery = FALSE;
+         arg_queue_only = FALSE;
+         queue_only_set = TRUE;
+         }
+
+      /* -odd: testsuite-only: add no inter-process delays */
+
+       else if (Ustrcmp(argrest, "d") == 0)
+         f.testsuite_delays = FALSE;
+
+      /* -odf: foreground delivery (smail-compatible option); same effect as
+        -odi: interactive (synchronous) delivery (sendmail-compatible option)
+      */
+
+       else if (Ustrcmp(argrest, "f") == 0 || Ustrcmp(argrest, "i") == 0)
+         {
+         f.synchronous_delivery = TRUE;
+         arg_queue_only = FALSE;
+         queue_only_set = TRUE;
+         }
+
+      /* -odq: queue only */
+
+       else if (Ustrcmp(argrest, "q") == 0)
+         {
+         f.synchronous_delivery = FALSE;
+         arg_queue_only = TRUE;
+         queue_only_set = TRUE;
+         }
+
+      /* -odqs: queue SMTP only - do local deliveries and remote routing,
+      but no remote delivery */
+
+       else if (Ustrcmp(argrest, "qs") == 0)
+         {
+         f.queue_smtp = TRUE;
+         arg_queue_only = FALSE;
+         queue_only_set = TRUE;
+         }
+       else badarg = TRUE;
+       break;
+
+      /* -oex: Sendmail error flags. As these are also accepted without the
+      leading -o prefix, for compatibility with vacation and other callers,
+      they are handled with -e above. */
+
+      /* -oi:     Set flag so dot doesn't end non-SMTP input (same as -i)
+        -oitrue: Another sendmail syntax for the same */
+
+      case 'i':
+       if (!*argrest || Ustrcmp(argrest, "true") == 0)
+         f.dot_ends = FALSE;
+       else badarg = TRUE;
+       break;

 
     /* -oM*: Set various characteristics for an incoming message; actually
     acted on for trusted callers only. */
 
 
     /* -oM*: Set various characteristics for an incoming message; actually
     acted on for trusted callers only. */
 

-    else if (*argrest == 'M')
-      {
-      if (i+1 >= argc)
-        {
-        fprintf(stderr, "exim: data expected after -o%s\n", argrest);
-        exit(EXIT_FAILURE);
-        }
+      case 'M':
+       {
+       if (i+1 >= argc)
+         exim_fail("exim: data expected after -oM%s\n", argrest);

 
 

-      /* -oMa: Set sender host address */
+       /* -oMa: Set sender host address */

 
 

-      if (Ustrcmp(argrest, "Ma") == 0) sender_host_address = argv[++i];
+       if (Ustrcmp(argrest, "a") == 0)
+         sender_host_address = string_copy_taint(
+           exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
+                                 EXIM_IPADDR_MAX, "-oMa"), GET_TAINTED);

 
 

-      /* -oMaa: Set authenticator name */
+       /* -oMaa: Set authenticator name */

 
 

-      else if (Ustrcmp(argrest, "Maa") == 0)
-        sender_host_authenticated = argv[++i];
+       else if (Ustrcmp(argrest, "aa") == 0)
+         sender_host_authenticated = string_copy_taint(
+           exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
+                                 EXIM_DRIVERNAME_MAX, "-oMaa"), GET_TAINTED);

 
 

-      /* -oMas: setting authenticated sender */
+       /* -oMas: setting authenticated sender */

 
 

-      else if (Ustrcmp(argrest, "Mas") == 0) authenticated_sender = argv[++i];
+       else if (Ustrcmp(argrest, "as") == 0)
+         authenticated_sender = string_copy_taint(
+           exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
+                                 EXIM_EMAILADDR_MAX, "-oMas"), GET_TAINTED);

 
 

-      /* -oMai: setting authenticated id */
+       /* -oMai: setting authenticated id */

 
 

-      else if (Ustrcmp(argrest, "Mai") == 0) authenticated_id = argv[++i];
+       else if (Ustrcmp(argrest, "ai") == 0)
+         authenticated_id = string_copy_taint(
+           exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
+                                 EXIM_EMAILADDR_MAX, "-oMai"), GET_TAINTED);

 
 

-      /* -oMi: Set incoming interface address */
+       /* -oMi: Set incoming interface address */

 
 

-      else if (Ustrcmp(argrest, "Mi") == 0) interface_address = argv[++i];
+       else if (Ustrcmp(argrest, "i") == 0)
+         interface_address = string_copy_taint(
+           exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
+                                 EXIM_IPADDR_MAX, "-oMi"), GET_TAINTED);

 
 

-      /* -oMm: Message reference */
+       /* -oMm: Message reference */

 
 

-      else if (Ustrcmp(argrest, "Mm") == 0)
-        {
-        if (!mac_ismsgid(argv[i+1]))
-          {
-            fprintf(stderr,"-oMm must be a valid message ID\n");
-            exit(EXIT_FAILURE);
-          }
-        if (!trusted_config)
-          {
-            fprintf(stderr,"-oMm must be called by a trusted user/config\n");
-            exit(EXIT_FAILURE);
-          }
-          message_reference = argv[++i];
-        }
-
-      /* -oMr: Received protocol */
-
-      else if (Ustrcmp(argrest, "Mr") == 0) received_protocol = argv[++i];
+       else if (Ustrcmp(argrest, "m") == 0)
+         {
+         if (!mac_ismsgid(argv[i+1]))
+             exim_fail("-oMm must be a valid message ID\n");
+         if (!f.trusted_config)
+             exim_fail("-oMm must be called by a trusted user/config\n");
+           message_reference = next_argv(argv, &i, argc, arg);
+         }

 
 

-      /* -oMs: Set sender host name */
+       /* -oMr: Received protocol */

 
 

-      else if (Ustrcmp(argrest, "Ms") == 0) sender_host_name = argv[++i];
-
-      /* -oMt: Set sender ident */
-
-      else if (Ustrcmp(argrest, "Mt") == 0)
-        {
-        sender_ident_set = TRUE;
-        sender_ident = argv[++i];
-        }
+       else if (Ustrcmp(argrest, "r") == 0)

 
 

-      /* Else a bad argument */
+         if (received_protocol)
+           exim_fail("received_protocol is set already\n");
+         else
+           if (++i >= argc) badarg = TRUE;
+           else
+             received_protocol = string_copy_taint(
+               exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-oMr"),
+               GET_TAINTED);
+
+       /* -oMs: Set sender host name */
+
+       else if (Ustrcmp(argrest, "s") == 0)
+         if (++i >= argc) badarg = TRUE;
+         else
+           sender_host_name = string_copy_taint(
+             exim_str_fail_toolong(argv[i], EXIM_HOSTNAME_MAX, "-oMs"),
+             GET_TAINTED);
+
+       /* -oMt: Set sender ident */
+
+       else if (Ustrcmp(argrest, "t") == 0)
+         if (++i >= argc) badarg = TRUE;
+         else
+           {
+           sender_ident_set = TRUE;
+           sender_ident = string_copy_taint(
+             exim_str_fail_toolong(argv[i], EXIM_IDENTUSER_MAX, "-oMt"),
+             GET_TAINTED);
+           }

 
 

-      else
-        {
-        badarg = TRUE;
-        break;
-        }
+       /* Else a bad argument */
+
+       else
+         badarg = TRUE;
+       }
+       break;
+
+      /* -om: Me-too flag for aliases. Exim always does this. Some programs
+      seem to call this as -m (undocumented), so that is also accepted (see
+      above). */
+      /* -oo: An ancient flag for old-style addresses which still seems to
+      crop up in some calls (see in SCO). */
+
+      case 'm':
+      case 'o':
+       if (*argrest) badarg = TRUE;
+       break;
+
+      /* -oP <name>: set pid file path for daemon
+        -oPX:       delete pid file of daemon */
+
+      case 'P':
+       if (!f.running_in_test_harness && real_uid != root_uid && real_uid != exim_uid)
+         exim_fail("exim: only uid=%d or uid=%d can use -oP and -oPX "
+                    "(uid=%d euid=%d | %d)\n",
+                    root_uid, exim_uid, getuid(), geteuid(), real_uid);
+       if (!*argrest)
+         if (++i < argc) override_pid_file_path = argv[i];
+         else badarg = TRUE;
+       else if (Ustrcmp(argrest, "X") == 0) delete_pid_file();
+       else badarg = TRUE;
+       break;
+
+
+      /* -or <n>: set timeout for non-SMTP acceptance
+        -os <n>: set timeout for SMTP acceptance */
+
+      case 'r':
+      case 's':
+       {
+       int * tp = argrest[-1] == 'r'
+         ? &arg_receive_timeout : &arg_smtp_receive_timeout;
+       if (*argrest)
+         *tp = readconf_readtime(argrest, 0, FALSE);
+       else if (i+1 < argc)
+         *tp = readconf_readtime(argv[++i], 0, FALSE);
+
+       if (*tp < 0)
+         exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
+       }
+       break;
+
+      /* -oX <list>: Override local_interfaces and/or default daemon ports */
+      /* Limits: Is there a real limit we want here?  1024 is very arbitrary. */
+
+      case 'X':
+       if (*argrest || ++i >= argc) badarg = TRUE;
+       else override_local_interfaces = string_copy_taint(
+         exim_str_fail_toolong(argv[i], 1024, "-oX"), GET_TAINTED);
+       break;
+
+      /* -oY: Override creation of daemon notifier socket */
+
+      case 'Y':
+       if (*argrest) badarg = TRUE;
+       else f.notifier_socket_en = FALSE;
+       break;
+
+      /* Unknown -o argument */
+
+      default:
+       badarg = TRUE;

       }
       }

-
-    /* -om: Me-too flag for aliases. Exim always does this. Some programs
-    seem to call this as -m (undocumented), so that is also accepted (see
-    above). */
-
-    else if (Ustrcmp(argrest, "m") == 0) {}
-
-    /* -oo: An ancient flag for old-style addresses which still seems to
-    crop up in some calls (see in SCO). */
-
-    else if (Ustrcmp(argrest, "o") == 0) {}
-
-    /* -oP <name>: set pid file path for daemon */
-
-    else if (Ustrcmp(argrest, "P") == 0)
-      override_pid_file_path = argv[++i];
-
-    /* -or <n>: set timeout for non-SMTP acceptance
-       -os <n>: set timeout for SMTP acceptance */
-
-    else if (*argrest == 'r' || *argrest == 's')
-      {
-      int *tp = (*argrest == 'r')?
-        &arg_receive_timeout : &arg_smtp_receive_timeout;
-      if (argrest[1] == 0)
-        {
-        if (i+1 < argc) *tp= readconf_readtime(argv[++i], 0, FALSE);
-        }
-      else *tp = readconf_readtime(argrest + 1, 0, FALSE);
-      if (*tp < 0)
-        {
-        fprintf(stderr, "exim: bad time value %s: abandoned\n", argv[i]);
-        exit(EXIT_FAILURE);
-        }
-      }
-
-    /* -oX <list>: Override local_interfaces and/or default daemon ports */
-
-    else if (Ustrcmp(argrest, "X") == 0)
-      override_local_interfaces = argv[++i];
-
-    /* Unknown -o argument */
-
-    else badarg = TRUE;

     break;
 
 
     break;
 
 


@@ -3113,200 +3715,193 @@ for (i = 1; i < argc; i++)
     /* -panythingelse is taken as the Sendmail-compatible argument -prval:sval,
     which sets the host protocol and host name */
 
     /* -panythingelse is taken as the Sendmail-compatible argument -prval:sval,
     which sets the host protocol and host name */
 

-    if (*argrest == 0)
-      {
-      if (i+1 < argc) argrest = argv[++i]; else
-        { badarg = TRUE; break; }
-      }
+    if (!*argrest)
+      argrest = next_argv(argv, &i, argc, arg);

 
 

-    if (*argrest != 0)
+    if (*argrest)

       {
       {

-      uschar *hn = Ustrchr(argrest, ':');
-      if (hn == NULL)
-        {
-        received_protocol = argrest;
-        }
+      uschar * hn = Ustrchr(argrest, ':');
+
+      if (received_protocol)
+        exim_fail("received_protocol is set already\n");
+
+      if (!hn)
+        received_protocol = string_copy_taint(
+         exim_str_fail_toolong(argrest, EXIM_DRIVERNAME_MAX, "-p<protocol>"),
+         GET_TAINTED);

       else
         {
       else
         {

-        received_protocol = string_copyn(argrest, hn - argrest);
-        sender_host_name = hn + 1;
+        (void) exim_str_fail_toolong(argrest, (EXIM_DRIVERNAME_MAX+1+EXIM_HOSTNAME_MAX), "-p<protocol>:<host>");
+        received_protocol = string_copyn_taint(argrest, hn - argrest, GET_TAINTED);
+        sender_host_name = string_copy_taint(hn + 1, GET_TAINTED);

         }
       }
     break;
 
         }
       }
     break;
 

+    /* -q:  set up queue runs */

 
     case 'q':
 
     case 'q':

-    receiving_message = FALSE;
-    if (queue_interval >= 0)

       {
       {

-      fprintf(stderr, "exim: -q specified more than once\n");
-      exit(EXIT_FAILURE);
-      }
+      BOOL two_stage, first_del, force, thaw = FALSE, local;

 
 

-    /* -qq...: Do queue runs in a 2-stage manner */
+      receiving_message = FALSE;

 
 

-    if (*argrest == 'q')
-      {
-      queue_2stage = TRUE;
-      argrest++;
-      }
+      /* -qq...: Do queue runs in a 2-stage manner */

 
 

-    /* -qi...: Do only first (initial) deliveries */
+      if ((two_stage = *argrest == 'q'))
+       argrest++;

 
 

-    if (*argrest == 'i')
-      {
-      queue_run_first_delivery = TRUE;
-      argrest++;
-      }
+      /* -qi...: Do only first (initial) deliveries */

 
 

-    /* -qf...: Run the queue, forcing deliveries
-       -qff..: Ditto, forcing thawing as well */
+      if ((first_del = *argrest == 'i'))
+       argrest++;

 
 

-    if (*argrest == 'f')
-      {
-      queue_run_force = TRUE;
-      if (*(++argrest) == 'f')
-        {
-        deliver_force_thaw = TRUE;
-        argrest++;
-        }
-      }
+      /* -qf...: Run the queue, forcing deliveries
+        -qff..: Ditto, forcing thawing as well */

 
 

-    /* -q[f][f]l...: Run the queue only on local deliveries */
+      if ((force = *argrest == 'f'))
+       if ((thaw = *++argrest == 'f'))
+         argrest++;

 
 

-    if (*argrest == 'l')
-      {
-      queue_run_local = TRUE;
-      argrest++;
-      }
+      /* -q[f][f]l...: Run the queue only on local deliveries */

 
 

-    /* -q[f][f][l]: Run the queue, optionally forced, optionally local only,
-    optionally starting from a given message id. */
+      if ((local = *argrest == 'l'))
+       argrest++;

 
 

-    if (*argrest == 0 &&
-        (i + 1 >= argc || argv[i+1][0] == '-' || mac_ismsgid(argv[i+1])))
-      {
-      queue_interval = 0;
-      if (i+1 < argc && mac_ismsgid(argv[i+1]))
-        start_queue_run_id = argv[++i];
-      if (i+1 < argc && mac_ismsgid(argv[i+1]))
-        stop_queue_run_id = argv[++i];
-      }
+      /* -q[f][f][l][G<name>]... Work on the named queue */

 
 

-    /* -q[f][f][l]<n>: Run the queue at regular intervals, optionally forced,
-    optionally local only. */
+      if (*argrest == 'G')
+       {
+       int i;
+       for (argrest++, i = 0; argrest[i] && argrest[i] != '/'; ) i++;
+       exim_len_fail_toolong(i, EXIM_DRIVERNAME_MAX, "-q*G<name>");
+       queue_name = string_copyn(argrest, i);
+       argrest += i;
+       if (*argrest == '/') argrest++;
+       }

 
 

-    else
-      {
-      if (*argrest != 0)
-        queue_interval = readconf_readtime(argrest, 0, FALSE);
-      else
-        queue_interval = readconf_readtime(argv[++i], 0, FALSE);
-      if (queue_interval <= 0)
-        {
-        fprintf(stderr, "exim: bad time value %s: abandoned\n", argv[i]);
-        exit(EXIT_FAILURE);
-        }
-      }
-    break;
+      /* -q[f][f][l][G<name>]: Run the queue, optionally forced, optionally local
+      only, optionally named, optionally starting from a given message id. */

 
 

+      if (!(list_queue || count_queue))
+       {
+       qrunner * q;

 
 

-    case 'R':   /* Synonymous with -qR... */
-    receiving_message = FALSE;
+       if (  !*argrest
+          && (i + 1 >= argc || argv[i+1][0] == '-' || mac_ismsgid(argv[i+1])))
+         {
+         q = alloc_onetime_qrunner();
+         if (i+1 < argc && mac_ismsgid(argv[i+1]))
+           start_queue_run_id = string_copy_taint(argv[++i], GET_TAINTED);
+         if (i+1 < argc && mac_ismsgid(argv[i+1]))
+           stop_queue_run_id = string_copy_taint(argv[++i], GET_TAINTED);
+         }

 
 

-    /* -Rf:   As -R (below) but force all deliveries,
-       -Rff:  Ditto, but also thaw all frozen messages,
-       -Rr:   String is regex
-       -Rrf:  Regex and force
-       -Rrff: Regex and force and thaw
+      /* -q[f][f][l][G<name>/]<n>: Run the queue at regular intervals, optionally
+      forced, optionally local only, optionally named. */

 
 

-    in all cases provided there are no further characters in this
-    argument. */
+       else
+         {
+         int intvl;
+         const uschar * s;

 
 

-    if (*argrest != 0)
-      {
-      int i;
-      for (i = 0; i < sizeof(rsopts)/sizeof(uschar *); i++)
-        {
-        if (Ustrcmp(argrest, rsopts[i]) == 0)
-          {
-          if (i != 2) queue_run_force = TRUE;
-          if (i >= 2) deliver_selectstring_regex = TRUE;
-          if (i == 1 || i == 4) deliver_force_thaw = TRUE;
-          argrest += Ustrlen(rsopts[i]);
-          }
-        }
-      }
+         if (*argrest) s = argrest;
+         else if (++i < argc) { badarg = TRUE; break; }
+         else s = argv[i];

 
 

-    /* -R: Set string to match in addresses for forced queue run to
-    pick out particular messages. */
+         if ((intvl = readconf_readtime(s, 0, FALSE)) <= 0)
+           exim_fail("exim: bad time value %s: abandoned\n", argv[i]);

 
 

-    if (*argrest == 0)
-      {
-      if (i+1 < argc) deliver_selectstring = argv[++i]; else
-        {
-        fprintf(stderr, "exim: string expected after -R\n");
-        exit(EXIT_FAILURE);
-        }
-      }
-    else deliver_selectstring = argrest;
-    break;
+         for (qrunner * qq = qrunners; qq; qq = qq->next)
+           if (  queue_name && qq->name && Ustrcmp(queue_name, qq->name) == 0
+              || !queue_name && !qq->name)
+             exim_fail("exim: queue-runner specified more than once\n");

 
 

+         q = alloc_qrunner();
+         q->interval = intvl;
+         }

 
 

-    /* -r: an obsolete synonym for -f (see above) */
+       q->name = *queue_name ? queue_name : NULL;      /* will be NULL for the default queue */
+       q->queue_run_force = force;
+       q->deliver_force_thaw = thaw;
+       q->queue_run_first_delivery = first_del;
+       q->queue_run_local = local;
+       q->queue_2stage = two_stage;
+       }

 
 

+      break;
+      }

 
 

-    /* -S: Like -R but works on sender. */

 
 

+    case 'R':   /* Synonymous with -qR... */

     case 'S':   /* Synonymous with -qS... */
     case 'S':   /* Synonymous with -qS... */

-    receiving_message = FALSE;
+      {
+      const uschar * tainted_selectstr;
+      uschar * s;
+
+      receiving_message = FALSE;
+
+    /* -Rf:   As -R (below) but force all deliveries,
+       -Rff:  Ditto, but also thaw all frozen messages,
+       -Rr:   String is regex
+       -Rrf:  Regex and force
+       -Rrff: Regex and force and thaw

 
 

-    /* -Sf:   As -S (below) but force all deliveries,
-       -Sff:  Ditto, but also thaw all frozen messages,
-       -Sr:   String is regex
-       -Srf:  Regex and force
-       -Srff: Regex and force and thaw
+       -S...: Like -R but works on sender.

 
     in all cases provided there are no further characters in this
     argument. */
 
 
     in all cases provided there are no further characters in this
     argument. */
 

-    if (*argrest != 0)
-      {
-      int i;
-      for (i = 0; i < sizeof(rsopts)/sizeof(uschar *); i++)
-        {
-        if (Ustrcmp(argrest, rsopts[i]) == 0)
-          {
-          if (i != 2) queue_run_force = TRUE;
-          if (i >= 2) deliver_selectstring_sender_regex = TRUE;
-          if (i == 1 || i == 4) deliver_force_thaw = TRUE;
-          argrest += Ustrlen(rsopts[i]);
-          }
-        }
-      }
+      if (!qrunners) alloc_onetime_qrunner();
+      qrunners->queue_2stage = f.queue_2stage;
+      if (*argrest)
+       for (int i = 0; i < nelem(rsopts); i++)
+         if (Ustrcmp(argrest, rsopts[i]) == 0)
+           {
+           if (i != 2) qrunners->queue_run_force = TRUE;
+           if (i >= 2)
+             if (switchchar == 'R')
+               f.deliver_selectstring_regex = TRUE;
+             else
+               f.deliver_selectstring_sender_regex = TRUE;
+           if (i == 1 || i == 4) qrunners->deliver_force_thaw = TRUE;
+           argrest += Ustrlen(rsopts[i]);
+           }

 
 

-    /* -S: Set string to match in addresses for forced queue run to
+    /* -R or -S: Set string to match in addresses for forced queue run to

     pick out particular messages. */
 
     pick out particular messages. */
 

-    if (*argrest == 0)
-      {
-      if (i+1 < argc) deliver_selectstring_sender = argv[++i]; else
-        {
-        fprintf(stderr, "exim: string expected after -S\n");
-        exit(EXIT_FAILURE);
-        }
+      /* Avoid attacks from people providing very long strings, and do so before
+      we make copies. */
+      if (*argrest)
+       tainted_selectstr = argrest;
+      else if (i+1 < argc)
+       tainted_selectstr = argv[++i];
+      else
+       exim_fail("exim: string expected after %s\n", switchchar == 'R' ? "-R" : "-S");
+
+      s = string_copy_taint(
+       exim_str_fail_toolong(tainted_selectstr, EXIM_EMAILADDR_MAX, "-R"),
+       GET_TAINTED);
+
+      if (switchchar == 'R')
+       deliver_selectstring = s;
+      else
+       deliver_selectstring_sender = s;

       }
       }

-    else deliver_selectstring_sender = argrest;

     break;
 
     break;
 

+
+    /* -r: an obsolete synonym for -f (see above) */
+

     /* -Tqt is an option that is exclusively for use by the testing suite.
     It is not recognized in other circumstances. It allows for the setting up
     of explicit "queue times" so that various warning/retry things can be
     tested. Otherwise variability of clock ticks etc. cause problems. */
 
     case 'T':
     /* -Tqt is an option that is exclusively for use by the testing suite.
     It is not recognized in other circumstances. It allows for the setting up
     of explicit "queue times" so that various warning/retry things can be
     tested. Otherwise variability of clock ticks etc. cause problems. */
 
     case 'T':

-    if (running_in_test_harness && Ustrcmp(argrest, "qt") == 0)
-      fudged_queue_times = argv[++i];
+    if (f.running_in_test_harness && Ustrcmp(argrest, "qt") == 0 && ++i < argc)
+      fudged_queue_times = string_copy_taint(argv[i], GET_TAINTED);

     else badarg = TRUE;
     break;
 
     else badarg = TRUE;
     break;
 


@@ -3314,7 +3909,7 @@ for (i = 1; i < argc; i++)
     /* -t: Set flag to extract recipients from body of message. */
 
     case 't':
     /* -t: Set flag to extract recipients from body of message. */
 
     case 't':

-    if (*argrest == 0) extract_recipients = TRUE;
+    if (!*argrest) extract_recipients = TRUE;

 
     /* -ti: Set flag to extract recipients from body of message, and also
     specify that dot does not end the message. */
 
     /* -ti: Set flag to extract recipients from body of message, and also
     specify that dot does not end the message. */


@@ -3322,12 +3917,12 @@ for (i = 1; i < argc; i++)
     else if (Ustrcmp(argrest, "i") == 0)
       {
       extract_recipients = TRUE;
     else if (Ustrcmp(argrest, "i") == 0)
       {
       extract_recipients = TRUE;

-      dot_ends = FALSE;
+      f.dot_ends = FALSE;

       }
 
     /* -tls-on-connect: don't wait for STARTTLS (for old clients) */
 
       }
 
     /* -tls-on-connect: don't wait for STARTTLS (for old clients) */
 

-    #ifdef SUPPORT_TLS
+    #ifndef DISABLE_TLS

     else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_in.on_connect = TRUE;
     #endif
 
     else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_in.on_connect = TRUE;
     #endif
 


@@ -3346,7 +3941,7 @@ for (i = 1; i < argc; i++)
     /* -v: verify things - this is a very low-level debugging */
 
     case 'v':
     /* -v: verify things - this is a very low-level debugging */
 
     case 'v':

-    if (*argrest == 0)
+    if (!*argrest)

       {
       debug_selector |= D_v;
       debug_file = stderr;
       {
       debug_selector |= D_v;
       debug_file = stderr;


@@ -3366,21 +3961,28 @@ for (i = 1; i < argc; i++)
     As Exim is 8-bit clean, it just ignores this flag. */
 
     case 'x':
     As Exim is 8-bit clean, it just ignores this flag. */
 
     case 'x':

-    if (*argrest != 0) badarg = TRUE;
+    if (*argrest) badarg = TRUE;

     break;
 
     /* -X: in sendmail: takes one parameter, logfile, and sends debugging
     logs to that file.  We swallow the parameter and otherwise ignore it. */
 
     break;
 
     /* -X: in sendmail: takes one parameter, logfile, and sends debugging
     logs to that file.  We swallow the parameter and otherwise ignore it. */
 

-    case 'X':
-    if (*argrest == '\0')
-      {
-      if (++i >= argc)
-        {
-        fprintf(stderr, "exim: string expected after -X\n");
-        exit(EXIT_FAILURE);
-        }
-      }
+    case 'X':
+    if (!*argrest)
+      if (++i >= argc)
+        exim_fail("exim: string expected after -X\n");
+    break;
+
+    /* -z: a line of text to log */
+
+    case 'z':
+    if (!*argrest)
+      if (++i < argc)
+       log_oneline = string_copy_taint(
+         exim_str_fail_toolong(argv[i], 2048, "-z logtext"),
+         GET_TAINTED);
+      else
+        exim_fail("exim: file name expected after %s\n", argv[i-1]);

     break;
 
     /* All other initial characters are errors */
     break;
 
     /* All other initial characters are errors */


@@ -3393,78 +3995,67 @@ for (i = 1; i < argc; i++)
   /* Failed to recognize the option, or syntax error */
 
   if (badarg)
   /* Failed to recognize the option, or syntax error */
 
   if (badarg)

-    {
-    fprintf(stderr, "exim abandoned: unknown, malformed, or incomplete "
+    exim_fail("exim abandoned: unknown, malformed, or incomplete "

       "option %s\n", arg);
       "option %s\n", arg);

-    exit(EXIT_FAILURE);
-    }

   }
 
 
 /* If -R or -S have been specified without -q, assume a single queue run. */
 
   }
 
 
 /* If -R or -S have been specified without -q, assume a single queue run. */
 

-if ((deliver_selectstring != NULL || deliver_selectstring_sender != NULL) &&
-  queue_interval < 0) queue_interval = 0;
+ if ((deliver_selectstring || deliver_selectstring_sender) && !qrunners)
+  alloc_onetime_qrunner();

 
 
 END_ARG:
 
 
 END_ARG:

+ store_pool = old_pool;
+ }
+

 /* If usage_wanted is set we call the usage function - which never returns */
 if (usage_wanted) exim_usage(called_as);
 
 /* Arguments have been processed. Check for incompatibilities. */
 /* If usage_wanted is set we call the usage function - which never returns */
 if (usage_wanted) exim_usage(called_as);
 
 /* Arguments have been processed. Check for incompatibilities. */

-if ((
-    (smtp_input || extract_recipients || recipients_arg < argc) &&
-    (daemon_listen || queue_interval >= 0 || bi_option ||
-      test_retry_arg >= 0 || test_rewrite_arg >= 0 ||
-      filter_test != FTEST_NONE || (msg_action_arg > 0 && !one_msg_action))
-    ) ||
-    (
-    msg_action_arg > 0 &&
-    (daemon_listen || queue_interval >= 0 || list_options ||
-      (checking && msg_action != MSG_LOAD) ||
-      bi_option || test_retry_arg >= 0 || test_rewrite_arg >= 0)
-    ) ||
-    (
-    (daemon_listen || queue_interval >= 0) &&
-    (sender_address != NULL || list_options || list_queue || checking ||
-      bi_option)
-    ) ||
-    (
-    daemon_listen && queue_interval == 0
-    ) ||
-    (
-    inetd_wait_mode && queue_interval >= 0
-    ) ||
-    (
-    list_options &&
-    (checking || smtp_input || extract_recipients ||
-      filter_test != FTEST_NONE || bi_option)
-    ) ||
-    (
-    verify_address_mode &&
-    (address_test_mode || smtp_input || extract_recipients ||
-      filter_test != FTEST_NONE || bi_option)
-    ) ||
-    (
-    address_test_mode && (smtp_input || extract_recipients ||
-      filter_test != FTEST_NONE || bi_option)
-    ) ||
-    (
-    smtp_input && (sender_address != NULL || filter_test != FTEST_NONE ||
-      extract_recipients)
-    ) ||
-    (
-    deliver_selectstring != NULL && queue_interval < 0
-    ) ||
-    (
-    msg_action == MSG_LOAD &&
-      (!expansion_test || expansion_test_message != NULL)
-    )
+if (    (smtp_input || extract_recipients || recipients_arg < argc)
+      && (  f.daemon_listen || qrunners || bi_option
+        || test_retry_arg >= 0 || test_rewrite_arg >= 0
+        || filter_test != FTEST_NONE
+        || msg_action_arg > 0 && !one_msg_action
+        )
+   ||   msg_action_arg > 0
+      && (  f.daemon_listen || is_multiple_qrun() || list_options
+        || checking && msg_action != MSG_LOAD
+        || bi_option || test_retry_arg >= 0 || test_rewrite_arg >= 0
+        )
+   ||   (f.daemon_listen || is_multiple_qrun())
+      && (  sender_address || list_options || list_queue || checking
+        || bi_option
+        )
+   || f.daemon_listen && is_onetime_qrun()
+   || f.inetd_wait_mode && qrunners
+   ||   list_options
+      && (  checking || smtp_input || extract_recipients
+        || filter_test != FTEST_NONE || bi_option
+        )
+   ||   verify_address_mode
+      && (  f.address_test_mode || smtp_input || extract_recipients
+        || filter_test != FTEST_NONE || bi_option
+        )
+   ||   f.address_test_mode
+      && (  smtp_input || extract_recipients || filter_test != FTEST_NONE
+        || bi_option
+        )
+   ||   smtp_input
+      && (sender_address || filter_test != FTEST_NONE || extract_recipients)
+   || deliver_selectstring && !qrunners
+   || msg_action == MSG_LOAD && (!expansion_test || expansion_test_message)
+   ||   atrn_mode
+      && (  f.daemon_listen || expansion_test || filter_test != FTEST_NONE
+        || checking /* || bi_option || info_stdout || receiving_message
+        || malware_test_file || list_queue || list_config || list_options
+        || version_printed || msg_action_arg > 0 || qrunners
+        */
+        )

    )
    )

-  {
-  fprintf(stderr, "exim: incompatible command-line options or arguments\n");
-  exit(EXIT_FAILURE);
-  }
+  exim_fail("exim: incompatible command-line options or arguments\n");

 
 /* If debugging is set up, set the file and the file descriptor to pass on to
 child processes. It should, of course, be 2 for stderr. Also, force the daemon
 
 /* If debugging is set up, set the file and the file descriptor to pass on to
 child processes. It should, of course, be 2 for stderr. Also, force the daemon


@@ -3474,15 +4065,15 @@ if (debug_selector != 0)
   {
   debug_file = stderr;
   debug_fd = fileno(debug_file);
   {
   debug_file = stderr;
   debug_fd = fileno(debug_file);

-  background_daemon = FALSE;
-  if (running_in_test_harness) millisleep(100);   /* lets caller finish */
+  f.background_daemon = FALSE;
+  testharness_pause_ms(100);   /* lets caller finish */

   if (debug_selector != D_v)    /* -v only doesn't show this */
     {
     debug_printf("Exim version %s uid=%ld gid=%ld pid=%d D=%x\n",
       version_string, (long int)real_uid, (long int)real_gid, (int)getpid(),
       debug_selector);
     if (!version_printed)
   if (debug_selector != D_v)    /* -v only doesn't show this */
     {
     debug_printf("Exim version %s uid=%ld gid=%ld pid=%d D=%x\n",
       version_string, (long int)real_uid, (long int)real_gid, (int)getpid(),
       debug_selector);
     if (!version_printed)

-      show_whats_supported(stderr);
+      show_whats_supported(FALSE);

     }
   }
 
     }
   }
 


@@ -3500,7 +4091,7 @@ else
   {
   struct rlimit rlp;
 
   {
   struct rlimit rlp;
 

-  #ifdef RLIMIT_NOFILE
+#ifdef RLIMIT_NOFILE

   if (getrlimit(RLIMIT_NOFILE, &rlp) < 0)
     {
     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NOFILE) failed: %s",
   if (getrlimit(RLIMIT_NOFILE, &rlp) < 0)
     {
     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NOFILE) failed: %s",


@@ -3523,9 +4114,9 @@ else
           strerror(errno));
       }
     }
           strerror(errno));
       }
     }

-  #endif
+#endif

 
 

-  #ifdef RLIMIT_NPROC
+#ifdef RLIMIT_NPROC

   if (getrlimit(RLIMIT_NPROC, &rlp) < 0)
     {
     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NPROC) failed: %s",
   if (getrlimit(RLIMIT_NPROC, &rlp) < 0)
     {
     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NPROC) failed: %s",


@@ -3533,20 +4124,20 @@ else
     rlp.rlim_cur = rlp.rlim_max = 0;
     }
 
     rlp.rlim_cur = rlp.rlim_max = 0;
     }
 

-  #ifdef RLIM_INFINITY
+# ifdef RLIM_INFINITY

   if (rlp.rlim_cur != RLIM_INFINITY && rlp.rlim_cur < 1000)
     {
     rlp.rlim_cur = rlp.rlim_max = RLIM_INFINITY;
   if (rlp.rlim_cur != RLIM_INFINITY && rlp.rlim_cur < 1000)
     {
     rlp.rlim_cur = rlp.rlim_max = RLIM_INFINITY;

-  #else
+# else

   if (rlp.rlim_cur < 1000)
     {
     rlp.rlim_cur = rlp.rlim_max = 1000;
   if (rlp.rlim_cur < 1000)
     {
     rlp.rlim_cur = rlp.rlim_max = 1000;

-  #endif
+# endif

     if (setrlimit(RLIMIT_NPROC, &rlp) < 0)
       log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NPROC) failed: %s",
         strerror(errno));
     }
     if (setrlimit(RLIMIT_NPROC, &rlp) < 0)
       log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NPROC) failed: %s",
         strerror(errno));
     }

-  #endif
+#endif

   }
 
 /* Exim is normally entered as root (but some special configurations are
   }
 
 /* Exim is normally entered as root (but some special configurations are


@@ -3561,12 +4152,8 @@ check on the additional groups for the admin user privilege - can't do that
 till after reading the config, which might specify the exim gid. Therefore,
 save the group list here first. */
 
 till after reading the config, which might specify the exim gid. Therefore,
 save the group list here first. */
 

-group_count = getgroups(NGROUPS_MAX, group_list);
-if (group_count < 0)
-  {
-  fprintf(stderr, "exim: getgroups() failed: %s\n", strerror(errno));
-  exit(EXIT_FAILURE);
-  }
+if ((group_count = getgroups(nelem(group_list), group_list)) < 0)
+  exim_fail("exim: getgroups() failed: %s\n", strerror(errno));

 
 /* There is a fundamental difference in some BSD systems in the matter of
 groups. FreeBSD and BSDI are known to be different; NetBSD and OpenBSD are
 
 /* There is a fundamental difference in some BSD systems in the matter of
 groups. FreeBSD and BSDI are known to be different; NetBSD and OpenBSD are


@@ -3579,19 +4166,22 @@ over a single group - the current group, which is always the first group in the
 list. Calling setgroups() with zero groups on a "different" system results in
 an error return. The following code should cope with both types of system.
 
 list. Calling setgroups() with zero groups on a "different" system results in
 an error return. The following code should cope with both types of system.
 

+ Unfortunately, recent MacOS, which should be a FreeBSD, "helpfully" succeeds
+ the "setgroups() with zero groups" - and changes the egid.
+ Thanks to that we had to stash the original_egid above, for use below
+ in the call to exim_setugid().
+

 However, if this process isn't running as root, setgroups() can't be used
 However, if this process isn't running as root, setgroups() can't be used

-since you have to be root to run it, even if throwing away groups. Not being
-root here happens only in some unusual configurations. We just ignore the
-error. */
+since you have to be root to run it, even if throwing away groups.
+Except, sigh, for Hurd - where you can.
+Not being root here happens only in some unusual configurations. */

 
 

-if (setgroups(0, NULL) != 0)
-  {
-  if (setgroups(1, group_list) != 0 && !unprivileged)
-    {
-    fprintf(stderr, "exim: setgroups() failed: %s\n", strerror(errno));
-    exit(EXIT_FAILURE);
-    }
-  }
+if (  !unprivileged
+#ifndef OS_SETGROUPS_ZERO_DROPS_ALL
+   && setgroups(0, NULL) != 0
+#endif
+   && setgroups(1, group_list) != 0)
+  exim_fail("exim: setgroups() failed: %s\n", strerror(errno));

 
 /* If the configuration file name has been altered by an argument on the
 command line (either a new file name or a macro definition) and the caller is
 
 /* If the configuration file name has been altered by an argument on the
 command line (either a new file name or a macro definition) and the caller is


@@ -3611,10 +4201,10 @@ values (such as the path name). If running in the test harness, pretend that
 configuration file changes and macro definitions haven't happened. */
 
 if ((                                            /* EITHER */
 configuration file changes and macro definitions haven't happened. */
 
 if ((                                            /* EITHER */

-    (!trusted_config ||                          /* Config changed, or */
-     !macros_trusted()) &&                       /*  impermissible macros and */
+    (!f.trusted_config ||                          /* Config changed, or */
+     !macros_trusted(opt_D_used)) &&            /*  impermissible macros and */

     real_uid != root_uid &&                      /* Not root, and */
     real_uid != root_uid &&                      /* Not root, and */

-    !running_in_test_harness                     /* Not fudged */
+    !f.running_in_test_harness                     /* Not fudged */

     ) ||                                         /*   OR   */
     expansion_test                               /* expansion testing */
     ||                                           /*   OR   */
     ) ||                                         /*   OR   */
     expansion_test                               /* expansion testing */
     ||                                           /*   OR   */


@@ -3634,8 +4224,8 @@ if ((                                            /* EITHER */
   Note that if the invoker is Exim, the logs remain available. Messing with
   this causes unlogged successful deliveries.  */
 
   Note that if the invoker is Exim, the logs remain available. Messing with
   this causes unlogged successful deliveries.  */
 

-  if ((log_stderr != NULL) && (real_uid != exim_uid))
-    really_exim = FALSE;
+  if (log_stderr && real_uid != exim_uid)
+    f.really_exim = FALSE;

   }
 
 /* Privilege is to be retained for the moment. It may be dropped later,
   }
 
 /* Privilege is to be retained for the moment. It may be dropped later,


@@ -3643,32 +4233,21 @@ depending on the job that this Exim process has been asked to do. For now, set
 the real uid to the effective so that subsequent re-execs of Exim are done by a
 privileged user. */
 
 the real uid to the effective so that subsequent re-execs of Exim are done by a
 privileged user. */
 

-else exim_setugid(geteuid(), getegid(), FALSE, US"forcing real = effective");
+else
+  exim_setugid(geteuid(), original_egid, FALSE, US"forcing real = effective");

 
 /* If testing a filter, open the file(s) now, before wasting time doing other
 setups and reading the message. */
 
 
 /* If testing a filter, open the file(s) now, before wasting time doing other
 setups and reading the message. */
 

-if ((filter_test & FTEST_SYSTEM) != 0)
-  {
-  filter_sfd = Uopen(filter_test_sfile, O_RDONLY, 0);
-  if (filter_sfd < 0)
-    {
-    fprintf(stderr, "exim: failed to open %s: %s\n", filter_test_sfile,
+if (filter_test & FTEST_SYSTEM)
+  if ((filter_sfd = Uopen(filter_test_sfile, O_RDONLY, 0)) < 0)
+    exim_fail("exim: failed to open %s: %s\n", filter_test_sfile,

       strerror(errno));
       strerror(errno));

-    return EXIT_FAILURE;
-    }
-  }

 
 

-if ((filter_test & FTEST_USER) != 0)
-  {
-  filter_ufd = Uopen(filter_test_ufile, O_RDONLY, 0);
-  if (filter_ufd < 0)
-    {
-    fprintf(stderr, "exim: failed to open %s: %s\n", filter_test_ufile,
+if (filter_test & FTEST_USER)
+  if ((filter_ufd = Uopen(filter_test_ufile, O_RDONLY, 0)) < 0)
+    exim_fail("exim: failed to open %s: %s\n", filter_test_ufile,

       strerror(errno));
       strerror(errno));

-    return EXIT_FAILURE;
-    }
-  }

 
 /* Initialise lookup_list
 If debugging, already called above via version reporting.
 
 /* Initialise lookup_list
 If debugging, already called above via version reporting.


@@ -3680,12 +4259,67 @@ is equivalent to the ability to modify a setuid binary!
 
 This needs to happen before we read the main configuration. */
 init_lookup_list();
 
 This needs to happen before we read the main configuration. */
 init_lookup_list();

+init_misc_mod_list();
+
+/*XXX this excrescence could move to the testsuite standard config setup file */
+#ifdef SUPPORT_I18N
+if (f.running_in_test_harness) smtputf8_advertise_hosts = NULL;
+#endif

 
 /* Read the main runtime configuration data; this gives up if there
 is a failure. It leaves the configuration file open so that the subsequent
 
 /* Read the main runtime configuration data; this gives up if there
 is a failure. It leaves the configuration file open so that the subsequent

-configuration data for delivery can be read if needed. */
+configuration data for delivery can be read if needed.
+
+NOTE: immediately after opening the configuration file we change the working
+directory to "/"! Later we change to $spool_directory. We do it there, because
+during readconf_main() some expansion takes place already. */
+
+/* Store the initial cwd before we change directories.  Can be NULL if the
+dir has already been unlinked. */
+initial_cwd = os_getcwd(NULL, 0);
+if (!initial_cwd && errno)
+  exim_fail("exim: getting initial cwd failed: %s\n", strerror(errno));
+
+if (initial_cwd && (strlen(CCS initial_cwd) >= BIG_BUFFER_SIZE))
+  exim_fail("exim: initial cwd is far too long (%d)\n", Ustrlen(CCS initial_cwd));
+
+/* checking:
+    -be[m] expansion test        -
+    -b[fF] filter test           new
+    -bh[c] host test             -
+    -bmalware malware_test_file  new
+    -brt   retry test            new
+    -brw   rewrite test          new
+    -bt    address test          -
+    -bv[s] address verify        -
+   list_options:
+    -bP <option> (except -bP config, which sets list_config)
+
+If any of these options is set, we suppress warnings about configuration
+issues (currently about tls_advertise_hosts and keep_environment not being
+defined) */
+
+  {
+  int old_pool = store_pool;
+#ifdef MEASURE_TIMING
+  struct timeval t0;
+  (void)gettimeofday(&t0, NULL);
+#endif
+
+  store_pool = POOL_CONFIG;
+  readconf_main(checking || list_options);
+  store_pool = old_pool;
+
+#ifdef MEASURE_TIMING
+  report_time_since(&t0, US"readconf_main (delta)");
+#endif
+  }
+
+/* Now in directory "/" */
+
+if (cleanup_environment() == FALSE)
+  log_write(0, LOG_PANIC_DIE, "Can't cleanup environment");

 
 

-readconf_main();

 
 /* If an action on specific messages is requested, or if a daemon or queue
 runner is being started, we need to know if Exim was called by an admin user.
 
 /* If an action on specific messages is requested, or if a daemon or queue
 runner is being started, we need to know if Exim was called by an admin user.


@@ -3696,22 +4330,15 @@ since some actions can be performed by non-admin users. Instead, set admin_user
 for later interrogation. */
 
 if (real_uid == root_uid || real_uid == exim_uid || real_gid == exim_gid)
 for later interrogation. */
 
 if (real_uid == root_uid || real_uid == exim_uid || real_gid == exim_gid)

-  admin_user = TRUE;
+  f.admin_user = TRUE;

 else
 else

-  {
-  int i, j;
-  for (i = 0; i < group_count; i++)
-    {
-    if (group_list[i] == exim_gid) admin_user = TRUE;
-    else if (admin_groups != NULL)
-      {
-      for (j = 1; j <= (int)(admin_groups[0]); j++)
+  for (int i = 0; i < group_count && !f.admin_user; i++)
+    if (group_list[i] == exim_gid)
+      f.admin_user = TRUE;
+    else if (admin_groups)
+      for (int j = 1; j <= (int)admin_groups[0] && !f.admin_user; j++)

         if (admin_groups[j] == group_list[i])
         if (admin_groups[j] == group_list[i])

-          { admin_user = TRUE; break; }
-      }
-    if (admin_user) break;
-    }
-  }
+          f.admin_user = TRUE;

 
 /* Another group of privileged users are the trusted users. These are root,
 exim, and any caller matching trusted_users or trusted_groups. Trusted callers
 
 /* Another group of privileged users are the trusted users. These are root,
 exim, and any caller matching trusted_users or trusted_groups. Trusted callers


@@ -3719,82 +4346,68 @@ are permitted to specify sender_addresses with -f on the command line, and
 other message parameters as well. */
 
 if (real_uid == root_uid || real_uid == exim_uid)
 other message parameters as well. */
 
 if (real_uid == root_uid || real_uid == exim_uid)

-  trusted_caller = TRUE;
+  f.trusted_caller = TRUE;

 else
   {
 else
   {

-  int i, j;
-
-  if (trusted_users != NULL)
-    {
-    for (i = 1; i <= (int)(trusted_users[0]); i++)
+  if (trusted_users)
+    for (int i = 1; i <= (int)trusted_users[0] && !f.trusted_caller; i++)

       if (trusted_users[i] == real_uid)
       if (trusted_users[i] == real_uid)

-        { trusted_caller = TRUE; break; }
-    }
+        f.trusted_caller = TRUE;

 
 

-  if (!trusted_caller && trusted_groups != NULL)
-    {
-    for (i = 1; i <= (int)(trusted_groups[0]); i++)
-      {
+  if (trusted_groups)
+    for (int i = 1; i <= (int)trusted_groups[0] && !f.trusted_caller; i++)

       if (trusted_groups[i] == real_gid)
       if (trusted_groups[i] == real_gid)

-        trusted_caller = TRUE;
-      else for (j = 0; j < group_count; j++)
-        {
+        f.trusted_caller = TRUE;
+      else for (int j = 0; j < group_count && !f.trusted_caller; j++)

         if (trusted_groups[i] == group_list[j])
         if (trusted_groups[i] == group_list[j])

-          { trusted_caller = TRUE; break; }
-        }
-      if (trusted_caller) break;
-      }
-    }
+          f.trusted_caller = TRUE;

   }
 
   }
 

+/* At this point, we know if the user is privileged and some command-line
+options become possibly impermissible, depending upon the configuration file. */
+
+if (checking && commandline_checks_require_admin && !f.admin_user)
+  exim_fail("exim: those command-line flags are set to require admin\n");
+

 /* Handle the decoding of logging options. */
 
 /* Handle the decoding of logging options. */
 

-decode_bits(&log_write_selector, &log_extra_selector, 0, 0,
+decode_bits(log_selector, log_selector_size, log_notall,

   log_selector_string, log_options, log_options_count, US"log", 0);
 
 DEBUG(D_any)
   {
   debug_printf("configuration file is %s\n", config_main_filename);
   log_selector_string, log_options, log_options_count, US"log", 0);
 
 DEBUG(D_any)
   {
   debug_printf("configuration file is %s\n", config_main_filename);

-  debug_printf("log selectors = %08x %08x\n", log_write_selector,
-    log_extra_selector);
+  debug_printf("log selectors =");
+  for (int i = 0; i < log_selector_size; i++)
+    debug_printf(" %08x", log_selector[i]);
+  debug_printf("\n");

   }
 
 /* If domain literals are not allowed, check the sender address that was
 supplied with -f. Ditto for a stripped trailing dot. */
 
   }
 
 /* If domain literals are not allowed, check the sender address that was
 supplied with -f. Ditto for a stripped trailing dot. */
 

-if (sender_address != NULL)
+if (sender_address)

   {
   if (sender_address[sender_address_domain] == '[' && !allow_domain_literals)
   {
   if (sender_address[sender_address_domain] == '[' && !allow_domain_literals)

-    {
-    fprintf(stderr, "exim: bad -f address \"%s\": domain literals not "
+    exim_fail("exim: bad -f address \"%s\": domain literals not "

       "allowed\n", sender_address);
       "allowed\n", sender_address);

-    return EXIT_FAILURE;
-    }

   if (f_end_dot && !strip_trailing_dot)
   if (f_end_dot && !strip_trailing_dot)

-    {
-    fprintf(stderr, "exim: bad -f address \"%s.\": domain is malformed "
+    exim_fail("exim: bad -f address \"%s.\": domain is malformed "

       "(trailing dot not allowed)\n", sender_address);
       "(trailing dot not allowed)\n", sender_address);

-    return EXIT_FAILURE;
-    }

   }
 
 /* See if an admin user overrode our logging. */
 
   }
 
 /* See if an admin user overrode our logging. */
 

-if (cmdline_syslog_name != NULL)
-  {
-  if (admin_user)
+if (cmdline_syslog_name)
+  if (f.admin_user)

     {
     syslog_processname = cmdline_syslog_name;
     log_file_path = string_copy(CUS"syslog");
     }
   else
     {
     syslog_processname = cmdline_syslog_name;
     log_file_path = string_copy(CUS"syslog");
     }
   else

-    {

     /* not a panic, non-privileged users should not be able to spam paniclog */
     /* not a panic, non-privileged users should not be able to spam paniclog */

-    fprintf(stderr,
+    exim_fail(

         "exim: you lack sufficient privilege to specify syslog process name\n");
         "exim: you lack sufficient privilege to specify syslog process name\n");

-    return EXIT_FAILURE;
-    }
-  }

 
 /* Paranoia check of maximum lengths of certain strings. There is a check
 on the length of the log file path in log.c, which will come into effect
 
 /* Paranoia check of maximum lengths of certain strings. There is a check
 on the length of the log file path in log.c, which will come into effect


@@ -3823,27 +4436,33 @@ if (Ustrlen(syslog_processname) > 32)
   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
     "syslog_processname is longer than 32 chars: aborting");
 
   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
     "syslog_processname is longer than 32 chars: aborting");
 

+if (log_oneline)
+  if (f.admin_user)
+    {
+    log_write(0, LOG_MAIN, "%s", log_oneline);
+    return EXIT_SUCCESS;
+    }
+  else
+    return EXIT_FAILURE;
+

 /* In some operating systems, the environment variable TMPDIR controls where
 temporary files are created; Exim doesn't use these (apart from when delivering
 to MBX mailboxes), but called libraries such as DBM libraries may require them.
 If TMPDIR is found in the environment, reset it to the value defined in the
 /* In some operating systems, the environment variable TMPDIR controls where
 temporary files are created; Exim doesn't use these (apart from when delivering
 to MBX mailboxes), but called libraries such as DBM libraries may require them.
 If TMPDIR is found in the environment, reset it to the value defined in the

-TMPDIR macro, if this macro is defined. */
+EXIM_TMPDIR macro, if this macro is defined.  For backward compatibility this
+macro may be called TMPDIR in old "Local/Makefile"s. It's converted to
+EXIM_TMPDIR by the build scripts.
+*/

 
 

-#ifdef TMPDIR
-  {
-  uschar **p;
-  for (p = USS environ; *p != NULL; p++)
-    {
-    if (Ustrncmp(*p, "TMPDIR=", 7) == 0 &&
-        Ustrcmp(*p+7, TMPDIR) != 0)
+#ifdef EXIM_TMPDIR
+  if (environ) for (uschar ** p = USS environ; *p; p++)
+    if (Ustrncmp(*p, "TMPDIR=", 7) == 0 && Ustrcmp(*p+7, EXIM_TMPDIR) != 0)

       {
       {

-      uschar *newp = malloc(Ustrlen(TMPDIR) + 8);
-      sprintf(CS newp, "TMPDIR=%s", TMPDIR);
+      uschar * newp = store_malloc(Ustrlen(EXIM_TMPDIR) + 8);
+      sprintf(CS newp, "TMPDIR=%s", EXIM_TMPDIR);

       *p = newp;
       *p = newp;

-      DEBUG(D_any) debug_printf("reset TMPDIR=%s in environment\n", TMPDIR);
+      DEBUG(D_any) debug_printf("reset TMPDIR=%s in environment\n", EXIM_TMPDIR);

       }
       }

-    }
-  }

 #endif
 
 /* Timezone handling. If timezone_string is "utc", set a flag to cause all
 #endif
 
 /* Timezone handling. If timezone_string is "utc", set a flag to cause all


@@ -3856,33 +4475,28 @@ about this earlier - but hopefully nothing will normally be logged earlier than
 this. We have to make a new environment if TZ is wrong, but don't bother if
 timestamps_utc is set, because then all times are in UTC anyway. */
 
 this. We have to make a new environment if TZ is wrong, but don't bother if
 timestamps_utc is set, because then all times are in UTC anyway. */
 

-if (timezone_string != NULL && strcmpic(timezone_string, US"UTC") == 0)
-  {
-  timestamps_utc = TRUE;
-  }
+if (timezone_string && strcmpic(timezone_string, US"UTC") == 0)
+  f.timestamps_utc = TRUE;

 else
   {
   uschar *envtz = US getenv("TZ");
 else
   {
   uschar *envtz = US getenv("TZ");

-  if ((envtz == NULL && timezone_string != NULL) ||
-      (envtz != NULL &&
-        (timezone_string == NULL ||
-         Ustrcmp(timezone_string, envtz) != 0)))
+  if (envtz
+      ? !timezone_string || Ustrcmp(timezone_string, envtz) != 0
+      : timezone_string != NULL
+     )

     {
     uschar **p = USS environ;
     uschar **new;
     uschar **newp;
     int count = 0;
     {
     uschar **p = USS environ;
     uschar **new;
     uschar **newp;
     int count = 0;

-    while (*p++ != NULL) count++;
-    if (envtz == NULL) count++;
-    newp = new = malloc(sizeof(uschar *) * (count + 1));
-    for (p = USS environ; *p != NULL; p++)
-      {
-      if (Ustrncmp(*p, "TZ=", 3) == 0) continue;
-      *newp++ = *p;
-      }
-    if (timezone_string != NULL)
+    if (environ) while (*p++) count++;
+    if (!envtz) count++;
+    newp = new = store_malloc(sizeof(uschar *) * (count + 1));
+    if (environ) for (p = USS environ; *p; p++)
+      if (Ustrncmp(*p, "TZ=", 3) != 0) *newp++ = *p;
+    if (timezone_string)

       {
       {

-      *newp = malloc(Ustrlen(timezone_string) + 4);
+      *newp = store_malloc(Ustrlen(timezone_string) + 4);

       sprintf(CS *newp++, "TZ=%s", timezone_string);
       }
     *newp = NULL;
       sprintf(CS *newp++, "TZ=%s", timezone_string);
       }
     *newp = NULL;


@@ -3914,16 +4528,15 @@ Exim user", but it hasn't, because either the -D option set macros, or the
       root for -C or -D, the caller must either be root or be invoking a
       trusted configuration file (when deliver_drop_privilege is false). */
 
       root for -C or -D, the caller must either be root or be invoking a
       trusted configuration file (when deliver_drop_privilege is false). */
 

-if (removed_privilege && (!trusted_config || macros != NULL) &&
-    real_uid == exim_uid)
-  {
+if (  removed_privilege
+   && (!f.trusted_config || opt_D_used)
+   && real_uid == exim_uid)

   if (deliver_drop_privilege)
   if (deliver_drop_privilege)

-    really_exim = TRUE; /* let logging work normally */
+    f.really_exim = TRUE; /* let logging work normally */

   else
     log_write(0, LOG_MAIN|LOG_PANIC,
       "exim user lost privilege for using %s option",
   else
     log_write(0, LOG_MAIN|LOG_PANIC,
       "exim user lost privilege for using %s option",

-      trusted_config? "-D" : "-C");
-  }
+      f.trusted_config? "-D" : "-C");

 
 /* Start up Perl interpreter if Perl support is configured and there is a
 perl_startup option, and the configuration or the command line specifies
 
 /* Start up Perl interpreter if Perl support is configured and there is a
 perl_startup option, and the configuration or the command line specifies


@@ -3935,14 +4548,17 @@ if (perl_start_option != 0)
   opt_perl_at_start = (perl_start_option > 0);
 if (opt_perl_at_start && opt_perl_startup != NULL)
   {
   opt_perl_at_start = (perl_start_option > 0);
 if (opt_perl_at_start && opt_perl_startup != NULL)
   {

-  uschar *errstr;
+  uschar * errstr;
+  const misc_module_info * mi = misc_mod_find(US"perl", &errstr);
+  typedef uschar * (*fn_t)(uschar *);
+
+  if (!mi)
+    exim_fail("exim: error finding perl module: %s\n", errstr);
+

   DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
   DEBUG(D_any) debug_printf("Starting Perl interpreter\n");

-  errstr = init_perl(opt_perl_startup);
-  if (errstr != NULL)
-    {
-    fprintf(stderr, "exim: error in perl_startup code: %s\n", errstr);
-    return EXIT_FAILURE;
-    }
+
+  if ((errstr = (((fn_t *) mi->functions)[PERL_STARTUP]) (opt_perl_startup)))
+    exim_fail("exim: error in perl_startup code: %s\n", errstr);

   opt_perl_started = TRUE;
   }
 #endif /* EXIM_PERL */
   opt_perl_started = TRUE;
   }
 #endif /* EXIM_PERL */


@@ -3952,42 +4568,48 @@ a debugging feature for finding out what arguments certain MUAs actually use.
 Don't attempt it if logging is disabled, or if listing variables or if
 verifying/testing addresses or expansions. */
 
 Don't attempt it if logging is disabled, or if listing variables or if
 verifying/testing addresses or expansions. */
 

-if (((debug_selector & D_any) != 0 || (log_extra_selector & LX_arguments) != 0)
-      && really_exim && !list_options && !checking)
+if (  (debug_selector & D_any  ||  LOGGING(arguments))
+   && f.really_exim && !list_options && !checking)

   {
   {

-  int i;

   uschar *p = big_buffer;
   uschar *p = big_buffer;

-  char * dummy;
-  Ustrcpy(p, "cwd= (failed)");
-  dummy = /* quieten compiler */ getcwd(CS p+4, big_buffer_size - 4);
-  while (*p) p++;
+  Ustrcpy(p, US"cwd= (failed)");
+
+  if (!initial_cwd)
+    p += 13;
+  else
+    {
+    p += 4;
+    snprintf(CS p, big_buffer_size - (p - big_buffer), "%s", CCS initial_cwd);
+    p += Ustrlen(CCS p);
+    }
+

   (void)string_format(p, big_buffer_size - (p - big_buffer), " %d args:", argc);
   while (*p) p++;
   (void)string_format(p, big_buffer_size - (p - big_buffer), " %d args:", argc);
   while (*p) p++;

-  for (i = 0; i < argc; i++)
+  for (int i = 0; i < argc; i++)

     {
     int len = Ustrlen(argv[i]);
     {
     int len = Ustrlen(argv[i]);

-    uschar *printing;
+    const uschar *printing;

     uschar *quote;
     if (p + len + 8 >= big_buffer + big_buffer_size)
       {
     uschar *quote;
     if (p + len + 8 >= big_buffer + big_buffer_size)
       {

-      Ustrcpy(p, " ...");
+      Ustrcpy(p, US" ...");

       log_write(0, LOG_MAIN, "%s", big_buffer);
       log_write(0, LOG_MAIN, "%s", big_buffer);

-      Ustrcpy(big_buffer, "...");
+      Ustrcpy(big_buffer, US"...");

       p = big_buffer + 3;
       }
     printing = string_printing(argv[i]);
       p = big_buffer + 3;
       }
     printing = string_printing(argv[i]);

-    if (printing[0] == 0) quote = US"\""; else
+    if (!*printing) quote = US"\"";
+    else

       {
       {

-      uschar *pp = printing;
+      const uschar *pp = printing;

       quote = US"";
       quote = US"";

-      while (*pp != 0) if (isspace(*pp++)) { quote = US"\""; break; }
+      while (*pp) if (isspace(*pp++)) { quote = US"\""; break; }

       }
       }

-    sprintf(CS p, " %s%.*s%s", quote, (int)(big_buffer_size -
+    p += sprintf(CS p, " %s%.*s%s", quote, (int)(big_buffer_size -

       (p - big_buffer) - 4), printing, quote);
       (p - big_buffer) - 4), printing, quote);

-    while (*p) p++;

     }
 
     }
 

-  if ((log_extra_selector & LX_arguments) != 0)
+  if (LOGGING(arguments))

     log_write(0, LOG_MAIN, "%s", big_buffer);
   else
     debug_printf("%s\n", big_buffer);
     log_write(0, LOG_MAIN, "%s", big_buffer);
   else
     debug_printf("%s\n", big_buffer);


@@ -4002,9 +4624,8 @@ privilege by now. Before the chdir, we try to ensure that the directory exists.
 
 if (Uchdir(spool_directory) != 0)
   {
 
 if (Uchdir(spool_directory) != 0)
   {

-  int dummy;
-  (void)directory_make(spool_directory, US"", SPOOL_DIRECTORY_MODE, FALSE);
-  dummy = /* quieten compiler */ Uchdir(spool_directory);
+  (void) directory_make(spool_directory, US"", SPOOL_DIRECTORY_MODE, FALSE);
+  if (Uchdir(spool_directory) < 0) ;

   }
 
 /* Handle calls with the -bi option. This is a sendmail option to rebuild *the*
   }
 
 /* Handle calls with the -bi option. This is a sendmail option to rebuild *the*


@@ -4015,24 +4636,23 @@ script. */
 
 if (bi_option)
   {
 
 if (bi_option)
   {

-  (void)fclose(config_file);
-  if (bi_command != NULL)
+  (void) fclose(config_file);
+  if (bi_command && *bi_command)

     {
     int i = 0;
     {
     int i = 0;

-    uschar *argv[3];
-    argv[i++] = bi_command;
-    if (alias_arg != NULL) argv[i++] = alias_arg;
+    const uschar * argv[3];
+    argv[i++] = bi_command;    /* nonexpanded option so assume untainted */
+    if (alias_arg) argv[i++] = alias_arg;

     argv[i++] = NULL;
 
     setgroups(group_count, group_list);
     exim_setugid(real_uid, real_gid, FALSE, US"running bi_command");
 
     argv[i++] = NULL;
 
     setgroups(group_count, group_list);
     exim_setugid(real_uid, real_gid, FALSE, US"running bi_command");
 

-    DEBUG(D_exec) debug_printf("exec %.256s %.256s\n", argv[0],
-      (argv[1] == NULL)? US"" : argv[1]);
+    DEBUG(D_exec) debug_printf("exec '%.256s' %s%.256s%s\n", argv[0],
+      argv[1] ? "'" : "", argv[1] ? argv[1] : US"", argv[1] ? "'" : "");

 
     execv(CS argv[0], (char *const *)argv);
 
     execv(CS argv[0], (char *const *)argv);

-    fprintf(stderr, "exim: exec failed: %s\n", strerror(errno));
-    exit(EXIT_FAILURE);
+    exim_fail("exim: exec '%s' failed: %s\n", argv[0], strerror(errno));

     }
   else
     {
     }
   else
     {


@@ -4045,8 +4665,8 @@ if (bi_option)
 configuration file.  We leave these prints here to ensure that syslog setup,
 logfile setup, and so on has already happened. */
 
 configuration file.  We leave these prints here to ensure that syslog setup,
 logfile setup, and so on has already happened. */
 

-if (trusted_caller) DEBUG(D_any) debug_printf("trusted user\n");
-if (admin_user) DEBUG(D_any) debug_printf("admin user\n");
+if (f.trusted_caller) DEBUG(D_any) debug_printf("trusted user\n");
+if (f.admin_user) DEBUG(D_any) debug_printf("admin user\n");

 
 /* Only an admin user may start the daemon or force a queue run in the default
 configuration, but the queue run restriction can be relaxed. Only an admin
 
 /* Only an admin user may start the daemon or force a queue run in the default
 configuration, but the queue run restriction can be relaxed. Only an admin


@@ -4056,18 +4676,18 @@ passwords, etc. in lookup queries). Only an admin user may request a queue
 count. Only an admin user can use the test interface to scan for email
 (because Exim will be in the spool dir and able to look at mails). */
 
 count. Only an admin user can use the test interface to scan for email
 (because Exim will be in the spool dir and able to look at mails). */
 

-if (!admin_user)
+if (!f.admin_user)

   {
   BOOL debugset = (debug_selector & ~D_v) != 0;
   {
   BOOL debugset = (debug_selector & ~D_v) != 0;

-  if (deliver_give_up || daemon_listen || malware_test_file ||
-     (count_queue && queue_list_requires_admin) ||
-     (list_queue && queue_list_requires_admin) ||
-     (queue_interval >= 0 && prod_requires_admin) ||
-     (debugset && !running_in_test_harness))
-    {
-    fprintf(stderr, "exim:%s permission denied\n", debugset? " debugging" : "");
-    exit(EXIT_FAILURE);
-    }
+  if (  deliver_give_up || f.daemon_listen || malware_test_file
+     || count_queue && queue_list_requires_admin
+     || list_queue && queue_list_requires_admin
+     || qrunners && prod_requires_admin
+     || queue_name_dest && prod_requires_admin
+     || debugset && !f.running_in_test_harness
+     )
+    exim_fail("exim:%s permission denied; not admin\n",
+             debugset ? " debugging" : "");

   }
 
 /* If the real user is not root or the exim uid, the argument for passing
   }
 
 /* If the real user is not root or the exim uid, the argument for passing


@@ -4076,22 +4696,21 @@ running with the -N option for any delivery action, unless this call to exim is
 one that supplied an input message, or we are using a patched exim for
 regression testing. */
 
 one that supplied an input message, or we are using a patched exim for
 regression testing. */
 

-if (real_uid != root_uid && real_uid != exim_uid &&
-     (continue_hostname != NULL ||
-       (dont_deliver &&
-         (queue_interval >= 0 || daemon_listen || msg_action_arg > 0)
-       )) && !running_in_test_harness)
-  {
-  fprintf(stderr, "exim: Permission denied\n");
-  return EXIT_FAILURE;
-  }
+if (  real_uid != root_uid && real_uid != exim_uid
+   && (  continue_hostname
+      || (  f.dont_deliver
+        && (qrunners || f.daemon_listen || msg_action_arg > 0)
+      )  )
+   && !f.running_in_test_harness
+   )
+  exim_fail("exim: Permission denied; not exim user or root\n");

 
 /* If the caller is not trusted, certain arguments are ignored when running for
 real, but are permitted when checking things (-be, -bv, -bt, -bh, -bf, -bF).
 Note that authority for performing certain actions on messages is tested in the
 queue_action() function. */
 
 
 /* If the caller is not trusted, certain arguments are ignored when running for
 real, but are permitted when checking things (-be, -bv, -bt, -bh, -bf, -bF).
 Note that authority for performing certain actions on messages is tested in the
 queue_action() function. */
 

-if (!trusted_caller && !checking && filter_test == FTEST_NONE)
+if (!f.trusted_caller && !checking)

   {
   sender_host_name = sender_host_address = interface_address =
     sender_ident = received_protocol = NULL;
   {
   sender_host_name = sender_host_address = interface_address =
     sender_ident = received_protocol = NULL;


@@ -4105,25 +4724,22 @@ Exim exits if the syntax is bad. */
 
 else
   {
 
 else
   {

-  if (sender_host_address != NULL)
+  if (sender_host_address)

     sender_host_port = check_port(sender_host_address);
     sender_host_port = check_port(sender_host_address);

-  if (interface_address != NULL)
+  if (interface_address)

     interface_port = check_port(interface_address);
   }
 
 /* If the caller is trusted, then they can use -G to suppress_local_fixups. */
 if (flag_G)
   {
     interface_port = check_port(interface_address);
   }
 
 /* If the caller is trusted, then they can use -G to suppress_local_fixups. */
 if (flag_G)
   {

-  if (trusted_caller)
+  if (f.trusted_caller)

     {
     {

-    suppress_local_fixups = suppress_local_fixups_default = TRUE;
+    f.suppress_local_fixups = f.suppress_local_fixups_default = TRUE;

     DEBUG(D_acl) debug_printf("suppress_local_fixups forced on by -G\n");
     }
   else
     DEBUG(D_acl) debug_printf("suppress_local_fixups forced on by -G\n");
     }
   else

-    {
-    fprintf(stderr, "exim: permission denied (-G requires a trusted user)\n");
-    return EXIT_FAILURE;
-    }
+    exim_fail("exim: permission denied (-G requires a trusted user)\n");

   }
 
 /* If an SMTP message is being received check to see if the standard input is a
   }
 
 /* If an SMTP message is being received check to see if the standard input is a


@@ -4151,18 +4767,15 @@ if (smtp_input)
 
       if (real_uid == root_uid || real_uid == exim_uid || interface_port < 1024)
         {
 
       if (real_uid == root_uid || real_uid == exim_uid || interface_port < 1024)
         {

-        is_inetd = TRUE;
-        sender_host_address = host_ntoa(-1, (struct sockaddr *)(&inetd_sock),
-          NULL, &sender_host_port);

         if (mua_wrapper) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Input from "
           "inetd is not supported when mua_wrapper is set");
         if (mua_wrapper) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Input from "
           "inetd is not supported when mua_wrapper is set");

+        f.is_inetd = TRUE;
+        sender_host_address = host_ntoa(-1, (struct sockaddr *)(&inetd_sock),
+          NULL, &sender_host_port);

         }
       else
         }
       else

-        {
-        fprintf(stderr,
+        exim_fail(

           "exim: Permission denied (unprivileged user, unprivileged port)\n");
           "exim: Permission denied (unprivileged user, unprivileged port)\n");

-        return EXIT_FAILURE;
-        }

       }
     }
   }
       }
     }
   }


@@ -4172,13 +4785,9 @@ now for those OS that require the first call to os_getloadavg() to be done as
 root. There will be further calls later for each message received. */
 
 #ifdef LOAD_AVG_NEEDS_ROOT
 root. There will be further calls later for each message received. */
 
 #ifdef LOAD_AVG_NEEDS_ROOT

-if (receiving_message &&
-      (queue_only_load >= 0 ||
-        (is_inetd && smtp_load_reserve >= 0)
-      ))
-  {
+if (  receiving_message
+   && (queue_only_load >= 0 ||  f.is_inetd && smtp_load_reserve >= 0))

   load_average = OS_GETLOADAVG();
   load_average = OS_GETLOADAVG();

-  }

 #endif
 
 /* The queue_only configuration option can be overridden by -odx on the command
 #endif
 
 /* The queue_only configuration option can be overridden by -odx on the command


@@ -4204,28 +4813,28 @@ retained only for starting the daemon. We always do the initgroups() in this
 situation (controlled by the TRUE below), in order to be as close as possible
 to the state Exim usually runs in. */
 
 situation (controlled by the TRUE below), in order to be as close as possible
 to the state Exim usually runs in. */
 

-if (!unprivileged &&                      /* originally had root AND */
-    !removed_privilege &&                 /* still got root AND      */
-    !daemon_listen &&                     /* not starting the daemon */
-    queue_interval <= 0 &&                /* (either kind of daemon) */
-      (                                   /*    AND EITHER           */
-      deliver_drop_privilege ||           /* requested unprivileged  */
-        (                                 /*       OR                */
-        queue_interval < 0 &&             /* not running the queue   */
-        (msg_action_arg < 0 ||            /*       and               */
-          msg_action != MSG_DELIVER) &&   /* not delivering and      */
-        (!checking || !address_test_mode) /* not address checking    */
-        )
-      ))
-  {
+if (  !unprivileged                            /* originally had root AND */
+   && !removed_privilege                       /* still got root AND      */
+   && !f.daemon_listen                         /* not starting the daemon */
+   && (!qrunners || is_onetime_qrun())         /* (either kind of daemon) */
+   && (                                                /*    AND EITHER           */
+         deliver_drop_privilege                        /* requested unprivileged  */
+      || (                                     /*       OR                */
+            !qrunners                          /* not running the queue   */
+         && (  msg_action_arg < 0              /*       and               */
+            || msg_action != MSG_DELIVER       /* not delivering          */
+           )                                   /*       and               */
+         && (!checking || !f.address_test_mode)        /* not address checking    */
+        && !rcpt_verify_quota                  /* and not quota checking  */
+   )  )  )

   exim_setugid(exim_uid, exim_gid, TRUE, US"privilege not needed");
   exim_setugid(exim_uid, exim_gid, TRUE, US"privilege not needed");

-  }

 
 /* When we are retaining a privileged uid, we still change to the exim gid. */
 
 else
   {
   int rv;
 
 /* When we are retaining a privileged uid, we still change to the exim gid. */
 
 else
   {
   int rv;

+  DEBUG(D_any) debug_printf("dropping to exim gid; retaining priv uid\n");

   rv = setgid(exim_gid);
   /* Impact of failure is that some stuff might end up with an incorrect group.
   We track this for failures from root, since any attempt to change privilege
   rv = setgid(exim_gid);
   /* Impact of failure is that some stuff might end up with an incorrect group.
   We track this for failures from root, since any attempt to change privilege


@@ -4233,17 +4842,13 @@ else
   there's no security risk.  For me, it's { exim -bV } on a just-built binary,
   no need to complain then. */
   if (rv == -1)
   there's no security risk.  For me, it's { exim -bV } on a just-built binary,
   no need to complain then. */
   if (rv == -1)

-    {

     if (!(unprivileged || removed_privilege))
     if (!(unprivileged || removed_privilege))

-      {
-      fprintf(stderr,
-          "exim: changing group failed: %s\n", strerror(errno));
-      exit(EXIT_FAILURE);
-      }
+      exim_fail("exim: changing group failed: %s\n", strerror(errno));

     else
     else

+      {

       DEBUG(D_any) debug_printf("changing group to %ld failed: %s\n",
           (long int)exim_gid, strerror(errno));
       DEBUG(D_any) debug_printf("changing group to %ld failed: %s\n",
           (long int)exim_gid, strerror(errno));

-    }
+      }

   }
 
 /* Handle a request to scan a file for malware */
   }
 
 /* Handle a request to scan a file for malware */


@@ -4252,16 +4857,15 @@ if (malware_test_file)
 #ifdef WITH_CONTENT_SCAN
   int result;
   set_process_info("scanning file for malware");
 #ifdef WITH_CONTENT_SCAN
   int result;
   set_process_info("scanning file for malware");

-  result = malware_in_file(malware_test_file);
-  if (result == FAIL)
+  if ((result = malware_in_file(malware_test_file)) == FAIL)

     {
     printf("No malware found.\n");
     {
     printf("No malware found.\n");

-    exit(EXIT_SUCCESS);
+    exim_exit(EXIT_SUCCESS);

     }
   if (result != OK)
     {
     printf("Malware lookup returned non-okay/fail: %d\n", result);
     }
   if (result != OK)
     {
     printf("Malware lookup returned non-okay/fail: %d\n", result);

-    exit(EXIT_FAILURE);
+    exim_exit(EXIT_FAILURE);

     }
   if (malware_name)
     printf("Malware found: %s\n", malware_name);
     }
   if (malware_name)
     printf("Malware found: %s\n", malware_name);


@@ -4270,7 +4874,7 @@ if (malware_test_file)
 #else
   printf("Malware scanning not enabled at compile time.\n");
 #endif
 #else
   printf("Malware scanning not enabled at compile time.\n");
 #endif

-  exit(EXIT_FAILURE);
+  exim_exit(EXIT_FAILURE);

   }
 
 /* Handle a request to list the delivery queue */
   }
 
 /* Handle a request to list the delivery queue */


@@ -4279,7 +4883,7 @@ if (list_queue)
   {
   set_process_info("listing the queue");
   queue_list(list_queue_option, argv + recipients_arg, argc - recipients_arg);
   {
   set_process_info("listing the queue");
   queue_list(list_queue_option, argv + recipients_arg, argc - recipients_arg);

-  exit(EXIT_SUCCESS);
+  exim_exit(EXIT_SUCCESS);

   }
 
 /* Handle a request to count the delivery queue */
   }
 
 /* Handle a request to count the delivery queue */


@@ -4287,8 +4891,8 @@ if (list_queue)
 if (count_queue)
   {
   set_process_info("counting the queue");
 if (count_queue)
   {
   set_process_info("counting the queue");

-  queue_count();
-  exit(EXIT_SUCCESS);
+  fprintf(stdout, "%u\n", queue_count());
+  exim_exit(EXIT_SUCCESS);

   }
 
 /* Handle actions on specific messages, except for the force delivery and
   }
 
 /* Handle actions on specific messages, except for the force delivery and


@@ -4301,33 +4905,73 @@ if (msg_action_arg > 0 && msg_action != MSG_DELIVER && msg_action != MSG_LOAD)
   int yield = EXIT_SUCCESS;
   set_process_info("acting on specified messages");
 
   int yield = EXIT_SUCCESS;
   set_process_info("acting on specified messages");
 

+  /* ACL definitions may be needed when removing a message (-Mrm) because
+  event_action gets expanded */
+
+  if (msg_action == MSG_REMOVE)
+    {
+    int old_pool = store_pool;
+    store_pool = POOL_CONFIG;
+    readconf_rest();
+    store_pool = old_pool;
+    store_writeprotect(POOL_CONFIG);
+    }
+

   if (!one_msg_action)
     {
     for (i = msg_action_arg; i < argc; i++)
       if (!queue_action(argv[i], msg_action, NULL, 0, 0))
         yield = EXIT_FAILURE;
   if (!one_msg_action)
     {
     for (i = msg_action_arg; i < argc; i++)
       if (!queue_action(argv[i], msg_action, NULL, 0, 0))
         yield = EXIT_FAILURE;

+    switch (msg_action)
+      {
+      case MSG_REMOVE: case MSG_FREEZE: case MSG_THAW: break;
+      default: printf("\n"); break;
+      }

     }
 
   else if (!queue_action(argv[msg_action_arg], msg_action, argv, argc,
     recipients_arg)) yield = EXIT_FAILURE;
     }
 
   else if (!queue_action(argv[msg_action_arg], msg_action, argv, argc,
     recipients_arg)) yield = EXIT_FAILURE;

-  exit(yield);
+  exim_exit(yield);

   }
 
 /* We used to set up here to skip reading the ACL section, on
   }
 
 /* We used to set up here to skip reading the ACL section, on

- (msg_action_arg > 0 || (queue_interval == 0 && !daemon_listen)
+ (msg_action_arg > 0 || (is_onetime_qrun() && !f.daemon_listen)

 Now, since the intro of the ${acl } expansion, ACL definitions may be
 needed in transports so we lost the optimisation. */
 
 Now, since the intro of the ${acl } expansion, ACL definitions may be
 needed in transports so we lost the optimisation. */
 

-readconf_rest();
+  {
+  int old_pool = store_pool;
+#ifdef MEASURE_TIMING
+  struct timeval t0;
+  (void)gettimeofday(&t0, NULL);
+#endif

 
 

-/* The configuration data will have been read into POOL_PERM because we won't
-ever want to reset back past it. Change the current pool to POOL_MAIN. In fact,
-this is just a bit of pedantic tidiness. It wouldn't really matter if the
-configuration were read into POOL_MAIN, because we don't do any resets till
-later on. However, it seems right, and it does ensure that both pools get used.
-*/
+  store_pool = POOL_CONFIG;
+  readconf_rest();
+  store_pool = old_pool;
+
+  /* -be can add macro definitions, needing to link to the macro structure
+  chain.  Otherwise, make the memory used for config data readonly. */

 
 

-store_pool = POOL_MAIN;
+  if (!expansion_test)
+    store_writeprotect(POOL_CONFIG);
+
+#ifdef MEASURE_TIMING
+  report_time_since(&t0, US"readconf_rest (delta)");
+#endif
+  }
+
+/* Handle a request to check quota */
+if (rcpt_verify_quota)
+  if (real_uid != root_uid && real_uid != exim_uid)
+    exim_fail("exim: Permission denied\n");
+  else if (recipients_arg >= argc)
+    exim_fail("exim: missing recipient for quota check\n");
+  else
+    {
+    verify_quota(US argv[recipients_arg]);     /*XXX we lose track of const here */
+    exim_exit(EXIT_SUCCESS);
+    }

 
 /* Handle the -brt option. This is for checking out retry configurations.
 The next three arguments are a domain name or a complete address, and
 
 /* Handle the -brt option. This is for checking out retry configurations.
 The next three arguments are a domain name or a complete address, and


@@ -4339,14 +4983,14 @@ if (test_retry_arg >= 0)
   retry_config *yield;
   int basic_errno = 0;
   int more_errno = 0;
   retry_config *yield;
   int basic_errno = 0;
   int more_errno = 0;

-  uschar *s1, *s2;
+  const uschar *s1, *s2;

 
   if (test_retry_arg >= argc)
     {
     printf("-brt needs a domain or address argument\n");
     exim_exit(EXIT_FAILURE);
     }
 
   if (test_retry_arg >= argc)
     {
     printf("-brt needs a domain or address argument\n");
     exim_exit(EXIT_FAILURE);
     }

-  s1 = argv[test_retry_arg++];
+  s1 = exim_str_fail_toolong(argv[test_retry_arg++], EXIM_EMAILADDR_MAX, "-brt");

   s2 = NULL;
 
   /* If the first argument contains no @ and no . it might be a local user
   s2 = NULL;
 
   /* If the first argument contains no @ and no . it might be a local user


@@ -4362,13 +5006,13 @@ if (test_retry_arg >= 0)
   /* There may be an optional second domain arg. */
 
   if (test_retry_arg < argc && Ustrchr(argv[test_retry_arg], '.') != NULL)
   /* There may be an optional second domain arg. */
 
   if (test_retry_arg < argc && Ustrchr(argv[test_retry_arg], '.') != NULL)

-    s2 = argv[test_retry_arg++];
+    s2 = exim_str_fail_toolong(argv[test_retry_arg++], EXIM_DOMAINNAME_MAX, "-brt 2nd");

 
   /* The final arg is an error name */
 
   if (test_retry_arg < argc)
     {
 
   /* The final arg is an error name */
 
   if (test_retry_arg < argc)
     {

-    uschar *ss = argv[test_retry_arg];
+    const uschar *ss = exim_str_fail_toolong(argv[test_retry_arg], EXIM_DRIVERNAME_MAX, "-brt 3rd");

     uschar *error =
       readconf_retry_error(ss, ss + Ustrlen(ss), &basic_errno, &more_errno);
     if (error != NULL)
     uschar *error =
       readconf_retry_error(ss, ss + Ustrlen(ss), &basic_errno, &more_errno);
     if (error != NULL)


@@ -4393,10 +5037,10 @@ if (test_retry_arg >= 0)
       }
     }
 
       }
     }
 

-  yield = retry_find_config(s1, s2, basic_errno, more_errno);
-  if (yield == NULL) printf("No retry information found\n"); else
+  if (!(yield = retry_find_config(s1, s2, basic_errno, more_errno)))
+    printf("No retry information found\n");
+  else

     {
     {

-    retry_rule *r;

     more_errno = yield->more_errno;
     printf("Retry rule: %s  ", yield->pattern);
 
     more_errno = yield->more_errno;
     printf("Retry rule: %s  ", yield->pattern);
 


@@ -4426,7 +5070,7 @@ if (test_retry_arg >= 0)
       printf("auth_failed  ");
     else printf("*  ");
 
       printf("auth_failed  ");
     else printf("*  ");
 

-    for (r = yield->rules; r != NULL; r = r->next)
+    for (retry_rule * r = yield->rules; r; r = r->next)

       {
       printf("%c,%s", r->rule, readconf_printtime(r->timeout)); /* Do not */
       printf(",%s", readconf_printtime(r->p1));                 /* amalgamate */
       {
       printf("%c,%s", r->rule, readconf_printtime(r->timeout)); /* Do not */
       printf(",%s", readconf_printtime(r->p1));                 /* amalgamate */


@@ -4457,24 +5101,39 @@ if (test_retry_arg >= 0)
 
 if (list_options)
   {
 
 if (list_options)
   {

+  BOOL fail = FALSE;

   set_process_info("listing variables");
   set_process_info("listing variables");

-  if (recipients_arg >= argc) readconf_print(US"all", NULL, flag_n);
-    else for (i = recipients_arg; i < argc; i++)
+  if (recipients_arg >= argc)
+    fail = !readconf_print(US"all", NULL, flag_n);
+  else for (i = recipients_arg; i < argc; i++)
+    {
+    if (i < argc - 1 &&
+       (Ustrcmp(argv[i], "router") == 0 ||
+        Ustrcmp(argv[i], "transport") == 0 ||
+        Ustrcmp(argv[i], "authenticator") == 0 ||
+        Ustrcmp(argv[i], "macro") == 0 ||
+        Ustrcmp(argv[i], "environment") == 0))

       {
       {

-      if (i < argc - 1 &&
-          (Ustrcmp(argv[i], "router") == 0 ||
-           Ustrcmp(argv[i], "transport") == 0 ||
-           Ustrcmp(argv[i], "authenticator") == 0 ||
-           Ustrcmp(argv[i], "macro") == 0))
-        {
-        readconf_print(argv[i+1], argv[i], flag_n);
-        i++;
-        }
-      else readconf_print(argv[i], NULL, flag_n);
+      fail |= !readconf_print(exim_str_fail_toolong(argv[i+1], EXIM_DRIVERNAME_MAX, "-bP name"), argv[i], flag_n);
+      i++;

       }
       }

-  exim_exit(EXIT_SUCCESS);
+    else
+      fail = !readconf_print(exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-bP item"), NULL, flag_n);
+    }
+  exim_exit(fail ? EXIT_FAILURE : EXIT_SUCCESS);

   }
 
   }
 

+if (list_config)
+  {
+  set_process_info("listing config");
+  exim_exit(readconf_print(US"config", NULL, flag_n)
+               ? EXIT_SUCCESS : EXIT_FAILURE);
+  }
+
+
+/* Initialise subsystems as required. */
+
+tcp_init();

 
 /* Handle a request to deliver one or more messages that are already on the
 queue. Values of msg_action other than MSG_DELIVER and MSG_LOAD are dealt with
 
 /* Handle a request to deliver one or more messages that are already on the
 queue. Values of msg_action other than MSG_DELIVER and MSG_LOAD are dealt with


@@ -4491,23 +5150,26 @@ message. */
 
 if (msg_action_arg > 0 && msg_action != MSG_LOAD)
   {
 
 if (msg_action_arg > 0 && msg_action != MSG_LOAD)
   {

-  if (prod_requires_admin && !admin_user)
+  if (prod_requires_admin && !f.admin_user)

     {
     fprintf(stderr, "exim: Permission denied\n");
     exim_exit(EXIT_FAILURE);
     }
   set_process_info("delivering specified messages");
     {
     fprintf(stderr, "exim: Permission denied\n");
     exim_exit(EXIT_FAILURE);
     }
   set_process_info("delivering specified messages");

-  if (deliver_give_up) forced_delivery = deliver_force_thaw = TRUE;
+  if (deliver_give_up) forced_delivery = f.deliver_force_thaw = TRUE;

   for (i = msg_action_arg; i < argc; i++)
     {
     int status;
     pid_t pid;
   for (i = msg_action_arg; i < argc; i++)
     {
     int status;
     pid_t pid;

+    /*XXX This use of argv[i] for msg_id should really be tainted, but doing
+    that runs into a later copy into the untainted global message_id[] */
+    /*XXX Do we need a length limit check here? */

     if (i == argc - 1)
       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
     if (i == argc - 1)
       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);

-    else if ((pid = fork()) == 0)
+    else if ((pid = exim_fork(US"cmdline-delivery")) == 0)

       {
       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
       {
       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);

-      _exit(EXIT_SUCCESS);
+      exim_underbar_exit(EXIT_SUCCESS);

       }
     else if (pid < 0)
       {
       }
     else if (pid < 0)
       {


@@ -4524,15 +5186,9 @@ if (msg_action_arg > 0 && msg_action != MSG_LOAD)
 /* If only a single queue run is requested, without SMTP listening, we can just
 turn into a queue runner, with an optional starting message id. */
 
 /* If only a single queue run is requested, without SMTP listening, we can just
 turn into a queue runner, with an optional starting message id. */
 

-if (queue_interval == 0 && !daemon_listen)
+if (is_onetime_qrun() && !f.daemon_listen)

   {
   {

-  DEBUG(D_queue_run) debug_printf("Single queue run%s%s%s%s\n",
-    (start_queue_run_id == NULL)? US"" : US" starting at ",
-    (start_queue_run_id == NULL)? US"" : start_queue_run_id,
-    (stop_queue_run_id == NULL)?  US"" : US" stopping at ",
-    (stop_queue_run_id == NULL)?  US"" : stop_queue_run_id);
-  set_process_info("running the queue (single queue run)");
-  queue_run(start_queue_run_id, stop_queue_run_id, FALSE);
+  single_queue_run(qrunners, start_queue_run_id, stop_queue_run_id);

   exim_exit(EXIT_SUCCESS);
   }
 
   exim_exit(EXIT_SUCCESS);
   }
 


@@ -4556,10 +5212,9 @@ for (i = 0;;)
     /* If user name has not been set by -F, set it from the passwd entry
     unless -f has been used to set the sender address by a trusted user. */
 
     /* If user name has not been set by -F, set it from the passwd entry
     unless -f has been used to set the sender address by a trusted user. */
 

-    if (originator_name == NULL)
+    if (!originator_name)

       {
       {

-      if (sender_address == NULL ||
-           (!trusted_caller && filter_test == FTEST_NONE))
+      if (!sender_address || (!f.trusted_caller && filter_test == FTEST_NONE))

         {
         uschar *name = US pw->pw_gecos;
         uschar *amp = Ustrchr(name, '&');
         {
         uschar *name = US pw->pw_gecos;
         uschar *amp = Ustrchr(name, '&');


@@ -4569,11 +5224,11 @@ for (i = 0;;)
         replaced by a copy of the login name, and some even specify that
         the first character should be upper cased, so that's what we do. */
 
         replaced by a copy of the login name, and some even specify that
         the first character should be upper cased, so that's what we do. */
 

-        if (amp != NULL)
+        if (amp)

           {
           int loffset;
           string_format(buffer, sizeof(buffer), "%.*s%n%s%s",
           {
           int loffset;
           string_format(buffer, sizeof(buffer), "%.*s%n%s%s",

-            amp - name, name, &loffset, originator_login, amp + 1);
+            (int)(amp - name), name, &loffset, originator_login, amp + 1);

           buffer[loffset] = toupper(buffer[loffset]);
           name = buffer;
           }
           buffer[loffset] = toupper(buffer[loffset]);
           name = buffer;
           }


@@ -4581,16 +5236,18 @@ for (i = 0;;)
         /* If a pattern for matching the gecos field was supplied, apply
         it and then expand the name string. */
 
         /* If a pattern for matching the gecos field was supplied, apply
         it and then expand the name string. */
 

-        if (gecos_pattern != NULL && gecos_name != NULL)
+       GET_OPTION("gecos_pattern");
+       GET_OPTION("gecos_name");
+        if (gecos_pattern && gecos_name)

           {
           {

-          const pcre *re;
-          re = regex_must_compile(gecos_pattern, FALSE, TRUE); /* Use malloc */
+          const pcre2_code *re;
+          re = regex_must_compile(gecos_pattern, MCS_NOFLAGS, TRUE); /* Use malloc */

 
           if (regex_match_and_setup(re, name, 0, -1))
             {
             uschar *new_name = expand_string(gecos_name);
             expand_nmax = -1;
 
           if (regex_match_and_setup(re, name, 0, -1))
             {
             uschar *new_name = expand_string(gecos_name);
             expand_nmax = -1;

-            if (new_name != NULL)
+            if (new_name)

               {
               DEBUG(D_receive) debug_printf("user name \"%s\" extracted from "
                 "gecos field \"%s\"\n", new_name, name);
               {
               DEBUG(D_receive) debug_printf("user name \"%s\" extracted from "
                 "gecos field \"%s\"\n", new_name, name);


@@ -4624,16 +5281,17 @@ for (i = 0;;)
 configuration specifies something to use. When running in the test harness,
 any setting of unknown_login overrides the actual name. */
 
 configuration specifies something to use. When running in the test harness,
 any setting of unknown_login overrides the actual name. */
 

-if (originator_login == NULL || running_in_test_harness)
+if (!originator_login || f.running_in_test_harness)

   {
   {

-  if (unknown_login != NULL)
+  GET_OPTION("unknown_login");
+  if (unknown_login)

     {
     originator_login = expand_string(unknown_login);
     {
     originator_login = expand_string(unknown_login);

-    if (originator_name == NULL && unknown_username != NULL)
+    if (!originator_name && unknown_username)

       originator_name = expand_string(unknown_username);
       originator_name = expand_string(unknown_username);

-    if (originator_name == NULL) originator_name = US"";
+    if (!originator_name) originator_name = US"";

     }
     }

-  if (originator_login == NULL)
+  if (!originator_login)

     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to get user name for uid %d",
       (int)real_uid);
   }
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to get user name for uid %d",
       (int)real_uid);
   }


@@ -4641,8 +5299,7 @@ if (originator_login == NULL || running_in_test_harness)
 /* Ensure that the user name is in a suitable form for use as a "phrase" in an
 RFC822 address.*/
 
 /* Ensure that the user name is in a suitable form for use as a "phrase" in an
 RFC822 address.*/
 

-originator_name = string_copy(parse_fix_phrase(originator_name,
-  Ustrlen(originator_name), big_buffer, big_buffer_size));
+originator_name = US parse_fix_phrase(originator_name, Ustrlen(originator_name));

 
 /* If a message is created by this call of Exim, the uid/gid of its originator
 are those of the caller. These values are overridden if an existing message is
 
 /* If a message is created by this call of Exim, the uid/gid of its originator
 are those of the caller. These values are overridden if an existing message is


@@ -4659,7 +5316,7 @@ returns. We leave this till here so that the originator_ fields are available
 for incoming messages via the daemon. The daemon cannot be run in mua_wrapper
 mode. */
 
 for incoming messages via the daemon. The daemon cannot be run in mua_wrapper
 mode. */
 

-if (daemon_listen || inetd_wait_mode || queue_interval > 0)
+if (f.daemon_listen || f.inetd_wait_mode || is_multiple_qrun())

   {
   if (mua_wrapper)
     {
   {
   if (mua_wrapper)
     {


@@ -4667,15 +5324,33 @@ if (daemon_listen || inetd_wait_mode || queue_interval > 0)
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Daemon cannot be run when "
       "mua_wrapper is set");
     }
     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Daemon cannot be run when "
       "mua_wrapper is set");
     }

+
+# ifndef DISABLE_TLS
+  /* This also checks that the library linkage is working and we can call
+  routines in it, so call even if tls_require_ciphers is unset */
+    {
+# ifdef MEASURE_TIMING
+    struct timeval t0;
+    (void)gettimeofday(&t0, NULL);
+# endif
+    if (!tls_dropprivs_validate_require_cipher(FALSE))
+      exim_exit(EXIT_FAILURE);
+# ifdef MEASURE_TIMING
+    report_time_since(&t0, US"validate_ciphers (delta)");
+# endif
+    }
+#endif
+

   daemon_go();
   daemon_go();

+  /*NOTREACHED*/

   }
 
 /* If the sender ident has not been set (by a trusted caller) set it to
 the caller. This will get overwritten below for an inetd call. If a trusted
 caller has set it empty, unset it. */
 
   }
 
 /* If the sender ident has not been set (by a trusted caller) set it to
 the caller. This will get overwritten below for an inetd call. If a trusted
 caller has set it empty, unset it. */
 

-if (sender_ident == NULL) sender_ident = originator_login;
-  else if (sender_ident[0] == 0) sender_ident = NULL;
+if (!sender_ident) sender_ident = originator_login;
+else if (!*sender_ident) sender_ident = NULL;

 
 /* Handle the -brw option, which is for checking out rewriting rules. Cause log
 writes (on errors) to go to stderr instead. Can't do this earlier, as want the
 
 /* Handle the -brw option, which is for checking out rewriting rules. Cause log
 writes (on errors) to go to stderr instead. Can't do this earlier, as want the


@@ -4683,13 +5358,13 @@ originator_* variables set. */
 
 if (test_rewrite_arg >= 0)
   {
 
 if (test_rewrite_arg >= 0)
   {

-  really_exim = FALSE;
+  f.really_exim = FALSE;

   if (test_rewrite_arg >= argc)
     {
     printf("-brw needs an address argument\n");
     exim_exit(EXIT_FAILURE);
     }
   if (test_rewrite_arg >= argc)
     {
     printf("-brw needs an address argument\n");
     exim_exit(EXIT_FAILURE);
     }

-  rewrite_test(argv[test_rewrite_arg]);
+  rewrite_test(exim_str_fail_toolong(argv[test_rewrite_arg], EXIM_EMAILADDR_MAX, "-brw"));

   exim_exit(EXIT_SUCCESS);
   }
 
   exim_exit(EXIT_SUCCESS);
   }
 


@@ -4697,19 +5372,19 @@ if (test_rewrite_arg >= 0)
 unless a trusted caller supplies a sender address with -f, or is passing in the
 message via SMTP (inetd invocation or otherwise). */
 
 unless a trusted caller supplies a sender address with -f, or is passing in the
 message via SMTP (inetd invocation or otherwise). */
 

-if ((sender_address == NULL && !smtp_input) ||
-    (!trusted_caller && filter_test == FTEST_NONE))
+if (  !sender_address && !smtp_input
+   || !f.trusted_caller && filter_test == FTEST_NONE)

   {
   {

-  sender_local = TRUE;
+  f.sender_local = TRUE;

 
   /* A trusted caller can supply authenticated_sender and authenticated_id
   via -oMas and -oMai and if so, they will already be set. Otherwise, force
   defaults except when host checking. */
 
 
   /* A trusted caller can supply authenticated_sender and authenticated_id
   via -oMas and -oMai and if so, they will already be set. Otherwise, force
   defaults except when host checking. */
 

-  if (authenticated_sender == NULL && !host_checking)
+  if (!authenticated_sender && !host_checking)

     authenticated_sender = string_sprintf("%s@%s", originator_login,
       qualify_domain_sender);
     authenticated_sender = string_sprintf("%s@%s", originator_login,
       qualify_domain_sender);

-  if (authenticated_id == NULL && !host_checking)
+  if (!authenticated_id && !host_checking)

     authenticated_id = originator_login;
   }
 
     authenticated_id = originator_login;
   }
 


@@ -4719,36 +5394,34 @@ is specified is the empty address. However, if a trusted caller does not
 specify a sender address for SMTP input, we leave sender_address unset. This
 causes the MAIL commands to be honoured. */
 
 specify a sender address for SMTP input, we leave sender_address unset. This
 causes the MAIL commands to be honoured. */
 

-if ((!smtp_input && sender_address == NULL) ||
-    !receive_check_set_sender(sender_address))
+if (  !smtp_input && !sender_address
+   || !receive_check_set_sender(sender_address))

   {
   /* Either the caller is not permitted to set a general sender, or this is
   non-SMTP input and the trusted caller has not set a sender. If there is no
   sender, or if a sender other than <> is set, override with the originator's
   login (which will get qualified below), except when checking things. */
 
   {
   /* Either the caller is not permitted to set a general sender, or this is
   non-SMTP input and the trusted caller has not set a sender. If there is no
   sender, or if a sender other than <> is set, override with the originator's
   login (which will get qualified below), except when checking things. */
 

-  if (sender_address == NULL             /* No sender_address set */
-       ||                                /*         OR            */
+  if (  !sender_address                  /* No sender_address set */
+     ||                                  /*         OR            */

        (sender_address[0] != 0 &&        /* Non-empty sender address, AND */
        (sender_address[0] != 0 &&        /* Non-empty sender address, AND */

-       !checking &&                      /* Not running tests, AND */
-       filter_test == FTEST_NONE))       /* Not testing a filter */
+       !checking))                       /* Not running tests, including filter tests */

     {
     sender_address = originator_login;
     {
     sender_address = originator_login;

-    sender_address_forced = FALSE;
+    f.sender_address_forced = FALSE;

     sender_address_domain = 0;
     }
   }
 
 /* Remember whether an untrusted caller set the sender address */
 
     sender_address_domain = 0;
     }
   }
 
 /* Remember whether an untrusted caller set the sender address */
 

-sender_set_untrusted = sender_address != originator_login && !trusted_caller;
+f.sender_set_untrusted = sender_address != originator_login && !f.trusted_caller;

 
 /* Ensure that the sender address is fully qualified unless it is the empty
 address, which indicates an error message, or doesn't exist (root caller, smtp
 interface, no -f argument). */
 
 
 /* Ensure that the sender address is fully qualified unless it is the empty
 address, which indicates an error message, or doesn't exist (root caller, smtp
 interface, no -f argument). */
 

-if (sender_address != NULL && sender_address[0] != 0 &&
-    sender_address_domain == 0)
+if (sender_address && *sender_address && sender_address_domain == 0)

   sender_address = string_sprintf("%s@%s", local_part_quote(sender_address),
     qualify_domain_sender);
 
   sender_address = string_sprintf("%s@%s", local_part_quote(sender_address),
     qualify_domain_sender);
 


@@ -4760,7 +5433,7 @@ predicated upon the sender. If no arguments are given, read addresses from
 stdin. Set debug_level to at least D_v to get full output for address testing.
 */
 
 stdin. Set debug_level to at least D_v to get full output for address testing.
 */
 

-if (verify_address_mode || address_test_mode)
+if (verify_address_mode || f.address_test_mode)

   {
   int exit_value = 0;
   int flags = vopt_qualify;
   {
   int exit_value = 0;
   int flags = vopt_qualify;


@@ -4781,11 +5454,13 @@ if (verify_address_mode || address_test_mode)
     }
 
   if (recipients_arg < argc)
     }
 
   if (recipients_arg < argc)

-    {

     while (recipients_arg < argc)
       {
     while (recipients_arg < argc)
       {

-      uschar *s = argv[recipients_arg++];
-      while (*s != 0)
+      /* Supplied addresses are tainted since they come from a user */
+      uschar * s = string_copy_taint(
+       exim_str_fail_toolong(argv[recipients_arg++], EXIM_DISPLAYMAIL_MAX, "address verification"),
+       GET_TAINTED);
+      while (*s)

         {
         BOOL finished = FALSE;
         uschar *ss = parse_find_address_end(s, FALSE);
         {
         BOOL finished = FALSE;
         uschar *ss = parse_find_address_end(s, FALSE);


@@ -4793,16 +5468,18 @@ if (verify_address_mode || address_test_mode)
         test_address(s, flags, &exit_value);
         s = ss;
         if (!finished)
         test_address(s, flags, &exit_value);
         s = ss;
         if (!finished)

-          while (*(++s) != 0 && (*s == ',' || isspace(*s)));
+          while (*++s == ',' || isspace(*s)) ;

         }
       }
         }
       }

-    }

 
   else for (;;)
     {
 
   else for (;;)
     {

-    uschar *s = get_stdinput(NULL, NULL);
-    if (s == NULL) break;
-    test_address(s, flags, &exit_value);
+    uschar * s = get_stdinput(NULL, NULL);
+    if (!s) break;
+    test_address(string_copy_taint(
+       exim_str_fail_toolong(s, EXIM_DISPLAYMAIL_MAX, "address verification (stdin)"),
+       GET_TAINTED),
+      flags, &exit_value);

     }
 
   route_tidyup();
     }
 
   route_tidyup();


@@ -4816,17 +5493,19 @@ Otherwise, if -bem was used, read a message from stdin. */
 
 if (expansion_test)
   {
 
 if (expansion_test)
   {

+  dns_init(FALSE, FALSE, FALSE);

   if (msg_action_arg > 0 && msg_action == MSG_LOAD)
     {
   if (msg_action_arg > 0 && msg_action == MSG_LOAD)
     {

-    uschar spoolname[256];  /* Not big_buffer; used in spool_read_header() */
-    if (!admin_user)
-      {
-      fprintf(stderr, "exim: permission denied\n");
-      exit(EXIT_FAILURE);
-      }
-    message_id = argv[msg_action_arg];
-    (void)string_format(spoolname, sizeof(spoolname), "%s-H", message_id);
-    if (!spool_open_datafile(message_id))
+    uschar * spoolname;
+    if (!f.admin_user)
+      exim_fail("exim: permission denied\n");
+    message_id = US exim_str_fail_toolong(argv[msg_action_arg], MESSAGE_ID_LENGTH, "message-id");
+    /* Checking the length of the ID is sufficient to validate it.
+    Get an untainted version so file opens can be done. */
+    message_id = string_copy_taint(message_id, GET_UNTAINTED);
+
+    spoolname = string_sprintf("%s-H", message_id);
+    if ((deliver_datafile = spool_open_datafile(message_id)) < 0)

       printf ("Failed to load message datafile %s\n", message_id);
     if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
       printf ("Failed to load message %s\n", message_id);
       printf ("Failed to load message datafile %s\n", message_id);
     if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
       printf ("Failed to load message %s\n", message_id);


@@ -4835,19 +5514,18 @@ if (expansion_test)
   /* Read a test message from a file. We fudge it up to be on stdin, saving
   stdin itself for later reading of expansion strings. */
 
   /* Read a test message from a file. We fudge it up to be on stdin, saving
   stdin itself for later reading of expansion strings. */
 

-  else if (expansion_test_message != NULL)
+  else if (expansion_test_message)

     {
     {

+    uschar * rme = expand_string(recipients_max);

     int save_stdin = dup(0);
     int fd = Uopen(expansion_test_message, O_RDONLY, 0);
     if (fd < 0)
     int save_stdin = dup(0);
     int fd = Uopen(expansion_test_message, O_RDONLY, 0);
     if (fd < 0)

-      {
-      fprintf(stderr, "exim: failed to open %s: %s\n", expansion_test_message,
+      exim_fail("exim: failed to open %s: %s\n", expansion_test_message,

         strerror(errno));
         strerror(errno));

-      return EXIT_FAILURE;
-      }

     (void) dup2(fd, 0);
     filter_test = FTEST_USER;      /* Fudge to make it look like filter test */
     message_ended = END_NOTENDED;
     (void) dup2(fd, 0);
     filter_test = FTEST_USER;      /* Fudge to make it look like filter test */
     message_ended = END_NOTENDED;

+    recipients_max_expanded = atoi(CCS rme);

     read_message_body(receive_msg(extract_recipients));
     message_linecount += body_linecount;
     (void)dup2(save_stdin, 0);
     read_message_body(receive_msg(extract_recipients));
     message_linecount += body_linecount;
     (void)dup2(save_stdin, 0);


@@ -4855,21 +5533,22 @@ if (expansion_test)
     clearerr(stdin);               /* Required by Darwin */
     }
 
     clearerr(stdin);               /* Required by Darwin */
     }
 

+  /* Only admin users may see config-file macros this way */
+
+  if (!f.admin_user) macros_user = macros = mlast = NULL;
+

   /* Allow $recipients for this testing */
 
   /* Allow $recipients for this testing */
 

-  enable_dollar_recipients = TRUE;
+  f.enable_dollar_recipients = TRUE;

 
   /* Expand command line items */
 
   if (recipients_arg < argc)
     {
 
   /* Expand command line items */
 
   if (recipients_arg < argc)
     {

-    while (recipients_arg < argc)
-      {
-      uschar *s = argv[recipients_arg++];
-      uschar *ss = expand_string(s);
-      if (ss == NULL) printf ("Failed: %s\n", expand_string_message);
-      else printf("%s\n", CS ss);
-      }
+    config_filename = US"-be args";
+    for (config_lineno = 1; recipients_arg < argc; config_lineno++)
+      expansion_test_line(exim_str_fail_toolong(argv[recipients_arg++],
+                                             EXIM_EMAILADDR_MAX, "-be arg"));

     }
 
   /* Read stdin */
     }
 
   /* Read stdin */


@@ -4878,25 +5557,20 @@ if (expansion_test)
     {
     char *(*fn_readline)(const char *) = NULL;
     void (*fn_addhist)(const char *) = NULL;
     {
     char *(*fn_readline)(const char *) = NULL;
     void (*fn_addhist)(const char *) = NULL;

+    uschar * s;

 
 

-    #ifdef USE_READLINE
+#ifdef USE_READLINE

     void *dlhandle = set_readline(&fn_readline, &fn_addhist);
     void *dlhandle = set_readline(&fn_readline, &fn_addhist);

-    #endif
+#endif

 
 

-    for (;;)
-      {
-      uschar *ss;
-      uschar *source = get_stdinput(fn_readline, fn_addhist);
-      if (source == NULL) break;
-      ss = expand_string(source);
-      if (ss == NULL)
-        printf ("Failed: %s\n", expand_string_message);
-      else printf("%s\n", CS ss);
-      }
+    config_filename = US"-be stdin";
+    for (config_lineno = 1; s = get_stdinput(fn_readline, fn_addhist);
+       config_lineno++)
+      expansion_test_line(s);

 
 

-    #ifdef USE_READLINE
-    if (dlhandle != NULL) dlclose(dlhandle);
-    #endif
+#ifdef USE_READLINE
+    if (dlhandle) dlclose(dlhandle);
+#endif

     }
 
   /* The data file will be open after -Mset */
     }
 
   /* The data file will be open after -Mset */


@@ -4916,17 +5590,18 @@ for hosts that want to play several parts at once. We need to ensure that it is
 set for host checking, and for receiving messages. */
 
 smtp_active_hostname = primary_hostname;
 set for host checking, and for receiving messages. */
 
 smtp_active_hostname = primary_hostname;

-if (raw_active_hostname != NULL)
+GET_OPTION("smtp_active_hostname");
+if (raw_active_hostname)

   {
   {

-  uschar *nah = expand_string(raw_active_hostname);
-  if (nah == NULL)
+  uschar * nah = expand_string(raw_active_hostname);
+  if (!nah)

     {
     {

-    if (!expand_string_forcedfail)
+    if (!f.expand_string_forcedfail)

       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand \"%s\" "
         "(smtp_active_hostname): %s", raw_active_hostname,
         expand_string_message);
     }
       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand \"%s\" "
         "(smtp_active_hostname): %s", raw_active_hostname,
         expand_string_message);
     }

-  else if (nah[0] != 0) smtp_active_hostname = nah;
+  else if (nah[0]) smtp_active_hostname = nah;

   }
 
 /* Handle host checking: this facility mocks up an incoming SMTP call from a
   }
 
 /* Handle host checking: this facility mocks up an incoming SMTP call from a


@@ -4944,17 +5619,20 @@ if (host_checking)
   if (!sender_ident_set)
     {
     sender_ident = NULL;
   if (!sender_ident_set)
     {
     sender_ident = NULL;

-    if (running_in_test_harness && sender_host_port != 0 &&
-        interface_address != NULL && interface_port != 0)
-      verify_get_ident(1413);
+    if (f.running_in_test_harness && sender_host_port
+       && interface_address && interface_port)
+      verify_get_ident(1223);          /* note hardwired port number */

     }
 
     }
 

-  /* In case the given address is a non-canonical IPv6 address, canonicize
-  it. The code works for both IPv4 and IPv6, as it happens. */
+  /* In case the given address is a non-canonical IPv6 address, canonicalize
+  it. Use the compressed form for IPv6. */

 
   size = host_aton(sender_host_address, x);
 
   size = host_aton(sender_host_address, x);

-  sender_host_address = store_get(48);  /* large enough for full IPv6 */
-  (void)host_nmtoa(size, x, -1, sender_host_address, ':');
+  sender_host_address = store_get(48, GET_UNTAINTED);  /* large enough for full IPv6 */
+  if (size == 1)
+    (void) host_nmtoa(size, x, -1, sender_host_address, ':');
+  else
+    (void) ipv6_nmtoa(x, sender_host_address);

 
   /* Now set up for testing */
 
 
   /* Now set up for testing */
 


@@ -4962,8 +5640,8 @@ if (host_checking)
   smtp_input = TRUE;
   smtp_in = stdin;
   smtp_out = stdout;
   smtp_input = TRUE;
   smtp_in = stdin;
   smtp_out = stdout;

-  sender_local = FALSE;
-  sender_host_notsocket = TRUE;
+  f.sender_local = FALSE;
+  f.sender_host_notsocket = TRUE;

   debug_file = stderr;
   debug_fd = fileno(debug_file);
   fprintf(stdout, "\n**** SMTP testing session as if from host %s\n"
   debug_file = stderr;
   debug_fd = fileno(debug_file);
   fprintf(stdout, "\n**** SMTP testing session as if from host %s\n"


@@ -4971,8 +5649,13 @@ if (host_checking)
     "**** This is not for real!\n\n",
       sender_host_address);
 
     "**** This is not for real!\n\n",
       sender_host_address);
 

+  set_connection_id();
+  memset(sender_host_cache, 0, sizeof(sender_host_cache));

   if (verify_check_host(&hosts_connection_nolog) == OK)
   if (verify_check_host(&hosts_connection_nolog) == OK)

-    log_write_selector &= ~L_smtp_connection;
+    {
+    BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
+    BIT_CLEAR(log_selector, log_selector_size, Li_smtp_no_mail);
+    }

   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
 
   /* NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,
   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
 
   /* NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,


@@ -4982,12 +5665,21 @@ if (host_checking)
 
   if (smtp_start_session())
     {
 
   if (smtp_start_session())
     {

-    reset_point = store_get(0);
-    for (;;)
+    rmark reset_point;
+    for (; (reset_point = store_mark()); store_reset(reset_point))

       {
       {

-      store_reset(reset_point);

       if (smtp_setup_msg() <= 0) break;
       if (!receive_msg(FALSE)) break;
       if (smtp_setup_msg() <= 0) break;
       if (!receive_msg(FALSE)) break;

+
+      return_path = sender_address = NULL;
+      dnslist_domain = dnslist_matched = NULL;
+      acl_var_m = NULL;
+      deliver_localpart_orig = NULL;
+      deliver_domain_orig = NULL;
+      callout_address = sending_ip_address = NULL;
+      deliver_localpart_data = deliver_domain_data =
+      recipient_data = sender_data = NULL;
+      sender_rate = sender_rate_limit = sender_rate_period = NULL;

       }
     smtp_log_no_mail();
     }
       }
     smtp_log_no_mail();
     }


@@ -5000,10 +5692,13 @@ otherwise complain unless a version print (-bV) happened or this is a filter
 verification test or info dump.
 In the former case, show the configuration file name. */
 
 verification test or info dump.
 In the former case, show the configuration file name. */
 

-if (recipients_arg >= argc && !extract_recipients && !smtp_input)
+if (  recipients_arg >= argc && !extract_recipients
+   && !smtp_input && !atrn_mode)

   {
   if (version_printed)
     {
   {
   if (version_printed)
     {

+    if (Ustrchr(config_main_filelist, ':'))
+      printf("Configuration file search path is %s\n", config_main_filelist);

     printf("Configuration file is %s\n", config_main_filename);
     return EXIT_SUCCESS;
     }
     printf("Configuration file is %s\n", config_main_filename);
     return EXIT_SUCCESS;
     }


@@ -5018,6 +5713,10 @@ if (recipients_arg >= argc && !extract_recipients && !smtp_input)
     exim_usage(called_as);
   }
 
     exim_usage(called_as);
   }
 

+/*XXX somewhere around here.  Maybe earlier, but no later.  ATRN customer */
+if (atrn_mode)
+  atrn_handle_customer();
+

 
 /* If mua_wrapper is set, Exim is being used to turn an MUA that submits on the
 standard input into an MUA that submits to a smarthost over TCP/IP. We know
 
 /* If mua_wrapper is set, Exim is being used to turn an MUA that submits on the
 standard input into an MUA that submits to a smarthost over TCP/IP. We know


@@ -5035,12 +5734,15 @@ to override any SMTP queueing. */
 
 if (mua_wrapper)
   {
 
 if (mua_wrapper)
   {

-  synchronous_delivery = TRUE;
+  f.synchronous_delivery = TRUE;

   arg_error_handling = ERRORS_STDERR;
   remote_max_parallel = 1;
   deliver_drop_privilege = TRUE;
   arg_error_handling = ERRORS_STDERR;
   remote_max_parallel = 1;
   deliver_drop_privilege = TRUE;

-  queue_smtp = FALSE;
+  f.queue_smtp = FALSE;

   queue_smtp_domains = NULL;
   queue_smtp_domains = NULL;

+#ifdef SUPPORT_I18N
+  message_utf8_downconvert = -1;       /* convert-if-needed */
+#endif

   }
 
 
   }
 
 


@@ -5059,7 +5761,7 @@ if (!smtp_input) error_handling = arg_error_handling;
 logging being sent down the socket and make an identd call to get the
 sender_ident. */
 
 logging being sent down the socket and make an identd call to get the
 sender_ident. */
 

-else if (is_inetd)
+else if (f.is_inetd && !atrn_mode)

   {
   (void)fclose(stderr);
   exim_nullstd();                       /* Re-open to /dev/null */
   {
   (void)fclose(stderr);
   exim_nullstd();                       /* Re-open to /dev/null */


@@ -5074,18 +5776,18 @@ already been done (which it will have been for inetd). This caters for the
 case when it is forced by -oMa. However, we must flag that it isn't a socket,
 so that the test for IP options is skipped for -bs input. */
 
 case when it is forced by -oMa. However, we must flag that it isn't a socket,
 so that the test for IP options is skipped for -bs input. */
 

-if (sender_host_address != NULL && sender_fullhost == NULL)
+if (sender_host_address && !sender_fullhost)

   {
   host_build_sender_fullhost();
   set_process_info("handling incoming connection from %s via -oMa",
     sender_fullhost);
   {
   host_build_sender_fullhost();
   set_process_info("handling incoming connection from %s via -oMa",
     sender_fullhost);

-  sender_host_notsocket = TRUE;
+  f.sender_host_notsocket = TRUE;

   }
 
 /* Otherwise, set the sender host as unknown except for inetd calls. This
 prevents host checking in the case of -bs not from inetd and also for -bS. */
 
   }
 
 /* Otherwise, set the sender host as unknown except for inetd calls. This
 prevents host checking in the case of -bs not from inetd and also for -bS. */
 

-else if (!is_inetd) sender_host_unknown = TRUE;
+else if (!f.is_inetd) f.sender_host_unknown = TRUE;

 
 /* If stdout does not exist, then dup stdin to stdout. This can happen
 if exim is started from inetd. In this case fd 0 will be set to the socket,
 
 /* If stdout does not exist, then dup stdin to stdout. This can happen
 if exim is started from inetd. In this case fd 0 will be set to the socket,


@@ -5101,14 +5803,17 @@ batch/HELO/EHLO/AUTH/TLS. */
 
 if (smtp_input)
   {
 
 if (smtp_input)
   {

-  if (!is_inetd) set_process_info("accepting a local %sSMTP message from <%s>",
+  if (!f.is_inetd) set_process_info("accepting a local %sSMTP message from <%s>",

     smtp_batched_input? "batched " : "",
     smtp_batched_input? "batched " : "",

-    (sender_address!= NULL)? sender_address : originator_login);
+    sender_address ? sender_address : originator_login);

   }
 else
   {
   }
 else
   {

-  if (received_protocol == NULL)
+  int old_pool = store_pool;
+  store_pool = POOL_PERM;
+  if (!received_protocol)

     received_protocol = string_sprintf("local%s", called_as);
     received_protocol = string_sprintf("local%s", called_as);

+  store_pool = old_pool;

   set_process_info("accepting a local non-SMTP message from <%s>",
     sender_address);
   }
   set_process_info("accepting a local non-SMTP message from <%s>",
     sender_address);
   }


@@ -5125,10 +5830,7 @@ message! (For interactive SMTP, the check happens at MAIL FROM and an SMTP
 error code is given.) */
 
 if ((!smtp_input || smtp_batched_input) && !receive_check_fs(0))
 error code is given.) */
 
 if ((!smtp_input || smtp_batched_input) && !receive_check_fs(0))

-  {
-  fprintf(stderr, "exim: insufficient disk space\n");
-  return EXIT_FAILURE;
-  }
+  exim_fail("exim: insufficient disk space\n");

 
 /* If this is smtp input of any kind, real or batched, handle the start of the
 SMTP session.
 
 /* If this is smtp input of any kind, real or batched, handle the start of the
 SMTP session.


@@ -5138,12 +5840,18 @@ because a log line has already been written for all its failure exists
 (usually "connection refused: <reason>") and writing another one is
 unnecessary clutter. */
 
 (usually "connection refused: <reason>") and writing another one is
 unnecessary clutter. */
 

+set_connection_id();

 if (smtp_input)
   {
   smtp_in = stdin;
   smtp_out = stdout;
 if (smtp_input)
   {
   smtp_in = stdin;
   smtp_out = stdout;

+
+  memset(sender_host_cache, 0, sizeof(sender_host_cache));

   if (verify_check_host(&hosts_connection_nolog) == OK)
   if (verify_check_host(&hosts_connection_nolog) == OK)

-    log_write_selector &= ~L_smtp_connection;
+    {
+    BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
+    BIT_CLEAR(log_selector, log_selector_size, Li_smtp_no_mail);
+    }

   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
   if (!smtp_start_session())
     {
   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
   if (!smtp_start_session())
     {


@@ -5152,20 +5860,22 @@ if (smtp_input)
     }
   }
 
     }
   }
 

-/* Otherwise, set up the input size limit here. */
+/* Otherwise, set up the input size limit here and set no stdin stdio buffer
+(we handle buferring so as to have visibility of fill level). */

 
 else
   {
 
 else
   {

+  GET_OPTION("message_size_limit");

   thismessage_size_limit = expand_string_integer(message_size_limit, TRUE);
   thismessage_size_limit = expand_string_integer(message_size_limit, TRUE);

-  if (expand_string_message != NULL)
-    {
+  if (expand_string_message)

     if (thismessage_size_limit == -1)
       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand "
         "message_size_limit: %s", expand_string_message);
     else
       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "invalid value for "
         "message_size_limit: %s", expand_string_message);
     if (thismessage_size_limit == -1)
       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand "
         "message_size_limit: %s", expand_string_message);
     else
       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "invalid value for "
         "message_size_limit: %s", expand_string_message);

-    }
+
+  setvbuf(stdin, NULL, _IONBF, 0);

   }
 
 /* Loop for several messages when reading SMTP input. If we fork any child
   }
 
 /* Loop for several messages when reading SMTP input. If we fork any child


@@ -5193,38 +5903,37 @@ February 2003: That's *still* not the end of the story. There are now versions
 of Linux (where SIG_IGN does work) that are picky. If, having set SIG_IGN, a
 process then calls waitpid(), a grumble is written to the system log, because
 this is logically inconsistent. In other words, it doesn't like the paranoia.
 of Linux (where SIG_IGN does work) that are picky. If, having set SIG_IGN, a
 process then calls waitpid(), a grumble is written to the system log, because
 this is logically inconsistent. In other words, it doesn't like the paranoia.

-As a consequenc of this, the waitpid() below is now excluded if we are sure
+As a consequence of this, the waitpid() below is now excluded if we are sure

 that SIG_IGN works. */
 
 that SIG_IGN works. */
 

-if (!synchronous_delivery)
+if (!f.synchronous_delivery)

   {
   {

-  #ifdef SA_NOCLDWAIT
+#ifdef SA_NOCLDWAIT

   struct sigaction act;
   act.sa_handler = SIG_IGN;
   sigemptyset(&(act.sa_mask));
   act.sa_flags = SA_NOCLDWAIT;
   sigaction(SIGCHLD, &act, NULL);
   struct sigaction act;
   act.sa_handler = SIG_IGN;
   sigemptyset(&(act.sa_mask));
   act.sa_flags = SA_NOCLDWAIT;
   sigaction(SIGCHLD, &act, NULL);

-  #else
+#else

   signal(SIGCHLD, SIG_IGN);
   signal(SIGCHLD, SIG_IGN);

-  #endif
+#endif

   }
 
 /* Save the current store pool point, for resetting at the start of
 each message, and save the real sender address, if any. */
 
   }
 
 /* Save the current store pool point, for resetting at the start of
 each message, and save the real sender address, if any. */
 

-reset_point = store_get(0);

 real_sender_address = sender_address;
 
 /* Loop to receive messages; receive_msg() returns TRUE if there are more
 messages to be read (SMTP input), or FALSE otherwise (not SMTP, or SMTP channel
 collapsed). */
 
 real_sender_address = sender_address;
 
 /* Loop to receive messages; receive_msg() returns TRUE if there are more
 messages to be read (SMTP input), or FALSE otherwise (not SMTP, or SMTP channel
 collapsed). */
 

-while (more)
+for (BOOL more = TRUE; more; )

   {
   {

-  store_reset(reset_point);
+  rmark reset_point = store_mark();

   message_id[0] = 0;
 
   message_id[0] = 0;
 

-  /* Handle the SMTP case; call smtp_setup_mst() to deal with the initial SMTP
+  /* Handle the SMTP case; call smtp_setup_msg() to deal with the initial SMTP

   input and build the recipients list, before calling receive_msg() to read the
   message proper. Whatever sender address is given in the SMTP transaction is
   often ignored for local senders - we use the actual sender, which is normally
   input and build the recipients list, before calling receive_msg() to read the
   message proper. Whatever sender address is given in the SMTP transaction is
   often ignored for local senders - we use the actual sender, which is normally


@@ -5237,8 +5946,8 @@ while (more)
     int rc;
     if ((rc = smtp_setup_msg()) > 0)
       {
     int rc;
     if ((rc = smtp_setup_msg()) > 0)
       {

-      if (real_sender_address != NULL &&
-          !receive_check_set_sender(sender_address))
+      if (   real_sender_address
+         && !receive_check_set_sender(sender_address))

         {
         sender_address = raw_sender = real_sender_address;
         sender_address_unrewritten = NULL;
         {
         sender_address = raw_sender = real_sender_address;
         sender_address_unrewritten = NULL;


@@ -5249,29 +5958,35 @@ while (more)
       the very end. The result of the ACL is ignored (as for other non-SMTP
       messages). It is run for its potential side effects. */
 
       the very end. The result of the ACL is ignored (as for other non-SMTP
       messages). It is run for its potential side effects. */
 

-      if (smtp_batched_input && acl_not_smtp_start != NULL)
-        {
-        uschar *user_msg, *log_msg;
-        enable_dollar_recipients = TRUE;
-        (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
-          &user_msg, &log_msg);
-        enable_dollar_recipients = FALSE;
-        }
+      if (smtp_batched_input)
+       {
+       GET_OPTION("acl_not_smtp_start");
+       if (acl_not_smtp_start)
+         {
+         uschar * user_msg, * log_msg;
+         f.enable_dollar_recipients = TRUE;
+         (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
+           &user_msg, &log_msg);
+         f.enable_dollar_recipients = FALSE;
+         }
+       }

 
       /* Now get the data for the message */
 
       more = receive_msg(extract_recipients);
 
       /* Now get the data for the message */
 
       more = receive_msg(extract_recipients);

-      if (message_id[0] == 0)
+      if (!message_id[0])

         {
         {

-        if (more) continue;
+       cancel_cutthrough_connection(TRUE, US"receive dropped");
+        if (more) goto MORELOOP;

         smtp_log_no_mail();               /* Log no mail if configured */
         exim_exit(EXIT_FAILURE);
         }
       }
     else
       {
         smtp_log_no_mail();               /* Log no mail if configured */
         exim_exit(EXIT_FAILURE);
         }
       }
     else
       {

+      cancel_cutthrough_connection(TRUE, US"message setup dropped");

       smtp_log_no_mail();               /* Log no mail if configured */
       smtp_log_no_mail();               /* Log no mail if configured */

-      exim_exit((rc == 0)? EXIT_SUCCESS : EXIT_FAILURE);
+      exim_exit(rc ? EXIT_FAILURE : EXIT_SUCCESS);

       }
     }
 
       }
     }
 


@@ -5283,67 +5998,89 @@ while (more)
 
   else
     {
 
   else
     {

-    int i;
-    int rcount = 0;
-    int count = argc - recipients_arg;
-    uschar **list = argv + recipients_arg;
+    uschar * rme = expand_string(recipients_max);
+    int rcount = 0, count = argc - recipients_arg;
+    const uschar ** list = argv + recipients_arg;
+
+    recipients_max_expanded = atoi(CCS rme);

 
     /* These options cannot be changed dynamically for non-SMTP messages */
 
 
     /* These options cannot be changed dynamically for non-SMTP messages */
 

-    active_local_sender_retain = local_sender_retain;
-    active_local_from_check = local_from_check;
+    f.active_local_sender_retain = local_sender_retain;
+    f.active_local_from_check = local_from_check;

 
     /* Save before any rewriting */
 
     raw_sender = string_copy(sender_address);
 
 
     /* Save before any rewriting */
 
     raw_sender = string_copy(sender_address);
 

-    /* Loop for each argument */
+    /* Loop for each argument (supplied by user hence tainted) */

 
 

-    for (i = 0; i < count; i++)
+    for (int i = 0; i < count; i++)

       {
       int start, end, domain;
       {
       int start, end, domain;

-      uschar *errmess;
-      uschar *s = list[i];
+      uschar * errmess;
+      /* There can be multiple addresses, so EXIM_DISPLAYMAIL_MAX (tuned for 1) is too short.
+      We'll still want to cap it to something, just in case. */
+      uschar * s = string_copy_taint(
+       exim_str_fail_toolong(list[i], BIG_BUFFER_SIZE, "address argument"),
+       GET_TAINTED);

 
       /* Loop for each comma-separated address */
 
 
       /* Loop for each comma-separated address */
 

-      while (*s != 0)
+      while (*s)

         {
         BOOL finished = FALSE;
         {
         BOOL finished = FALSE;

-        uschar *recipient;
-        uschar *ss = parse_find_address_end(s, FALSE);
+        uschar * recipient;
+        uschar * ss = parse_find_address_end(s, FALSE);

 
         if (*ss == ',') *ss = 0; else finished = TRUE;
 
         /* Check max recipients - if -t was used, these aren't recipients */
 
 
         if (*ss == ',') *ss = 0; else finished = TRUE;
 
         /* Check max recipients - if -t was used, these aren't recipients */
 

-        if (recipients_max > 0 && ++rcount > recipients_max &&
-            !extract_recipients)
-          {
+        if (  recipients_max_expanded > 0 && ++rcount > recipients_max_expanded
+          && !extract_recipients)
+         {
+         DEBUG(D_all) debug_printf("excess reipients (max %d)\n",
+           recipients_max_expanded);
+

           if (error_handling == ERRORS_STDERR)
             {
             fprintf(stderr, "exim: too many recipients\n");
             exim_exit(EXIT_FAILURE);
             }
           else
           if (error_handling == ERRORS_STDERR)
             {
             fprintf(stderr, "exim: too many recipients\n");
             exim_exit(EXIT_FAILURE);
             }
           else

-            {

             return
               moan_to_sender(ERRMESS_TOOMANYRECIP, NULL, NULL, stdin, TRUE)?
                 errors_sender_rc : EXIT_FAILURE;
             return
               moan_to_sender(ERRMESS_TOOMANYRECIP, NULL, NULL, stdin, TRUE)?
                 errors_sender_rc : EXIT_FAILURE;

-            }
-          }
+         }

 
 

+#ifdef SUPPORT_I18N
+       {
+       BOOL b = allow_utf8_domains;
+       allow_utf8_domains = TRUE;
+#endif

         recipient =
           parse_extract_address(s, &errmess, &start, &end, &domain, FALSE);
 
         recipient =
           parse_extract_address(s, &errmess, &start, &end, &domain, FALSE);
 

-        if (domain == 0 && !allow_unqualified_recipient)
+#ifdef SUPPORT_I18N
+        if (recipient)
+          if (string_is_utf8(recipient)) message_smtputf8 = TRUE;
+          else allow_utf8_domains = b;
+       }
+#else
+        ;
+#endif
+        if (domain == 0 && !f.allow_unqualified_recipient)

           {
           recipient = NULL;
           errmess = US"unqualified recipient address not allowed";
           }
 
           {
           recipient = NULL;
           errmess = US"unqualified recipient address not allowed";
           }
 

-        if (recipient == NULL)
-          {
+        if (!recipient)
+         {
+         DEBUG(D_all) debug_printf("bad recipient address \"%s\": %s\n",
+           string_printing(list[i]), errmess);
+

           if (error_handling == ERRORS_STDERR)
             {
             fprintf(stderr, "exim: bad recipient address \"%s\": %s\n",
           if (error_handling == ERRORS_STDERR)
             {
             fprintf(stderr, "exim: bad recipient address \"%s\": %s\n",


@@ -5360,12 +6097,12 @@ while (more)
               moan_to_sender(ERRMESS_BADARGADDRESS, &eblock, NULL, stdin, TRUE)?
                 errors_sender_rc : EXIT_FAILURE;
             }
               moan_to_sender(ERRMESS_BADARGADDRESS, &eblock, NULL, stdin, TRUE)?
                 errors_sender_rc : EXIT_FAILURE;
             }

-          }
+         }

 
 

-        receive_add_recipient(recipient, -1);
+        receive_add_recipient(string_copy_taint(recipient, GET_TAINTED), -1);

         s = ss;
         if (!finished)
         s = ss;
         if (!finished)

-          while (*(++s) != 0 && (*s == ',' || isspace(*s)));
+          while (*++s && (*s == ',' || isspace(*s)));

         }
       }
 
         }
       }
 


@@ -5373,12 +6110,11 @@ while (more)
 
     DEBUG(D_receive)
       {
 
     DEBUG(D_receive)
       {

-      int i;
-      if (sender_address != NULL) debug_printf("Sender: %s\n", sender_address);
-      if (recipients_list != NULL)
+      if (sender_address) debug_printf("Sender: %s\n", sender_address);
+      if (recipients_list)

         {
         debug_printf("Recipients:\n");
         {
         debug_printf("Recipients:\n");

-        for (i = 0; i < recipients_count; i++)
+        for (int i = 0; i < recipients_count; i++)

           debug_printf("  %s\n", recipients_list[i].address);
         }
       }
           debug_printf("  %s\n", recipients_list[i].address);
         }
       }


@@ -5387,15 +6123,25 @@ while (more)
     ignored; rejecting here would just add complication, and it can just as
     well be done later. Allow $recipients to be visible in the ACL. */
 
     ignored; rejecting here would just add complication, and it can just as
     well be done later. Allow $recipients to be visible in the ACL. */
 

-    if (acl_not_smtp_start != NULL)
+    GET_OPTION("acl_not_smtp_start");
+    if (acl_not_smtp_start)

       {
       {

-      uschar *user_msg, *log_msg;
-      enable_dollar_recipients = TRUE;
+      uschar * user_msg, * log_msg;
+      f.enable_dollar_recipients = TRUE;

       (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
         &user_msg, &log_msg);
       (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
         &user_msg, &log_msg);

-      enable_dollar_recipients = FALSE;
+      f.enable_dollar_recipients = FALSE;

       }
 
       }
 

+    /* Pause for a while waiting for input.  If none received in that time,
+    close the logfile, if we had one open; then if we wait for a long-running
+    datasource (months, in one use-case) log rotation will not leave us holding
+    the file copy. */
+
+    if (!receive_timeout)
+      if (poll_one_fd(0, POLLIN, 30*60*1000) == 0)     /* 30 minutes */
+       mainlog_close();
+

     /* Read the data for the message. If filter_test is not FTEST_NONE, this
     will just read the headers for the message, and not write anything onto the
     spool. */
     /* Read the data for the message. If filter_test is not FTEST_NONE, this
     will just read the headers for the message, and not write anything onto the
     spool. */


@@ -5407,7 +6153,7 @@ while (more)
     for real; when reading the headers of a message for filter testing,
     it is TRUE if the headers were terminated by '.' and FALSE otherwise. */
 
     for real; when reading the headers of a message for filter testing,
     it is TRUE if the headers were terminated by '.' and FALSE otherwise. */
 

-    if (message_id[0] == 0) exim_exit(EXIT_FAILURE);
+    if (!message_id[0]) exim_exit(EXIT_FAILURE);

     }  /* Non-SMTP message reception */
 
   /* If this is a filter testing run, there are headers in store, but
     }  /* Non-SMTP message reception */
 
   /* If this is a filter testing run, there are headers in store, but


@@ -5419,37 +6165,33 @@ while (more)
 
   if (filter_test != FTEST_NONE)
     {
 
   if (filter_test != FTEST_NONE)
     {

-    deliver_domain = (ftest_domain != NULL)?
-      ftest_domain : qualify_domain_recipient;
+    deliver_domain = ftest_domain ? ftest_domain : qualify_domain_recipient;

     deliver_domain_orig = deliver_domain;
     deliver_domain_orig = deliver_domain;

-    deliver_localpart = (ftest_localpart != NULL)?
-      ftest_localpart : originator_login;
+    deliver_localpart = ftest_localpart ? US ftest_localpart : originator_login;

     deliver_localpart_orig = deliver_localpart;
     deliver_localpart_orig = deliver_localpart;

-    deliver_localpart_prefix = ftest_prefix;
-    deliver_localpart_suffix = ftest_suffix;
+    deliver_localpart_prefix = US ftest_prefix;
+    deliver_localpart_suffix = US ftest_suffix;

     deliver_home = originator_home;
 
     deliver_home = originator_home;
 

-    if (return_path == NULL)
+    if (!return_path)

       {
       printf("Return-path copied from sender\n");
       return_path = string_copy(sender_address);
       }
     else
       {
       printf("Return-path copied from sender\n");
       return_path = string_copy(sender_address);
       }
     else

-      {

       printf("Return-path = %s\n", (return_path[0] == 0)? US"<>" : return_path);
       printf("Return-path = %s\n", (return_path[0] == 0)? US"<>" : return_path);

-      }

     printf("Sender      = %s\n", (sender_address[0] == 0)? US"<>" : sender_address);
 
     receive_add_recipient(
       string_sprintf("%s%s%s@%s",
     printf("Sender      = %s\n", (sender_address[0] == 0)? US"<>" : sender_address);
 
     receive_add_recipient(
       string_sprintf("%s%s%s@%s",

-        (ftest_prefix == NULL)? US"" : ftest_prefix,
+        ftest_prefix ? ftest_prefix : US"",

         deliver_localpart,
         deliver_localpart,

-        (ftest_suffix == NULL)? US"" : ftest_suffix,
+        ftest_suffix ? ftest_suffix : US"",

         deliver_domain), -1);
 
     printf("Recipient   = %s\n", recipients_list[0].address);
         deliver_domain), -1);
 
     printf("Recipient   = %s\n", recipients_list[0].address);

-    if (ftest_prefix != NULL) printf("Prefix    = %s\n", ftest_prefix);
-    if (ftest_suffix != NULL) printf("Suffix    = %s\n", ftest_suffix);
+    if (ftest_prefix) printf("Prefix    = %s\n", ftest_prefix);
+    if (ftest_suffix) printf("Suffix    = %s\n", ftest_suffix);

 
     if (chdir("/"))   /* Get away from wherever the user is running this from */
       {
 
     if (chdir("/"))   /* Get away from wherever the user is running this from */
       {


@@ -5462,19 +6204,15 @@ while (more)
     available to the user filter. We need to copy the filter variables
     explicitly. */
 
     available to the user filter. We need to copy the filter variables
     explicitly. */
 

-    if ((filter_test & FTEST_SYSTEM) != 0)
-      {
+    if (filter_test & FTEST_SYSTEM)

       if (!filter_runtest(filter_sfd, filter_test_sfile, TRUE, more))
         exim_exit(EXIT_FAILURE);
       if (!filter_runtest(filter_sfd, filter_test_sfile, TRUE, more))
         exim_exit(EXIT_FAILURE);

-      }

 
     memcpy(filter_sn, filter_n, sizeof(filter_sn));
 
 
     memcpy(filter_sn, filter_n, sizeof(filter_sn));
 

-    if ((filter_test & FTEST_USER) != 0)
-      {
+    if (filter_test & FTEST_USER)

       if (!filter_runtest(filter_ufd, filter_test_ufile, FALSE, more))
         exim_exit(EXIT_FAILURE);
       if (!filter_runtest(filter_ufd, filter_test_ufile, FALSE, more))
         exim_exit(EXIT_FAILURE);

-      }

 
     exim_exit(EXIT_SUCCESS);
     }
 
     exim_exit(EXIT_SUCCESS);
     }


@@ -5484,9 +6222,9 @@ while (more)
   will be TRUE. If it is not, check on the number of messages received in this
   connection. */
 
   will be TRUE. If it is not, check on the number of messages received in this
   connection. */
 

-  if (!session_local_queue_only &&
-      smtp_accept_queue_per_connection > 0 &&
-      receive_messagecount > smtp_accept_queue_per_connection)
+  if (  !session_local_queue_only
+     && smtp_accept_queue_per_connection > 0
+     && receive_messagecount > smtp_accept_queue_per_connection)

     {
     session_local_queue_only = TRUE;
     queue_only_reason = 2;
     {
     session_local_queue_only = TRUE;
     queue_only_reason = 2;


@@ -5502,42 +6240,45 @@ while (more)
   ones. However, there are odd cases where this is not wanted, so this can be
   changed by setting queue_only_load_latch false. */
 
   ones. However, there are odd cases where this is not wanted, so this can be
   changed by setting queue_only_load_latch false. */
 

-  local_queue_only = session_local_queue_only;
-  if (!local_queue_only && queue_only_load >= 0)
-    {
-    local_queue_only = (load_average = OS_GETLOADAVG()) > queue_only_load;
-    if (local_queue_only)
+  if (!(local_queue_only = session_local_queue_only) && queue_only_load >= 0)
+    if ((local_queue_only = (load_average = OS_GETLOADAVG()) > queue_only_load))

       {
       queue_only_reason = 3;
       if (queue_only_load_latch) session_local_queue_only = TRUE;
       }
       {
       queue_only_reason = 3;
       if (queue_only_load_latch) session_local_queue_only = TRUE;
       }

-    }

 
   /* If running as an MUA wrapper, all queueing options and freezing options
   are ignored. */
 
   if (mua_wrapper)
 
   /* If running as an MUA wrapper, all queueing options and freezing options
   are ignored. */
 
   if (mua_wrapper)

-    local_queue_only = queue_only_policy = deliver_freeze = FALSE;
+    local_queue_only = f.queue_only_policy = f.deliver_freeze = FALSE;

 
   /* Log the queueing here, when it will get a message id attached, but
   not if queue_only is set (case 0). Case 1 doesn't happen here (too many
   connections). */
 
 
   /* Log the queueing here, when it will get a message id attached, but
   not if queue_only is set (case 0). Case 1 doesn't happen here (too many
   connections). */
 

-  if (local_queue_only) switch(queue_only_reason)
+  if (local_queue_only)

     {
     {

-    case 2:
-    log_write(L_delay_delivery,
-              LOG_MAIN, "no immediate delivery: more than %d messages "
-      "received in one connection", smtp_accept_queue_per_connection);
-    break;
-
-    case 3:
-    log_write(L_delay_delivery,
-              LOG_MAIN, "no immediate delivery: load average %.2f",
-              (double)load_average/1000.0);
-    break;
+    cancel_cutthrough_connection(TRUE, US"no delivery; queueing");
+    switch(queue_only_reason)
+      {
+      case 2:
+       log_write(L_delay_delivery,
+               LOG_MAIN, "no immediate delivery: more than %d messages "
+         "received in one connection", smtp_accept_queue_per_connection);
+       break;
+
+      case 3:
+       log_write(L_delay_delivery,
+               LOG_MAIN, "no immediate delivery: load average %.2f",
+               (double)load_average/1000.0);
+      break;
+      }

     }
 
     }
 

+  else if (f.queue_only_policy || f.deliver_freeze)
+    cancel_cutthrough_connection(TRUE, US"no delivery; queueing");
+

   /* Else do the delivery unless the ACL or local_scan() called for queue only
   or froze the message. Always deliver in a separate process. A fork failure is
   not a disaster, as the delivery will eventually happen on a subsequent queue
   /* Else do the delivery unless the ACL or local_scan() called for queue only
   or froze the message. Always deliver in a separate process. A fork failure is
   not a disaster, as the delivery will eventually happen on a subsequent queue


@@ -5546,12 +6287,12 @@ while (more)
   thereby defer the delivery if it tries to use (for example) a cached ldap
   connection that the parent has called unbind on. */
 
   thereby defer the delivery if it tries to use (for example) a cached ldap
   connection that the parent has called unbind on. */
 

-  else if (!queue_only_policy && !deliver_freeze)
+  else

     {
     pid_t pid;
     search_tidyup();
 
     {
     pid_t pid;
     search_tidyup();
 

-    if ((pid = fork()) == 0)
+    if ((pid = exim_fork(US"local-accept-delivery")) == 0)

       {
       int rc;
       close_unwanted();      /* Close unwanted file descriptors and TLS */
       {
       int rc;
       close_unwanted();      /* Close unwanted file descriptors and TLS */


@@ -5562,8 +6303,7 @@ while (more)
 
       if (geteuid() != root_uid && !deliver_drop_privilege && !unprivileged)
         {
 
       if (geteuid() != root_uid && !deliver_drop_privilege && !unprivileged)
         {

-        (void)child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 2, US"-Mc",
-          message_id);
+       delivery_re_exec(CEE_EXEC_EXIT);

         /* Control does not return here. */
         }
 
         /* Control does not return here. */
         }
 


@@ -5571,28 +6311,33 @@ while (more)
 
       rc = deliver_message(message_id, FALSE, FALSE);
       search_tidyup();
 
       rc = deliver_message(message_id, FALSE, FALSE);
       search_tidyup();

-      _exit((!mua_wrapper || rc == DELIVER_MUA_SUCCEEDED)?
-        EXIT_SUCCESS : EXIT_FAILURE);
+      exim_underbar_exit(!mua_wrapper || rc == DELIVER_MUA_SUCCEEDED
+        ? EXIT_SUCCESS : EXIT_FAILURE);

       }
 
     if (pid < 0)
       {
       }
 
     if (pid < 0)
       {

+      cancel_cutthrough_connection(TRUE, US"delivery fork failed");

       log_write(0, LOG_MAIN|LOG_PANIC, "failed to fork automatic delivery "
         "process: %s", strerror(errno));
       }
       log_write(0, LOG_MAIN|LOG_PANIC, "failed to fork automatic delivery "
         "process: %s", strerror(errno));
       }

-
-    /* In the parent, wait if synchronous delivery is required. This will
-    always be the case in MUA wrapper mode. */
-
-    else if (synchronous_delivery)
+    else

       {
       {

-      int status;
-      while (wait(&status) != pid);
-      if ((status & 0x00ff) != 0)
-        log_write(0, LOG_MAIN|LOG_PANIC,
-          "process %d crashed with signal %d while delivering %s",
-          (int)pid, status & 0x00ff, message_id);
-      if (mua_wrapper && (status & 0xffff) != 0) exim_exit(EXIT_FAILURE);
+      release_cutthrough_connection(US"msg passed for delivery");
+
+      /* In the parent, wait if synchronous delivery is required. This will
+      always be the case in MUA wrapper mode. */
+
+      if (f.synchronous_delivery)
+       {
+       int status;
+       while (wait(&status) != pid);
+       if ((status & 0x00ff) != 0)
+         log_write(0, LOG_MAIN|LOG_PANIC,
+           "process %d crashed with signal %d while delivering %s",
+           (int)pid, status & 0x00ff, message_id);
+       if (mua_wrapper && (status & 0xffff) != 0) exim_exit(EXIT_FAILURE);
+       }

       }
     }
 
       }
     }
 


@@ -5601,13 +6346,36 @@ while (more)
   finished subprocesses here, in case there are lots of messages coming in
   from the same source. */
 
   finished subprocesses here, in case there are lots of messages coming in
   from the same source. */
 

-  #ifndef SIG_IGN_WORKS
+#ifndef SIG_IGN_WORKS

   while (waitpid(-1, NULL, WNOHANG) > 0);
   while (waitpid(-1, NULL, WNOHANG) > 0);

-  #endif
+#endif
+
+MORELOOP:
+  return_path = sender_address = NULL;
+  authenticated_sender = NULL;
+  deliver_localpart_orig = NULL;
+  deliver_domain_orig = NULL;
+  deliver_host = deliver_host_address = NULL;
+  dnslist_domain = dnslist_matched = NULL;
+#ifdef WITH_CONTENT_SCAN
+  malware_name = NULL;
+  regex_vars_clear();
+#endif
+  callout_address = NULL;
+  sending_ip_address = NULL;
+  deliver_localpart_data = deliver_domain_data =
+  recipient_data = sender_data = NULL;
+  acl_var_m = NULL;
+  lookup_value = NULL;                            /* Can be set by ACL */
+
+  store_reset(reset_point);

   }
 
 exim_exit(EXIT_SUCCESS);   /* Never returns */
 return 0;                  /* To stop compiler warning */
 }
 
   }
 
 exim_exit(EXIT_SUCCESS);   /* Never returns */
 return 0;                  /* To stop compiler warning */
 }
 

+

 /* End of exim.c */
 /* End of exim.c */

+/* vi: aw ai sw=2
+*/