Adding upstream version 4.92.upstream/4.92upstream

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

1 files changed, 5657 insertions, 0 deletions

diff --git a/src/exim.c b/src/exim.c
new file mode 100644
index 0000000..f6f15f4
--- /dev/null
+++ b/src/exim.c
@@ -0,0 +1,5657 @@
+/*************************************************
+*     Exim - an Internet mail transport agent    *
+*************************************************/
+
+/* Copyright (c) University of Cambridge 1995 - 2018 */
+/* See the file NOTICE for conditions of use and distribution. */
+
+
+/* The main function: entry point, initialization, and high-level control.
+Also a few functions that don't naturally fit elsewhere. */
+
+
+#include "exim.h"
+
+#if defined(__GLIBC__) && !defined(__UCLIBC__)
+# include <gnu/libc-version.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);
+
+
+
+/*************************************************
+*      Function interface to store functions     *
+*************************************************/
+
+/* We need some real functions to pass to the PCRE regular expression library
+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. */
+
+static void *
+function_store_get(size_t size)
+{
+return store_get((int)size);
+}
+
+static void
+function_dummy_free(void *block) { block = block; }
+
+static void *
+function_store_malloc(size_t size)
+{
+return store_malloc((int)size);
+}
+
+static void
+function_store_free(void *block)
+{
+store_free(block);
+}
+
+
+
+
+/*************************************************
+*         Enums for cmdline interface            *
+*************************************************/
+
+enum commandline_info { CMDINFO_NONE=0,
+  CMDINFO_HELP, CMDINFO_SIEVE, CMDINFO_DSCP };
+
+
+
+
+/*************************************************
+*  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
+
+Returns:      pointer to the compiled pattern
+*/
+
+const pcre *
+regex_must_compile(const 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(CCS 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;
+}
+
+
+
+
+/*************************************************
+*   Execute regular expression and set strings   *
+*************************************************/
+
+/* This function runs a regular expression match, and sets up the pointers to
+the matched substrings.
+
+Arguments:
+  re          the compiled expression
+  subject     the subject string
+  options     additional PCRE options
+  setup       if < 0 do full setup
+              if >= 0 setup from setup+1 onwards,
+                excluding the full matched string
+
+Returns:      TRUE or FALSE
+*/
+
+BOOL
+regex_match_and_setup(const pcre *re, const uschar *subject, int options, int setup)
+{
+int ovector[3*(EXPAND_MAXN+1)];
+uschar * s = string_copy(subject);	/* de-constifying */
+int n = pcre_exec(re, NULL, CS s, Ustrlen(s), 0,
+  PCRE_EOPT | options, ovector, nelem(ovector));
+BOOL yield = n >= 0;
+if (n == 0) n = EXPAND_MAXN + 1;
+if (yield)
+  {
+  int nn;
+  expand_nmax = setup < 0 ? 0 : setup + 1;
+  for (nn = setup < 0 ? 0 : 2; nn < n*2; nn += 2)
+    {
+    expand_nstring[expand_nmax] = s + ovector[nn];
+    expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
+    }
+  expand_nmax--;
+  }
+return yield;
+}
+
+
+
+
+/*************************************************
+*            Set up processing details           *
+*************************************************/
+
+/* Save a text string for dumping when SIGUSR1 is received.
+Do checks for overruns.
+
+Arguments: format and arguments, as for printf()
+Returns:   nothing
+*/
+
+void
+set_process_info(const char *format, ...)
+{
+gstring gs = { .size = PROCESS_INFO_SIZE - 2, .ptr = 0, .s = process_info };
+gstring * g;
+int len;
+va_list ap;
+
+g = string_fmt_append(&gs, "%5d ", (int)getpid());
+len = g->ptr;
+va_start(ap, format);
+if (!string_vformat(g, FALSE, format, ap))
+  {
+  gs.ptr = len;
+  g = string_cat(&gs, US"**** string overflowed buffer ****");
+  }
+g = string_catn(g, US"\n", 1);
+string_from_gstring(g);
+process_info_len = g->ptr;
+DEBUG(D_process_info) debug_printf("set_process_info: %s", process_info);
+va_end(ap);
+}
+
+/***********************************************
+*            Handler for SIGTERM               *
+***********************************************/
+
+static void
+term_handler(int sig)
+{
+  exit(1);
+}
+
+
+/*************************************************
+*             Handler for SIGUSR1                *
+*************************************************/
+
+/* SIGUSR1 causes any exim process to write to the process log details of
+what it is currently doing. It will only be used if the OS is capable of
+setting up a handler that causes automatic restarting of any system call
+that is in progress at the time.
+
+This function takes care to be signal-safe.
+
+Argument: the signal number (SIGUSR1)
+Returns:  nothing
+*/
+
+static void
+usr1_handler(int sig)
+{
+int fd;
+
+os_restarting_signal(sig, usr1_handler);
+
+if ((fd = Uopen(process_log_path, O_APPEND|O_WRONLY, LOG_MODE)) < 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 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
+to disrupt whatever is going on outside the signal handler. */
+
+if (fd < 0) return;
+
+(void)write(fd, process_info, process_info_len);
+(void)close(fd);
+}
+
+
+
+/*************************************************
+*             Timeout handler                    *
+*************************************************/
+
+/* This handler is enabled most of the time that Exim is running. The handler
+doesn't actually get used unless alarm() has been called to set a timer, to
+place a time limit on a system call of some kind. When the handler is run, it
+re-enables itself.
+
+There are some other SIGALRM handlers that are used in special cases when more
+than just a flag setting is required; for example, when reading a message's
+input. These are normally set up in the code module that uses them, and the
+SIGALRM handler is reset to this one afterwards.
+
+Argument: the signal value (SIGALRM)
+Returns:  nothing
+*/
+
+void
+sigalrm_handler(int sig)
+{
+sig = sig;      /* Keep picky compilers happy */
+sigalrm_seen = TRUE;
+os_non_restarting_signal(SIGALRM, sigalrm_handler);
+}
+
+
+
+/*************************************************
+*      Sleep for a fractional time interval      *
+*************************************************/
+
+/* This function is called by millisleep() and exim_wait_tick() to wait for a
+period of time that may include a fraction of a second. The coding is somewhat
+tedious. We do not expect setitimer() ever to fail, but if it does, the process
+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. :-)
+
+We assume it to be not worth sleeping for under 100us; 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
+*/
+
+static void
+milliwait(struct itimerval *itval)
+{
+sigset_t sigmask;
+sigset_t old_sigmask;
+
+if (itval->it_value.tv_usec < 100 && 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 */
+if (setitimer(ITIMER_REAL, itval, NULL) < 0)           /* Start timer */
+  log_write(0, LOG_MAIN|LOG_PANIC_DIE,
+    "setitimer() failed: %s", strerror(errno));
+(void)sigfillset(&sigmask);                            /* All signals */
+(void)sigdelset(&sigmask, SIGALRM);                    /* Remove SIGALRM */
+(void)sigsuspend(&sigmask);                            /* Until SIGALRM */
+(void)sigprocmask(SIG_SETMASK, &old_sigmask, NULL);    /* Restore mask */
+}
+
+
+
+
+/*************************************************
+*         Millisecond sleep function             *
+*************************************************/
+
+/* The basic sleep() function has a granularity of 1 second, which is too rough
+in some cases - for example, when using an increasing delay to slow down
+spammers.
+
+Argument:    number of millseconds
+Returns:     nothing
+*/
+
+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;
+milliwait(&itval);
+}
+
+
+
+/*************************************************
+*         Compare microsecond times              *
+*************************************************/
+
+/*
+Arguments:
+  tv1         the first time
+  tv2         the second time
+
+Returns:      -1, 0, or +1
+*/
+
+static int
+exim_tvcmp(struct timeval *t1, struct timeval *t2)
+{
+if (t1->tv_sec > t2->tv_sec) return +1;
+if (t1->tv_sec < t2->tv_sec) return -1;
+if (t1->tv_usec > t2->tv_usec) return +1;
+if (t1->tv_usec < t2->tv_usec) return -1;
+return 0;
+}
+
+
+
+
+/*************************************************
+*          Clock tick wait function              *
+*************************************************/
+
+/* 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 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
+function prepares for the time when things are faster - and it also copes with
+clocks that go backwards.
+
+Arguments:
+  then_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.
+  resolution   The resolution that was used to divide the microseconds
+                 (1 for maildir, larger for message ids)
+
+Returns:       nothing
+*/
+
+void
+exim_wait_tick(struct timeval *then_tv, int resolution)
+{
+struct timeval now_tv;
+long int now_true_usec;
+
+(void)gettimeofday(&now_tv, NULL);
+now_true_usec = now_tv.tv_usec;
+now_tv.tv_usec = (now_true_usec/resolution) * resolution;
+
+if (exim_tvcmp(&now_tv, then_tv) <= 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;
+
+  /* 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 greater than zero. The following correction is therefore safe. */
+
+  if (itval.it_value.tv_usec < 0)
+    {
+    itval.it_value.tv_usec += 1000000;
+    itval.it_value.tv_sec -= 1;
+    }
+
+  DEBUG(D_transport|D_receive)
+    {
+    if (!f.running_in_test_harness)
+      {
+      debug_printf("tick check: " TIME_T_FMT ".%06lu " TIME_T_FMT ".%06lu\n",
+        then_tv->tv_sec, (long) then_tv->tv_usec,
+       	now_tv.tv_sec, (long) now_tv.tv_usec);
+      debug_printf("waiting " TIME_T_FMT ".%06lu\n",
+        itval.it_value.tv_sec, (long) itval.it_value.tv_usec);
+      }
+    }
+
+  milliwait(&itval);
+  }
+}
+
+
+
+
+/*************************************************
+*   Call fopen() with umask 777 and adjust mode  *
+*************************************************/
+
+/* Exim runs with umask(0) so that files created with open() have the mode that
+is specified in the open() call. However, there are some files, typically in
+the spool directory, that are created with fopen(). They end up world-writeable
+if no precautions are taken. Although the spool directory is not accessible to
+the world, this is an untidiness. So this is a wrapper function for fopen()
+that sorts out the mode of the created file.
+
+Arguments:
+   filename       the file name
+   options        the fopen() options
+   mode           the required mode
+
+Returns:          the fopened FILE or NULL
+*/
+
+FILE *
+modefopen(const uschar *filename, const char *options, mode_t mode)
+{
+mode_t saved_umask = umask(0777);
+FILE *f = Ufopen(filename, options);
+(void)umask(saved_umask);
+if (f != NULL) (void)fchmod(fileno(f), mode);
+return f;
+}
+
+
+
+
+/*************************************************
+*   Ensure stdin, stdout, and stderr exist       *
+*************************************************/
+
+/* Some operating systems grumble if an exec() happens without a standard
+input, output, and error (fds 0, 1, 2) being defined. The worry is that some
+file will be opened and will use these fd values, and then some other bit of
+code will assume, for example, that it can write error messages to stderr.
+This function ensures that fds 0, 1, and 2 are open if they do not already
+exist, by connecting them to /dev/null.
+
+This function is also used to ensure that std{in,out,err} exist at all times,
+so that if any library that Exim calls tries to use them, it doesn't crash.
+
+Arguments:  None
+Returns:    Nothing
+*/
+
+void
+exim_nullstd(void)
+{
+int i;
+int devnull = -1;
+struct stat statbuf;
+for (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",
+      string_open_failed(errno, "/dev/null"));
+    if (devnull != i) (void)dup2(devnull, i);
+    }
+  }
+if (devnull > 2) (void)close(devnull);
+}
+
+
+
+
+/*************************************************
+*   Close unwanted file descriptors for delivery *
+*************************************************/
+
+/* This function is called from a new process that has been forked to deliver
+an incoming message, either directly, or using exec.
+
+We want any smtp input streams to be closed in this new process. However, it
+has been observed that using fclose() here causes trouble. When reading in -bS
+input, duplicate copies of messages have been seen. The files will be sharing a
+file pointer with the parent process, and it seems that fclose() (at least on
+some systems - I saw this on Solaris 2.5.1) messes with that file pointer, at
+least sometimes. Hence we go for closing the underlying file descriptors.
+
+If TLS is active, we want to shut down the TLS library, but without molesting
+the parent's SSL connection.
+
+For delivery of a non-SMTP message, we want to close stdin and stdout (and
+stderr unless debugging) because the calling process might have set them up as
+pipes and be waiting for them to close before it waits for the submission
+process to terminate. If they aren't closed, they hold up the calling process
+until the initial delivery process finishes, which is not what we want.
+
+Exception: We do want it for synchronous delivery!
+
+And notwithstanding all the above, if D_resolver is set, implying resolver
+debugging, leave stdout open, because that's where the resolver writes its
+debugging output.
+
+When we close stderr (which implies we've also closed stdout), we also get rid
+of any controlling terminal.
+
+Arguments:   None
+Returns:     Nothing
+*/
+
+static void
+close_unwanted(void)
+{
+if (smtp_input)
+  {
+#ifdef SUPPORT_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;
+  }
+else
+  {
+  (void)close(0);                                          /* stdin */
+  if ((debug_selector & D_resolver) == 0) (void)close(1);  /* stdout */
+  if (debug_selector == 0)                                 /* stderr */
+    {
+    if (!f.synchronous_delivery)
+      {
+      (void)close(2);
+      log_stderr = NULL;
+      }
+    (void)setsid();
+    }
+  }
+}
+
+
+
+
+/*************************************************
+*          Set uid and gid                       *
+*************************************************/
+
+/* This function sets a new uid and gid permanently, optionally calling
+initgroups() to set auxiliary groups. There are some special cases when running
+Exim in unprivileged modes. In these situations the effective uid will not be
+root; if we already have the right effective uid/gid, and don't need to
+initialize any groups, leave things as they are.
+
+Arguments:
+  uid        the uid
+  gid        the gid
+  igflag     TRUE if initgroups() wanted
+  msg        text to use in debugging output and failure log
+
+Returns:     nothing; bombs out on failure
+*/
+
+void
+exim_setugid(uid_t uid, gid_t gid, BOOL igflag, uschar *msg)
+{
+uid_t euid = geteuid();
+gid_t egid = getegid();
+
+if (euid == root_uid || euid != uid || egid != gid || igflag)
+  {
+  /* At least one OS returns +1 for initgroups failure, so just check for
+  non-zero. */
+
+  if (igflag)
+    {
+    struct passwd *pw = getpwuid(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)
+    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 */
+
+DEBUG(D_uid)
+  {
+  int group_count, save_errno;
+  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());
+  group_count = getgroups(nelem(group_list), group_list);
+  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]);
+    }
+  else if (group_count < 0)
+    debug_printf(" <error: %s>", strerror(save_errno));
+  else debug_printf(" <none>");
+  debug_printf("\n");
+  }
+}
+
+
+
+
+/*************************************************
+*               Exit point                       *
+*************************************************/
+
+/* Exim exits via this function so that it always clears up any open
+databases.
+
+Arguments:
+  rc         return code
+
+Returns:     does not return
+*/
+
+void
+exim_exit(int rc, const uschar * process)
+{
+search_tidyup();
+DEBUG(D_any)
+  debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d %s%s%sterminating with rc=%d "
+    ">>>>>>>>>>>>>>>>\n", (int)getpid(),
+    process ? "(" : "", process, process ? ") " : "", 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);
+exit(EXIT_FAILURE);
+}
+
+
+
+/*************************************************
+*         Extract port from host address         *
+*************************************************/
+
+/* Called to extract the port from the values given to -oMa and -oMi.
+It also checks the syntax of the address, and terminates it before the
+port data when a port is extracted.
+
+Argument:
+  address   the address, with possible port on the end
+
+Returns:    the port, or zero if there isn't one
+            bombs out on a syntax error
+*/
+
+static int
+check_port(uschar *address)
+{
+int port = host_address_extract_port(address);
+if (string_is_ip_address(address, NULL) == 0)
+  exim_fail("exim abandoned: \"%s\" is not an IP address\n", address);
+return port;
+}
+
+
+
+/*************************************************
+*              Test/verify an address            *
+*************************************************/
+
+/* This function is called by the -bv and -bt code. It extracts a working
+address from a full RFC 822 address. This isn't really necessary per se, but it
+has the effect of collapsing source routes.
+
+Arguments:
+  s            the address string
+  flags        flag bits for verify_address()
+  exit_value   to be set for failures
+
+Returns:       nothing
+*/
+
+static void
+test_address(uschar *s, int flags, int *exit_value)
+{
+int start, end, domain;
+uschar *parse_error = NULL;
+uschar *address = parse_extract_address(s, &parse_error, &start, &end, &domain,
+  FALSE);
+if (address == NULL)
+  {
+  fprintf(stdout, "syntax error: %s\n", parse_error);
+  *exit_value = 2;
+  }
+else
+  {
+  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;
+  }
+}
+
+
+
+/*************************************************
+*          Show supported features               *
+*************************************************/
+
+static void
+show_db_version(FILE * f)
+{
+#ifdef DB_VERSION_STRING
+DEBUG(D_any)
+  {
+  fprintf(f, "Library version: BDB: Compile: %s\n", DB_VERSION_STRING);
+  fprintf(f, "                      Runtime: %s\n",
+    db_version(NULL, NULL, NULL));
+  }
+else
+  fprintf(f, "Berkeley DB: %s\n", DB_VERSION_STRING);
+
+#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
+
+#elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
+fprintf(f, "Probably ndbm\n");
+#elif defined(USE_TDB)
+fprintf(f, "Using tdb\n");
+#else
+  #ifdef USE_GDBM
+  fprintf(f, "Probably GDBM (native mode)\n");
+  #else
+  fprintf(f, "Probably GDBM (compatibility mode)\n");
+  #endif
+#endif
+}
+
+
+/* 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
+show_whats_supported(FILE * fp)
+{
+auth_info * authi;
+
+DEBUG(D_any) {} else show_db_version(fp);
+
+fprintf(fp, "Support for:");
+#ifdef SUPPORT_CRYPTEQ
+  fprintf(fp, " crypteq");
+#endif
+#if HAVE_ICONV
+  fprintf(fp, " iconv()");
+#endif
+#if HAVE_IPV6
+  fprintf(fp, " IPv6");
+#endif
+#ifdef HAVE_SETCLASSRESOURCES
+  fprintf(fp, " use_setclassresources");
+#endif
+#ifdef SUPPORT_PAM
+  fprintf(fp, " PAM");
+#endif
+#ifdef EXIM_PERL
+  fprintf(fp, " Perl");
+#endif
+#ifdef EXPAND_DLFUNC
+  fprintf(fp, " Expand_dlfunc");
+#endif
+#ifdef USE_TCP_WRAPPERS
+  fprintf(fp, " TCPwrappers");
+#endif
+#ifdef SUPPORT_TLS
+# ifdef USE_GNUTLS
+  fprintf(fp, " GnuTLS");
+# else
+  fprintf(fp, " OpenSSL");
+# endif
+#endif
+#ifdef SUPPORT_TRANSLATE_IP_ADDRESS
+  fprintf(fp, " translate_ip_address");
+#endif
+#ifdef SUPPORT_MOVE_FROZEN_MESSAGES
+  fprintf(fp, " move_frozen_messages");
+#endif
+#ifdef WITH_CONTENT_SCAN
+  fprintf(fp, " Content_Scanning");
+#endif
+#ifdef SUPPORT_DANE
+  fprintf(fp, " DANE");
+#endif
+#ifndef DISABLE_DKIM
+  fprintf(fp, " DKIM");
+#endif
+#ifndef DISABLE_DNSSEC
+  fprintf(fp, " DNSSEC");
+#endif
+#ifndef DISABLE_EVENT
+  fprintf(fp, " Event");
+#endif
+#ifdef SUPPORT_I18N
+  fprintf(fp, " I18N");
+#endif
+#ifndef DISABLE_OCSP
+  fprintf(fp, " OCSP");
+#endif
+#ifndef DISABLE_PRDR
+  fprintf(fp, " PRDR");
+#endif
+#ifdef SUPPORT_PROXY
+  fprintf(fp, " PROXY");
+#endif
+#ifdef SUPPORT_SOCKS
+  fprintf(fp, " SOCKS");
+#endif
+#ifdef SUPPORT_SPF
+  fprintf(fp, " SPF");
+#endif
+#ifdef TCP_FASTOPEN
+  deliver_init();
+  if (f.tcp_fastopen_ok) fprintf(fp, " TCP_Fast_Open");
+#endif
+#ifdef EXPERIMENTAL_LMDB
+  fprintf(fp, " Experimental_LMDB");
+#endif
+#ifdef EXPERIMENTAL_QUEUEFILE
+  fprintf(fp, " Experimental_QUEUEFILE");
+#endif
+#ifdef EXPERIMENTAL_SRS
+  fprintf(fp, " Experimental_SRS");
+#endif
+#ifdef EXPERIMENTAL_ARC
+  fprintf(fp, " Experimental_ARC");
+#endif
+#ifdef EXPERIMENTAL_BRIGHTMAIL
+  fprintf(fp, " Experimental_Brightmail");
+#endif
+#ifdef EXPERIMENTAL_DCC
+  fprintf(fp, " Experimental_DCC");
+#endif
+#ifdef EXPERIMENTAL_DMARC
+  fprintf(fp, " Experimental_DMARC");
+#endif
+#ifdef EXPERIMENTAL_DSN_INFO
+  fprintf(fp, " Experimental_DSN_info");
+#endif
+#ifdef EXPERIMENTAL_REQUIRETLS
+  fprintf(fp, " Experimental_REQUIRETLS");
+#endif
+#ifdef EXPERIMENTAL_PIPE_CONNECT
+  fprintf(fp, " Experimental_PIPE_CONNECT");
+#endif
+fprintf(fp, "\n");
+
+fprintf(fp, "Lookups (built-in):");
+#if defined(LOOKUP_LSEARCH) && LOOKUP_LSEARCH!=2
+  fprintf(fp, " lsearch wildlsearch nwildlsearch iplsearch");
+#endif
+#if defined(LOOKUP_CDB) && LOOKUP_CDB!=2
+  fprintf(fp, " cdb");
+#endif
+#if defined(LOOKUP_DBM) && LOOKUP_DBM!=2
+  fprintf(fp, " dbm dbmjz dbmnz");
+#endif
+#if defined(LOOKUP_DNSDB) && LOOKUP_DNSDB!=2
+  fprintf(fp, " dnsdb");
+#endif
+#if defined(LOOKUP_DSEARCH) && LOOKUP_DSEARCH!=2
+  fprintf(fp, " dsearch");
+#endif
+#if defined(LOOKUP_IBASE) && LOOKUP_IBASE!=2
+  fprintf(fp, " ibase");
+#endif
+#if defined(LOOKUP_LDAP) && LOOKUP_LDAP!=2
+  fprintf(fp, " ldap ldapdn ldapm");
+#endif
+#ifdef EXPERIMENTAL_LMDB
+  fprintf(fp, " lmdb");
+#endif
+#if defined(LOOKUP_MYSQL) && LOOKUP_MYSQL!=2
+  fprintf(fp, " mysql");
+#endif
+#if defined(LOOKUP_NIS) && LOOKUP_NIS!=2
+  fprintf(fp, " nis nis0");
+#endif
+#if defined(LOOKUP_NISPLUS) && LOOKUP_NISPLUS!=2
+  fprintf(fp, " nisplus");
+#endif
+#if defined(LOOKUP_ORACLE) && LOOKUP_ORACLE!=2
+  fprintf(fp, " oracle");
+#endif
+#if defined(LOOKUP_PASSWD) && LOOKUP_PASSWD!=2
+  fprintf(fp, " passwd");
+#endif
+#if defined(LOOKUP_PGSQL) && LOOKUP_PGSQL!=2
+  fprintf(fp, " pgsql");
+#endif
+#if defined(LOOKUP_REDIS) && LOOKUP_REDIS!=2
+  fprintf(fp, " redis");
+#endif
+#if defined(LOOKUP_SQLITE) && LOOKUP_SQLITE!=2
+  fprintf(fp, " sqlite");
+#endif
+#if defined(LOOKUP_TESTDB) && LOOKUP_TESTDB!=2
+  fprintf(fp, " testdb");
+#endif
+#if defined(LOOKUP_WHOSON) && LOOKUP_WHOSON!=2
+  fprintf(fp, " whoson");
+#endif
+fprintf(fp, "\n");
+
+auth_show_supported(fp);
+route_show_supported(fp);
+transport_show_supported(fp);
+
+#ifdef WITH_CONTENT_SCAN
+malware_show_supported(fp);
+#endif
+
+if (fixed_never_users[0] > 0)
+  {
+  int i;
+  fprintf(fp, "Fixed never_users: ");
+  for (i = 1; i <= (int)fixed_never_users[0] - 1; i++)
+    fprintf(fp, "%d:", (unsigned int)fixed_never_users[i]);
+  fprintf(fp, "%d\n", (unsigned int)fixed_never_users[i]);
+  }
+
+fprintf(fp, "Configure owner: %d:%d\n", config_uid, config_gid);
+
+fprintf(fp, "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. */
+DEBUG(D_any) do {
+
+  int i;
+
+/* clang defines __GNUC__ (at least, for me) so test for it first */
+#if defined(__clang__)
+  fprintf(fp, "Compiler: CLang [%s]\n", __clang_version__);
+#elif defined(__GNUC__)
+  fprintf(fp, "Compiler: GCC [%s]\n",
+# ifdef __VERSION__
+      __VERSION__
+# else
+      "? unknown version ?"
+# endif
+      );
+#else
+  fprintf(fp, "Compiler: <unknown>\n");
+#endif
+
+#if defined(__GLIBC__) && !defined(__UCLIBC__)
+  fprintf(fp, "Library version: Glibc: Compile: %d.%d\n",
+	       	__GLIBC__, __GLIBC_MINOR__);
+  if (__GLIBC_PREREQ(2, 1))
+    fprintf(fp, "                        Runtime: %s\n",
+	       	gnu_get_libc_version());
+#endif
+
+show_db_version(fp);
+
+#ifdef SUPPORT_TLS
+  tls_version_report(fp);
+#endif
+#ifdef SUPPORT_I18N
+  utf8_version_report(fp);
+#endif
+
+  for (authi = auths_available; *authi->driver_name != '\0'; ++authi)
+    if (authi->version_report)
+      (*authi->version_report)(fp);
+
+  /* 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
+#endif
+#define QUOTE(X) #X
+#define EXPAND_AND_QUOTE(X) QUOTE(X)
+  fprintf(fp, "Library version: PCRE: Compile: %d.%d%s\n"
+             "                       Runtime: %s\n",
+          PCRE_MAJOR, PCRE_MINOR,
+          EXPAND_AND_QUOTE(PCRE_PRERELEASE) "",
+          pcre_version());
+#undef QUOTE
+#undef EXPAND_AND_QUOTE
+
+  init_lookup_list();
+  for (i = 0; i < lookup_list_count; i++)
+    if (lookup_list[i]->version_report)
+      lookup_list[i]->version_report(fp);
+
+#ifdef WHITELIST_D_MACROS
+  fprintf(fp, "WHITELIST_D_MACROS: \"%s\"\n", WHITELIST_D_MACROS);
+#else
+  fprintf(fp, "WHITELIST_D_MACROS unset\n");
+#endif
+#ifdef TRUSTED_CONFIG_LIST
+  fprintf(fp, "TRUSTED_CONFIG_LIST: \"%s\"\n", TRUSTED_CONFIG_LIST);
+#else
+  fprintf(fp, "TRUSTED_CONFIG_LIST unset\n");
+#endif
+
+} while (0);
+}
+
+
+/*************************************************
+*     Show auxiliary information about Exim      *
+*************************************************/
+
+static void
+show_exim_information(enum commandline_info request, FILE *stream)
+{
+const uschar **pp;
+
+switch(request)
+  {
+  case CMDINFO_NONE:
+    fprintf(stream, "Oops, something went wrong.\n");
+    return;
+  case CMDINFO_HELP:
+    fprintf(stream,
+"The -bI: flag takes a string indicating which information to provide.\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    list of known dscp value keywords\n"
+"  exim -bI:sieve   list of supported sieve extensions\n"
+);
+    return;
+  case CMDINFO_SIEVE:
+    for (pp = exim_sieve_extension_list; *pp; ++pp)
+      fprintf(stream, "%s\n", *pp);
+    return;
+  case CMDINFO_DSCP:
+    dscp_list_to_stream(stream);
+    return;
+  }
+}
+
+
+/*************************************************
+*               Quote a local part               *
+*************************************************/
+
+/* This function is used when a sender address or a From: or Sender: header
+line is being created from the caller's login, or from an authenticated_id. It
+applies appropriate quoting rules for a local part.
+
+Argument:    the local part
+Returns:     the local part, quoted if necessary
+*/
+
+uschar *
+local_part_quote(uschar *lpart)
+{
+BOOL needs_quote = FALSE;
+gstring * g;
+uschar *t;
+
+for (t = lpart; !needs_quote && *t != 0; t++)
+  {
+  needs_quote = !isalnum(*t) && strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
+    (*t != '.' || t == lpart || t[1] == 0);
+  }
+
+if (!needs_quote) return lpart;
+
+g = string_catn(NULL, US"\"", 1);
+
+for (;;)
+  {
+  uschar *nq = US Ustrpbrk(lpart, "\\\"");
+  if (nq == NULL)
+    {
+    g = string_cat(g, lpart);
+    break;
+    }
+  g = string_catn(g, lpart, nq - lpart);
+  g = string_catn(g, US"\\", 1);
+  g = string_catn(g, nq, 1);
+  lpart = nq + 1;
+  }
+
+g = string_catn(g, US"\"", 1);
+return string_from_gstring(g);
+}
+
+
+
+#ifdef USE_READLINE
+/*************************************************
+*         Load readline() functions              *
+*************************************************/
+
+/* This function is called from testing executions that read data from stdin,
+but only when running as the calling user. Currently, only -be does this. The
+function loads the readline() function library and passes back the functions.
+On some systems, it needs the curses library, so load that too, but try without
+it if loading fails. All this functionality has to be requested at build time.
+
+Arguments:
+  fn_readline_ptr   pointer to where to put the readline pointer
+  fn_addhist_ptr    pointer to where to put the addhistory function
+
+Returns:            the dlopen handle or NULL on failure
+*/
+
+static void *
+set_readline(char * (**fn_readline_ptr)(const char *),
+             void   (**fn_addhist_ptr)(const char *))
+{
+void *dlhandle;
+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 != NULL)
+  {
+  /* Checked manual pages; at least in GNU Readline 6.1, the prototypes are:
+   *   char * readline (const char *prompt);
+   *   void add_history (const char *string);
+   */
+  *fn_readline_ptr = (char *(*)(const char*))dlsym(dlhandle, "readline");
+  *fn_addhist_ptr = (void(*)(const char*))dlsym(dlhandle, "add_history");
+  }
+else
+  {
+  DEBUG(D_any) debug_printf("failed to load readline: %s\n", dlerror());
+  }
+
+return dlhandle;
+}
+#endif
+
+
+
+/*************************************************
+*    Get a line from stdin for testing things    *
+*************************************************/
+
+/* This function is called when running tests that can take a number of lines
+of input (for example, -be and -bt). It handles continuations and trailing
+spaces. And prompting and a blank line output on eof. If readline() is in use,
+the arguments are non-NULL and provide the relevant functions.
+
+Arguments:
+  fn_readline   readline function or NULL
+  fn_addhist    addhist function or NULL
+
+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 *))
+{
+int i;
+gstring * g = NULL;
+
+if (!fn_readline) { printf("> "); fflush(stdout); }
+
+for (i = 0;; i++)
+  {
+  uschar buffer[1024];
+  uschar *p, *ss;
+
+  #ifdef USE_READLINE
+  char *readline_line = NULL;
+  if (fn_readline != NULL)
+    {
+    if ((readline_line = fn_readline((i > 0)? "":"> ")) == NULL) break;
+    if (*readline_line != 0 && fn_addhist != NULL) fn_addhist(readline_line);
+    p = US readline_line;
+    }
+  else
+  #endif
+
+  /* readline() not in use */
+
+    {
+    if (Ufgets(buffer, sizeof(buffer), stdin) == NULL) break;
+    p = buffer;
+    }
+
+  /* Handle the line */
+
+  ss = p + (int)Ustrlen(p);
+  while (ss > p && isspace(ss[-1])) ss--;
+
+  if (i > 0)
+    {
+    while (p < ss && isspace(*p)) p++;   /* leading space after cont */
+    }
+
+  g = string_catn(g, p, ss - p);
+
+  #ifdef USE_READLINE
+  if (fn_readline) free(readline_line);
+  #endif
+
+  /* g can only be NULL if ss==p */
+  if (ss == p || g->s[g->ptr-1] != '\\')
+    break;
+
+  --g->ptr;
+  (void) string_from_gstring(g);
+  }
+
+if (!g) printf("\n");
+return string_from_gstring(g);
+}
+
+
+
+/*************************************************
+*    Output usage information for the program    *
+*************************************************/
+
+/* This function is called when there are no recipients
+   or a specific --help argument was added.
+
+Arguments:
+  progname      information on what name we were called by
+
+Returns:        DOES NOT RETURN
+*/
+
+static void
+exim_usage(uschar *progname)
+{
+
+/* Handle specific program invocation variants */
+if (Ustrcmp(progname, US"-mailq") == 0)
+  exim_fail(
+    "mailq - list the contents of the mail queue\n\n"
+    "For a list of options, see the Exim documentation.\n");
+
+/* Generic usage - we output this whatever happens */
+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");
+}
+
+
+
+/*************************************************
+*    Validate that the macros given are okay     *
+*************************************************/
+
+/* Typically, Exim will drop privileges if macros are supplied.  In some
+cases, we want to not do so.
+
+Arguments:    opt_D_used - true if the commandline had a "-D" option
+Returns:      true if trusted, false otherwise
+*/
+
+static BOOL
+macros_trusted(BOOL opt_D_used)
+{
+#ifdef WHITELIST_D_MACROS
+macro_item *m;
+uschar *whitelisted, *end, *p, **whites, **w;
+int white_count, i, n;
+size_t len;
+BOOL prev_char_item, found;
+#endif
+
+if (!opt_D_used)
+  return TRUE;
+#ifndef WHITELIST_D_MACROS
+return FALSE;
+#else
+
+/* We only trust -D overrides for some invoking users:
+root, the exim run-time user, the optional config owner user.
+I don't know why config-owner would be needed, but since they can own the
+config files anyway, there's no security risk to letting them override -D. */
+if ( ! ((real_uid == root_uid)
+     || (real_uid == exim_uid)
+#ifdef CONFIGURE_OWNER
+     || (real_uid == config_uid)
+#endif
+   ))
+  {
+  debug_printf("macros_trusted rejecting macros for uid %d\n", (int) real_uid);
+  return FALSE;
+  }
+
+/* Get a list of macros which are whitelisted */
+whitelisted = string_copy_malloc(US WHITELIST_D_MACROS);
+prev_char_item = FALSE;
+white_count = 0;
+for (p = whitelisted; *p != '\0'; ++p)
+  {
+  if (*p == ':' || isspace(*p))
+    {
+    *p = '\0';
+    if (prev_char_item)
+      ++white_count;
+    prev_char_item = FALSE;
+    continue;
+    }
+  if (!prev_char_item)
+    prev_char_item = TRUE;
+  }
+end = p;
+if (prev_char_item)
+  ++white_count;
+if (!white_count)
+  return FALSE;
+whites = store_malloc(sizeof(uschar *) * (white_count+1));
+for (p = whitelisted, i = 0; (p != end) && (i < white_count); ++p)
+  {
+  if (*p != '\0')
+    {
+    whites[i++] = p;
+    if (i == white_count)
+      break;
+    while (*p != '\0' && p < end)
+      ++p;
+    }
+  }
+whites[i] = NULL;
+
+/* The list of commandline macros should be very short.
+Accept the N*M complexity. */
+for (m = macros_user; m; m = m->next) if (m->command_line)
+  {
+  found = FALSE;
+  for (w = whites; *w; ++w)
+    if (Ustrcmp(*w, m->name) == 0)
+      {
+      found = TRUE;
+      break;
+      }
+  if (!found)
+    return FALSE;
+  if (!m->replacement)
+    continue;
+  if ((len = m->replen) == 0)
+    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);
+    return FALSE;
+    }
+  }
+DEBUG(D_any) debug_printf("macros_trusted overridden to true by whitelisting\n");
+return TRUE;
+#endif
+}
+
+
+/*************************************************
+*          Expansion testing			 *
+*************************************************/
+
+/* Expand and print one item, doing macro-processing.
+
+Arguments:
+  item		line for expansion
+*/
+
+static void
+expansion_test_line(uschar * line)
+{
+int len;
+BOOL dummy_macexp;
+
+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);
+
+if (isupper(big_buffer[0]))
+  {
+  if (macro_read_assignment(big_buffer))
+    printf("Defined macro '%s'\n", mlast->name);
+  }
+else
+  if ((line = expand_string(big_buffer))) printf("%s\n", CS line);
+  else printf("Failed: %s\n", expand_string_message);
+}
+
+
+
+/*************************************************
+*          Entry point and high-level code       *
+*************************************************/
+
+/* Entry point for the Exim mailer. Analyse the arguments and arrange to take
+the appropriate action. All the necessary functions are present in the one
+binary. I originally thought one should split it up, but it turns out that so
+much of the apparatus is needed in each chunk that one might as well just have
+it all available all the time, which then makes the coding easier as well.
+
+Arguments:
+  argc      count of entries in argv
+  argv      argument strings, with argv[0] being the program name
+
+Returns:    EXIT_SUCCESS if terminated successfully
+            EXIT_FAILURE otherwise, except when a message has been sent
+              to the sender, and -oee was given
+*/
+
+int
+main(int argc, char **cargv)
+{
+uschar **argv = USS cargv;
+int  arg_receive_timeout = -1;
+int  arg_smtp_receive_timeout = -1;
+int  arg_error_handling = error_handling;
+int  filter_sfd = -1;
+int  filter_ufd = -1;
+int  group_count;
+int  i, rv;
+int  list_queue_option = 0;
+int  msg_action = 0;
+int  msg_action_arg = -1;
+int  namelen = (argv[0] == NULL)? 0 : Ustrlen(argv[0]);
+int  queue_only_reason = 0;
+#ifdef EXIM_PERL
+int  perl_start_option = 0;
+#endif
+int  recipients_arg = argc;
+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 count_queue = FALSE;
+BOOL expansion_test = FALSE;
+BOOL extract_recipients = FALSE;
+BOOL flag_G = FALSE;
+BOOL flag_n = FALSE;
+BOOL forced_delivery = FALSE;
+BOOL f_end_dot = FALSE;
+BOOL deliver_give_up = FALSE;
+BOOL list_queue = FALSE;
+BOOL list_options = FALSE;
+BOOL list_config = FALSE;
+BOOL local_queue_only;
+BOOL more = TRUE;
+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 session_local_queue_only;
+BOOL unprivileged;
+BOOL removed_privilege = FALSE;
+BOOL usage_wanted = FALSE;
+BOOL verify_address_mode = FALSE;
+BOOL verify_as_sender = 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 *log_oneline = NULL;
+uschar *malware_test_file = NULL;
+uschar *real_sender_address;
+uschar *originator_home = US"/";
+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;
+gid_t group_list[EXIM_GROUPLIST_SIZE];
+
+/* For the -bI: flag */
+enum commandline_info info_flag = CMDINFO_NONE;
+BOOL info_stdout = FALSE;
+
+/* Possible options for -R and -S */
+
+static uschar *rsopts[] = { US"f", US"ff", US"r", US"rf", US"rff" };
+
+/* Need to define this in case we need to change the environment in order
+to get rid of a bogus time zone. We have to make it char rather than uschar
+because some OS define it in /usr/include/unistd.h. */
+
+extern char **environ;
+
+/* 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. */
+
+#ifdef EXIM_USERNAME
+if (route_finduser(US EXIM_USERNAME, &pw, &exim_uid))
+  {
+  if (exim_uid == 0)
+    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
+    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");
+#endif
+  }
+else
+  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))
+  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))
+  exim_fail("exim: failed to find uid for user name \"%s\"\n",
+    CONFIGURE_OWNERNAME);
+#endif
+
+/* We default the system_filter_user to be the Exim run-time user, as a
+sane non-root value. */
+system_filter_uid = exim_uid;
+
+#ifdef CONFIGURE_GROUPNAME
+if (!route_findgroup(US CONFIGURE_GROUPNAME, &config_gid))
+  exim_fail("exim: failed to find gid for group name \"%s\"\n",
+    CONFIGURE_GROUPNAME);
+#endif
+
+/* 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
+#endif
+
+/* 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. */
+
+f.running_in_test_harness =
+  *running_status == '<' && Ustrcmp(running_status, "<<<testing>>>") == 0;
+if (f.running_in_test_harness)
+  debug_store = TRUE;
+
+/* 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
+follow this. A "strange" locale can affect the formatting of timestamps, so we
+make quite sure. */
+
+setlocale(LC_ALL, "C");
+
+/* Set up the default handler for timing using alarm(). */
+
+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. */
+
+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
+indirection, because some systems don't allow writing to the variable "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. */
+
+big_buffer = store_malloc(big_buffer_size);
+
+/* Set up the handler for the data request signal, and set the initial
+descriptive text. */
+
+set_process_info("initializing");
+os_restarting_signal(SIGUSR1, usr1_handler);
+
+/* 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. */
+
+signal(SIGHUP, SIG_IGN);
+
+/* We don't want to die on pipe errors as the code is written to handle
+the write error instead. */
+
+signal(SIGPIPE, SIG_IGN);
+
+/* Under some circumstance on some OS, Exim can get called with SIGCHLD
+set to SIG_IGN. This causes subprocesses that complete before the parent
+process waits for them not to hang around, so when Exim calls wait(), nothing
+is there. The wait() code has been made robust against this, but let's ensure
+that SIGCHLD is set to SIG_DFL, because it's tidier to wait and get a process
+ending status. We use sigaction rather than plain signal() on those OS where
+SA_NOCLDWAIT exists, because we want to be sure it is turned off. (There was a
+problem on AIX with this.) */
+
+#ifdef SA_NOCLDWAIT
+  {
+  struct sigaction act;
+  act.sa_handler = SIG_DFL;
+  sigemptyset(&(act.sa_mask));
+  act.sa_flags = 0;
+  sigaction(SIGCHLD, &act, NULL);
+  }
+#else
+signal(SIGCHLD, SIG_DFL);
+#endif
+
+/* Save the arguments for use if we re-exec exim as a daemon after receiving
+SIGHUP. */
+
+sighup_argv = argv;
+
+/* Set up the version number. Set up the leading 'E' for the external form of
+message ids, set the pointer to the internal form, and initialize it to
+indicate no message being processed. */
+
+version_init();
+message_id_option[0] = '-';
+message_id_external = message_id_option + 1;
+message_id_external[0] = 'E';
+message_id = message_id_external + 1;
+message_id[0] = 0;
+
+/* Set the umask to zero so that any files Exim creates using open() are
+created with the modes that it specifies. NOTE: Files created with fopen() have
+a problem, which was not recognized till rather late (February 2006). With this
+umask, such files will be world writeable. (They are all content scanning files
+in the spool directory, which isn't world-accessible, so this is not a
+disaster, but it's untidy.) I don't want to change this overall setting,
+however, because it will interact badly with the open() calls. Instead, there's
+now a function called modefopen() that fiddles with the umask while calling
+fopen(). */
+
+(void)umask(0);
+
+/* Precompile the regular expression for matching a message id. Keep this in
+step with the code that generates ids in the accept.c module. We need to do
+this here, because the -M options check their arguments for syntactic validity
+using mac_ismsgid, which uses this. */
+
+regex_ismsgid =
+  regex_must_compile(US"^(?:[^\\W_]{6}-){2}[^\\W_]{2}$", FALSE, 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
+terminating whitespace character is included. */
+
+regex_smtp_code =
+  regex_must_compile(US"^\\d\\d\\d\\s(?:\\d\\.\\d\\d?\\d?\\.\\d\\d?\\d?\\s)?",
+    FALSE, TRUE);
+
+#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);
+#endif
+
+for (i = 0; i < REGEX_VARS; i++) regex_vars[i] = NULL;
+
+/* 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 ((namelen == 5 && Ustrcmp(argv[0], "mailq") == 0) ||
+    (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/mailq", 6) == 0))
+  {
+  list_queue = TRUE;
+  receiving_message = FALSE;
+  called_as = US"-mailq";
+  }
+
+/* If the program is called as "rmail" treat it as equivalent to
+"exim -i -oee", thus allowing UUCP messages to be input using non-SMTP mode,
+i.e. preventing a single dot on a line from terminating the message, and
+returning with zero return code, even in cases of error (provided an error
+message has been sent). */
+
+if ((namelen == 5 && Ustrcmp(argv[0], "rmail") == 0) ||
+    (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rmail", 6) == 0))
+  {
+  f.dot_ends = FALSE;
+  called_as = US"-rmail";
+  errors_sender_rc = EXIT_SUCCESS;
+  }
+
+/* If the program is called as "rsmtp" treat it as equivalent to "exim -bS";
+this is a smail convention. */
+
+if ((namelen == 5 && Ustrcmp(argv[0], "rsmtp") == 0) ||
+    (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rsmtp", 6) == 0))
+  {
+  smtp_input = smtp_batched_input = TRUE;
+  called_as = US"-rsmtp";
+  }
+
+/* If the program is called as "runq" treat it as equivalent to "exim -q";
+this is a smail convention. */
+
+if ((namelen == 4 && Ustrcmp(argv[0], "runq") == 0) ||
+    (namelen  > 4 && Ustrncmp(argv[0] + namelen - 5, "/runq", 5) == 0))
+  {
+  queue_interval = 0;
+  receiving_message = FALSE;
+  called_as = US"-runq";
+  }
+
+/* If the program is called as "newaliases" treat it as equivalent to
+"exim -bi"; this is a sendmail convention. */
+
+if ((namelen == 10 && Ustrcmp(argv[0], "newaliases") == 0) ||
+    (namelen  > 10 && Ustrncmp(argv[0] + namelen - 11, "/newaliases", 11) == 0))
+  {
+  bi_option = TRUE;
+  receiving_message = FALSE;
+  called_as = US"-newaliases";
+  }
+
+/* Save the original effective uid for a couple of uses later. It should
+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
+(or setgid) to something other than root, which could be the case in some
+special configurations. */
+
+real_uid = getuid();
+real_gid = getgid();
+
+if (real_uid == root_uid)
+  {
+  if ((rv = setgid(real_gid)))
+    exim_fail("exim: setgid(%ld) failed: %s\n",
+        (long int)real_gid, strerror(errno));
+  if ((rv = setuid(real_uid)))
+    exim_fail("exim: setuid(%ld) failed: %s\n",
+        (long int)real_uid, strerror(errno));
+  }
+
+/* If neither the original real uid nor the original euid was root, Exim is
+running in an unprivileged state. */
+
+unprivileged = (real_uid != root_uid && original_euid != root_uid);
+
+/* 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++)
+  {
+  BOOL badarg = FALSE;
+  uschar *arg = argv[i];
+  uschar *argrest;
+  int switchchar;
+
+  /* An argument not starting with '-' is the start of a recipients list;
+  break out of the options-scanning loop. */
+
+  if (arg[0] != '-')
+    {
+    recipients_arg = i;
+    break;
+    }
+
+  /* An option consisting of -- terminates the options */
+
+  if (Ustrcmp(arg, "--") == 0)
+    {
+    recipients_arg = i + 1;
+    break;
+    }
+
+  /* Handle flagged options */
+
+  switchchar = arg[1];
+  argrest = arg+2;
+
+  /* Make all -ex options synonymous with -oex arguments, since that
+  is assumed by various callers. Also make -qR options synonymous with -R
+  options, as that seems to be required as well. Allow for -qqR too, and
+  the same for -S options. */
+
+  if (Ustrncmp(arg+1, "oe", 2) == 0 ||
+      Ustrncmp(arg+1, "qR", 2) == 0 ||
+      Ustrncmp(arg+1, "qS", 2) == 0)
+    {
+    switchchar = arg[2];
+    argrest++;
+    }
+  else if (Ustrncmp(arg+1, "qqR", 3) == 0 || Ustrncmp(arg+1, "qqS", 3) == 0)
+    {
+    switchchar = arg[3];
+    argrest += 2;
+    f.queue_2stage = TRUE;
+    }
+
+  /* Make -r synonymous with -f, since it is a documented alias */
+
+  else if (arg[1] == 'r') switchchar = 'f';
+
+  /* Make -ov synonymous with -v */
+
+  else if (Ustrcmp(arg, "-ov") == 0)
+    {
+    switchchar = 'v';
+    argrest++;
+    }
+
+  /* deal with --option_aliases */
+  else if (switchchar == '-')
+    {
+    if (Ustrcmp(argrest, "help") == 0)
+      {
+      usage_wanted = TRUE;
+      break;
+      }
+    else if (Ustrcmp(argrest, "version") == 0)
+      {
+      switchchar = 'b';
+      argrest = US"V";
+      }
+    }
+
+  /* High-level switch on active initial letter */
+
+  switch(switchchar)
+    {
+
+    /* 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;
+
+    /* -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;
+
+
+    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')
+      {
+      f.daemon_listen = TRUE;
+      if (*(++argrest) == 'f') 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
+    */
+
+    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; }
+      }
+
+    /* -bF:  Run system filter test */
+
+    else if (*argrest == 'F')
+      {
+      filter_test |= checking = FTEST_SYSTEM;
+      if (*(++argrest) != 0) { badarg = TRUE; break; }
+      if (++i < argc) filter_test_sfile = argv[i]; else
+        exim_fail("exim: file name expected after %s\n", argv[i-1]);
+      }
+
+    /* -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
+    */
+
+    else if (*argrest == 'f')
+      {
+      if (*(++argrest) == 0)
+        {
+        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 = 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; }
+        }
+      }
+
+    /* -bh: Host checking - an IP address must follow. */
+
+    else if (Ustrcmp(argrest, "h") == 0 || Ustrcmp(argrest, "hc") == 0)
+      {
+      if (++i >= argc) { badarg = TRUE; break; }
+      sender_host_address = argv[i];
+      host_checking = checking = f.log_testing_mode = TRUE;
+      f.host_checking_callout = argrest[1] == 'c';
+      message_logs = FALSE;
+      }
+
+    /* -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, "i") == 0) bi_option = TRUE;
+
+    /* -bI: provide information, of the type to follow after a colon.
+    This is an Exim flag. */
+
+    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;
+          }
+        }
+      }
+
+    /* -bm: Accept and deliver message - the default option. Reinstate
+    receiving_message, which got turned off for all -b options. */
+
+    else if (Ustrcmp(argrest, "m") == 0) receiving_message = TRUE;
+
+    /* -bmalware: test the filename given for malware */
+
+    else if (Ustrcmp(argrest, "malware") == 0)
+      {
+      if (++i >= argc) { badarg = TRUE; break; }
+      checking = TRUE;
+      malware_test_file = argv[i];
+      }
+
+    /* -bnq: For locally originating messages, do not qualify unqualified
+    addresses. In the envelope, this causes errors; in header lines they
+    just get left. */
+
+    else if (Ustrcmp(argrest, "nq") == 0)
+      {
+      f.allow_unqualified_sender = FALSE;
+      f.allow_unqualified_recipient = FALSE;
+      }
+
+    /* -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;
+        }
+
+      if (*argrest == 'r')
+        {
+        list_queue_option = 8;
+        argrest++;
+        }
+      else list_queue_option = 0;
+
+      list_queue = TRUE;
+
+      /* -bp: List the contents of the mail queue, top-level only */
+
+      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)
+      {
+      /* -bP config: we need to setup here, because later,
+       * when list_options is checked, the config is read already */
+      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;
+        }
+      }
+
+    /* -brt: Test retry configuration lookup */
+
+    else if (Ustrcmp(argrest, "rt") == 0)
+      {
+      checking = TRUE;
+      test_retry_arg = i + 1;
+      goto END_ARG;
+      }
+
+    /* -brw: Test rewrite configuration */
+
+    else if (Ustrcmp(argrest, "rw") == 0)
+      {
+      checking = TRUE;
+      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)
+      f.address_test_mode = checking = f.log_testing_mode = TRUE;
+
+    /* -bv: verify addresses */
+
+    else if (Ustrcmp(argrest, "v") == 0)
+      verify_address_mode = checking = f.log_testing_mode = TRUE;
+
+    /* -bvs: verify sender addresses */
+
+    else if (Ustrcmp(argrest, "vs") == 0)
+      {
+      verify_address_mode = checking = f.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);
+      f.log_testing_mode = TRUE;
+      }
+
+    /* -bw: inetd wait mode, accept a listening socket as stdin */
+
+    else if (*argrest == 'w')
+      {
+      f.inetd_wait_mode = TRUE;
+      f.background_daemon = FALSE;
+      f.daemon_listen = TRUE;
+      if (*(++argrest) != '\0')
+        if ((inetd_wait_timeout = readconf_readtime(argrest, 0, FALSE)) <= 0)
+          exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
+      }
+
+    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);
+      const 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))
+          exim_fail("-C Permission denied\n");
+        }
+      #endif
+      if (real_uid != root_uid)
+        {
+        #ifdef TRUSTED_CONFIG_LIST
+
+        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 (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... */
+              void *reset_point = store_get(0);
+              uschar *trusted_configs[32];
+              int nr_configs = 0;
+              int i = 0;
+
+              while (Ufgets(big_buffer, big_buffer_size, trust_list))
+                {
+                uschar *start = big_buffer, *nl;
+                while (*start && isspace(*start))
+                start++;
+                if (*start != '/')
+                  continue;
+                nl = Ustrchr(start, '\n');
+                if (nl)
+                  *nl = 0;
+                trusted_configs[nr_configs++] = string_copy(start);
+                if (nr_configs == 32)
+                  break;
+                }
+              fclose(trust_list);
+
+              if (nr_configs)
+                {
+                int sep = 0;
+                const uschar *list = argrest;
+                uschar *filename;
+                while (f.trusted_config && (filename = string_nextinlist(&list,
+                        &sep, big_buffer, big_buffer_size)) != NULL)
+                  {
+                  for (i=0; i < nr_configs; i++)
+                    {
+                    if (Ustrcmp(filename, trusted_configs[i]) == 0)
+                      break;
+                    }
+                  if (i == nr_configs)
+                    {
+                    f.trusted_config = FALSE;
+                    break;
+                    }
+                  }
+                store_reset(reset_point);
+                }
+              else
+                {
+                /* No valid prefixes found in trust_list file. */
+                f.trusted_config = FALSE;
+                }
+              }
+	    }
+          else
+            {
+            /* Could not open trust_list file. */
+            f.trusted_config = FALSE;
+            }
+          }
+      #else
+        /* Not root; don't trust config */
+        f.trusted_config = FALSE;
+      #endif
+        }
+
+      config_main_filelist = argrest;
+      f.config_changed = TRUE;
+      }
+    break;
+
+
+    /* -D: set up a macro definition */
+
+    case 'D':
+#ifdef DISABLE_D_OPTION
+      exim_fail("exim: -D is not available in this Exim binary\n");
+#else
+      {
+      int ptr = 0;
+      macro_item *m;
+      uschar name[24];
+      uschar *s = argrest;
+
+      opt_D_used = TRUE;
+      while (isspace(*s)) s++;
+
+      if (*s < 'A' || *s > 'Z')
+        exim_fail("exim: macro name set by -D must start with "
+          "an upper case letter\n");
+
+      while (isalnum(*s) || *s == '_')
+        {
+        if (ptr < sizeof(name)-1) name[ptr++] = *s;
+        s++;
+        }
+      name[ptr] = 0;
+      if (ptr == 0) { badarg = TRUE; break; }
+      while (isspace(*s)) s++;
+      if (*s != 0)
+        {
+        if (*s++ != '=') { badarg = TRUE; break; }
+        while (isspace(*s)) s++;
+        }
+
+      for (m = macros_user; m; m = m->next)
+        if (Ustrcmp(m->name, name) == 0)
+          exim_fail("exim: duplicated -D in command line\n");
+
+      m = macro_create(name, s, TRUE);
+
+      if (clmacro_count >= MAX_CLMACROS)
+        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;
+
+    /* -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':
+    if (Ustrcmp(argrest, "ropcr") == 0)
+      {
+      /* drop_cr = TRUE; */
+      }
+
+    /* Use an intermediate variable so that we don't set debugging while
+    decoding the debugging bits. */
+
+    else
+      {
+      unsigned int selector = D_default;
+      debug_selector = 0;
+      debug_file = NULL;
+      if (*argrest == 'd')
+        {
+        f.debug_daemon = TRUE;
+        argrest++;
+        }
+      if (*argrest != 0)
+        decode_bits(&selector, 1, debug_notall, argrest,
+          debug_options, debug_options_count, US"debug", 0);
+      debug_selector = selector;
+      }
+    break;
+
+
+    /* -E: This is a local error message. This option is not intended for
+    external use at all, but is not restricted to trusted callers because it
+    does no harm (just suppresses certain error messages) and if Exim is run
+    not setuid root it won't always be trusted when it generates error
+    messages using this option. If there is a message id following -E, point
+    message_reference at it, for logging. */
+
+    case 'E':
+    f.local_error_message = TRUE;
+    if (mac_ismsgid(argrest)) message_reference = argrest;
+    break;
+
+
+    /* -ex: The vacation program calls sendmail with the undocumented "-eq"
+    option, so it looks as if historically the -oex options are also callable
+    without the leading -o. So we have to accept them. Before the switch,
+    anything starting -oe has been converted to -e. Exim does not support all
+    of the sendmail error options. */
+
+    case 'e':
+    if (Ustrcmp(argrest, "e") == 0)
+      {
+      arg_error_handling = ERRORS_SENDER;
+      errors_sender_rc = EXIT_SUCCESS;
+      }
+    else if (Ustrcmp(argrest, "m") == 0) arg_error_handling = ERRORS_SENDER;
+    else if (Ustrcmp(argrest, "p") == 0) arg_error_handling = ERRORS_STDERR;
+    else if (Ustrcmp(argrest, "q") == 0) arg_error_handling = ERRORS_STDERR;
+    else if (Ustrcmp(argrest, "w") == 0) arg_error_handling = ERRORS_SENDER;
+    else badarg = TRUE;
+    break;
+
+
+    /* -F: Set sender's full name, used instead of the gecos entry from
+    the password file. Since users can usually alter their gecos entries,
+    there's no security involved in using this instead. The data can follow
+    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;
+    f.sender_name_forced = TRUE;
+    break;
+
+
+    /* -f: Set sender's address - this value is only actually used if Exim is
+    run by a trusted user, or if untrusted_set_sender is set and matches the
+    address, except that the null address can always be set by any user. The
+    test for this happens later, when the value given here is ignored when not
+    permitted. For an untrusted user, the actual sender is still put in Sender:
+    if it doesn't match the From: header (unless no_local_from_check is set).
+    The data can follow the -f or be in the next argument. The -r switch is an
+    obsolete form of -f but since there appear to be programs out there that
+    use anything that sendmail has ever supported, better accept it - the
+    synonymizing is done before the switch above.
+
+    At this stage, we must allow domain literal addresses, because we don't
+    know what the setting of allow_domain_literals is yet. Ditto for trailing
+    dots and strip_trailing_dot. */
+
+    case 'f':
+      {
+      int dummy_start, dummy_end;
+      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 */
+      else
+        {
+        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;
+#ifdef SUPPORT_I18N
+	allow_utf8_domains = TRUE;
+#endif
+        sender_address = parse_extract_address(argrest, &errmess,
+          &dummy_start, &dummy_end, &sender_address_domain, TRUE);
+#ifdef SUPPORT_I18N
+	message_smtputf8 =  string_is_utf8(sender_address);
+	allow_utf8_domains = FALSE;
+#endif
+        allow_domain_literals = FALSE;
+        strip_trailing_dot = FALSE;
+        if (!sender_address)
+          exim_fail("exim: bad -f address \"%s\": %s\n", argrest, errmess);
+        }
+      f.sender_address_forced = TRUE;
+      }
+    break;
+
+    /* -G: sendmail invocation to specify that it's a gateway submission and
+    sendmail may complain about problems instead of fixing them.
+    We make it equivalent to an ACL "control = suppress_local_fixups" and do
+    not at this time complain about problems. */
+
+    case 'G':
+    flag_G = TRUE;
+    break;
+
+    /* -h: Set the hop count for an incoming message. Exim does not currently
+    support this; it always computes it by counting the Received: headers.
+    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 (!isdigit(*argrest)) badarg = TRUE;
+    break;
+
+
+    /* -i: Set flag so dot doesn't end non-SMTP input (same as -oi, seems
+    not to be documented for sendmail but mailx (at least) uses it) */
+
+    case 'i':
+    if (*argrest == 0) f.dot_ends = FALSE; else badarg = TRUE;
+    break;
+
+
+    /* -L: set the identifier used for syslog; equivalent to setting
+    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; }
+      }
+    if ((sz = Ustrlen(argrest)) > 32)
+      exim_fail("exim: the -L syslog name is too long: \"%s\"\n", argrest);
+    if (sz < 1)
+      exim_fail("exim: the -L syslog name is too short\n");
+    cmdline_syslog_name = argrest;
+    break;
+
+    case 'M':
+    receiving_message = FALSE;
+
+    /* -MC:  continue delivery of another message via an existing open
+    file descriptor. This option is used for an internal call by the
+    smtp transport when there is a pending message waiting to go to an
+    address to which it has got a connection. Five subsequent arguments are
+    required: transport name, host name, IP address, sequence number, and
+    message_id. Transports may decline to create new processes if the sequence
+    number gets too big. The channel is stdin. This (-MC) must be the last
+    argument. There's a subsequent check that the real-uid is privileged.
+
+    If we are running in the test harness. delay for a bit, to let the process
+    that set this one up complete. This makes for repeatability of the logging,
+    etc. output. */
+
+    if (Ustrcmp(argrest, "C") == 0)
+      {
+      union sockaddr_46 interface_sock;
+      EXIM_SOCKLEN_T size = sizeof(interface_sock);
+
+      if (argc != i + 6)
+        exim_fail("exim: too many or too few arguments after -MC\n");
+
+      if (msg_action_arg >= 0)
+        exim_fail("exim: incompatible arguments\n");
+
+      continue_transport = argv[++i];
+      continue_hostname = argv[++i];
+      continue_host_address = argv[++i];
+      continue_sequence = Uatoi(argv[++i]);
+      msg_action = MSG_DELIVER;
+      msg_action_arg = ++i;
+      forced_delivery = TRUE;
+      queue_run_pid = passed_qr_pid;
+      queue_run_pipe = passed_qr_pipe;
+
+      if (!mac_ismsgid(argv[i]))
+        exim_fail("exim: malformed message id %s after -MC option\n",
+          argv[i]);
+
+      /* Set up $sending_ip_address and $sending_port, unless proxied */
+
+      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 (f.running_in_test_harness) millisleep(500);
+      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. */
+
+	case 'A': f.smtp_authenticated = TRUE; break;
+
+    /* -MCD: set the smtp_use_dsn flag; this indicates that the host
+       that exim is connected to supports the esmtp extension DSN */
+
+	case 'D': smtp_peer_options |= OPTION_DSN; break;
+
+    /* -MCG: set the queue name, to a non-default value */
+
+	case 'G': if (++i < argc) queue_name = string_copy(argv[i]);
+		  else badarg = TRUE;
+		  break;
+
+    /* -MCK: the peer offered CHUNKING.  Must precede -MC */
+
+	case 'K': smtp_peer_options |= OPTION_CHUNKING; break;
+
+    /* -MCP: set the smtp_use_pipelining flag; this is useful only when
+    it preceded -MC (see above) */
+
+	case 'P': smtp_peer_options |= OPTION_PIPE; break;
+
+    /* -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) */
+
+	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;
+
+    /* -MCS: set the smtp_use_size flag; this is useful only when it
+    precedes -MC (see above) */
+
+	case 'S': smtp_peer_options |= OPTION_SIZE; break;
+
+#ifdef SUPPORT_TLS
+    /* -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 = argv[i];
+		  else badarg = TRUE;
+		  if (++i < argc) sending_port = (int)(Uatol(argv[i]));
+		  else badarg = TRUE;
+		  if (++i < argc) continue_proxy_cipher = argv[i];
+		  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. */
+
+	case 'T': smtp_peer_options |= OPTION_TLS; break;
+#endif
+
+	default:  badarg = TRUE; break;
+	}
+      break;
+      }
+
+#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_REQUIRETLS)
+    /* -MS   set REQUIRETLS on (new) message */
+
+    else if (*argrest == 'S')
+      {
+      tls_requiretls |= REQUIRETLS_MSG;
+      break;
+      }
+#endif
+
+    /* -M[x]: various operations on the following list of message ids:
+       -M    deliver the messages, ignoring next retry times and thawing
+       -Mc   deliver the messages, checking next retry times, no thawing
+       -Mf   freeze the messages
+       -Mg   give up on the messages
+       -Mt   thaw the messages
+       -Mrm  remove the messages
+    In the above cases, this must be the last option. There are also the
+    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)
+       -Mmad mark all recipients delivered
+       -Mmd  mark recipients(s) delivered
+       -Mes  edit sender
+       -Mset load a message for use with -be
+       -Mvb  show body
+       -Mvc  show copy (of whole message, in RFC 2822 format)
+       -Mvh  show header
+       -Mvl  show log
+    */
+
+    else if (*argrest == 0)
+      {
+      msg_action = MSG_DELIVER;
+      forced_delivery = f.deliver_force_thaw = TRUE;
+      }
+    else if (Ustrcmp(argrest, "ar") == 0)
+      {
+      msg_action = MSG_ADD_RECIPIENT;
+      one_msg_action = TRUE;
+      }
+    else if (Ustrcmp(argrest, "c") == 0)  msg_action = MSG_DELIVER;
+    else if (Ustrcmp(argrest, "es") == 0)
+      {
+      msg_action = MSG_EDIT_SENDER;
+      one_msg_action = TRUE;
+      }
+    else if (Ustrcmp(argrest, "f") == 0)  msg_action = MSG_FREEZE;
+    else if (Ustrcmp(argrest, "g") == 0)
+      {
+      msg_action = MSG_DELIVER;
+      deliver_give_up = TRUE;
+      }
+    else if (Ustrcmp(argrest, "mad") == 0)
+      {
+      msg_action = MSG_MARK_ALL_DELIVERED;
+      }
+    else if (Ustrcmp(argrest, "md") == 0)
+      {
+      msg_action = MSG_MARK_DELIVERED;
+      one_msg_action = TRUE;
+      }
+    else if (Ustrcmp(argrest, "rm") == 0) msg_action = MSG_REMOVE;
+    else if (Ustrcmp(argrest, "set") == 0)
+      {
+      msg_action = MSG_LOAD;
+      one_msg_action = TRUE;
+      }
+    else if (Ustrcmp(argrest, "t") == 0)  msg_action = MSG_THAW;
+    else if (Ustrcmp(argrest, "vb") == 0)
+      {
+      msg_action = MSG_SHOW_BODY;
+      one_msg_action = TRUE;
+      }
+    else if (Ustrcmp(argrest, "vc") == 0)
+      {
+      msg_action = MSG_SHOW_COPY;
+      one_msg_action = TRUE;
+      }
+    else if (Ustrcmp(argrest, "vh") == 0)
+      {
+      msg_action = MSG_SHOW_HEADER;
+      one_msg_action = TRUE;
+      }
+    else if (Ustrcmp(argrest, "vl") == 0)
+      {
+      msg_action = MSG_SHOW_LOG;
+      one_msg_action = TRUE;
+      }
+    else { badarg = TRUE; break; }
+
+    /* All the -Mxx options require at least one message id. */
+
+    msg_action_arg = i + 1;
+    if (msg_action_arg >= argc)
+      exim_fail("exim: no message ids given after %s option\n", arg);
+
+    /* 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]))
+        exim_fail("exim: malformed message id %s after %s option\n",
+          argv[j], arg);
+      goto END_ARG;   /* Remaining args are ids */
+      }
+
+    /* Others require only one message id, possibly followed by addresses,
+    which will be handled as normal arguments. */
+
+    else
+      {
+      if (!mac_ismsgid(argv[msg_action_arg]))
+        exim_fail("exim: malformed message id %s after %s option\n",
+          argv[msg_action_arg], arg);
+      i++;
+      }
+    break;
+
+
+    /* Some programs seem to call the -om option without the leading o;
+    for sendmail it askes for "me too". Exim always does this. */
+
+    case 'm':
+    if (*argrest != 0) badarg = TRUE;
+    break;
+
+
+    /* -N: don't do delivery - a debugging option that stops transports doing
+    their thing. It implies debugging at the D_v level. */
+
+    case 'N':
+    if (*argrest == 0)
+      {
+      f.dont_deliver = TRUE;
+      debug_selector |= D_v;
+      debug_file = stderr;
+      }
+    else badarg = TRUE;
+    break;
+
+
+    /* -n: This means "don't alias" in sendmail, apparently.
+    For normal invocations, it has no effect.
+    It may affect some other options. */
+
+    case 'n':
+    flag_n = TRUE;
+    break;
+
+    /* -O: Just ignore it. In sendmail, apparently -O option=value means set
+    option to the specified value. This form uses long names. We need to handle
+    -O option=value and -Ooption=value. */
+
+    case 'O':
+    if (*argrest == 0)
+      {
+      if (++i >= argc)
+        exim_fail("exim: string expected after -O\n");
+      }
+    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
+          exim_fail("exim: string expected after -oA\n");
+        }
+      }
+
+    /* -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))
+          exim_fail("exim: number expected after -oB\n");
+        connection_max_messages = Uatoi(p);
+        }
+      }
+
+    /* -odb: background delivery */
+
+    else if (Ustrcmp(argrest, "db") == 0)
+      {
+      f.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)
+      {
+      f.synchronous_delivery = TRUE;
+      arg_queue_only = FALSE;
+      queue_only_set = TRUE;
+      }
+
+    /* -odq: queue only */
+
+    else if (Ustrcmp(argrest, "dq") == 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, "dqs") == 0)
+      {
+      f.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 */
+
+    else if (Ustrcmp(argrest, "i") == 0 ||
+             Ustrcmp(argrest, "itrue") == 0)
+      f.dot_ends = FALSE;
+
+    /* -oM*: Set various characteristics for an incoming message; actually
+    acted on for trusted callers only. */
+
+    else if (*argrest == 'M')
+      {
+      if (i+1 >= argc)
+        exim_fail("exim: data expected after -o%s\n", argrest);
+
+      /* -oMa: Set sender host address */
+
+      if (Ustrcmp(argrest, "Ma") == 0) sender_host_address = argv[++i];
+
+      /* -oMaa: Set authenticator name */
+
+      else if (Ustrcmp(argrest, "Maa") == 0)
+        sender_host_authenticated = argv[++i];
+
+      /* -oMas: setting authenticated sender */
+
+      else if (Ustrcmp(argrest, "Mas") == 0) authenticated_sender = argv[++i];
+
+      /* -oMai: setting authenticated id */
+
+      else if (Ustrcmp(argrest, "Mai") == 0) authenticated_id = argv[++i];
+
+      /* -oMi: Set incoming interface address */
+
+      else if (Ustrcmp(argrest, "Mi") == 0) interface_address = argv[++i];
+
+      /* -oMm: Message reference */
+
+      else if (Ustrcmp(argrest, "Mm") == 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 = argv[++i];
+        }
+
+      /* -oMr: Received protocol */
+
+      else if (Ustrcmp(argrest, "Mr") == 0)
+
+        if (received_protocol)
+          exim_fail("received_protocol is set already\n");
+        else
+	  received_protocol = argv[++i];
+
+      /* -oMs: Set sender host name */
+
+      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 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). */
+
+    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)
+        exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
+      }
+
+    /* -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;
+
+
+    /* -ps: force Perl startup; -pd force delayed Perl startup */
+
+    case 'p':
+    #ifdef EXIM_PERL
+    if (*argrest == 's' && argrest[1] == 0)
+      {
+      perl_start_option = 1;
+      break;
+      }
+    if (*argrest == 'd' && argrest[1] == 0)
+      {
+      perl_start_option = -1;
+      break;
+      }
+    #endif
+
+    /* -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 != 0)
+      {
+      uschar *hn;
+
+      if (received_protocol)
+        exim_fail("received_protocol is set already\n");
+
+      hn = Ustrchr(argrest, ':');
+      if (hn == NULL)
+        received_protocol = argrest;
+      else
+        {
+	int old_pool = store_pool;
+	store_pool = POOL_PERM;
+        received_protocol = string_copyn(argrest, hn - argrest);
+	store_pool = old_pool;
+        sender_host_name = hn + 1;
+        }
+      }
+    break;
+
+
+    case 'q':
+    receiving_message = FALSE;
+    if (queue_interval >= 0)
+      exim_fail("exim: -q specified more than once\n");
+
+    /* -qq...: Do queue runs in a 2-stage manner */
+
+    if (*argrest == 'q')
+      {
+      f.queue_2stage = TRUE;
+      argrest++;
+      }
+
+    /* -qi...: Do only first (initial) deliveries */
+
+    if (*argrest == 'i')
+      {
+      f.queue_run_first_delivery = TRUE;
+      argrest++;
+      }
+
+    /* -qf...: Run the queue, forcing deliveries
+       -qff..: Ditto, forcing thawing as well */
+
+    if (*argrest == 'f')
+      {
+      f.queue_run_force = TRUE;
+      if (*++argrest == 'f')
+        {
+        f.deliver_force_thaw = TRUE;
+        argrest++;
+        }
+      }
+
+    /* -q[f][f]l...: Run the queue only on local deliveries */
+
+    if (*argrest == 'l')
+      {
+      f.queue_run_local = TRUE;
+      argrest++;
+      }
+
+    /* -q[f][f][l][G<name>]... Work on the named queue */
+
+    if (*argrest == 'G')
+      {
+      int i;
+      for (argrest++, i = 0; argrest[i] && argrest[i] != '/'; ) i++;
+      queue_name = string_copyn(argrest, i);
+      argrest += i;
+      if (*argrest == '/') argrest++;
+      }
+
+    /* -q[f][f][l][G<name>]: Run the queue, optionally forced, optionally local
+    only, optionally named, optionally starting from a given message id. */
+
+    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>/]<n>: Run the queue at regular intervals, optionally
+    forced, optionally local only, optionally named. */
+
+    else if ((queue_interval = readconf_readtime(*argrest ? argrest : argv[++i],
+						0, FALSE)) <= 0)
+      exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
+    break;
+
+
+    case 'R':   /* Synonymous with -qR... */
+    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
+
+    in all cases provided there are no further characters in this
+    argument. */
+
+    if (*argrest != 0)
+      {
+      int i;
+      for (i = 0; i < nelem(rsopts); i++)
+        if (Ustrcmp(argrest, rsopts[i]) == 0)
+          {
+          if (i != 2) f.queue_run_force = TRUE;
+          if (i >= 2) f.deliver_selectstring_regex = TRUE;
+          if (i == 1 || i == 4) f.deliver_force_thaw = TRUE;
+          argrest += Ustrlen(rsopts[i]);
+          }
+      }
+
+    /* -R: Set string to match in addresses for forced queue run to
+    pick out particular messages. */
+
+    if (*argrest)
+      deliver_selectstring = argrest;
+    else if (i+1 < argc)
+      deliver_selectstring = argv[++i];
+    else
+      exim_fail("exim: string expected after -R\n");
+    break;
+
+
+    /* -r: an obsolete synonym for -f (see above) */
+
+
+    /* -S: Like -R but works on sender. */
+
+    case 'S':   /* Synonymous with -qS... */
+    receiving_message = FALSE;
+
+    /* -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
+
+    in all cases provided there are no further characters in this
+    argument. */
+
+    if (*argrest)
+      {
+      int i;
+      for (i = 0; i < nelem(rsopts); i++)
+        if (Ustrcmp(argrest, rsopts[i]) == 0)
+          {
+          if (i != 2) f.queue_run_force = TRUE;
+          if (i >= 2) f.deliver_selectstring_sender_regex = TRUE;
+          if (i == 1 || i == 4) f.deliver_force_thaw = TRUE;
+          argrest += Ustrlen(rsopts[i]);
+          }
+      }
+
+    /* -S: Set string to match in addresses for forced queue run to
+    pick out particular messages. */
+
+    if (*argrest)
+      deliver_selectstring_sender = argrest;
+    else if (i+1 < argc)
+      deliver_selectstring_sender = argv[++i];
+    else
+      exim_fail("exim: string expected after -S\n");
+    break;
+
+    /* -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 (f.running_in_test_harness && Ustrcmp(argrest, "qt") == 0)
+      fudged_queue_times = argv[++i];
+    else badarg = TRUE;
+    break;
+
+
+    /* -t: Set flag to extract recipients from body of message. */
+
+    case 't':
+    if (*argrest == 0) extract_recipients = TRUE;
+
+    /* -ti: Set flag to extract recipients from body of message, and also
+    specify that dot does not end the message. */
+
+    else if (Ustrcmp(argrest, "i") == 0)
+      {
+      extract_recipients = TRUE;
+      f.dot_ends = FALSE;
+      }
+
+    /* -tls-on-connect: don't wait for STARTTLS (for old clients) */
+
+    #ifdef SUPPORT_TLS
+    else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_in.on_connect = TRUE;
+    #endif
+
+    else badarg = TRUE;
+    break;
+
+
+    /* -U: This means "initial user submission" in sendmail, apparently. The
+    doc claims that in future sendmail may refuse syntactically invalid
+    messages instead of fixing them. For the moment, we just ignore it. */
+
+    case 'U':
+    break;
+
+
+    /* -v: verify things - this is a very low-level debugging */
+
+    case 'v':
+    if (*argrest == 0)
+      {
+      debug_selector |= D_v;
+      debug_file = stderr;
+      }
+    else badarg = TRUE;
+    break;
+
+
+    /* -x: AIX uses this to indicate some fancy 8-bit character stuff:
+
+      The -x flag tells the sendmail command that mail from a local
+      mail program has National Language Support (NLS) extended characters
+      in the body of the mail item. The sendmail command can send mail with
+      extended NLS characters across networks that normally corrupts these
+      8-bit characters.
+
+    As Exim is 8-bit clean, it just ignores this flag. */
+
+    case 'x':
+    if (*argrest != 0) 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. */
+
+    case 'X':
+    if (*argrest == '\0')
+      if (++i >= argc)
+        exim_fail("exim: string expected after -X\n");
+    break;
+
+    case 'z':
+    if (*argrest == '\0')
+      if (++i < argc)
+	log_oneline = argv[i];
+      else
+        exim_fail("exim: file name expected after %s\n", argv[i-1]);
+    break;
+
+    /* All other initial characters are errors */
+
+    default:
+    badarg = TRUE;
+    break;
+    }         /* End of high-level switch statement */
+
+  /* Failed to recognize the option, or syntax error */
+
+  if (badarg)
+    exim_fail("exim abandoned: unknown, malformed, or incomplete "
+      "option %s\n", arg);
+  }
+
+
+/* If -R or -S have been specified without -q, assume a single queue run. */
+
+if (  (deliver_selectstring || deliver_selectstring_sender)
+   && queue_interval < 0)
+    queue_interval = 0;
+
+
+END_ARG:
+/* 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) &&
+    (f.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 &&
+    (f.daemon_listen || queue_interval > 0 || list_options ||
+      (checking && msg_action != MSG_LOAD) ||
+      bi_option || test_retry_arg >= 0 || test_rewrite_arg >= 0)
+    ) ||
+    (
+    (f.daemon_listen || queue_interval > 0) &&
+    (sender_address != NULL || list_options || list_queue || checking ||
+      bi_option)
+    ) ||
+    (
+    f.daemon_listen && queue_interval == 0
+    ) ||
+    (
+    f.inetd_wait_mode && queue_interval >= 0
+    ) ||
+    (
+    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 != NULL || filter_test != FTEST_NONE ||
+      extract_recipients)
+    ) ||
+    (
+    deliver_selectstring != NULL && queue_interval < 0
+    ) ||
+    (
+    msg_action == MSG_LOAD &&
+      (!expansion_test || expansion_test_message != NULL)
+    )
+   )
+  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
+to run in the foreground. */
+
+if (debug_selector != 0)
+  {
+  debug_file = stderr;
+  debug_fd = fileno(debug_file);
+  f.background_daemon = FALSE;
+  if (f.running_in_test_harness) millisleep(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)
+      show_whats_supported(stderr);
+    }
+  }
+
+/* When started with root privilege, ensure that the limits on the number of
+open files and the number of processes (where that is accessible) are
+sufficiently large, or are unset, in case Exim has been called from an
+environment where the limits are screwed down. Not all OS have the ability to
+change some of these limits. */
+
+if (unprivileged)
+  {
+  DEBUG(D_any) debug_print_ids(US"Exim has no root privilege:");
+  }
+else
+  {
+  struct rlimit rlp;
+
+  #ifdef RLIMIT_NOFILE
+  if (getrlimit(RLIMIT_NOFILE, &rlp) < 0)
+    {
+    log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NOFILE) failed: %s",
+      strerror(errno));
+    rlp.rlim_cur = rlp.rlim_max = 0;
+    }
+
+  /* I originally chose 1000 as a nice big number that was unlikely to
+  be exceeded. It turns out that some older OS have a fixed upper limit of
+  256. */
+
+  if (rlp.rlim_cur < 1000)
+    {
+    rlp.rlim_cur = rlp.rlim_max = 1000;
+    if (setrlimit(RLIMIT_NOFILE, &rlp) < 0)
+      {
+      rlp.rlim_cur = rlp.rlim_max = 256;
+      if (setrlimit(RLIMIT_NOFILE, &rlp) < 0)
+        log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NOFILE) failed: %s",
+          strerror(errno));
+      }
+    }
+  #endif
+
+  #ifdef RLIMIT_NPROC
+  if (getrlimit(RLIMIT_NPROC, &rlp) < 0)
+    {
+    log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NPROC) failed: %s",
+      strerror(errno));
+    rlp.rlim_cur = rlp.rlim_max = 0;
+    }
+
+  #ifdef RLIM_INFINITY
+  if (rlp.rlim_cur != RLIM_INFINITY && rlp.rlim_cur < 1000)
+    {
+    rlp.rlim_cur = rlp.rlim_max = RLIM_INFINITY;
+  #else
+  if (rlp.rlim_cur < 1000)
+    {
+    rlp.rlim_cur = rlp.rlim_max = 1000;
+  #endif
+    if (setrlimit(RLIMIT_NPROC, &rlp) < 0)
+      log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NPROC) failed: %s",
+        strerror(errno));
+    }
+  #endif
+  }
+
+/* Exim is normally entered as root (but some special configurations are
+possible that don't do this). However, it always spins off sub-processes that
+set their uid and gid as required for local delivery. We don't want to pass on
+any extra groups that root may belong to, so we want to get rid of them all at
+this point.
+
+We need to obey setgroups() at this stage, before possibly giving up root
+privilege for a changed configuration file, but later on we might need to
+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. */
+
+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
+known not to be different. On the "different" systems there is a single group
+list, and the first entry in it is the current group. On all other versions of
+Unix there is a supplementary group list, which is in *addition* to the current
+group. Consequently, to get rid of all extraneous groups on a "standard" system
+you pass over 0 groups to setgroups(), while on a "different" system you pass
+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.
+
+ 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
+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. */
+
+if (setgroups(0, NULL) != 0 && setgroups(1, group_list) != 0 && !unprivileged)
+  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
+not root, or if this is a filter testing run, remove any setuid privilege the
+program has and run as the underlying user.
+
+The exim user is locked out of this, which severely restricts the use of -C
+for some purposes.
+
+Otherwise, set the real ids to the effective values (should be root unless run
+from inetd, which it can either be root or the exim uid, if one is configured).
+
+There is a private mechanism for bypassing some of this, in order to make it
+possible to test lots of configurations automatically, without having either to
+recompile each time, or to patch in an actual configuration file name and other
+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 */
+    (!f.trusted_config ||                          /* Config changed, or */
+     !macros_trusted(opt_D_used)) &&		 /*  impermissible macros and */
+    real_uid != root_uid &&                      /* Not root, and */
+    !f.running_in_test_harness                     /* Not fudged */
+    ) ||                                         /*   OR   */
+    expansion_test                               /* expansion testing */
+    ||                                           /*   OR   */
+    filter_test != FTEST_NONE)                   /* Filter testing */
+  {
+  setgroups(group_count, group_list);
+  exim_setugid(real_uid, real_gid, FALSE,
+    US"-C, -D, -be or -bf forces real uid");
+  removed_privilege = TRUE;
+
+  /* In the normal case when Exim is called like this, stderr is available
+  and should be used for any logging information because attempts to write
+  to the log will usually fail. To arrange this, we unset really_exim. However,
+  if no stderr is available there is no point - we might as well have a go
+  at the log (if it fails, syslog will be written).
+
+  Note that if the invoker is Exim, the logs remain available. Messing with
+  this causes unlogged successful deliveries.  */
+
+  if (log_stderr && real_uid != exim_uid)
+    f.really_exim = FALSE;
+  }
+
+/* Privilege is to be retained for the moment. It may be dropped later,
+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. */
+
+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 (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));
+
+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));
+
+/* Initialise lookup_list
+If debugging, already called above via version reporting.
+In either case, we initialise the list of available lookups while running
+as root.  All dynamically modules are loaded from a directory which is
+hard-coded into the binary and is code which, if not a module, would be
+part of Exim already.  Ability to modify the content of the directory
+is equivalent to the ability to modify a setuid binary!
+
+This needs to happen before we read the main configuration. */
+init_lookup_list();
+
+#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
+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);
+
+/* 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) */
+
+readconf_main(checking || list_options);
+
+
+/* Now in directory "/" */
+
+if (cleanup_environment() == FALSE)
+  log_write(0, LOG_PANIC_DIE, "Can't cleanup environment");
+
+
+/* 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.
+This is the case if the real user is root or exim, or if the real group is
+exim, or if one of the supplementary groups is exim or a group listed in
+admin_groups. We don't fail all message actions immediately if not admin_user,
+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)
+  f.admin_user = TRUE;
+else
+  {
+  int i, j;
+  for (i = 0; i < group_count && !f.admin_user; i++)
+    if (group_list[i] == exim_gid)
+      f.admin_user = TRUE;
+    else if (admin_groups)
+      for (j = 1; j <= (int)admin_groups[0] && !f.admin_user; j++)
+        if (admin_groups[j] == group_list[i])
+          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
+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)
+  f.trusted_caller = TRUE;
+else
+  {
+  int i, j;
+
+  if (trusted_users)
+    for (i = 1; i <= (int)trusted_users[0] && !f.trusted_caller; i++)
+      if (trusted_users[i] == real_uid)
+        f.trusted_caller = TRUE;
+
+  if (trusted_groups)
+    for (i = 1; i <= (int)trusted_groups[0] && !f.trusted_caller; i++)
+      if (trusted_groups[i] == real_gid)
+        f.trusted_caller = TRUE;
+      else for (j = 0; j < group_count && !f.trusted_caller; j++)
+        if (trusted_groups[i] == group_list[j])
+          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. */
+
+decode_bits(log_selector, log_selector_size, log_notall,
+  log_selector_string, log_options, log_options_count, US"log", 0);
+
+DEBUG(D_any)
+  {
+  int i;
+  debug_printf("configuration file is %s\n", config_main_filename);
+  debug_printf("log selectors =");
+  for (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 (sender_address)
+  {
+  if (sender_address[sender_address_domain] == '[' && !allow_domain_literals)
+    exim_fail("exim: bad -f address \"%s\": domain literals not "
+      "allowed\n", sender_address);
+  if (f_end_dot && !strip_trailing_dot)
+    exim_fail("exim: bad -f address \"%s.\": domain is malformed "
+      "(trailing dot not allowed)\n", sender_address);
+  }
+
+/* See if an admin user overrode our logging. */
+
+if (cmdline_syslog_name)
+  if (f.admin_user)
+    {
+    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 */
+    exim_fail(
+        "exim: you lack sufficient privilege to specify syslog process name\n");
+
+/* 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
+if there are any calls to write the log earlier than this. However, if we
+get this far but the string is very long, it is better to stop now than to
+carry on and (e.g.) receive a message and then have to collapse. The call to
+log_write() from here will cause the ultimate panic collapse if the complete
+file name exceeds the buffer length. */
+
+if (Ustrlen(log_file_path) > 200)
+  log_write(0, LOG_MAIN|LOG_PANIC_DIE,
+    "log_file_path is longer than 200 chars: aborting");
+
+if (Ustrlen(pid_file_path) > 200)
+  log_write(0, LOG_MAIN|LOG_PANIC_DIE,
+    "pid_file_path is longer than 200 chars: aborting");
+
+if (Ustrlen(spool_directory) > 200)
+  log_write(0, LOG_MAIN|LOG_PANIC_DIE,
+    "spool_directory is longer than 200 chars: aborting");
+
+/* Length check on the process name given to syslog for its TAG field,
+which is only permitted to be 32 characters or less. See RFC 3164. */
+
+if (Ustrlen(syslog_processname) > 32)
+  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
+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 EXIM_TMPDIR
+  {
+  uschar **p;
+  if (environ) for (p = USS environ; *p; p++)
+    if (Ustrncmp(*p, "TMPDIR=", 7) == 0 && Ustrcmp(*p+7, EXIM_TMPDIR) != 0)
+      {
+      uschar * newp = store_malloc(Ustrlen(EXIM_TMPDIR) + 8);
+      sprintf(CS newp, "TMPDIR=%s", EXIM_TMPDIR);
+      *p = newp;
+      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
+timestamps to be in UTC (gmtime() is used instead of localtime()). Otherwise,
+we may need to get rid of a bogus timezone setting. This can arise when Exim is
+called by a user who has set the TZ variable. This then affects the timestamps
+in log files and in Received: headers, and any created Date: header lines. The
+required timezone is settable in the configuration file, so nothing can be done
+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. */
+
+if (timezone_string && strcmpic(timezone_string, US"UTC") == 0)
+  f.timestamps_utc = TRUE;
+else
+  {
+  uschar *envtz = US getenv("TZ");
+  if (envtz
+      ? !timezone_string || Ustrcmp(timezone_string, envtz) != 0
+      : timezone_string != NULL
+     )
+    {
+    uschar **p = USS environ;
+    uschar **new;
+    uschar **newp;
+    int count = 0;
+    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 = store_malloc(Ustrlen(timezone_string) + 4);
+      sprintf(CS *newp++, "TZ=%s", timezone_string);
+      }
+    *newp = NULL;
+    environ = CSS new;
+    tzset();
+    DEBUG(D_any) debug_printf("Reset TZ to %s: time is %s\n", timezone_string,
+      tod_stamp(tod_log));
+    }
+  }
+
+/* Handle the case when we have removed the setuid privilege because of -C or
+-D. This means that the caller of Exim was not root.
+
+There is a problem if we were running as the Exim user. The sysadmin may
+expect this case to retain privilege because "the binary was called by the
+Exim user", but it hasn't, because either the -D option set macros, or the
+-C option set a non-trusted configuration file. There are two possibilities:
+
+  (1) If deliver_drop_privilege is set, Exim is not going to re-exec in order
+      to do message deliveries. Thus, the fact that it is running as a
+      non-privileged user is plausible, and might be wanted in some special
+      configurations. However, really_exim will have been set false when
+      privilege was dropped, to stop Exim trying to write to its normal log
+      files. Therefore, re-enable normal log processing, assuming the sysadmin
+      has set up the log directory correctly.
+
+  (2) If deliver_drop_privilege is not set, the configuration won't work as
+      apparently intended, and so we log a panic message. In order to retain
+      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
+   && (!f.trusted_config || opt_D_used)
+   && real_uid == exim_uid)
+  if (deliver_drop_privilege)
+    f.really_exim = TRUE; /* let logging work normally */
+  else
+    log_write(0, LOG_MAIN|LOG_PANIC,
+      "exim user lost privilege for using %s option",
+      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
+initializing starting. Note that the global variables are actually called
+opt_perl_xxx to avoid clashing with perl's namespace (perl_*). */
+
+#ifdef EXIM_PERL
+if (perl_start_option != 0)
+  opt_perl_at_start = (perl_start_option > 0);
+if (opt_perl_at_start && opt_perl_startup != NULL)
+  {
+  uschar *errstr;
+  DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
+  if ((errstr = init_perl(opt_perl_startup)))
+    exim_fail("exim: error in perl_startup code: %s\n", errstr);
+  opt_perl_started = TRUE;
+  }
+#endif /* EXIM_PERL */
+
+/* Log the arguments of the call if the configuration file said so. This is
+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. */
+
+if (  (debug_selector & D_any  ||  LOGGING(arguments))
+   && f.really_exim && !list_options && !checking)
+  {
+  int i;
+  uschar *p = big_buffer;
+  Ustrcpy(p, "cwd= (failed)");
+
+  if (!initial_cwd)
+    p += 13;
+  else
+    {
+    Ustrncpy(p + 4, initial_cwd, big_buffer_size-5);
+    p += 4 + Ustrlen(initial_cwd);
+    /* in case p is near the end and we don't provide enough space for
+     * string_format to be willing to write. */
+    *p = '\0';
+    }
+
+  (void)string_format(p, big_buffer_size - (p - big_buffer), " %d args:", argc);
+  while (*p) p++;
+  for (i = 0; i < argc; i++)
+    {
+    int len = Ustrlen(argv[i]);
+    const uschar *printing;
+    uschar *quote;
+    if (p + len + 8 >= big_buffer + big_buffer_size)
+      {
+      Ustrcpy(p, " ...");
+      log_write(0, LOG_MAIN, "%s", big_buffer);
+      Ustrcpy(big_buffer, "...");
+      p = big_buffer + 3;
+      }
+    printing = string_printing(argv[i]);
+    if (printing[0] == 0) quote = US"\""; else
+      {
+      const uschar *pp = printing;
+      quote = US"";
+      while (*pp != 0) if (isspace(*pp++)) { quote = US"\""; break; }
+      }
+    p += sprintf(CS p, " %s%.*s%s", quote, (int)(big_buffer_size -
+      (p - big_buffer) - 4), printing, quote);
+    }
+
+  if (LOGGING(arguments))
+    log_write(0, LOG_MAIN, "%s", big_buffer);
+  else
+    debug_printf("%s\n", big_buffer);
+  }
+
+/* Set the working directory to be the top-level spool directory. We don't rely
+on this in the code, which always uses fully qualified names, but it's useful
+for core dumps etc. Don't complain if it fails - the spool directory might not
+be generally accessible and calls with the -C option (and others) have lost
+privilege by now. Before the chdir, we try to ensure that the directory exists.
+*/
+
+if (Uchdir(spool_directory) != 0)
+  {
+  int dummy;
+  (void)directory_make(spool_directory, US"", SPOOL_DIRECTORY_MODE, FALSE);
+  dummy = /* quieten compiler */ Uchdir(spool_directory);
+  dummy = dummy;	/* yet more compiler quietening, sigh */
+  }
+
+/* Handle calls with the -bi option. This is a sendmail option to rebuild *the*
+alias file. Exim doesn't have such a concept, but this call is screwed into
+Sun's YP makefiles. Handle this by calling a configured script, as the real
+user who called Exim. The -oA option can be used to pass an argument to the
+script. */
+
+if (bi_option)
+  {
+  (void)fclose(config_file);
+  if (bi_command != NULL)
+    {
+    int i = 0;
+    uschar *argv[3];
+    argv[i++] = bi_command;
+    if (alias_arg != NULL) argv[i++] = alias_arg;
+    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]);
+
+    execv(CS argv[0], (char *const *)argv);
+    exim_fail("exim: exec failed: %s\n", strerror(errno));
+    }
+  else
+    {
+    DEBUG(D_any) debug_printf("-bi used but bi_command not set; exiting\n");
+    exit(EXIT_SUCCESS);
+    }
+  }
+
+/* We moved the admin/trusted check to be immediately after reading the
+configuration file.  We leave these prints here to ensure that syslog setup,
+logfile setup, and so on has already happened. */
+
+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
+user may request that a message be returned to its sender forthwith. Only an
+admin user may specify a debug level greater than D_v (because it might show
+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). */
+
+if (!f.admin_user)
+  {
+  BOOL debugset = (debug_selector & ~D_v) != 0;
+  if (deliver_give_up || f.daemon_listen || malware_test_file ||
+     (count_queue && queue_list_requires_admin) ||
+     (list_queue && queue_list_requires_admin) ||
+     (queue_interval >= 0 && prod_requires_admin) ||
+     (debugset && !f.running_in_test_harness))
+    exim_fail("exim:%s permission denied\n", debugset? " debugging" : "");
+  }
+
+/* If the real user is not root or the exim uid, the argument for passing
+in an open TCP/IP connection for another message is not permitted, nor is
+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. */
+
+if (real_uid != root_uid && real_uid != exim_uid &&
+     (continue_hostname != NULL ||
+       (f.dont_deliver &&
+         (queue_interval >= 0 || f.daemon_listen || msg_action_arg > 0)
+       )) && !f.running_in_test_harness)
+  exim_fail("exim: Permission denied\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 (!f.trusted_caller && !checking)
+  {
+  sender_host_name = sender_host_address = interface_address =
+    sender_ident = received_protocol = NULL;
+  sender_host_port = interface_port = 0;
+  sender_host_authenticated = authenticated_sender = authenticated_id = NULL;
+  }
+
+/* If a sender host address is set, extract the optional port number off the
+end of it and check its syntax. Do the same thing for the interface address.
+Exim exits if the syntax is bad. */
+
+else
+  {
+  if (sender_host_address != NULL)
+    sender_host_port = check_port(sender_host_address);
+  if (interface_address != NULL)
+    interface_port = check_port(interface_address);
+  }
+
+/* If the caller is trusted, then they can use -G to suppress_local_fixups. */
+if (flag_G)
+  {
+  if (f.trusted_caller)
+    {
+    f.suppress_local_fixups = f.suppress_local_fixups_default = TRUE;
+    DEBUG(D_acl) debug_printf("suppress_local_fixups forced on by -G\n");
+    }
+  else
+    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
+TCP/IP socket. If it is, we assume that Exim was called from inetd if the
+caller is root or the Exim user, or if the port is a privileged one. Otherwise,
+barf. */
+
+if (smtp_input)
+  {
+  union sockaddr_46 inetd_sock;
+  EXIM_SOCKLEN_T size = sizeof(inetd_sock);
+  if (getpeername(0, (struct sockaddr *)(&inetd_sock), &size) == 0)
+    {
+    int family = ((struct sockaddr *)(&inetd_sock))->sa_family;
+    if (family == AF_INET || family == AF_INET6)
+      {
+      union sockaddr_46 interface_sock;
+      size = sizeof(interface_sock);
+
+      if (getsockname(0, (struct sockaddr *)(&interface_sock), &size) == 0)
+        interface_address = host_ntoa(-1, &interface_sock, NULL,
+          &interface_port);
+
+      if (host_is_tls_on_connect_port(interface_port)) tls_in.on_connect = TRUE;
+
+      if (real_uid == root_uid || real_uid == exim_uid || interface_port < 1024)
+        {
+        f.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");
+        }
+      else
+        exim_fail(
+          "exim: Permission denied (unprivileged user, unprivileged port)\n");
+      }
+    }
+  }
+
+/* If the load average is going to be needed while receiving a message, get it
+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
+if (receiving_message &&
+      (queue_only_load >= 0 ||
+        (f.is_inetd && smtp_load_reserve >= 0)
+      ))
+  {
+  load_average = OS_GETLOADAVG();
+  }
+#endif
+
+/* The queue_only configuration option can be overridden by -odx on the command
+line, except that if queue_only_override is false, queue_only cannot be unset
+from the command line. */
+
+if (queue_only_set && (queue_only_override || arg_queue_only))
+  queue_only = arg_queue_only;
+
+/* The receive_timeout and smtp_receive_timeout options can be overridden by
+-or and -os. */
+
+if (arg_receive_timeout >= 0) receive_timeout = arg_receive_timeout;
+if (arg_smtp_receive_timeout >= 0)
+  smtp_receive_timeout = arg_smtp_receive_timeout;
+
+/* If Exim was started with root privilege, unless we have already removed the
+root privilege above as a result of -C, -D, -be, -bf or -bF, remove it now
+except when starting the daemon or doing some kind of delivery or address
+testing (-bt). These are the only cases when root need to be retained. We run
+as exim for -bv and -bh. However, if deliver_drop_privilege is set, root is
+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. */
+
+if (!unprivileged &&                      /* originally had root AND */
+    !removed_privilege &&                 /* still got root AND      */
+    !f.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 || !f.address_test_mode) /* not address checking    */
+   )  ) )
+  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;
+  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
+  by root should succeed and failures should be examined.  For non-root,
+  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))
+      exim_fail("exim: changing group failed: %s\n", strerror(errno));
+    else
+      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 */
+if (malware_test_file)
+  {
+#ifdef WITH_CONTENT_SCAN
+  int result;
+  set_process_info("scanning file for malware");
+  result = malware_in_file(malware_test_file);
+  if (result == FAIL)
+    {
+    printf("No malware found.\n");
+    exit(EXIT_SUCCESS);
+    }
+  if (result != OK)
+    {
+    printf("Malware lookup returned non-okay/fail: %d\n", result);
+    exit(EXIT_FAILURE);
+    }
+  if (malware_name)
+    printf("Malware found: %s\n", malware_name);
+  else
+    printf("Malware scan detected malware of unknown name.\n");
+#else
+  printf("Malware scanning not enabled at compile time.\n");
+#endif
+  exit(EXIT_FAILURE);
+  }
+
+/* Handle a request to list the delivery queue */
+
+if (list_queue)
+  {
+  set_process_info("listing the queue");
+  queue_list(list_queue_option, argv + recipients_arg, argc - recipients_arg);
+  exit(EXIT_SUCCESS);
+  }
+
+/* Handle a request to count the delivery queue */
+
+if (count_queue)
+  {
+  set_process_info("counting the queue");
+  queue_count();
+  exit(EXIT_SUCCESS);
+  }
+
+/* Handle actions on specific messages, except for the force delivery and
+message load actions, which are done below. Some actions take a whole list of
+message ids, which are known to continue up to the end of the arguments. Others
+take a single message id and then operate on the recipients list. */
+
+if (msg_action_arg > 0 && msg_action != MSG_DELIVER && msg_action != MSG_LOAD)
+  {
+  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)
+    readconf_rest();
+
+  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;
+    }
+
+  else if (!queue_action(argv[msg_action_arg], msg_action, argv, argc,
+    recipients_arg)) yield = EXIT_FAILURE;
+  exit(yield);
+  }
+
+/* We used to set up here to skip reading the ACL section, on
+ (msg_action_arg > 0 || (queue_interval == 0 && !f.daemon_listen)
+Now, since the intro of the ${acl } expansion, ACL definitions may be
+needed in transports so we lost the optimisation. */
+
+readconf_rest();
+
+/* 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_MAIN;
+
+/* Handle the -brt option. This is for checking out retry configurations.
+The next three arguments are a domain name or a complete address, and
+optionally two error numbers. All it does is to call the function that
+scans the retry configuration data. */
+
+if (test_retry_arg >= 0)
+  {
+  retry_config *yield;
+  int basic_errno = 0;
+  int more_errno = 0;
+  uschar *s1, *s2;
+
+  if (test_retry_arg >= argc)
+    {
+    printf("-brt needs a domain or address argument\n");
+    exim_exit(EXIT_FAILURE, US"main");
+    }
+  s1 = argv[test_retry_arg++];
+  s2 = NULL;
+
+  /* If the first argument contains no @ and no . it might be a local user
+  or it might be a single-component name. Treat as a domain. */
+
+  if (Ustrchr(s1, '@') == NULL && Ustrchr(s1, '.') == NULL)
+    {
+    printf("Warning: \"%s\" contains no '@' and no '.' characters. It is "
+      "being \ntreated as a one-component domain, not as a local part.\n\n",
+      s1);
+    }
+
+  /* There may be an optional second domain arg. */
+
+  if (test_retry_arg < argc && Ustrchr(argv[test_retry_arg], '.') != NULL)
+    s2 = argv[test_retry_arg++];
+
+  /* The final arg is an error name */
+
+  if (test_retry_arg < argc)
+    {
+    uschar *ss = argv[test_retry_arg];
+    uschar *error =
+      readconf_retry_error(ss, ss + Ustrlen(ss), &basic_errno, &more_errno);
+    if (error != NULL)
+      {
+      printf("%s\n", CS error);
+      return EXIT_FAILURE;
+      }
+
+    /* For the {MAIL,RCPT,DATA}_4xx errors, a value of 255 means "any", and a
+    code > 100 as an error is for matching codes to the decade. Turn them into
+    a real error code, off the decade. */
+
+    if (basic_errno == ERRNO_MAIL4XX ||
+        basic_errno == ERRNO_RCPT4XX ||
+        basic_errno == ERRNO_DATA4XX)
+      {
+      int code = (more_errno >> 8) & 255;
+      if (code == 255)
+        more_errno = (more_errno & 0xffff00ff) | (21 << 8);
+      else if (code > 100)
+        more_errno = (more_errno & 0xffff00ff) | ((code - 96) << 8);
+      }
+    }
+
+  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);
+
+    if (yield->basic_errno == ERRNO_EXIMQUOTA)
+      {
+      printf("quota%s%s  ",
+        (more_errno > 0)? "_" : "",
+        (more_errno > 0)? readconf_printtime(more_errno) : US"");
+      }
+    else if (yield->basic_errno == ECONNREFUSED)
+      {
+      printf("refused%s%s  ",
+        (more_errno > 0)? "_" : "",
+        (more_errno == 'M')? "MX" :
+        (more_errno == 'A')? "A" : "");
+      }
+    else if (yield->basic_errno == ETIMEDOUT)
+      {
+      printf("timeout");
+      if ((more_errno & RTEF_CTOUT) != 0) printf("_connect");
+      more_errno &= 255;
+      if (more_errno != 0) printf("_%s",
+        (more_errno == 'M')? "MX" : "A");
+      printf("  ");
+      }
+    else if (yield->basic_errno == ERRNO_AUTHFAIL)
+      printf("auth_failed  ");
+    else printf("*  ");
+
+    for (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 */
+      if (r->rule == 'G')
+        {
+        int x = r->p2;
+        int f = x % 1000;
+        int d = 100;
+        printf(",%d.", x/1000);
+        do
+          {
+          printf("%d", f/d);
+          f %= d;
+          d /= 10;
+          }
+        while (f != 0);
+        }
+      printf("; ");
+      }
+
+    printf("\n");
+    }
+  exim_exit(EXIT_SUCCESS, US"main");
+  }
+
+/* Handle a request to list one or more configuration options */
+/* If -n was set, we suppress some information */
+
+if (list_options)
+  {
+  BOOL fail = FALSE;
+  set_process_info("listing variables");
+  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))
+      {
+      fail |= !readconf_print(argv[i+1], argv[i], flag_n);
+      i++;
+      }
+    else
+      fail = !readconf_print(argv[i], NULL, flag_n);
+    }
+  exim_exit(fail ? EXIT_FAILURE : EXIT_SUCCESS, US"main");
+  }
+
+if (list_config)
+  {
+  set_process_info("listing config");
+  exim_exit(readconf_print(US"config", NULL, flag_n)
+		? EXIT_SUCCESS : EXIT_FAILURE, US"main");
+  }
+
+
+/* Initialise subsystems as required */
+#ifndef DISABLE_DKIM
+dkim_exim_init();
+#endif
+deliver_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
+above. MSG_LOAD is handled with -be (which is the only time it applies) below.
+
+Delivery of specific messages is typically used for a small number when
+prodding by hand (when the option forced_delivery will be set) or when
+re-execing to regain root privilege. Each message delivery must happen in a
+separate process, so we fork a process for each one, and run them sequentially
+so that debugging output doesn't get intertwined, and to avoid spawning too
+many processes if a long list is given. However, don't fork for the last one;
+this saves a process in the common case when Exim is called to deliver just one
+message. */
+
+if (msg_action_arg > 0 && msg_action != MSG_LOAD)
+  {
+  if (prod_requires_admin && !f.admin_user)
+    {
+    fprintf(stderr, "exim: Permission denied\n");
+    exim_exit(EXIT_FAILURE, US"main");
+    }
+  set_process_info("delivering specified messages");
+  if (deliver_give_up) forced_delivery = f.deliver_force_thaw = TRUE;
+  for (i = msg_action_arg; i < argc; i++)
+    {
+    int status;
+    pid_t pid;
+    if (i == argc - 1)
+      (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
+    else if ((pid = fork()) == 0)
+      {
+      (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
+      _exit(EXIT_SUCCESS);
+      }
+    else if (pid < 0)
+      {
+      fprintf(stderr, "failed to fork delivery process for %s: %s\n", argv[i],
+        strerror(errno));
+      exim_exit(EXIT_FAILURE, US"main");
+      }
+    else wait(&status);
+    }
+  exim_exit(EXIT_SUCCESS, US"main");
+  }
+
+
+/* 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 && !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);
+  if (*queue_name)
+    set_process_info("running the '%s' queue (single queue run)", queue_name);
+  else
+    set_process_info("running the queue (single queue run)");
+  queue_run(start_queue_run_id, stop_queue_run_id, FALSE);
+  exim_exit(EXIT_SUCCESS, US"main");
+  }
+
+
+/* Find the login name of the real user running this process. This is always
+needed when receiving a message, because it is written into the spool file. It
+may also be used to construct a from: or a sender: header, and in this case we
+need the user's full name as well, so save a copy of it, checked for RFC822
+syntax and munged if necessary, if it hasn't previously been set by the -F
+argument. We may try to get the passwd entry more than once, in case NIS or
+other delays are in evidence. Save the home directory for use in filter testing
+(only). */
+
+for (i = 0;;)
+  {
+  if ((pw = getpwuid(real_uid)) != NULL)
+    {
+    originator_login = string_copy(US pw->pw_name);
+    originator_home = string_copy(US pw->pw_dir);
+
+    /* 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)
+      {
+      if (!sender_address || (!f.trusted_caller && filter_test == FTEST_NONE))
+        {
+        uschar *name = US pw->pw_gecos;
+        uschar *amp = Ustrchr(name, '&');
+        uschar buffer[256];
+
+        /* Most Unix specify that a '&' character in the gecos field is
+        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)
+          {
+          int loffset;
+          string_format(buffer, sizeof(buffer), "%.*s%n%s%s",
+            (int)(amp - name), name, &loffset, originator_login, amp + 1);
+          buffer[loffset] = toupper(buffer[loffset]);
+          name = buffer;
+          }
+
+        /* If a pattern for matching the gecos field was supplied, apply
+        it and then expand the name string. */
+
+        if (gecos_pattern && gecos_name)
+          {
+          const pcre *re;
+          re = regex_must_compile(gecos_pattern, FALSE, TRUE); /* Use malloc */
+
+          if (regex_match_and_setup(re, name, 0, -1))
+            {
+            uschar *new_name = expand_string(gecos_name);
+            expand_nmax = -1;
+            if (new_name)
+              {
+              DEBUG(D_receive) debug_printf("user name \"%s\" extracted from "
+                "gecos field \"%s\"\n", new_name, name);
+              name = new_name;
+              }
+            else DEBUG(D_receive) debug_printf("failed to expand gecos_name string "
+              "\"%s\": %s\n", gecos_name, expand_string_message);
+            }
+          else DEBUG(D_receive) debug_printf("gecos_pattern \"%s\" did not match "
+            "gecos field \"%s\"\n", gecos_pattern, name);
+          store_free((void *)re);
+          }
+        originator_name = string_copy(name);
+        }
+
+      /* A trusted caller has used -f but not -F */
+
+      else originator_name = US"";
+      }
+
+    /* Break the retry loop */
+
+    break;
+    }
+
+  if (++i > finduser_retries) break;
+  sleep(1);
+  }
+
+/* If we cannot get a user login, log the incident and give up, unless the
+configuration specifies something to use. When running in the test harness,
+any setting of unknown_login overrides the actual name. */
+
+if (originator_login == NULL || f.running_in_test_harness)
+  {
+  if (unknown_login != NULL)
+    {
+    originator_login = expand_string(unknown_login);
+    if (originator_name == NULL && unknown_username != NULL)
+      originator_name = expand_string(unknown_username);
+    if (originator_name == NULL) originator_name = US"";
+    }
+  if (originator_login == NULL)
+    log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to get user name for uid %d",
+      (int)real_uid);
+  }
+
+/* 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));
+
+/* 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
+read in from the spool. */
+
+originator_uid = real_uid;
+originator_gid = real_gid;
+
+DEBUG(D_receive) debug_printf("originator: uid=%d gid=%d login=%s name=%s\n",
+  (int)originator_uid, (int)originator_gid, originator_login, originator_name);
+
+/* Run in daemon and/or queue-running mode. The function daemon_go() never
+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. */
+
+if (f.daemon_listen || f.inetd_wait_mode || queue_interval > 0)
+  {
+  if (mua_wrapper)
+    {
+    fprintf(stderr, "Daemon cannot be run when mua_wrapper is set\n");
+    log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Daemon cannot be run when "
+      "mua_wrapper is set");
+    }
+  daemon_go();
+  }
+
+/* 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;
+
+/* 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
+originator_* variables set. */
+
+if (test_rewrite_arg >= 0)
+  {
+  f.really_exim = FALSE;
+  if (test_rewrite_arg >= argc)
+    {
+    printf("-brw needs an address argument\n");
+    exim_exit(EXIT_FAILURE, US"main");
+    }
+  rewrite_test(argv[test_rewrite_arg]);
+  exim_exit(EXIT_SUCCESS, US"main");
+  }
+
+/* A locally-supplied message is considered to be coming from a local user
+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) ||
+    (!f.trusted_caller && filter_test == FTEST_NONE))
+  {
+  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. */
+
+  if (authenticated_sender == NULL && !host_checking)
+    authenticated_sender = string_sprintf("%s@%s", originator_login,
+      qualify_domain_sender);
+  if (authenticated_id == NULL && !host_checking)
+    authenticated_id = originator_login;
+  }
+
+/* Trusted callers are always permitted to specify the sender address.
+Untrusted callers may specify it if it matches untrusted_set_sender, or if what
+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. */
+
+if ((!smtp_input && sender_address == NULL) ||
+    !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. */
+
+  if (sender_address == NULL             /* No sender_address set */
+       ||                                /*         OR            */
+       (sender_address[0] != 0 &&        /* Non-empty sender address, AND */
+       !checking))                       /* Not running tests, including filter tests */
+    {
+    sender_address = originator_login;
+    f.sender_address_forced = FALSE;
+    sender_address_domain = 0;
+    }
+  }
+
+/* Remember whether an untrusted caller set the sender address */
+
+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). */
+
+if (sender_address != NULL && sender_address[0] != 0 &&
+    sender_address_domain == 0)
+  sender_address = string_sprintf("%s@%s", local_part_quote(sender_address),
+    qualify_domain_sender);
+
+DEBUG(D_receive) debug_printf("sender address = %s\n", sender_address);
+
+/* Handle a request to verify a list of addresses, or test them for delivery.
+This must follow the setting of the sender address, since routers can be
+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.
+*/
+
+if (verify_address_mode || f.address_test_mode)
+  {
+  int exit_value = 0;
+  int flags = vopt_qualify;
+
+  if (verify_address_mode)
+    {
+    if (!verify_as_sender) flags |= vopt_is_recipient;
+    DEBUG(D_verify) debug_print_ids(US"Verifying:");
+    }
+
+  else
+    {
+    flags |= vopt_is_recipient;
+    debug_selector |= D_v;
+    debug_file = stderr;
+    debug_fd = fileno(debug_file);
+    DEBUG(D_verify) debug_print_ids(US"Address testing:");
+    }
+
+  if (recipients_arg < argc)
+    {
+    while (recipients_arg < argc)
+      {
+      uschar *s = argv[recipients_arg++];
+      while (*s != 0)
+        {
+        BOOL finished = FALSE;
+        uschar *ss = parse_find_address_end(s, FALSE);
+        if (*ss == ',') *ss = 0; else finished = TRUE;
+        test_address(s, flags, &exit_value);
+        s = ss;
+        if (!finished)
+          while (*(++s) != 0 && (*s == ',' || isspace(*s)));
+        }
+      }
+    }
+
+  else for (;;)
+    {
+    uschar *s = get_stdinput(NULL, NULL);
+    if (s == NULL) break;
+    test_address(s, flags, &exit_value);
+    }
+
+  route_tidyup();
+  exim_exit(exit_value, US"main");
+  }
+
+/* Handle expansion checking. Either expand items on the command line, or read
+from stdin if there aren't any. If -Mset was specified, load the message so
+that its variables can be used, but restrict this facility to admin users.
+Otherwise, if -bem was used, read a message from stdin. */
+
+if (expansion_test)
+  {
+  dns_init(FALSE, FALSE, FALSE);
+  if (msg_action_arg > 0 && msg_action == MSG_LOAD)
+    {
+    uschar spoolname[256];  /* Not big_buffer; used in spool_read_header() */
+    if (!f.admin_user)
+      exim_fail("exim: permission denied\n");
+    message_id = argv[msg_action_arg];
+    (void)string_format(spoolname, sizeof(spoolname), "%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);
+    }
+
+  /* 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)
+    {
+    int save_stdin = dup(0);
+    int fd = Uopen(expansion_test_message, O_RDONLY, 0);
+    if (fd < 0)
+      exim_fail("exim: failed to open %s: %s\n", expansion_test_message,
+        strerror(errno));
+    (void) dup2(fd, 0);
+    filter_test = FTEST_USER;      /* Fudge to make it look like filter test */
+    message_ended = END_NOTENDED;
+    read_message_body(receive_msg(extract_recipients));
+    message_linecount += body_linecount;
+    (void)dup2(save_stdin, 0);
+    (void)close(save_stdin);
+    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 */
+
+  f.enable_dollar_recipients = TRUE;
+
+  /* Expand command line items */
+
+  if (recipients_arg < argc)
+    while (recipients_arg < argc)
+      expansion_test_line(argv[recipients_arg++]);
+
+  /* Read stdin */
+
+  else
+    {
+    char *(*fn_readline)(const char *) = NULL;
+    void (*fn_addhist)(const char *) = NULL;
+    uschar * s;
+
+#ifdef USE_READLINE
+    void *dlhandle = set_readline(&fn_readline, &fn_addhist);
+#endif
+
+    while (s = get_stdinput(fn_readline, fn_addhist))
+      expansion_test_line(s);
+
+#ifdef USE_READLINE
+    if (dlhandle) dlclose(dlhandle);
+#endif
+    }
+
+  /* The data file will be open after -Mset */
+
+  if (deliver_datafile >= 0)
+    {
+    (void)close(deliver_datafile);
+    deliver_datafile = -1;
+    }
+
+  exim_exit(EXIT_SUCCESS, US"main: expansion test");
+  }
+
+
+/* The active host name is normally the primary host name, but it can be varied
+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;
+if (raw_active_hostname != NULL)
+  {
+  uschar *nah = expand_string(raw_active_hostname);
+  if (nah == NULL)
+    {
+    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);
+    }
+  else if (nah[0] != 0) smtp_active_hostname = nah;
+  }
+
+/* Handle host checking: this facility mocks up an incoming SMTP call from a
+given IP address so that the blocking and relay configuration can be tested.
+Unless a sender_ident was set by -oMt, we discard it (the default is the
+caller's login name). An RFC 1413 call is made only if we are running in the
+test harness and an incoming interface and both ports are specified, because
+there is no TCP/IP call to find the ident for. */
+
+if (host_checking)
+  {
+  int x[4];
+  int size;
+
+  if (!sender_ident_set)
+    {
+    sender_ident = NULL;
+    if (f.running_in_test_harness && sender_host_port != 0 &&
+        interface_address != NULL && interface_port != 0)
+      verify_get_ident(1413);
+    }
+
+  /* In case the given address is a non-canonical IPv6 address, canonicalize
+  it. The code works for both IPv4 and IPv6, as it happens. */
+
+  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, ':');
+
+  /* Now set up for testing */
+
+  host_build_sender_fullhost();
+  smtp_input = TRUE;
+  smtp_in = stdin;
+  smtp_out = stdout;
+  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"
+    "**** but without any ident (RFC 1413) callback.\n"
+    "**** This is not for real!\n\n",
+      sender_host_address);
+
+  memset(sender_host_cache, 0, sizeof(sender_host_cache));
+  if (verify_check_host(&hosts_connection_nolog) == OK)
+    BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
+  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,
+  because a log line has already been written for all its failure exists
+  (usually "connection refused: <reason>") and writing another one is
+  unnecessary clutter. */
+
+  if (smtp_start_session())
+    {
+    for (reset_point = store_get(0); ; store_reset(reset_point))
+      {
+      if (smtp_setup_msg() <= 0) break;
+      if (!receive_msg(FALSE)) break;
+
+      return_path = sender_address = NULL;
+      dnslist_domain = dnslist_matched = NULL;
+#ifndef DISABLE_DKIM
+      dkim_cur_signer = NULL;
+#endif
+      acl_var_m = NULL;
+      deliver_localpart_orig = NULL;
+      deliver_domain_orig = NULL;
+      callout_address = sending_ip_address = NULL;
+      sender_rate = sender_rate_limit = sender_rate_period = NULL;
+      }
+    smtp_log_no_mail();
+    }
+  exim_exit(EXIT_SUCCESS, US"main");
+  }
+
+
+/* Arrange for message reception if recipients or SMTP were specified;
+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. */
+
+if (recipients_arg >= argc && !extract_recipients && !smtp_input)
+  {
+  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;
+    }
+
+  if (info_flag != CMDINFO_NONE)
+    {
+    show_exim_information(info_flag, info_stdout ? stdout : stderr);
+    return info_stdout ? EXIT_SUCCESS : EXIT_FAILURE;
+    }
+
+  if (filter_test == FTEST_NONE)
+    exim_usage(called_as);
+  }
+
+
+/* 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
+that we are not called from inetd, because that is rejected above. The
+following configuration settings are forced here:
+
+  (1) Synchronous delivery (-odi)
+  (2) Errors to stderr (-oep == -oeq)
+  (3) No parallel remote delivery
+  (4) Unprivileged delivery
+
+We don't force overall queueing options because there are several of them;
+instead, queueing is avoided below when mua_wrapper is set. However, we do need
+to override any SMTP queueing. */
+
+if (mua_wrapper)
+  {
+  f.synchronous_delivery = TRUE;
+  arg_error_handling = ERRORS_STDERR;
+  remote_max_parallel = 1;
+  deliver_drop_privilege = TRUE;
+  f.queue_smtp = FALSE;
+  queue_smtp_domains = NULL;
+#ifdef SUPPORT_I18N
+  message_utf8_downconvert = -1;	/* convert-if-needed */
+#endif
+  }
+
+
+/* Prepare to accept one or more new messages on the standard input. When a
+message has been read, its id is returned in message_id[]. If doing immediate
+delivery, we fork a delivery process for each received message, except for the
+last one, where we can save a process switch.
+
+It is only in non-smtp mode that error_handling is allowed to be changed from
+its default of ERRORS_SENDER by argument. (Idle thought: are any of the
+sendmail error modes other than -oem ever actually used? Later: yes.) */
+
+if (!smtp_input) error_handling = arg_error_handling;
+
+/* If this is an inetd call, ensure that stderr is closed to prevent panic
+logging being sent down the socket and make an identd call to get the
+sender_ident. */
+
+else if (f.is_inetd)
+  {
+  (void)fclose(stderr);
+  exim_nullstd();                       /* Re-open to /dev/null */
+  verify_get_ident(IDENT_PORT);
+  host_build_sender_fullhost();
+  set_process_info("handling incoming connection from %s via inetd",
+    sender_fullhost);
+  }
+
+/* If the sender host address has been set, build sender_fullhost if it hasn't
+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. */
+
+if (sender_host_address && !sender_fullhost)
+  {
+  host_build_sender_fullhost();
+  set_process_info("handling incoming connection from %s via -oMa",
+    sender_fullhost);
+  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. */
+
+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,
+but fd 1 will not be set. This also happens for passed SMTP channels. */
+
+if (fstat(1, &statbuf) < 0) (void)dup2(0, 1);
+
+/* Set up the incoming protocol name and the state of the program. Root is
+allowed to force received protocol via the -oMr option above. If we have come
+via inetd, the process info has already been set up. We don't set
+received_protocol here for smtp input, as it varies according to
+batch/HELO/EHLO/AUTH/TLS. */
+
+if (smtp_input)
+  {
+  if (!f.is_inetd) set_process_info("accepting a local %sSMTP message from <%s>",
+    smtp_batched_input? "batched " : "",
+    (sender_address!= NULL)? sender_address : originator_login);
+  }
+else
+  {
+  int old_pool = store_pool;
+  store_pool = POOL_PERM;
+  if (!received_protocol)
+    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);
+  }
+
+/* Initialize the session_local_queue-only flag (this will be ignored if
+mua_wrapper is set) */
+
+queue_check_only();
+session_local_queue_only = queue_only;
+
+/* For non-SMTP and for batched SMTP input, check that there is enough space on
+the spool if so configured. On failure, we must not attempt to send an error
+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))
+  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.
+
+NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,
+because a log line has already been written for all its failure exists
+(usually "connection refused: <reason>") and writing another one is
+unnecessary clutter. */
+
+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)
+    BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
+  log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
+  if (!smtp_start_session())
+    {
+    mac_smtp_fflush();
+    exim_exit(EXIT_SUCCESS, US"smtp_start toplevel");
+    }
+  }
+
+/* Otherwise, set up the input size limit here. */
+
+else
+  {
+  thismessage_size_limit = expand_string_integer(message_size_limit, TRUE);
+  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);
+  }
+
+/* Loop for several messages when reading SMTP input. If we fork any child
+processes, we don't want to wait for them unless synchronous delivery is
+requested, so set SIGCHLD to SIG_IGN in that case. This is not necessarily the
+same as SIG_DFL, despite the fact that documentation often lists the default as
+"ignore". This is a confusing area. This is what I know:
+
+At least on some systems (e.g. Solaris), just setting SIG_IGN causes child
+processes that complete simply to go away without ever becoming defunct. You
+can't then wait for them - but we don't want to wait for them in the
+non-synchronous delivery case. However, this behaviour of SIG_IGN doesn't
+happen for all OS (e.g. *BSD is different).
+
+But that's not the end of the story. Some (many? all?) systems have the
+SA_NOCLDWAIT option for sigaction(). This requests the behaviour that Solaris
+has by default, so it seems that the difference is merely one of default
+(compare restarting vs non-restarting signals).
+
+To cover all cases, Exim sets SIG_IGN with SA_NOCLDWAIT here if it can. If not,
+it just sets SIG_IGN. To be on the safe side it also calls waitpid() at the end
+of the loop below. Paranoia rules.
+
+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.
+As a consequence of this, the waitpid() below is now excluded if we are sure
+that SIG_IGN works. */
+
+if (!f.synchronous_delivery)
+  {
+  #ifdef SA_NOCLDWAIT
+  struct sigaction act;
+  act.sa_handler = SIG_IGN;
+  sigemptyset(&(act.sa_mask));
+  act.sa_flags = SA_NOCLDWAIT;
+  sigaction(SIGCHLD, &act, NULL);
+  #else
+  signal(SIGCHLD, SIG_IGN);
+  #endif
+  }
+
+/* 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). */
+
+while (more)
+  {
+  message_id[0] = 0;
+
+  /* Handle the SMTP case; call smtp_setup_mst() 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
+  either the underlying user running this process or a -f argument provided by
+  a trusted caller. It is saved in real_sender_address. The test for whether to
+  accept the SMTP sender is encapsulated in receive_check_set_sender(). */
+
+  if (smtp_input)
+    {
+    int rc;
+    if ((rc = smtp_setup_msg()) > 0)
+      {
+      if (real_sender_address != NULL &&
+          !receive_check_set_sender(sender_address))
+        {
+        sender_address = raw_sender = real_sender_address;
+        sender_address_unrewritten = NULL;
+        }
+
+      /* For batched SMTP, we have to run the acl_not_smtp_start ACL, since it
+      isn't really SMTP, so no other ACL will run until the acl_not_smtp one at
+      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;
+        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);
+      if (message_id[0] == 0)
+        {
+	cancel_cutthrough_connection(TRUE, US"receive dropped");
+        if (more) goto moreloop;
+        smtp_log_no_mail();               /* Log no mail if configured */
+        exim_exit(EXIT_FAILURE, US"receive toplevel");
+        }
+      }
+    else
+      {
+      cancel_cutthrough_connection(TRUE, US"message setup dropped");
+      smtp_log_no_mail();               /* Log no mail if configured */
+      exim_exit(rc ? EXIT_FAILURE : EXIT_SUCCESS, US"msg setup toplevel");
+      }
+    }
+
+  /* In the non-SMTP case, we have all the information from the command
+  line, but must process it in case it is in the more general RFC822
+  format, and in any case, to detect syntax errors. Also, it appears that
+  the use of comma-separated lists as single arguments is common, so we
+  had better support them. */
+
+  else
+    {
+    int i;
+    int rcount = 0;
+    int count = argc - recipients_arg;
+    uschar **list = argv + recipients_arg;
+
+    /* These options cannot be changed dynamically for non-SMTP messages */
+
+    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);
+
+    /* Loop for each argument */
+
+    for (i = 0; i < count; i++)
+      {
+      int start, end, domain;
+      uschar *errmess;
+      uschar *s = list[i];
+
+      /* Loop for each comma-separated address */
+
+      while (*s != 0)
+        {
+        BOOL finished = 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 (recipients_max > 0 && ++rcount > recipients_max &&
+            !extract_recipients)
+          if (error_handling == ERRORS_STDERR)
+            {
+            fprintf(stderr, "exim: too many recipients\n");
+            exim_exit(EXIT_FAILURE, US"main");
+            }
+          else
+            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);
+
+#ifdef SUPPORT_I18N
+	if (string_is_utf8(recipient))
+	  message_smtputf8 = TRUE;
+	else
+	  allow_utf8_domains = b;
+	}
+#endif
+        if (domain == 0 && !f.allow_unqualified_recipient)
+          {
+          recipient = NULL;
+          errmess = US"unqualified recipient address not allowed";
+          }
+
+        if (recipient == NULL)
+          {
+          if (error_handling == ERRORS_STDERR)
+            {
+            fprintf(stderr, "exim: bad recipient address \"%s\": %s\n",
+              string_printing(list[i]), errmess);
+            exim_exit(EXIT_FAILURE, US"main");
+            }
+          else
+            {
+            error_block eblock;
+            eblock.next = NULL;
+            eblock.text1 = string_printing(list[i]);
+            eblock.text2 = errmess;
+            return
+              moan_to_sender(ERRMESS_BADARGADDRESS, &eblock, NULL, stdin, TRUE)?
+                errors_sender_rc : EXIT_FAILURE;
+            }
+          }
+
+        receive_add_recipient(recipient, -1);
+        s = ss;
+        if (!finished)
+          while (*(++s) != 0 && (*s == ',' || isspace(*s)));
+        }
+      }
+
+    /* Show the recipients when debugging */
+
+    DEBUG(D_receive)
+      {
+      int i;
+      if (sender_address != NULL) debug_printf("Sender: %s\n", sender_address);
+      if (recipients_list != NULL)
+        {
+        debug_printf("Recipients:\n");
+        for (i = 0; i < recipients_count; i++)
+          debug_printf("  %s\n", recipients_list[i].address);
+        }
+      }
+
+    /* Run the acl_not_smtp_start ACL if required. The result of the ACL is
+    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)
+      {
+      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;
+      }
+
+    /* 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)
+      {
+      struct timeval t = { .tv_sec = 30*60, .tv_usec = 0 };	/* 30 minutes */
+      fd_set r;
+
+      FD_ZERO(&r); FD_SET(0, &r);
+      if (select(1, &r, NULL, NULL, &t) == 0) 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. */
+
+    message_ended = END_NOTENDED;
+    more = receive_msg(extract_recipients);
+
+    /* more is always FALSE here (not SMTP message) when reading a message
+    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, US"main");
+    }  /* Non-SMTP message reception */
+
+  /* If this is a filter testing run, there are headers in store, but
+  no message on the spool. Run the filtering code in testing mode, setting
+  the domain to the qualify domain and the local part to the current user,
+  unless they have been set by options. The prefix and suffix are left unset
+  unless specified. The the return path is set to to the sender unless it has
+  already been set from a return-path header in the message. */
+
+  if (filter_test != FTEST_NONE)
+    {
+    deliver_domain = (ftest_domain != NULL)?
+      ftest_domain : qualify_domain_recipient;
+    deliver_domain_orig = deliver_domain;
+    deliver_localpart = (ftest_localpart != NULL)?
+      ftest_localpart : originator_login;
+    deliver_localpart_orig = deliver_localpart;
+    deliver_localpart_prefix = ftest_prefix;
+    deliver_localpart_suffix = ftest_suffix;
+    deliver_home = originator_home;
+
+    if (return_path == NULL)
+      {
+      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("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,
+        deliver_localpart,
+        (ftest_suffix == NULL)? US"" : ftest_suffix,
+        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 (chdir("/"))   /* Get away from wherever the user is running this from */
+      {
+      DEBUG(D_receive) debug_printf("chdir(\"/\") failed\n");
+      exim_exit(EXIT_FAILURE, US"main");
+      }
+
+    /* Now we run either a system filter test, or a user filter test, or both.
+    In the latter case, headers added by the system filter will persist and be
+    available to the user filter. We need to copy the filter variables
+    explicitly. */
+
+    if ((filter_test & FTEST_SYSTEM) != 0)
+      if (!filter_runtest(filter_sfd, filter_test_sfile, TRUE, more))
+        exim_exit(EXIT_FAILURE, US"main");
+
+    memcpy(filter_sn, filter_n, sizeof(filter_sn));
+
+    if ((filter_test & FTEST_USER) != 0)
+      if (!filter_runtest(filter_ufd, filter_test_ufile, FALSE, more))
+        exim_exit(EXIT_FAILURE, US"main");
+
+    exim_exit(EXIT_SUCCESS, US"main");
+    }
+
+  /* Else act on the result of message reception. We should not get here unless
+  message_id[0] is non-zero. If queue_only is set, session_local_queue_only
+  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)
+    {
+    session_local_queue_only = TRUE;
+    queue_only_reason = 2;
+    }
+
+  /* Initialize local_queue_only from session_local_queue_only. If it is false,
+  and queue_only_load is set, check that the load average is below it. If it is
+  not, set local_queue_only TRUE. If queue_only_load_latch is true (the
+  default), we put the whole session into queue_only mode. It then remains this
+  way for any subsequent messages on the same SMTP connection. This is a
+  deliberate choice; even though the load average may fall, it doesn't seem
+  right to deliver later messages on the same call when not delivering earlier
+  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)
+      {
+      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)
+    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). */
+
+  if (local_queue_only)
+    {
+    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
+  run. The search cache must be tidied before the fork, as the parent will
+  do it before exiting. The child will trigger a lookup failure and
+  thereby defer the delivery if it tries to use (for example) a cached ldap
+  connection that the parent has called unbind on. */
+
+  else
+    {
+    pid_t pid;
+    search_tidyup();
+
+    if ((pid = fork()) == 0)
+      {
+      int rc;
+      close_unwanted();      /* Close unwanted file descriptors and TLS */
+      exim_nullstd();        /* Ensure std{in,out,err} exist */
+
+      /* Re-exec Exim if we need to regain privilege (note: in mua_wrapper
+      mode, deliver_drop_privilege is forced TRUE). */
+
+      if (geteuid() != root_uid && !deliver_drop_privilege && !unprivileged)
+        {
+	delivery_re_exec(CEE_EXEC_EXIT);
+        /* Control does not return here. */
+        }
+
+      /* No need to re-exec */
+
+      rc = deliver_message(message_id, FALSE, FALSE);
+      search_tidyup();
+      _exit((!mua_wrapper || rc == DELIVER_MUA_SUCCEEDED)?
+        EXIT_SUCCESS : EXIT_FAILURE);
+      }
+
+    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));
+      }
+    else
+      {
+      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, US"main");
+	}
+      }
+    }
+
+  /* The loop will repeat if more is TRUE. If we do not know know that the OS
+  automatically reaps children (see comments above the loop), clear away any
+  finished subprocesses here, in case there are lots of messages coming in
+  from the same source. */
+
+  #ifndef SIG_IGN_WORKS
+  while (waitpid(-1, NULL, WNOHANG) > 0);
+  #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;
+#endif
+  callout_address = NULL;
+  sending_ip_address = NULL;
+  acl_var_m = NULL;
+  { int i; for(i=0; i<REGEX_VARS; i++) regex_vars[i] = NULL; }
+
+  store_reset(reset_point);
+  }
+
+exim_exit(EXIT_SUCCESS, US"main");   /* Never returns */
+return 0;                  /* To stop compiler warning */
+}
+
+
+/* End of exim.c */