src/src/exim.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2024 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-or-later */
   9
  10
  11 /* The main function: entry point, initialization, and high-level control.
  12 Also a few functions that don't naturally fit elsewhere. */
  13
  14
  15 #include "exim.h"
  16
  17 #if defined(__GLIBC__) && !defined(__UCLIBC__)
  18 # include <gnu/libc-version.h>
  19 #endif
  20
  21 #ifndef _TIME_H
  22 # include <time.h>
  23 #endif
  24 #ifndef NO_EXECINFO
  25 # include <execinfo.h>
  26 #endif
  27
  28 #ifdef USE_GNUTLS
  29 # include <gnutls/gnutls.h>
  30 # if GNUTLS_VERSION_NUMBER < 0x030103 && !defined(DISABLE_OCSP)
  31 #  define DISABLE_OCSP
  32 # endif
  33 #endif
  34
  35 extern void init_lookup_list(void);
  36
  37
  38
  39 /*************************************************
  40 *      Function interface to store functions     *
  41 *************************************************/
  42
  43 /* We need some real functions to pass to the PCRE regular expression library
  44 for store allocation via Exim's store manager. The normal calls are actually
  45 macros that pass over location information to make tracing easier. These
  46 functions just interface to the standard macro calls. A good compiler will
  47 optimize out the tail recursion and so not make them too expensive. */
  48
  49 static void *
  50 function_store_malloc(PCRE2_SIZE size, void * tag)
  51 {
  52 if (size > INT_MAX)
  53   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "excessive memory alloc request");
  54 return store_malloc((int)size);
  55 }
  56
  57 static void
  58 function_store_free(void * block, void * tag)
  59 {
  60 /* At least some version of pcre2 pass a null pointer */
  61 if (block) store_free(block);
  62 }
  63
  64
  65 static void *
  66 function_store_get(PCRE2_SIZE size, void * tag)
  67 {
  68 if (size > INT_MAX)
  69   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "excessive memory alloc request");
  70 return store_get((int)size, GET_UNTAINTED);     /* loses track of taint */
  71 }
  72
  73 static void
  74 function_store_nullfree(void * block, void * tag)
  75 {
  76 /* We cannot free memory allocated using store_get() */
  77 }
  78
  79
  80
  81
  82 /*************************************************
  83 *         Enums for cmdline interface            *
  84 *************************************************/
  85
  86 enum commandline_info { CMDINFO_NONE=0,
  87   CMDINFO_HELP, CMDINFO_SIEVE, CMDINFO_DSCP };
  88
  89
  90
  91
  92 static void
  93 pcre_init(void)
  94 {
  95 pcre_mlc_ctx = pcre2_general_context_create(function_store_malloc, function_store_free, NULL);
  96 pcre_gen_ctx = pcre2_general_context_create(function_store_get, function_store_nullfree, NULL);
  97
  98 pcre_mlc_cmp_ctx = pcre2_compile_context_create(pcre_mlc_ctx);
  99 pcre_gen_cmp_ctx = pcre2_compile_context_create(pcre_gen_ctx);
 100
 101 pcre_gen_mtc_ctx = pcre2_match_context_create(pcre_gen_ctx);
 102 }
 103
 104
 105
 106
 107 /*************************************************
 108 *   Execute regular expression and set strings   *
 109 *************************************************/
 110
 111 /* This function runs a regular expression match, and sets up the pointers to
 112 the matched substrings.  The matched strings are copied so the lifetime of
 113 the subject is not a problem.  Matched strings will have the same taint status
 114 as the subject string (this is not a de-taint method, and must not be made so
 115 given the support for wildcards in REs).
 116
 117 Arguments:
 118   re          the compiled expression
 119   subject     the subject string
 120   options     additional PCRE options
 121   setup       if < 0 do full setup
 122               if >= 0 setup from setup+1 onwards,
 123                 excluding the full matched string
 124
 125 Returns:      TRUE if matched, or FALSE
 126 */
 127
 128 BOOL
 129 regex_match_and_setup(const pcre2_code * re, const uschar * subject, int options, int setup)
 130 {
 131 pcre2_match_data * md = pcre2_match_data_create_from_pattern(re, pcre_gen_ctx);
 132 int res = pcre2_match(re, (PCRE2_SPTR)subject, PCRE2_ZERO_TERMINATED, 0,
 133                         PCRE_EOPT | options, md, pcre_gen_mtc_ctx);
 134 BOOL yield;
 135
 136 if ((yield = (res >= 0)))
 137   {
 138   PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
 139   res = pcre2_get_ovector_count(md);
 140   expand_nmax = setup < 0 ? 0 : setup + 1;
 141   for (int matchnum = setup < 0 ? 0 : 1; matchnum < res; matchnum++)
 142     {
 143     /* Although PCRE2 has a pcre2_substring_get_bynumber() conveneience, it
 144     seems to return a bad pointer when a capture group had no data, eg. (.*)
 145     matching zero letters.  So use the underlying ovec and hope (!) that the
 146     offsets are sane (including that case).  Should we go further and range-
 147     check each one vs. the subject string length? */
 148     int off = matchnum * 2;
 149     int len = ovec[off + 1] - ovec[off];
 150     expand_nstring[expand_nmax] = string_copyn(subject + ovec[off], len);
 151     expand_nlength[expand_nmax++] = len;
 152     }
 153   expand_nmax--;
 154   }
 155 else if (res != PCRE2_ERROR_NOMATCH) DEBUG(D_any)
 156   {
 157   uschar errbuf[128];
 158   pcre2_get_error_message(res, errbuf, sizeof(errbuf));
 159   debug_printf_indent("pcre2: %s\n", errbuf);
 160   }
 161 /* pcre2_match_data_free(md);   gen ctx needs no free */
 162 return yield;
 163 }
 164
 165
 166 /* Check just for match with regex.  Uses the common memory-handling.
 167
 168 Arguments:
 169         re      compiled regex
 170         subject string to be checked
 171         slen    length of subject; -1 for nul-terminated
 172         rptr    pointer for matched string, copied, or NULL
 173
 174 Return: TRUE for a match.
 175 */
 176
 177 BOOL
 178 regex_match(const pcre2_code * re, const uschar * subject, int slen, uschar ** rptr)
 179 {
 180 pcre2_match_data * md = pcre2_match_data_create(1, pcre_gen_ctx);
 181 int rc = pcre2_match(re, (PCRE2_SPTR)subject,
 182                       slen >= 0 ? slen : PCRE2_ZERO_TERMINATED,
 183                       0, PCRE_EOPT, md, pcre_gen_mtc_ctx);
 184 PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
 185 BOOL ret = FALSE;
 186
 187 if (rc >= 0)
 188   {
 189   if (rptr)
 190     *rptr = string_copyn(subject + ovec[0], ovec[1] - ovec[0]);
 191   ret = TRUE;
 192   }
 193 /* pcre2_match_data_free(md);   gen ctx needs no free */
 194 return ret;
 195 }
 196
 197
 198
 199 /*************************************************
 200 *            Set up processing details           *
 201 *************************************************/
 202
 203 /* Save a text string for dumping when SIGUSR1 is received.
 204 Do checks for overruns.
 205
 206 Arguments: format and arguments, as for printf()
 207 Returns:   nothing
 208 */
 209
 210 void
 211 set_process_info(const char * format, ...)
 212 {
 213 gstring gs = { .size = PROCESS_INFO_SIZE - 2, .ptr = 0, .s = process_info };
 214 gstring * g;
 215 int len;
 216 uschar * s;
 217 va_list ap;
 218
 219 g = string_fmt_append(&gs, "%5d ", (int)getpid());
 220 len = gstring_length(g);
 221 va_start(ap, format);
 222 if (!string_vformat(g, 0, format, ap))
 223   {
 224   gs.ptr = len;
 225   g = string_cat(&gs, US"**** string overflowed buffer ****");
 226   }
 227 g = string_catn(g, US"\n", 1);
 228 process_info_len = len_string_from_gstring(g, &s);
 229 DEBUG(D_process_info) debug_printf("set_process_info: %s", process_info);
 230 va_end(ap);
 231 }
 232
 233 /***********************************************
 234 *            Handler for SIGTERM               *
 235 ***********************************************/
 236
 237 static void
 238 term_handler(int sig)
 239 {
 240 exim_exit(EXIT_FAILURE);
 241 }
 242
 243
 244 /***********************************************
 245 *            Handler for SIGSEGV               *
 246 ***********************************************/
 247
 248 #define STACKDUMP_MAX 24
 249 void
 250 stackdump(void)
 251 {
 252 #ifndef NO_EXECINFO
 253 void * buf[STACKDUMP_MAX];
 254 char ** ss;
 255 int nptrs = backtrace(buf, STACKDUMP_MAX);
 256
 257 log_write(0, LOG_MAIN|LOG_PANIC, "backtrace");
 258 log_write(0, LOG_MAIN|LOG_PANIC, "---");
 259 if ((ss = backtrace_symbols(buf, nptrs)))
 260   {
 261   for (int i = 0; i < nptrs; i++)
 262     log_write(0, LOG_MAIN|LOG_PANIC, "\t%s", ss[i]);
 263   free(ss);
 264   }
 265 else
 266   log_write(0, LOG_MAIN|LOG_PANIC, "backtrace_symbols: %s", strerror(errno));
 267 log_write(0, LOG_MAIN|LOG_PANIC, "---");
 268 #endif
 269 }
 270 #undef STACKDUMP_MAX
 271
 272
 273 static void
 274 #ifdef SA_SIGINFO
 275 segv_handler(int sig, siginfo_t * info, void * uctx)
 276 {
 277 if (!panic_coredump)
 278   {
 279   log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (fault address: %p)", info->si_addr);
 280   # if defined(SEGV_MAPERR) && defined(SEGV_ACCERR) && defined(SEGV_BNDERR) && defined(SEGV_PKUERR)
 281   switch (info->si_code)
 282     {
 283     case SEGV_MAPERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_MAPERR"); break;
 284     case SEGV_ACCERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_ACCERR"); break;
 285     case SEGV_BNDERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_BNDERR"); break;
 286     case SEGV_PKUERR: log_write(0, LOG_MAIN|LOG_PANIC, "SEGV_PKUERR"); break;
 287     }
 288   # endif
 289   }
 290 if (panic_coredump)
 291   log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (deliberate trap)");
 292 else if (US info->si_addr < US 4096)
 293   log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (null pointer indirection)");
 294 else
 295   log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (maybe attempt to write to immutable memory)");
 296 if (process_info_len > 0)
 297   log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (%s: %.*s)",
 298     process_purpose, process_info_len, process_info);
 299 stackdump();
 300 signal(SIGSEGV, SIG_DFL);
 301 kill(getpid(), sig);
 302 }
 303
 304 #else
 305 segv_handler(int sig)
 306 {
 307 log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (maybe attempt to write to immutable memory)");
 308 if (process_info_len > 0)
 309   log_write(0, LOG_MAIN|LOG_PANIC, "SIGSEGV (%.*s)", process_info_len, process_info);
 310 stackdump();
 311 signal(SIGSEGV, SIG_DFL);
 312 kill(getpid(), sig);
 313 }
 314 #endif
 315
 316
 317 /*************************************************
 318 *             Handler for SIGUSR1                *
 319 *************************************************/
 320
 321 /* SIGUSR1 causes any exim process to write to the process log details of
 322 what it is currently doing. It will only be used if the OS is capable of
 323 setting up a handler that causes automatic restarting of any system call
 324 that is in progress at the time.
 325
 326 This function takes care to be signal-safe.
 327
 328 Argument: the signal number (SIGUSR1)
 329 Returns:  nothing
 330 */
 331
 332 static void
 333 usr1_handler(int sig)
 334 {
 335 int fd;
 336
 337 os_restarting_signal(sig, usr1_handler);
 338
 339 if (!process_log_path) return;
 340 fd = log_open_as_exim(process_log_path);
 341
 342 /* If we are neither exim nor root, or if we failed to create the log file,
 343 give up. There is not much useful we can do with errors, since we don't want
 344 to disrupt whatever is going on outside the signal handler. */
 345
 346 if (fd < 0) return;
 347
 348 (void)write(fd, process_info, process_info_len);
 349 (void)close(fd);
 350 }
 351
 352
 353
 354 /*************************************************
 355 *             Timeout handler                    *
 356 *************************************************/
 357
 358 /* This handler is enabled most of the time that Exim is running. The handler
 359 doesn't actually get used unless alarm() has been called to set a timer, to
 360 place a time limit on a system call of some kind. When the handler is run, it
 361 re-enables itself.
 362
 363 There are some other SIGALRM handlers that are used in special cases when more
 364 than just a flag setting is required; for example, when reading a message's
 365 input. These are normally set up in the code module that uses them, and the
 366 SIGALRM handler is reset to this one afterwards.
 367
 368 Argument: the signal value (SIGALRM)
 369 Returns:  nothing
 370 */
 371
 372 void
 373 sigalrm_handler(int sig)
 374 {
 375 sigalrm_seen = TRUE;
 376 os_non_restarting_signal(SIGALRM, sigalrm_handler);
 377 }
 378
 379
 380
 381 /*************************************************
 382 *      Sleep for a fractional time interval      *
 383 *************************************************/
 384
 385 /* This function is called by millisleep() and exim_wait_tick() to wait for a
 386 period of time that may include a fraction of a second. The coding is somewhat
 387 tedious. We do not expect setitimer() ever to fail, but if it does, the process
 388 will wait for ever, so we panic in this instance. (There was a case of this
 389 when a bug in a function that calls milliwait() caused it to pass invalid data.
 390 That's when I added the check. :-)
 391
 392 We assume it to be not worth sleeping for under 50us; this value will
 393 require revisiting as hardware advances.  This avoids the issue of
 394 a zero-valued timer setting meaning "never fire".
 395
 396 Argument:  an itimerval structure containing the interval
 397 Returns:   nothing
 398 */
 399
 400 static void
 401 milliwait(struct itimerval *itval)
 402 {
 403 sigset_t sigmask;
 404 sigset_t old_sigmask;
 405 int save_errno = errno;
 406
 407 if (itval->it_value.tv_usec < 50 && itval->it_value.tv_sec == 0)
 408   return;
 409 (void)sigemptyset(&sigmask);                           /* Empty mask */
 410 (void)sigaddset(&sigmask, SIGALRM);                    /* Add SIGALRM */
 411 (void)sigprocmask(SIG_BLOCK, &sigmask, &old_sigmask);  /* Block SIGALRM */
 412 if (setitimer(ITIMER_REAL, itval, NULL) < 0)           /* Start timer */
 413   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
 414     "setitimer() failed: %s", strerror(errno));
 415 (void)sigfillset(&sigmask);                            /* All signals */
 416 (void)sigdelset(&sigmask, SIGALRM);                    /* Remove SIGALRM */
 417 (void)sigsuspend(&sigmask);                            /* Until SIGALRM */
 418 (void)sigprocmask(SIG_SETMASK, &old_sigmask, NULL);    /* Restore mask */
 419 errno = save_errno;
 420 sigalrm_seen = FALSE;
 421 }
 422
 423
 424
 425
 426 /*************************************************
 427 *         Millisecond sleep function             *
 428 *************************************************/
 429
 430 /* The basic sleep() function has a granularity of 1 second, which is too rough
 431 in some cases - for example, when using an increasing delay to slow down
 432 spammers.
 433
 434 Argument:    number of millseconds
 435 Returns:     nothing
 436 */
 437
 438 void
 439 millisleep(int msec)
 440 {
 441 struct itimerval itval = {.it_interval = {.tv_sec = 0, .tv_usec = 0},
 442                           .it_value = {.tv_sec = msec/1000,
 443                                        .tv_usec = (msec % 1000) * 1000}};
 444 milliwait(&itval);
 445 }
 446
 447
 448
 449 /*************************************************
 450 *         Compare microsecond times              *
 451 *************************************************/
 452
 453 /*
 454 Arguments:
 455   tv1         the first time
 456   tv2         the second time
 457
 458 Returns:      -1, 0, or +1
 459 */
 460
 461 static int
 462 exim_tvcmp(struct timeval *t1, struct timeval *t2)
 463 {
 464 if (t1->tv_sec > t2->tv_sec) return +1;
 465 if (t1->tv_sec < t2->tv_sec) return -1;
 466 if (t1->tv_usec > t2->tv_usec) return +1;
 467 if (t1->tv_usec < t2->tv_usec) return -1;
 468 return 0;
 469 }
 470
 471
 472
 473
 474 /*************************************************
 475 *          Clock tick wait function              *
 476 *************************************************/
 477
 478 #ifdef _POSIX_MONOTONIC_CLOCK
 479 # ifdef CLOCK_BOOTTIME
 480 #  define EXIM_CLOCKTYPE CLOCK_BOOTTIME
 481 # else
 482 #  define EXIM_CLOCKTYPE CLOCK_MONOTONIC
 483 # endif
 484
 485 /* Amount EXIM_CLOCK is behind realtime, at startup. */
 486 static struct timespec offset_ts;
 487
 488 static void
 489 exim_clock_init(void)
 490 {
 491 struct timeval tv;
 492 if (clock_gettime(EXIM_CLOCKTYPE, &offset_ts) != 0) return;
 493 (void)gettimeofday(&tv, NULL);
 494 offset_ts.tv_sec = tv.tv_sec - offset_ts.tv_sec;
 495 offset_ts.tv_nsec = tv.tv_usec * 1000 - offset_ts.tv_nsec;
 496 if (offset_ts.tv_nsec >= 0) return;
 497 offset_ts.tv_sec--;
 498 offset_ts.tv_nsec += 1000*1000*1000;
 499 }
 500 #endif
 501
 502
 503 void
 504 exim_gettime(struct timeval * tv)
 505 {
 506 #ifdef _POSIX_MONOTONIC_CLOCK
 507 struct timespec now_ts;
 508
 509 if (clock_gettime(EXIM_CLOCKTYPE, &now_ts) == 0)
 510   {
 511   now_ts.tv_sec += offset_ts.tv_sec;
 512   if ((now_ts.tv_nsec += offset_ts.tv_nsec) >= 1000*1000*1000)
 513     {
 514     now_ts.tv_sec++;
 515     now_ts.tv_nsec -= 1000*1000*1000;
 516     }
 517   tv->tv_sec = now_ts.tv_sec;
 518   tv->tv_usec = now_ts.tv_nsec / 1000;
 519   }
 520 else
 521 #endif
 522   (void)gettimeofday(tv, NULL);
 523 }
 524
 525
 526 /* Exim uses a time + a pid to generate a unique identifier in two places: its
 527 message IDs, and in file names for maildir deliveries. Because some OS now
 528 re-use pids within the same second, sub-second times are now being used.
 529 However, for absolute certainty, we must ensure the clock has ticked before
 530 allowing the relevant process to complete. At the time of implementation of
 531 this code (February 2003), the speed of processors is such that the clock will
 532 invariably have ticked already by the time a process has done its job. This
 533 function prepares for the time when things are faster - and it also copes with
 534 clocks that go backwards.
 535
 536 Arguments:
 537   prev_tv      A timeval which was used to create uniqueness; its usec field
 538                  has been rounded down to the value of the resolution.
 539                  We want to be sure the current time is greater than this.
 540                  On return, updated to current (rounded down).
 541   resolution   The resolution that was used to divide the microseconds
 542                  (1 for maildir, larger for message ids)
 543
 544 Returns:       nothing
 545 */
 546
 547 void
 548 exim_wait_tick(struct timeval * prev_tv, int resolution)
 549 {
 550 struct timeval now_tv;
 551 long int now_true_usec;
 552
 553 exim_gettime(&now_tv);
 554 now_true_usec = now_tv.tv_usec;
 555 now_tv.tv_usec = (now_true_usec/resolution) * resolution;
 556
 557 while (exim_tvcmp(&now_tv, prev_tv) <= 0)
 558   {
 559   struct itimerval itval;
 560   itval.it_interval.tv_sec = 0;
 561   itval.it_interval.tv_usec = 0;
 562   itval.it_value.tv_sec = prev_tv->tv_sec - now_tv.tv_sec;
 563   itval.it_value.tv_usec = prev_tv->tv_usec + resolution - now_true_usec;
 564
 565   /* We know that, overall, "now" is less than or equal to "then". Therefore, a
 566   negative value for the microseconds is possible only in the case when "now"
 567   is more than a second less than "tgt". That means that itval.it_value.tv_sec
 568   is greater than zero. The following correction is therefore safe. */
 569
 570   if (itval.it_value.tv_usec < 0)
 571     {
 572     itval.it_value.tv_usec += 1000000;
 573     itval.it_value.tv_sec -= 1;
 574     }
 575
 576   DEBUG(D_transport|D_receive)
 577     {
 578     if (!f.running_in_test_harness)
 579       {
 580       debug_printf("tick check: " TIME_T_FMT ".%06lu " TIME_T_FMT ".%06lu\n",
 581         prev_tv->tv_sec, (long) prev_tv->tv_usec,
 582         now_tv.tv_sec, (long) now_tv.tv_usec);
 583       debug_printf("waiting " TIME_T_FMT ".%06lu sec\n",
 584         itval.it_value.tv_sec, (long) itval.it_value.tv_usec);
 585       }
 586     }
 587
 588   milliwait(&itval);
 589
 590   /* Be prapared to go around if the kernel does not implement subtick
 591   granularity (GNU Hurd) */
 592
 593   exim_gettime(&now_tv);
 594   now_true_usec = now_tv.tv_usec;
 595   now_tv.tv_usec = (now_true_usec/resolution) * resolution;
 596   }
 597 *prev_tv = now_tv;
 598 }
 599
 600
 601
 602
 603 /*************************************************
 604 *   Call fopen() with umask 777 and adjust mode  *
 605 *************************************************/
 606
 607 /* Exim runs with umask(0) so that files created with open() have the mode that
 608 is specified in the open() call. However, there are some files, typically in
 609 the spool directory, that are created with fopen(). They end up world-writeable
 610 if no precautions are taken. Although the spool directory is not accessible to
 611 the world, this is an untidiness. So this is a wrapper function for fopen()
 612 that sorts out the mode of the created file.
 613
 614 Arguments:
 615    filename       the file name
 616    options        the fopen() options
 617    mode           the required mode
 618
 619 Returns:          the fopened FILE or NULL
 620 */
 621
 622 FILE *
 623 modefopen(const uschar *filename, const char *options, mode_t mode)
 624 {
 625 mode_t saved_umask = umask(0777);
 626 FILE *f = Ufopen(filename, options);
 627 (void)umask(saved_umask);
 628 if (f != NULL) (void)fchmod(fileno(f), mode);
 629 return f;
 630 }
 631
 632
 633 /*************************************************
 634 *   Ensure stdin, stdout, and stderr exist       *
 635 *************************************************/
 636
 637 /* Some operating systems grumble if an exec() happens without a standard
 638 input, output, and error (fds 0, 1, 2) being defined. The worry is that some
 639 file will be opened and will use these fd values, and then some other bit of
 640 code will assume, for example, that it can write error messages to stderr.
 641 This function ensures that fds 0, 1, and 2 are open if they do not already
 642 exist, by connecting them to /dev/null.
 643
 644 This function is also used to ensure that std{in,out,err} exist at all times,
 645 so that if any library that Exim calls tries to use them, it doesn't crash.
 646
 647 Arguments:  None
 648 Returns:    Nothing
 649 */
 650
 651 void
 652 exim_nullstd(void)
 653 {
 654 int devnull = -1;
 655 struct stat statbuf;
 656 for (int i = 0; i <= 2; i++)
 657   {
 658   if (fstat(i, &statbuf) < 0 && errno == EBADF)
 659     {
 660     if (devnull < 0) devnull = open("/dev/null", O_RDWR);
 661     if (devnull < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
 662       string_open_failed("/dev/null", NULL));
 663     if (devnull != i) (void)dup2(devnull, i);
 664     }
 665   }
 666 if (devnull > 2) (void)close(devnull);
 667 }
 668
 669
 670
 671
 672 /*************************************************
 673 *   Close unwanted file descriptors for delivery *
 674 *************************************************/
 675
 676 /* This function is called from a new process that has been forked to deliver
 677 an incoming message, either directly, or using exec.
 678
 679 We want any smtp input streams to be closed in this new process. However, it
 680 has been observed that using fclose() here causes trouble. When reading in -bS
 681 input, duplicate copies of messages have been seen. The files will be sharing a
 682 file pointer with the parent process, and it seems that fclose() (at least on
 683 some systems - I saw this on Solaris 2.5.1) messes with that file pointer, at
 684 least sometimes. Hence we go for closing the underlying file descriptors.
 685
 686 If TLS is active, we want to shut down the TLS library, but without molesting
 687 the parent's SSL connection.
 688
 689 For delivery of a non-SMTP message, we want to close stdin and stdout (and
 690 stderr unless debugging) because the calling process might have set them up as
 691 pipes and be waiting for them to close before it waits for the submission
 692 process to terminate. If they aren't closed, they hold up the calling process
 693 until the initial delivery process finishes, which is not what we want.
 694
 695 Exception: We do want it for synchronous delivery!
 696
 697 And notwithstanding all the above, if D_resolver is set, implying resolver
 698 debugging, leave stdout open, because that's where the resolver writes its
 699 debugging output.
 700
 701 When we close stderr (which implies we've also closed stdout), we also get rid
 702 of any controlling terminal.
 703
 704 Arguments:   None
 705 Returns:     Nothing
 706 */
 707
 708 static void
 709 close_unwanted(void)
 710 {
 711 if (smtp_input)
 712   {
 713 #ifndef DISABLE_TLS
 714   tls_close(NULL, TLS_NO_SHUTDOWN);      /* Shut down the TLS library */
 715 #endif
 716   (void)close(fileno(smtp_in));
 717   (void)close(fileno(smtp_out));
 718   smtp_in = NULL;
 719   }
 720 else
 721   {
 722   (void)close(0);                                          /* stdin */
 723   if ((debug_selector & D_resolver) == 0) (void)close(1);  /* stdout */
 724   if (debug_selector == 0)                                 /* stderr */
 725     {
 726     if (!f.synchronous_delivery)
 727       {
 728       (void)close(2);
 729       log_stderr = NULL;
 730       }
 731     (void)setsid();
 732     }
 733   }
 734 }
 735
 736
 737
 738
 739 /*************************************************
 740 *          Set uid and gid                       *
 741 *************************************************/
 742
 743 /* This function sets a new uid and gid permanently, optionally calling
 744 initgroups() to set auxiliary groups. There are some special cases when running
 745 Exim in unprivileged modes. In these situations the effective uid will not be
 746 root; if we already have the right effective uid/gid, and don't need to
 747 initialize any groups, leave things as they are.
 748
 749 Arguments:
 750   uid        the uid
 751   gid        the gid
 752   igflag     TRUE if initgroups() wanted
 753   msg        text to use in debugging output and failure log
 754
 755 Returns:     nothing; bombs out on failure
 756 */
 757
 758 void
 759 exim_setugid(uid_t uid, gid_t gid, BOOL igflag, const uschar * msg)
 760 {
 761 uid_t euid = geteuid();
 762 gid_t egid = getegid();
 763
 764 if (euid == root_uid || euid != uid || egid != gid || igflag)
 765   {
 766   /* At least one OS returns +1 for initgroups failure, so just check for
 767   non-zero. */
 768
 769   if (igflag)
 770     {
 771     struct passwd *pw = getpwuid(uid);
 772     if (!pw)
 773       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "cannot run initgroups(): "
 774         "no passwd entry for uid=%ld", (long int)uid);
 775
 776     if (initgroups(pw->pw_name, gid) != 0)
 777       log_write(0,LOG_MAIN|LOG_PANIC_DIE,"initgroups failed for uid=%ld: %s",
 778         (long int)uid, strerror(errno));
 779     }
 780
 781   if (setgid(gid) < 0 || setuid(uid) < 0)
 782     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to set gid=%ld or uid=%ld "
 783       "(euid=%ld): %s", (long int)gid, (long int)uid, (long int)euid, msg);
 784   }
 785
 786 /* Debugging output included uid/gid and all groups */
 787
 788 DEBUG(D_uid)
 789   {
 790   int group_count, save_errno;
 791   gid_t group_list[EXIM_GROUPLIST_SIZE];
 792   debug_printf("changed uid/gid: %s\n  uid=%ld gid=%ld pid=%ld\n", msg,
 793     (long int)geteuid(), (long int)getegid(), (long int)getpid());
 794   group_count = getgroups(nelem(group_list), group_list);
 795   save_errno = errno;
 796   debug_printf("  auxiliary group list:");
 797   if (group_count > 0)
 798     for (int i = 0; i < group_count; i++) debug_printf(" %d", (int)group_list[i]);
 799   else if (group_count < 0)
 800     debug_printf(" <error: %s>", strerror(save_errno));
 801   else debug_printf(" <none>");
 802   debug_printf("\n");
 803   }
 804 }
 805
 806
 807
 808
 809 /*************************************************
 810 *               Exit point                       *
 811 *************************************************/
 812
 813 /* Exim exits via this function so that it always clears up any open
 814 databases.
 815
 816 Arguments:
 817   rc         return code
 818
 819 Returns:     does not return
 820 */
 821
 822 void
 823 exim_exit(int rc)
 824 {
 825 search_tidyup();
 826 store_exit();
 827 DEBUG(D_any)
 828   debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d (%s) terminating with rc=%d "
 829     ">>>>>>>>>>>>>>>>\n",
 830     (int)getpid(), process_purpose, rc);
 831 exit(rc);
 832 }
 833
 834
 835 void
 836 exim_underbar_exit(int rc)
 837 {
 838 store_exit();
 839 DEBUG(D_any)
 840   debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d (%s) terminating with rc=%d "
 841     ">>>>>>>>>>>>>>>>\n",
 842     (int)getpid(), process_purpose, rc);
 843 _exit(rc);
 844 }
 845
 846
 847
 848 /* Print error string, then die */
 849 static void
 850 exim_fail(const char * fmt, ...)
 851 {
 852 va_list ap;
 853 va_start(ap, fmt);
 854 vfprintf(stderr, fmt, ap);
 855 va_end(ap);
 856 exit(EXIT_FAILURE);
 857 }
 858
 859 /* fail if a length is too long */
 860 static inline void
 861 exim_len_fail_toolong(int itemlen, int maxlen, const char * description)
 862 {
 863 if (itemlen <= maxlen)
 864   return;
 865 fprintf(stderr, "exim: length limit exceeded (%d > %d) for: %s\n",
 866         itemlen, maxlen, description);
 867 exit(EXIT_FAILURE);
 868 }
 869
 870 /* only pass through the string item back to the caller if it's short enough */
 871 static inline const uschar *
 872 exim_str_fail_toolong(const uschar * item, int maxlen, const char * description)
 873 {
 874 if (!item)
 875   exim_fail("exim: bad item for: %s\n", description);
 876 exim_len_fail_toolong(Ustrlen(item), maxlen, description);
 877 return item;
 878 }
 879
 880 /* exim_chown_failure() called from exim_chown()/exim_fchown() on failure
 881 of chown()/fchown().  See src/functions.h for more explanation */
 882 int
 883 exim_chown_failure(int fd, const uschar *name, uid_t owner, gid_t group)
 884 {
 885 int saved_errno = errno;  /* from the preceeding chown call */
 886 #if 1
 887 log_write(0, LOG_MAIN|LOG_PANIC,
 888   __FILE__ ":%d: chown(%s, %d:%d) failed (%s)."
 889   " Please contact the authors and refer to https://bugs.exim.org/show_bug.cgi?id=2391",
 890   __LINE__, name?name:US"<unknown>", owner, group, strerror(errno));
 891 #else
 892 /* I leave this here, commented, in case the "bug"(?) comes up again.
 893    It is not an Exim bug, but we can provide a workaround.
 894    See Bug 2391
 895    HS 2019-04-18 */
 896
 897 struct stat buf;
 898
 899 if (0 == (fd < 0 ? stat(name, &buf) : fstat(fd, &buf)))
 900   {
 901   if (buf.st_uid == owner && buf.st_gid == group) return 0;
 902   log_write(0, LOG_MAIN|LOG_PANIC, "Wrong ownership on %s", name);
 903   }
 904 else log_write(0, LOG_MAIN|LOG_PANIC, "Stat failed on %s: %s", name, strerror(errno));
 905
 906 #endif
 907 errno = saved_errno;
 908 return -1;
 909 }
 910
 911
 912 /* Bump the index for argv, checking for overflow,
 913 and return the argument. */
 914
 915 static const uschar *
 916 next_argv(const uschar ** argv, int * pi, int argc, const uschar * where)
 917 {
 918 int i = *pi;
 919 if (++i >= argc) exim_fail("exim: bad item for: %s\n", where);
 920 return argv[*pi = i];
 921 }
 922
 923
 924 /*************************************************
 925 *         Extract port from host address         *
 926 *************************************************/
 927
 928 /* Called to extract the port from the values given to -oMa and -oMi.
 929 It also checks the syntax of the address, and terminates it before the
 930 port data when a port is extracted.
 931
 932 Argument:
 933   address   the address, with possible port on the end
 934
 935 Returns:    the port, or zero if there isn't one
 936             bombs out on a syntax error
 937 */
 938
 939 static int
 940 check_port(uschar *address)
 941 {
 942 int port = host_address_extract_port(address);
 943 if (string_is_ip_address(address, NULL) == 0)
 944   exim_fail("exim abandoned: \"%s\" is not an IP address\n", address);
 945 return port;
 946 }
 947
 948
 949
 950 /*************************************************
 951 *              Test/verify an address            *
 952 *************************************************/
 953
 954 /* This function is called by the -bv and -bt code. It extracts a working
 955 address from a full RFC 822 address. This isn't really necessary per se, but it
 956 has the effect of collapsing source routes.
 957
 958 Arguments:
 959   s            the address string
 960   flags        flag bits for verify_address()
 961   exit_value   to be set for failures
 962
 963 Returns:       nothing
 964 */
 965
 966 static void
 967 test_address(uschar *s, int flags, int *exit_value)
 968 {
 969 int start, end, domain;
 970 uschar *parse_error = NULL;
 971 uschar *address = parse_extract_address(s, &parse_error, &start, &end, &domain,
 972   FALSE);
 973 if (!address)
 974   {
 975   fprintf(stdout, "syntax error: %s\n", parse_error);
 976   *exit_value = 2;
 977   }
 978 else
 979   {
 980   int rc = verify_address(deliver_make_addr(address,TRUE), stdout, flags, -1,
 981     -1, -1, NULL, NULL, NULL);
 982   if (rc == FAIL) *exit_value = 2;
 983   else if (rc == DEFER && *exit_value == 0) *exit_value = 1;
 984   }
 985 }
 986
 987
 988
 989 /*************************************************
 990 *          Show supported features               *
 991 *************************************************/
 992
 993 static void
 994 show_string(BOOL is_stdout, gstring * g)
 995 {
 996 const uschar * s = string_from_gstring(g);
 997 if (s)
 998   if (is_stdout) fputs(CCS s, stdout);
 999   else debug_printf("%s", s);
1000 }
1001
1002
1003 static gstring *
1004 show_db_version(gstring * g)
1005 {
1006 g = string_cat(g, US"Hints DB:\n");
1007 #ifdef DB_VERSION_STRING
1008 DEBUG(D_any)
1009   {
1010   g = string_fmt_append(g, " Library version: BDB: Compile: %s\n", DB_VERSION_STRING);
1011   g = string_fmt_append(g, "                       Runtime: %s\n",
1012     db_version(NULL, NULL, NULL));
1013   }
1014 else
1015   g = string_fmt_append(g, " Berkeley DB: %s\n", DB_VERSION_STRING);
1016
1017 #elif defined(BTREEVERSION) && defined(HASHVERSION)
1018 # ifdef USE_DB
1019   g = string_cat(g, US" Probably Berkeley DB version 1.8x (native mode)\n");
1020 # else
1021   g = string_cat(g, US" Probably Berkeley DB version 1.8x (compatibility mode)\n");
1022 # endif
1023
1024 #elif defined(_DBM_RDONLY) || defined(dbm_dirfno)
1025 g = string_cat(g, US" Probably ndbm\n");
1026 #elif defined(USE_SQLITE)
1027 g = string_cat(g, US" Using sqlite3\n");
1028 #elif defined(USE_TDB)
1029 g = string_cat(g, US" Using tdb\n");
1030 #else
1031 # ifdef USE_GDBM
1032 g = string_cat(g, US" Probably GDBM (native mode)\n");
1033 # else
1034 g = string_cat(g, US" Probably GDBM (compatibility mode)\n");
1035 # endif
1036 #endif
1037 return g;
1038 }
1039
1040
1041 static gstring *
1042 lookup_show_supported(gstring * g)
1043 {
1044 gstring * b = NULL, * d = NULL;
1045
1046 #ifdef LOOKUP_LSEARCH
1047 # if LOOKUP_LSEARCH!=2
1048   b = string_cat(b, US" lsearch wildlsearch nwildlsearch iplsearch");
1049 # else
1050   d = string_cat(d, US" lsearch wildlsearch nwildlsearch iplsearch");
1051 # endif
1052 #endif
1053 #ifdef LOOKUP_CDB
1054 # if LOOKUP_CDB!=2
1055   b = string_cat(b, US" cdb");
1056 # else
1057   d = string_cat(d, US" cdb");
1058 # endif
1059 #endif
1060 #ifdef LOOKUP_DBM
1061 # if LOOKUP_DBM!=2
1062   b = string_cat(b, US" dbm dbmjz dbmnz");
1063 # else
1064   d = string_cat(d, US" dbm dbmjz dbmnz");
1065 # endif
1066 #endif
1067 #ifdef LOOKUP_DNSDB
1068 # if LOOKUP_DNSDB!=2
1069   b = string_cat(b, US" dnsdb");
1070 # else
1071   d = string_cat(d, US" dnsdb");
1072 # endif
1073 #endif
1074 #ifdef LOOKUP_DSEARCH
1075 # if LOOKUP_DSEARCH!=2
1076   b = string_cat(b, US" dsearch");
1077 # else
1078   d = string_cat(d, US" dsearch");
1079 # endif
1080 #endif
1081 #ifdef LOOKUP_IBASE
1082 # if LOOKUP_IBASE!=2
1083   b = string_cat(b, US" ibase");
1084 # else
1085   d = string_cat(d, US" ibase");
1086 # endif
1087 #endif
1088 #ifdef LOOKUP_JSON
1089 # if LOOKUP_JSON!=2
1090   b = string_cat(b, US" json");
1091 # else
1092   d = string_cat(d, US" json");
1093 # endif
1094 #endif
1095 #ifdef LOOKUP_LDAP
1096 # if LOOKUP_LDAP!=2
1097   b = string_cat(b, US" ldap ldapdn ldapm");
1098 # else
1099   d = string_cat(d, US" ldap ldapdn ldapm");
1100 # endif
1101 #endif
1102 #ifdef LOOKUP_LMDB
1103 # if LOOKUP_LMDB!=2
1104   b = string_cat(b, US" lmdb");
1105 # else
1106   d = string_cat(d, US" lmdb");
1107 # endif
1108 #endif
1109 #ifdef LOOKUP_MYSQL
1110 # if LOOKUP_MYSQL!=2
1111   b = string_cat(b, US" mysql");
1112 # else
1113   d = string_cat(d, US" mysql");
1114 # endif
1115 #endif
1116 #ifdef LOOKUP_NIS
1117 # if LOOKUP_NIS!=2
1118   b = string_cat(b, US" nis nis0");
1119 # else
1120   d = string_cat(d, US" nis nis0");
1121 # endif
1122 #endif
1123 #ifdef LOOKUP_NISPLUS
1124 # if LOOKUP_NISPLUS!=2
1125   b = string_cat(b, US" nisplus");
1126 # else
1127   d = string_cat(d, US" nisplus");
1128 # endif
1129 #endif
1130 #ifdef LOOKUP_ORACLE
1131 # if LOOKUP_ORACLE!=2
1132   b = string_cat(b, US" oracle");
1133 # else
1134   d = string_cat(d, US" oracle");
1135 # endif
1136 #endif
1137 #ifdef LOOKUP_PASSWD
1138 # if LOOKUP_PASSWD!=2
1139   b = string_cat(b, US" passwd");
1140 # else
1141   d = string_cat(d, US" passwd");
1142 # endif
1143 #endif
1144 #ifdef LOOKUP_PGSQL
1145 # if LOOKUP_PGSQL!=2
1146   b = string_cat(b, US" pgsql");
1147 # else
1148   d = string_cat(d, US" pgsql");
1149 # endif
1150 #endif
1151 #ifdef LOOKUP_REDIS
1152 # if LOOKUP_REDIS!=2
1153   b = string_cat(b, US" redis");
1154 # else
1155   d = string_cat(d, US" redis");
1156 # endif
1157 #endif
1158 #ifdef LOOKUP_SQLITE
1159 # if LOOKUP_SQLITE!=2
1160   b = string_cat(b, US" sqlite");
1161 # else
1162   d = string_cat(d, US" sqlite");
1163 # endif
1164 #endif
1165 #ifdef LOOKUP_TESTDB
1166 # if LOOKUP_TESTDB!=2
1167   b = string_cat(b, US" testdb");
1168 # else
1169   d = string_cat(d, US" testdb");
1170 # endif
1171 #endif
1172 #ifdef LOOKUP_WHOSON
1173 # if LOOKUP_WHOSON!=2
1174   b = string_cat(b, US" whoson");
1175 # else
1176   d = string_cat(d, US" whoson");
1177 # endif
1178 #endif
1179
1180 if (b) g = string_fmt_append(g, "Lookups (built-in):%Y\n", b);
1181 if (d) g = string_fmt_append(g, "Lookups (dynamic): %Y\n", d);
1182 return g;
1183 }
1184
1185
1186 static void
1187 lookup_version_report_cb(uschar * name, uschar * ptr, void * ctx)
1188 {
1189 const lookup_info * li = (lookup_info *)ptr;
1190 gstring ** gp = ctx;
1191
1192 if (li->version_report)
1193   *gp = li->version_report(*gp);
1194 }
1195
1196
1197 /* This function is called for -bV/--version and for -d to output the optional
1198 features of the current Exim binary.
1199
1200 Arguments:  BOOL, true for stdout else debug channel
1201 Returns:    nothing
1202 */
1203
1204 static void
1205 show_whats_supported(BOOL is_stdout)
1206 {
1207 rmark reset_point = store_mark();
1208 gstring * g = NULL;
1209
1210 DEBUG(D_any) {} else g = show_db_version(g);
1211
1212 g = string_cat(g, US"Support for:");
1213 #ifdef WITH_CONTENT_SCAN
1214   g = string_cat(g, US" Content_Scanning");
1215 #endif
1216 #ifdef SUPPORT_CRYPTEQ
1217   g = string_cat(g, US" crypteq");
1218 #endif
1219 #ifdef EXPAND_DLFUNC
1220   g = string_cat(g, US" Expand_dlfunc");
1221 #endif
1222 #if HAVE_ICONV
1223   g = string_cat(g, US" iconv()");
1224 #endif
1225 #if HAVE_IPV6
1226   g = string_cat(g, US" IPv6");
1227 #endif
1228 #ifdef SUPPORT_PAM
1229   g = string_cat(g, US" PAM");
1230 #endif
1231 #ifdef EXIM_PERL
1232   g = string_cat(g, US" Perl");
1233 #endif
1234 #ifdef USE_GNUTLS
1235   g = string_cat(g, US" GnuTLS");
1236 #endif
1237 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
1238   g = string_cat(g, US" move_frozen_messages");
1239 #endif
1240 #ifdef USE_OPENSSL
1241   g = string_cat(g, US" OpenSSL");
1242 #endif
1243 #if defined(CYRUS_PWCHECK_SOCKET)
1244   g = string_cat(g, US" pwcheck");
1245 #endif
1246 #if defined(RADIUS_CONFIG_FILE)
1247   g = string_cat(g, US" radius");
1248 #endif
1249 #ifndef DISABLE_TLS_RESUME
1250   g = string_cat(g, US" TLS_resume");
1251 #endif
1252 #ifdef SUPPORT_TRANSLATE_IP_ADDRESS
1253   g = string_cat(g, US" translate_ip_address");
1254 #endif
1255 #ifdef USE_TCP_WRAPPERS
1256   g = string_cat(g, US" TCPwrappers");
1257 #endif
1258 #ifdef HAVE_SETCLASSRESOURCES
1259   g = string_cat(g, US" use_setclassresources");
1260 #endif
1261 #ifdef SUPPORT_DANE
1262   g = string_cat(g, US" DANE");
1263 #endif
1264 #ifndef DISABLE_DKIM
1265   g = string_cat(g, US" DKIM");
1266 #endif
1267 #ifdef SUPPORT_DMARC
1268   g = string_cat(g, US" DMARC");
1269 #endif
1270 #ifndef DISABLE_DNSSEC
1271   g = string_cat(g, US" DNSSEC");
1272 #endif
1273 #ifndef DISABLE_ESMTP_LIMITS
1274   g = string_cat(g, US" ESMTP_Limits");
1275 #endif
1276 #ifndef DISABLE_WELLKNOWN
1277   g = string_cat(g, US" ESMTP_Wellknown");
1278 #endif
1279 #ifndef DISABLE_EVENT
1280   g = string_cat(g, US" Event");
1281 #endif
1282 #ifdef SUPPORT_I18N
1283   g = string_cat(g, US" I18N");
1284 #endif
1285 #ifndef DISABLE_OCSP
1286   g = string_cat(g, US" OCSP");
1287 #endif
1288 #ifndef DISABLE_PIPE_CONNECT
1289   g = string_cat(g, US" PIPECONNECT");
1290 #endif
1291 #ifndef DISABLE_PRDR
1292   g = string_cat(g, US" PRDR");
1293 #endif
1294 #ifdef SUPPORT_PROXY
1295   g = string_cat(g, US" PROXY");
1296 #endif
1297 #ifndef DISABLE_QUEUE_RAMP
1298   g = string_cat(g, US" Queue_Ramp");
1299 #endif
1300 #ifdef SUPPORT_SOCKS
1301   g = string_cat(g, US" SOCKS");
1302 #endif
1303 #ifdef SUPPORT_SPF
1304   g = string_cat(g, US" SPF");
1305 #endif
1306 #if defined(SUPPORT_SRS)
1307   g = string_cat(g, US" SRS");
1308 #endif
1309 #ifdef TCP_FASTOPEN
1310   tcp_init();
1311   if (f.tcp_fastopen_ok) g = string_cat(g, US" TCP_Fast_Open");
1312 #endif
1313 #ifdef EXPERIMENTAL_ARC
1314   g = string_cat(g, US" Experimental_ARC");
1315 #endif
1316 #ifdef EXPERIMENTAL_BRIGHTMAIL
1317   g = string_cat(g, US" Experimental_Brightmail");
1318 #endif
1319 #ifdef EXPERIMENTAL_DCC
1320   g = string_cat(g, US" Experimental_DCC");
1321 #endif
1322 #ifdef EXPERIMENTAL_DSN_INFO
1323   g = string_cat(g, US" Experimental_DSN_info");
1324 #endif
1325 #ifdef EXPERIMENTAL_QUEUEFILE
1326   g = string_cat(g, US" Experimental_QUEUEFILE");
1327 #endif
1328 #ifdef EXPERIMENTAL_XCLIENT
1329   g = string_cat(g, US" Experimental_XCLIENT");
1330 #endif
1331 g = string_cat(g, US"\n");
1332
1333 g = lookup_show_supported(g);
1334 g = auth_show_supported(g);
1335 g = route_show_supported(g);
1336 g = transport_show_supported(g);
1337
1338 #ifdef WITH_CONTENT_SCAN
1339 g = malware_show_supported(g);
1340 #endif
1341 show_string(is_stdout, g); g = NULL;
1342
1343 if (fixed_never_users[0] > 0)
1344   {
1345   int i;
1346   g = string_cat(g, US"Fixed never_users: ");
1347   for (i = 1; i <= (int)fixed_never_users[0] - 1; i++)
1348     string_fmt_append(g, "%u:", (unsigned)fixed_never_users[i]);
1349   g = string_fmt_append(g, "%u\n", (unsigned)fixed_never_users[i]);
1350   }
1351
1352 g = string_fmt_append(g, "Configure owner: %d:%d\n", config_uid, config_gid);
1353
1354 g = string_fmt_append(g, "Size of off_t: " SIZE_T_FMT "\n", sizeof(off_t));
1355
1356 /* Everything else is details which are only worth reporting when debugging.
1357 Perhaps the tls_version_report should move into this too. */
1358 DEBUG(D_any)
1359   {
1360
1361 /* clang defines __GNUC__ (at least, for me) so test for it first */
1362 #if defined(__clang__)
1363   g = string_fmt_append(g, "Compiler: CLang [%s]\n", __clang_version__);
1364 #elif defined(__GNUC__)
1365 # ifdef __VERSION__
1366   g = string_fmt_append(g, "Compiler: GCC [%s]\n", __VERSION__);
1367 # else
1368   g = string_fmt_append(g, "Compiler: GCC [%s]\n", "? unknown version ?";
1369 # endif
1370 #else
1371   g = string_cat(g, US"Compiler: <unknown>\n");
1372 #endif
1373
1374 #if defined(__GLIBC__) && !defined(__UCLIBC__)
1375   g = string_fmt_append(g, "Library version: Glibc: Compile: %d.%d\n",
1376                 __GLIBC__, __GLIBC_MINOR__);
1377   if (__GLIBC_PREREQ(2, 1))
1378     g = string_fmt_append(g, "                        Runtime: %s\n",
1379                 gnu_get_libc_version());
1380 #endif
1381
1382   g = show_db_version(g);
1383
1384 #ifndef DISABLE_TLS
1385   g = tls_version_report(g);
1386 #endif
1387 #ifdef SUPPORT_I18N
1388   g = utf8_version_report(g);
1389 #endif
1390 #ifdef SUPPORT_DMARC
1391   g = dmarc_version_report(g);
1392 #endif
1393 #ifdef SUPPORT_SPF
1394   g = spf_lib_version_report(g);
1395 #endif
1396
1397   show_string(is_stdout, g);
1398   g = NULL;
1399
1400   for (auth_info * ai = auths_available; ai; ai = (auth_info *)ai->drinfo.next)
1401     if (ai->version_report)
1402       g = (*ai->version_report)(g);
1403
1404   /* PCRE_PRERELEASE is either defined and empty or a bare sequence of
1405   characters; unless it's an ancient version of PCRE in which case it
1406   is not defined. */
1407 #ifndef PCRE_PRERELEASE
1408 # define PCRE_PRERELEASE
1409 #endif
1410 #define QUOTE(X) #X
1411 #define EXPAND_AND_QUOTE(X) QUOTE(X)
1412     {
1413     uschar buf[24];
1414     pcre2_config(PCRE2_CONFIG_VERSION, buf);
1415     g = string_fmt_append(g, "Library version: PCRE2: Compile: %d.%d%s\n"
1416                 "                        Runtime: %s\n",
1417             PCRE2_MAJOR, PCRE2_MINOR,
1418             EXPAND_AND_QUOTE(PCRE2_PRERELEASE) "",
1419             buf);
1420     }
1421 #undef QUOTE
1422 #undef EXPAND_AND_QUOTE
1423
1424   show_string(is_stdout, g);
1425   g = NULL;
1426
1427   init_lookup_list();
1428   tree_walk(lookups_tree, lookup_version_report_cb, &g);
1429   show_string(is_stdout, g);
1430   g = NULL;
1431
1432 #ifdef WHITELIST_D_MACROS
1433   g = string_fmt_append(g, "WHITELIST_D_MACROS: \"%s\"\n", WHITELIST_D_MACROS);
1434 #else
1435   g = string_cat(g, US"WHITELIST_D_MACROS unset\n");
1436 #endif
1437 #ifdef TRUSTED_CONFIG_LIST
1438   g = string_fmt_append(g, "TRUSTED_CONFIG_LIST: \"%s\"\n", TRUSTED_CONFIG_LIST);
1439 #else
1440   g = string_cat(g, US"TRUSTED_CONFIG_LIST unset\n");
1441 #endif
1442   }
1443
1444 show_string(is_stdout, g);
1445 store_reset(reset_point);
1446 }
1447
1448
1449 /*************************************************
1450 *     Show auxiliary information about Exim      *
1451 *************************************************/
1452
1453 static void
1454 show_exim_information(enum commandline_info request, FILE *stream)
1455 {
1456 switch(request)
1457   {
1458   case CMDINFO_NONE:
1459     fprintf(stream, "Oops, something went wrong.\n");
1460     return;
1461   case CMDINFO_HELP:
1462     fprintf(stream,
1463 "The -bI: flag takes a string indicating which information to provide.\n"
1464 "If the string is not recognised, you'll get this help (on stderr).\n"
1465 "\n"
1466 "  exim -bI:help    this information\n"
1467 "  exim -bI:dscp    list of known dscp value keywords\n"
1468 "  exim -bI:sieve   list of supported sieve extensions\n"
1469 );
1470     return;
1471   case CMDINFO_SIEVE:
1472     for (const uschar ** pp = exim_sieve_extension_list; *pp; ++pp)
1473       fprintf(stream, "%s\n", *pp);
1474     return;
1475   case CMDINFO_DSCP:
1476     dscp_list_to_stream(stream);
1477     return;
1478   }
1479 }
1480
1481
1482 /*************************************************
1483 *               Quote a local part               *
1484 *************************************************/
1485
1486 /* This function is used when a sender address or a From: or Sender: header
1487 line is being created from the caller's login, or from an authenticated_id. It
1488 applies appropriate quoting rules for a local part.
1489
1490 Argument:    the local part
1491 Returns:     the local part, quoted if necessary
1492 */
1493
1494 const uschar *
1495 local_part_quote(const uschar * lpart)
1496 {
1497 BOOL needs_quote = FALSE;
1498 gstring * g;
1499
1500 for (const uschar * t = lpart; !needs_quote && *t; t++)
1501   needs_quote = !isalnum(*t) && strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
1502     (*t != '.' || t == lpart || t[1] == 0);
1503
1504 if (!needs_quote) return lpart;
1505
1506 g = string_catn(NULL, US"\"", 1);
1507
1508 for (;;)
1509   {
1510   uschar * nq = US Ustrpbrk(lpart, "\\\"");
1511   if (!nq)
1512     {
1513     g = string_cat(g, lpart);
1514     break;
1515     }
1516   g = string_catn(g, lpart, nq - lpart);
1517   g = string_catn(g, US"\\", 1);
1518   g = string_catn(g, nq, 1);
1519   lpart = nq + 1;
1520   }
1521
1522 g = string_catn(g, US"\"", 1);
1523 return string_from_gstring(g);
1524 }
1525
1526
1527
1528 #ifdef USE_READLINE
1529 /*************************************************
1530 *         Load readline() functions              *
1531 *************************************************/
1532
1533 /* This function is called from testing executions that read data from stdin,
1534 but only when running as the calling user. Currently, only -be does this. The
1535 function loads the readline() function library and passes back the functions.
1536 On some systems, it needs the curses library, so load that too, but try without
1537 it if loading fails. All this functionality has to be requested at build time.
1538
1539 Arguments:
1540   fn_readline_ptr   pointer to where to put the readline pointer
1541   fn_addhist_ptr    pointer to where to put the addhistory function
1542
1543 Returns:            the dlopen handle or NULL on failure
1544 */
1545
1546 static void *
1547 set_readline(char * (**fn_readline_ptr)(const char *),
1548              void   (**fn_addhist_ptr)(const char *))
1549 {
1550 void *dlhandle;
1551 void *dlhandle_curses = dlopen("libcurses." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_LAZY);
1552
1553 dlhandle = dlopen("libreadline." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_NOW);
1554 if (dlhandle_curses) dlclose(dlhandle_curses);
1555
1556 if (dlhandle)
1557   {
1558   /* Checked manual pages; at least in GNU Readline 6.1, the prototypes are:
1559    *   char * readline (const char *prompt);
1560    *   void add_history (const char *string);
1561    */
1562   *fn_readline_ptr = (char *(*)(const char*))dlsym(dlhandle, "readline");
1563   *fn_addhist_ptr = (void(*)(const char*))dlsym(dlhandle, "add_history");
1564   }
1565 else
1566   DEBUG(D_any) debug_printf("failed to load readline: %s\n", dlerror());
1567
1568 return dlhandle;
1569 }
1570 #endif
1571
1572
1573
1574 /*************************************************
1575 *    Get a line from stdin for testing things    *
1576 *************************************************/
1577
1578 /* This function is called when running tests that can take a number of lines
1579 of input (for example, -be and -bt). It handles continuations and trailing
1580 spaces. And prompting and a blank line output on eof. If readline() is in use,
1581 the arguments are non-NULL and provide the relevant functions.
1582
1583 Arguments:
1584   fn_readline   readline function or NULL
1585   fn_addhist    addhist function or NULL
1586
1587 Returns:        pointer to dynamic memory, or NULL at end of file
1588 */
1589
1590 static uschar *
1591 get_stdinput(char *(*fn_readline)(const char *), void(*fn_addhist)(const char *))
1592 {
1593 gstring * g = NULL;
1594 BOOL had_input = FALSE;
1595
1596 if (!fn_readline) { printf("> "); fflush(stdout); }
1597
1598 for (int i = 0;; i++)
1599   {
1600   uschar buffer[1024];
1601   uschar * p, * ss;
1602
1603 #ifdef USE_READLINE
1604   char *readline_line = NULL;
1605   if (fn_readline)
1606     {
1607     if (!(readline_line = fn_readline((i > 0)? "":"> "))) break;
1608     if (*readline_line && fn_addhist) fn_addhist(readline_line);
1609     p = US readline_line;
1610     }
1611   else
1612 #endif
1613
1614   /* readline() not in use */
1615
1616     {
1617     if (Ufgets(buffer, sizeof(buffer), stdin) == NULL) break;   /*EOF*/
1618     p = buffer;
1619     }
1620
1621   /* Handle the line */
1622
1623   had_input = TRUE;
1624   ss = p + Ustrlen(p);
1625   while (ss > p && isspace(ss[-1])) ss--; /* strip trailing newline (and spaces) */
1626
1627   if (i > 0)
1628     while (p < ss && isspace(*p)) p++;   /* strip leading space after cont */
1629
1630   g = string_catn(g, p, ss - p);
1631
1632 #ifdef USE_READLINE
1633   if (fn_readline) free(readline_line);
1634 #endif
1635
1636   /* g can only be NULL if ss==p */
1637   if (ss == p || gstring_last_char(g) != '\\') /* not continuation; done */
1638     break;
1639
1640   gstring_trim(g, 1);                           /* drop the \ */
1641   }
1642
1643 if (had_input) return g ? string_from_gstring(g) : US"";
1644 printf("\n");
1645 return NULL;
1646 }
1647
1648
1649
1650 /*************************************************
1651 *    Output usage information for the program    *
1652 *************************************************/
1653
1654 /* This function is called when there are no recipients
1655    or a specific --help argument was added.
1656
1657 Arguments:
1658   progname      information on what name we were called by
1659
1660 Returns:        DOES NOT RETURN
1661 */
1662
1663 static void
1664 exim_usage(const uschar * progname)
1665 {
1666
1667 /* Handle specific program invocation variants */
1668 if (Ustrcmp(progname, US"-mailq") == 0)
1669   exim_fail(
1670     "mailq - list the contents of the mail queue\n\n"
1671     "For a list of options, see the Exim documentation.\n");
1672
1673 /* Generic usage - we output this whatever happens */
1674 exim_fail(
1675   "Exim is a Mail Transfer Agent. It is normally called by Mail User Agents,\n"
1676   "not directly from a shell command line. Options and/or arguments control\n"
1677   "what it does when called. For a list of options, see the Exim documentation.\n");
1678 }
1679
1680
1681
1682 /*************************************************
1683 *    Validate that the macros given are okay     *
1684 *************************************************/
1685
1686 /* Typically, Exim will drop privileges if macros are supplied.  In some
1687 cases, we want to not do so.
1688
1689 Arguments:    opt_D_used - true if the commandline had a "-D" option
1690 Returns:      true if trusted, false otherwise
1691 */
1692
1693 static BOOL
1694 macros_trusted(BOOL opt_D_used)
1695 {
1696 #ifdef WHITELIST_D_MACROS
1697 uschar *whitelisted, *end, *p, **whites;
1698 int white_count, i, n;
1699 size_t len;
1700 BOOL prev_char_item, found;
1701 #endif
1702
1703 if (!opt_D_used)
1704   return TRUE;
1705 #ifndef WHITELIST_D_MACROS
1706 return FALSE;
1707 #else
1708
1709 /* We only trust -D overrides for some invoking users:
1710 root, the exim run-time user, the optional config owner user.
1711 I don't know why config-owner would be needed, but since they can own the
1712 config files anyway, there's no security risk to letting them override -D. */
1713 if ( ! ((real_uid == root_uid)
1714      || (real_uid == exim_uid)
1715 #ifdef CONFIGURE_OWNER
1716      || (real_uid == config_uid)
1717 #endif
1718    ))
1719   {
1720   debug_printf("macros_trusted rejecting macros for uid %d\n", (int) real_uid);
1721   return FALSE;
1722   }
1723
1724 /* Get a list of macros which are whitelisted */
1725 whitelisted = string_copy_perm(US WHITELIST_D_MACROS, FALSE);
1726 prev_char_item = FALSE;
1727 white_count = 0;
1728 for (p = whitelisted; *p != '\0'; ++p)
1729   {
1730   if (*p == ':' || isspace(*p))
1731     {
1732     *p = '\0';
1733     if (prev_char_item)
1734       ++white_count;
1735     prev_char_item = FALSE;
1736     continue;
1737     }
1738   if (!prev_char_item)
1739     prev_char_item = TRUE;
1740   }
1741 end = p;
1742 if (prev_char_item)
1743   ++white_count;
1744 if (!white_count)
1745   return FALSE;
1746 whites = store_malloc(sizeof(uschar *) * (white_count+1));
1747 for (p = whitelisted, i = 0; (p != end) && (i < white_count); ++p)
1748   {
1749   if (*p != '\0')
1750     {
1751     whites[i++] = p;
1752     if (i == white_count)
1753       break;
1754     while (*p != '\0' && p < end)
1755       ++p;
1756     }
1757   }
1758 whites[i] = NULL;
1759
1760 /* The list of commandline macros should be very short.
1761 Accept the N*M complexity. */
1762 for (macro_item * m = macros_user; m; m = m->next) if (m->command_line)
1763   {
1764   found = FALSE;
1765   for (uschar ** w = whites; *w; ++w)
1766     if (Ustrcmp(*w, m->name) == 0)
1767       {
1768       found = TRUE;
1769       break;
1770       }
1771   if (!found)
1772     return FALSE;
1773   if (!m->replacement)
1774     continue;
1775   if ((len = m->replen) == 0)
1776     continue;
1777   if (!regex_match(regex_whitelisted_macro, m->replacement, len, NULL))
1778     return FALSE;
1779   }
1780 DEBUG(D_any) debug_printf("macros_trusted overridden to true by whitelisting\n");
1781 return TRUE;
1782 #endif
1783 }
1784
1785
1786 /*************************************************
1787 *          Expansion testing                     *
1788 *************************************************/
1789
1790 /* Expand and print one item, doing macro-processing.
1791
1792 Arguments:
1793   item          line for expansion
1794 */
1795
1796 static void
1797 expansion_test_line(const uschar * line)
1798 {
1799 int len;
1800 BOOL dummy_macexp;
1801 uschar * s;
1802
1803 Ustrncpy(big_buffer, line, big_buffer_size);
1804 big_buffer[big_buffer_size-1] = '\0';
1805 len = Ustrlen(big_buffer);
1806
1807 (void) macros_expand(0, &len, &dummy_macexp);
1808
1809 #ifdef LOOKUP_MODULE_DIR
1810 //mod_load_check(big_buffer);
1811 #endif
1812
1813 if (isupper(big_buffer[0]))
1814   {
1815   if (macro_read_assignment(big_buffer))
1816     printf("Defined macro '%s'\n", mlast->name);
1817   }
1818 else if (Ustrncmp(big_buffer, "set,t ", 6) == 0)
1819   printf("%s\n", acl_standalone_setvar(big_buffer+6, TRUE));
1820 else if (Ustrncmp(big_buffer, "set ", 4) == 0)
1821   printf("%s\n", acl_standalone_setvar(big_buffer+4, FALSE));
1822 else
1823   if ((s = expand_string(big_buffer))) printf("%s\n", CS s);
1824   else printf("Failed: %s\n", expand_string_message);
1825 }
1826
1827
1828
1829 /*************************************************
1830 *          Queue-runner operations               *
1831 *************************************************/
1832
1833 /* Prefix a new qrunner descriptor to the qrunners list */
1834
1835 static qrunner *
1836 alloc_qrunner(void)
1837 {
1838 qrunner * q = qrunners;
1839 qrunners = store_get(sizeof(qrunner), GET_UNTAINTED);
1840 memset(qrunners, 0, sizeof(qrunner));           /* default queue, zero interval */
1841 qrunners->next = q;
1842 qrunners->next_tick = time(NULL);               /* run right away */
1843 return qrunners;
1844 }
1845
1846 static qrunner *
1847 alloc_onetime_qrunner(void)
1848 {
1849 qrunners = store_get_perm(sizeof(qrunner), GET_UNTAINTED);
1850 memset(qrunners, 0, sizeof(qrunner));           /* default queue, zero interval */
1851 qrunners->next_tick = time(NULL);               /* run right away */
1852 qrunners->run_max = 1;
1853 return qrunners;
1854 }
1855
1856
1857 /*************************************************
1858 *          Entry point and high-level code       *
1859 *************************************************/
1860
1861 /* Entry point for the Exim mailer. Analyse the arguments and arrange to take
1862 the appropriate action. All the necessary functions are present in the one
1863 binary. I originally thought one should split it up, but it turns out that so
1864 much of the apparatus is needed in each chunk that one might as well just have
1865 it all available all the time, which then makes the coding easier as well.
1866
1867 Arguments:
1868   argc      count of entries in argv
1869   argv      argument strings, with argv[0] being the program name
1870
1871 Returns:    EXIT_SUCCESS if terminated successfully
1872             EXIT_FAILURE otherwise, except when a message has been sent
1873               to the sender, and -oee was given
1874 */
1875
1876 int
1877 main(int argc, char ** cargv)
1878 {
1879 const uschar ** argv = CUSS cargv;
1880 int  arg_receive_timeout = -1;
1881 int  arg_smtp_receive_timeout = -1;
1882 int  arg_error_handling = error_handling;
1883 int  filter_sfd = -1;
1884 int  filter_ufd = -1;
1885 int  group_count;
1886 int  i, rv;
1887 int  list_queue_option = QL_BASIC;
1888 int  msg_action = 0;
1889 int  msg_action_arg = -1;
1890 int  namelen = argv[0] ? Ustrlen(argv[0]) : 0;
1891 int  queue_only_reason = 0;
1892 #ifdef EXIM_PERL
1893 int  perl_start_option = 0;
1894 #endif
1895 int  recipients_arg = argc;
1896 int  sender_address_domain = 0;
1897 int  test_retry_arg = -1;
1898 int  test_rewrite_arg = -1;
1899 gid_t original_egid;
1900 BOOL arg_queue_only = FALSE;
1901 BOOL bi_option = FALSE;
1902 BOOL checking = FALSE;
1903 BOOL count_queue = FALSE;
1904 BOOL expansion_test = FALSE;
1905 BOOL extract_recipients = FALSE;
1906 BOOL flag_G = FALSE;
1907 BOOL flag_n = FALSE;
1908 BOOL forced_delivery = FALSE;
1909 BOOL f_end_dot = FALSE;
1910 BOOL deliver_give_up = FALSE;
1911 BOOL list_queue = FALSE;
1912 BOOL list_options = FALSE;
1913 BOOL list_config = FALSE;
1914 BOOL local_queue_only;
1915 BOOL one_msg_action = FALSE;
1916 BOOL opt_D_used = FALSE;
1917 BOOL queue_only_set = FALSE;
1918 BOOL receiving_message = TRUE;
1919 BOOL sender_ident_set = FALSE;
1920 BOOL session_local_queue_only;
1921 BOOL unprivileged;
1922 BOOL removed_privilege = FALSE;
1923 BOOL usage_wanted = FALSE;
1924 BOOL verify_address_mode = FALSE;
1925 BOOL verify_as_sender = FALSE;
1926 BOOL rcpt_verify_quota = FALSE;
1927 BOOL version_printed = FALSE;
1928 const uschar * alias_arg = NULL;
1929 const uschar * called_as = US"";
1930 const uschar * cmdline_syslog_name = NULL;
1931 const uschar * start_queue_run_id = NULL;
1932 const uschar * stop_queue_run_id = NULL;
1933 const uschar * expansion_test_message = NULL;
1934 const uschar * ftest_domain = NULL;
1935 const uschar * ftest_localpart = NULL;
1936 const uschar * ftest_prefix = NULL;
1937 const uschar * ftest_suffix = NULL;
1938 uschar * log_oneline = NULL;
1939 const uschar * malware_test_file = NULL;
1940 const uschar * real_sender_address;
1941 uschar * originator_home = US"/";
1942 size_t sz;
1943
1944 struct passwd *pw;
1945 struct stat statbuf;
1946 pid_t passed_qr_pid = (pid_t)0;
1947 int passed_qr_pipe = -1;
1948 gid_t group_list[EXIM_GROUPLIST_SIZE];
1949
1950 /* For the -bI: flag */
1951 enum commandline_info info_flag = CMDINFO_NONE;
1952 BOOL info_stdout = FALSE;
1953
1954 /* Possible options for -R and -S */
1955
1956 static uschar *rsopts[] = { US"f", US"ff", US"r", US"rf", US"rff" };
1957
1958 /* Need to define this in case we need to change the environment in order
1959 to get rid of a bogus time zone. We have to make it char rather than uschar
1960 because some OS define it in /usr/include/unistd.h. */
1961
1962 extern char **environ;
1963
1964 #ifdef MEASURE_TIMING
1965 (void)gettimeofday(&timestamp_startup, NULL);
1966 #endif
1967
1968 store_init();   /* Initialise the memory allocation susbsystem */
1969 pcre_init();    /* Set up memory handling for pcre */
1970
1971 /* If the Exim user and/or group and/or the configuration file owner/group were
1972 defined by ref:name at build time, we must now find the actual uid/gid values.
1973 This is a feature to make the lives of binary distributors easier. */
1974
1975 #ifdef EXIM_USERNAME
1976 if (route_finduser(US EXIM_USERNAME, &pw, &exim_uid))
1977   {
1978   if (exim_uid == 0)
1979     exim_fail("exim: refusing to run with uid 0 for \"%s\"\n", EXIM_USERNAME);
1980
1981   /* If ref:name uses a number as the name, route_finduser() returns
1982   TRUE with exim_uid set and pw coerced to NULL. */
1983   if (pw)
1984     exim_gid = pw->pw_gid;
1985 #ifndef EXIM_GROUPNAME
1986   else
1987     exim_fail(
1988         "exim: ref:name should specify a usercode, not a group.\n"
1989         "exim: can't let you get away with it unless you also specify a group.\n");
1990 #endif
1991   }
1992 else
1993   exim_fail("exim: failed to find uid for user name \"%s\"\n", EXIM_USERNAME);
1994 #endif
1995
1996 #ifdef EXIM_GROUPNAME
1997 if (!route_findgroup(US EXIM_GROUPNAME, &exim_gid))
1998   exim_fail("exim: failed to find gid for group name \"%s\"\n", EXIM_GROUPNAME);
1999 #endif
2000
2001 #ifdef CONFIGURE_OWNERNAME
2002 if (!route_finduser(US CONFIGURE_OWNERNAME, NULL, &config_uid))
2003   exim_fail("exim: failed to find uid for user name \"%s\"\n",
2004     CONFIGURE_OWNERNAME);
2005 #endif
2006
2007 /* We default the system_filter_user to be the Exim run-time user, as a
2008 sane non-root value. */
2009 system_filter_uid = exim_uid;
2010
2011 #ifdef CONFIGURE_GROUPNAME
2012 if (!route_findgroup(US CONFIGURE_GROUPNAME, &config_gid))
2013   exim_fail("exim: failed to find gid for group name \"%s\"\n",
2014     CONFIGURE_GROUPNAME);
2015 #endif
2016
2017 /* In the Cygwin environment, some initialization used to need doing.
2018 It was fudged in by means of this macro; now no longer but we'll leave
2019 it in case of others. */
2020
2021 #ifdef OS_INIT
2022 OS_INIT
2023 #endif
2024
2025 /* Check a field which is patched when we are running Exim within its
2026 testing harness; do a fast initial check, and then the whole thing. */
2027
2028 f.running_in_test_harness =
2029   *running_status == '<' && Ustrcmp(running_status, "<<<testing>>>") == 0;
2030 if (f.running_in_test_harness)
2031   debug_store = TRUE;
2032
2033 /* Protect against abusive argv[0] */
2034 if (!argv[0] || !argc) exim_fail("exim: executable name required\n");
2035 exim_str_fail_toolong(argv[0], PATH_MAX, "argv[0]");
2036
2037 /* The C standard says that the equivalent of setlocale(LC_ALL, "C") is obeyed
2038 at the start of a program; however, it seems that some environments do not
2039 follow this. A "strange" locale can affect the formatting of timestamps, so we
2040 make quite sure. */
2041
2042 setlocale(LC_ALL, "C");
2043
2044 /* Get the offset between CLOCK_MONOTONIC/CLOCK_BOOTTIME and wallclock */
2045
2046 #ifdef _POSIX_MONOTONIC_CLOCK
2047 exim_clock_init();
2048 #endif
2049
2050 /* Set up the default handler for timing using alarm(). */
2051
2052 os_non_restarting_signal(SIGALRM, sigalrm_handler);
2053
2054 /* Ensure we have a buffer for constructing log entries. Use malloc directly,
2055 because store_malloc writes a log entry on failure. */
2056
2057 if (!(log_buffer = US malloc(LOG_BUFFER_SIZE)))
2058   exim_fail("exim: failed to get store for log buffer\n");
2059
2060 /* Initialize the default log options. */
2061
2062 bits_set(log_selector, log_selector_size, log_default);
2063
2064 /* Set log_stderr to stderr, provided that stderr exists. This gets reset to
2065 NULL when the daemon is run and the file is closed. We have to use this
2066 indirection, because some systems don't allow writing to the variable "stderr".
2067 */
2068
2069 if (fstat(fileno(stderr), &statbuf) >= 0) log_stderr = stderr;
2070
2071 /* Ensure there is a big buffer for temporary use in several places. It is put
2072 in malloc store so that it can be freed for enlargement if necessary. */
2073
2074 big_buffer = store_malloc(big_buffer_size);
2075
2076 /* Set up the handler for the data request signal, and set the initial
2077 descriptive text. */
2078
2079 process_info = store_get(PROCESS_INFO_SIZE, GET_TAINTED);
2080 set_process_info("initializing");
2081 os_restarting_signal(SIGUSR1, usr1_handler);            /* exiwhat */
2082 #ifdef SA_SIGINFO
2083   {
2084   struct sigaction act = { .sa_sigaction = segv_handler, .sa_flags = SA_RESETHAND | SA_SIGINFO };
2085   sigaction(SIGSEGV, &act, NULL);
2086   }
2087 #else
2088 signal(SIGSEGV, segv_handler);                          /* log faults */
2089 #endif
2090
2091 /* If running in a dockerized environment, the TERM signal is only
2092 delegated to the PID 1 if we request it by setting an signal handler */
2093
2094 if (getpid() == 1) signal(SIGTERM, term_handler);
2095
2096 /* SIGHUP is used to get the daemon to reconfigure. It gets set as appropriate
2097 in the daemon code. For the rest of Exim's uses, we ignore it. */
2098
2099 signal(SIGHUP, SIG_IGN);
2100
2101 /* We don't want to die on pipe errors as the code is written to handle
2102 the write error instead. */
2103
2104 signal(SIGPIPE, SIG_IGN);
2105
2106 /* Under some circumstance on some OS, Exim can get called with SIGCHLD
2107 set to SIG_IGN. This causes subprocesses that complete before the parent
2108 process waits for them not to hang around, so when Exim calls wait(), nothing
2109 is there. The wait() code has been made robust against this, but let's ensure
2110 that SIGCHLD is set to SIG_DFL, because it's tidier to wait and get a process
2111 ending status. We use sigaction rather than plain signal() on those OS where
2112 SA_NOCLDWAIT exists, because we want to be sure it is turned off. (There was a
2113 problem on AIX with this.) */
2114
2115 #ifdef SA_NOCLDWAIT
2116   {
2117   struct sigaction act;
2118   act.sa_handler = SIG_DFL;
2119   sigemptyset(&(act.sa_mask));
2120   act.sa_flags = 0;
2121   sigaction(SIGCHLD, &act, NULL);
2122   }
2123 #else
2124 signal(SIGCHLD, SIG_DFL);
2125 #endif
2126
2127 /* Save the arguments for use if we re-exec exim as a daemon after receiving
2128 SIGHUP. */
2129
2130 sighup_argv = argv;
2131
2132 /* Set up the version number. Set up the leading 'E' for the external form of
2133 message ids, set the pointer to the internal form, and initialize it to
2134 indicate no message being processed. */
2135
2136 version_init();
2137 message_id_option[0] = '-';
2138 message_id_external = message_id_option + 1;
2139 message_id_external[0] = 'E';
2140 message_id = message_id_external + 1;
2141 message_id[0] = 0;
2142
2143 /* Set the umask to zero so that any files Exim creates using open() are
2144 created with the modes that it specifies. NOTE: Files created with fopen() have
2145 a problem, which was not recognized till rather late (February 2006). With this
2146 umask, such files will be world writeable. (They are all content scanning files
2147 in the spool directory, which isn't world-accessible, so this is not a
2148 disaster, but it's untidy.) I don't want to change this overall setting,
2149 however, because it will interact badly with the open() calls. Instead, there's
2150 now a function called modefopen() that fiddles with the umask while calling
2151 fopen(). */
2152
2153 (void)umask(0);
2154
2155 /* Precompile the regular expression for matching a message id. Keep this in
2156 step with the code that generates ids in the accept.c module. We need to do
2157 this here, because the -M options check their arguments for syntactic validity
2158 using mac_ismsgid, which uses this. */
2159
2160 regex_ismsgid =
2161   regex_must_compile(US"^(?:"
2162           "[^\\W_]{" str(MESSAGE_ID_TIME_LEN) "}"
2163           "-[^\\W_]{" str(MESSAGE_ID_PID_LEN) "}"
2164           "-[^\\W_]{" str(MESSAGE_ID_SUBTIME_LEN) "}"
2165         "|"
2166           "(?:[^\\W_]{6}-){2}[^\\W_]{2}"                /* old ID format */
2167         ")$",
2168     MCS_NOFLAGS, TRUE);
2169
2170 /* Precompile the regular expression that is used for matching an SMTP error
2171 code, possibly extended, at the start of an error message. Note that the
2172 terminating whitespace character is included. */
2173
2174 regex_smtp_code =
2175   regex_must_compile(US"^\\d\\d\\d\\s(?:\\d\\.\\d\\d?\\d?\\.\\d\\d?\\d?\\s)?",
2176     MCS_NOFLAGS, TRUE);
2177
2178 #ifdef WHITELIST_D_MACROS
2179 /* Precompile the regular expression used to filter the content of macros
2180 given to -D for permissibility. */
2181
2182 regex_whitelisted_macro =
2183   regex_must_compile(US"^[A-Za-z0-9_/.-]*$", MCS_NOFLAGS, TRUE);
2184 #endif
2185
2186 /* If the program is called as "mailq" treat it as equivalent to "exim -bp";
2187 this seems to be a generally accepted convention, since one finds symbolic
2188 links called "mailq" in standard OS configurations. */
2189
2190 if ((namelen == 5 && Ustrcmp(argv[0], "mailq") == 0) ||
2191     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/mailq", 6) == 0))
2192   {
2193   list_queue = TRUE;
2194   receiving_message = FALSE;
2195   called_as = US"-mailq";
2196   }
2197
2198 /* If the program is called as "rmail" treat it as equivalent to
2199 "exim -i -oee", thus allowing UUCP messages to be input using non-SMTP mode,
2200 i.e. preventing a single dot on a line from terminating the message, and
2201 returning with zero return code, even in cases of error (provided an error
2202 message has been sent). */
2203
2204 if ((namelen == 5 && Ustrcmp(argv[0], "rmail") == 0) ||
2205     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rmail", 6) == 0))
2206   {
2207   f.dot_ends = FALSE;
2208   called_as = US"-rmail";
2209   errors_sender_rc = EXIT_SUCCESS;
2210   }
2211
2212 /* If the program is called as "rsmtp" treat it as equivalent to "exim -bS";
2213 this is a smail convention. */
2214
2215 if ((namelen == 5 && Ustrcmp(argv[0], "rsmtp") == 0) ||
2216     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rsmtp", 6) == 0))
2217   {
2218   smtp_input = smtp_batched_input = TRUE;
2219   called_as = US"-rsmtp";
2220   }
2221
2222 /* If the program is called as "runq" treat it as equivalent to "exim -q";
2223 this is a smail convention. */
2224
2225 if ((namelen == 4 && Ustrcmp(argv[0], "runq") == 0) ||
2226     (namelen  > 4 && Ustrncmp(argv[0] + namelen - 5, "/runq", 5) == 0))
2227   {
2228   alloc_onetime_qrunner();
2229   receiving_message = FALSE;
2230   called_as = US"-runq";
2231   }
2232
2233 /* If the program is called as "newaliases" treat it as equivalent to
2234 "exim -bi"; this is a sendmail convention. */
2235
2236 if ((namelen == 10 && Ustrcmp(argv[0], "newaliases") == 0) ||
2237     (namelen  > 10 && Ustrncmp(argv[0] + namelen - 11, "/newaliases", 11) == 0))
2238   {
2239   bi_option = TRUE;
2240   receiving_message = FALSE;
2241   called_as = US"-newaliases";
2242   }
2243
2244 /* Save the original effective uid for a couple of uses later. It should
2245 normally be root, but in some esoteric environments it may not be. */
2246
2247 original_euid = geteuid();
2248 original_egid = getegid();
2249
2250 /* Get the real uid and gid. If the caller is root, force the effective uid/gid
2251 to be the same as the real ones. This makes a difference only if Exim is setuid
2252 (or setgid) to something other than root, which could be the case in some
2253 special configurations. */
2254
2255 real_uid = getuid();
2256 real_gid = getgid();
2257
2258 if (real_uid == root_uid)
2259   {
2260   if ((rv = setgid(real_gid)))
2261     exim_fail("exim: setgid(%ld) failed: %s\n",
2262         (long int)real_gid, strerror(errno));
2263   if ((rv = setuid(real_uid)))
2264     exim_fail("exim: setuid(%ld) failed: %s\n",
2265         (long int)real_uid, strerror(errno));
2266   }
2267
2268 /* If neither the original real uid nor the original euid was root, Exim is
2269 running in an unprivileged state. */
2270
2271 unprivileged = (real_uid != root_uid && original_euid != root_uid);
2272
2273 /* For most of the args-parsing we need to use permanent pool memory */
2274  {
2275  int old_pool = store_pool;
2276  store_pool = POOL_PERM;
2277
2278 /* Scan the program's arguments. Some can be dealt with right away; others are
2279 simply recorded for checking and handling afterwards. Do a high-level switch
2280 on the second character (the one after '-'), to save some effort. */
2281
2282  for (i = 1; i < argc; i++)
2283   {
2284   BOOL badarg = FALSE;
2285   const uschar * arg = argv[i];
2286   const uschar * argrest;
2287   uschar switchchar;
2288
2289   /* An argument not starting with '-' is the start of a recipients list;
2290   break out of the options-scanning loop. */
2291
2292   if (arg[0] != '-')
2293     {
2294     recipients_arg = i;
2295     break;
2296     }
2297
2298   /* An option consisting of -- terminates the options */
2299
2300   if (Ustrcmp(arg, "--") == 0)
2301     {
2302     recipients_arg = i + 1;
2303     break;
2304     }
2305
2306   /* Handle flagged options */
2307
2308   switchchar = arg[1];
2309   argrest = arg+2;
2310
2311   /* Make all -ex options synonymous with -oex arguments, since that
2312   is assumed by various callers. Also make -qR options synonymous with -R
2313   options, as that seems to be required as well. Allow for -qqR too, and
2314   the same for -S options. */
2315
2316   if (Ustrncmp(arg+1, "oe", 2) == 0 ||
2317       Ustrncmp(arg+1, "qR", 2) == 0 ||
2318       Ustrncmp(arg+1, "qS", 2) == 0)
2319     {
2320     switchchar = arg[2];
2321     argrest++;
2322     }
2323   else if (Ustrncmp(arg+1, "qqR", 3) == 0 || Ustrncmp(arg+1, "qqS", 3) == 0)
2324     {
2325     switchchar = arg[3];
2326     argrest += 2;
2327     f.queue_2stage = TRUE;
2328     }
2329
2330   /* Make -r synonymous with -f, since it is a documented alias */
2331
2332   else if (arg[1] == 'r') switchchar = 'f';
2333
2334   /* Make -ov synonymous with -v */
2335
2336   else if (Ustrcmp(arg, "-ov") == 0)
2337     {
2338     switchchar = 'v';
2339     argrest++;
2340     }
2341
2342   /* deal with --option_aliases */
2343   else if (switchchar == '-')
2344     {
2345     if (Ustrcmp(argrest, "help") == 0)
2346       {
2347       usage_wanted = TRUE;
2348       break;
2349       }
2350     else if (Ustrcmp(argrest, "version") == 0)
2351       {
2352       switchchar = 'b';
2353       argrest = US"V";
2354       }
2355     }
2356
2357   /* High-level switch on active initial letter */
2358
2359   switch(switchchar)
2360     {
2361
2362     /* sendmail uses -Ac and -Am to control which .cf file is used;
2363     we ignore them. */
2364     case 'A':
2365     if (!*argrest) { badarg = TRUE; break; }
2366     else
2367       {
2368       BOOL ignore = FALSE;
2369       switch (*argrest)
2370         {
2371         case 'c':
2372         case 'm':
2373           if (*(argrest + 1) == '\0')
2374             ignore = TRUE;
2375           break;
2376         }
2377       if (!ignore) badarg = TRUE;
2378       }
2379     break;
2380
2381     /* -Btype is a sendmail option for 7bit/8bit setting. Exim is 8-bit clean
2382     so has no need of it. */
2383
2384     case 'B':
2385     if (!*argrest) i++;       /* Skip over the type */
2386     break;
2387
2388
2389     case 'b':
2390       {
2391       receiving_message = FALSE;    /* Reset TRUE for -bm, -bS, -bs below */
2392
2393       switch (*argrest++)
2394         {
2395         /* -bd:  Run in daemon mode, awaiting SMTP connections.
2396            -bdf: Ditto, but in the foreground.
2397         */
2398         case 'd':
2399           f.daemon_listen = f.daemon_scion = TRUE;
2400           if (*argrest == 'f') f.background_daemon = FALSE;
2401           else if (*argrest) badarg = TRUE;
2402           break;
2403
2404         /* -be:  Run in expansion test mode
2405            -bem: Ditto, but read a message from a file first
2406         */
2407         case 'e':
2408           expansion_test = checking = TRUE;
2409           if (*argrest == 'm')
2410             {
2411             if (++i >= argc) { badarg = TRUE; break; }
2412             expansion_test_message = argv[i];
2413             argrest++;
2414             }
2415           if (*argrest) badarg = TRUE;
2416           break;
2417
2418         /* -bF:  Run system filter test */
2419         case 'F':
2420           filter_test |= checking = FTEST_SYSTEM;
2421           if (*argrest) badarg = TRUE;
2422           else if (++i < argc) filter_test_sfile = argv[i];
2423           else exim_fail("exim: file name expected after %s\n", argv[i-1]);
2424           break;
2425
2426         /* -bf:  Run user filter test
2427            -bfd: Set domain for filter testing
2428            -bfl: Set local part for filter testing
2429            -bfp: Set prefix for filter testing
2430            -bfs: Set suffix for filter testing
2431         */
2432         case 'f':
2433           if (!*argrest)
2434             {
2435             filter_test |= checking = FTEST_USER;
2436             if (++i < argc) filter_test_ufile = argv[i];
2437             else exim_fail("exim: file name expected after %s\n", argv[i-1]);
2438             }
2439           else
2440             {
2441             if (++i >= argc)
2442               exim_fail("exim: string expected after %s\n", arg);
2443             if (Ustrcmp(argrest, "d") == 0) ftest_domain = exim_str_fail_toolong(argv[i], EXIM_DOMAINNAME_MAX, "-bfd");
2444             else if (Ustrcmp(argrest, "l") == 0) ftest_localpart = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfl");
2445             else if (Ustrcmp(argrest, "p") == 0) ftest_prefix = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfp");
2446             else if (Ustrcmp(argrest, "s") == 0) ftest_suffix = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfs");
2447             else badarg = TRUE;
2448             }
2449           break;
2450
2451         /* -bh: Host checking - an IP address must follow. */
2452         case 'h':
2453           if (  (!*argrest || Ustrcmp(argrest, "c") == 0)
2454              && ++i < argc)
2455             {
2456             sender_host_address = string_copy_taint(
2457                   exim_str_fail_toolong(argv[i], EXIM_IPADDR_MAX, "-bh"),
2458                   GET_TAINTED);
2459             host_checking = checking = f.log_testing_mode = TRUE;
2460             f.host_checking_callout = *argrest == 'c';
2461             message_logs = FALSE;
2462             }
2463           else
2464             badarg = TRUE;
2465           break;
2466
2467         /* -bi: This option is used by sendmail to initialize *the* alias file,
2468         though it has the -oA option to specify a different file. Exim has no
2469         concept of *the* alias file, but since Sun's YP make script calls
2470         sendmail this way, some support must be provided. */
2471         case 'i':
2472           if (!*argrest) bi_option = TRUE;
2473           else badarg = TRUE;
2474           break;
2475
2476         /* -bI: provide information, of the type to follow after a colon.
2477         This is an Exim flag. */
2478         case 'I':
2479           if (Ustrlen(argrest) >= 1 && *argrest == ':')
2480             {
2481             const uschar * p = argrest+1;
2482             info_flag = CMDINFO_HELP;
2483             if (Ustrlen(p))
2484               if (strcmpic(p, CUS"sieve") == 0)
2485                 {
2486                 info_flag = CMDINFO_SIEVE;
2487                 info_stdout = TRUE;
2488                 }
2489               else if (strcmpic(p, CUS"dscp") == 0)
2490                 {
2491                 info_flag = CMDINFO_DSCP;
2492                 info_stdout = TRUE;
2493                 }
2494               else if (strcmpic(p, CUS"help") == 0)
2495                 info_stdout = TRUE;
2496             }
2497           else badarg = TRUE;
2498           break;
2499
2500         /* -bm: Accept and deliver message - the default option. Reinstate
2501         receiving_message, which got turned off for all -b options.
2502            -bmalware: test the filename given for malware */
2503         case 'm':
2504           if (!*argrest) receiving_message = TRUE;
2505           else if (Ustrcmp(argrest, "alware") == 0)
2506             {
2507             if (++i >= argc) { badarg = TRUE; break; }
2508             checking = TRUE;
2509             malware_test_file = argv[i];
2510             }
2511           else badarg = TRUE;
2512           break;
2513
2514         /* -bnq: For locally originating messages, do not qualify unqualified
2515         addresses. In the envelope, this causes errors; in header lines they
2516         just get left. */
2517         case 'n':
2518           if (Ustrcmp(argrest, "q") == 0)
2519             {
2520             f.allow_unqualified_sender = FALSE;
2521             f.allow_unqualified_recipient = FALSE;
2522             }
2523           else badarg = TRUE;
2524           break;
2525
2526         /* -bpxx: List the contents of the mail queue, in various forms. If
2527         the option is -bpc, just a queue count is needed. Otherwise, if the
2528         first letter after p is r, then order is random. */
2529         case 'p':
2530           if (*argrest == 'c')
2531             {
2532             count_queue = TRUE;
2533             if (*++argrest) badarg = TRUE;
2534             break;
2535             }
2536
2537           if (*argrest == 'r')
2538             list_queue_option = QL_UNSORTED, argrest++;
2539           else
2540             list_queue_option = QL_BASIC;
2541
2542           list_queue = TRUE;
2543
2544           /* -bp: List the contents of the mail queue, top-level only */
2545
2546           if (!*argrest) {}
2547
2548           /* -bpu: List the contents of the mail queue, top-level undelivered */
2549
2550           else if (Ustrcmp(argrest, "u") == 0) list_queue_option |= QL_UNDELIVERED_ONLY;
2551
2552           /* -bpa: List the contents of the mail queue, including all delivered */
2553
2554           else if (Ustrcmp(argrest, "a") == 0) list_queue_option |= QL_PLUS_GENERATED;
2555
2556           /* -bpi: List only message IDs */
2557
2558           else if (Ustrcmp(argrest, "i") == 0) list_queue_option |= QL_MSGID_ONLY;
2559
2560           /* Unknown after -bp[r] */
2561
2562           else badarg = TRUE;
2563           break;
2564
2565
2566         /* -bP: List the configuration variables given as the address list.
2567         Force -v, so configuration errors get displayed. */
2568         case 'P':
2569
2570           /* -bP config: we need to setup here, because later,
2571           when list_options is checked, the config is read already */
2572           if (*argrest)
2573             badarg = TRUE;
2574           else if (argv[i+1] && Ustrcmp(argv[i+1], "config") == 0)
2575             {
2576             list_config = TRUE;
2577             readconf_save_config(version_string);
2578             }
2579           else
2580             {
2581             list_options = TRUE;
2582             debug_selector |= D_v;
2583             debug_file = stderr;
2584             }
2585           break;
2586
2587         /* -brt: Test retry configuration lookup */
2588         case 'r':
2589           if (Ustrcmp(argrest, "t") == 0)
2590             {
2591             checking = TRUE;
2592             test_retry_arg = i + 1;
2593             goto END_ARG;
2594             }
2595
2596           /* -brw: Test rewrite configuration */
2597
2598           else if (Ustrcmp(argrest, "w") == 0)
2599             {
2600             checking = TRUE;
2601             test_rewrite_arg = i + 1;
2602             goto END_ARG;
2603             }
2604           else badarg = TRUE;
2605           break;
2606
2607         /* -bS: Read SMTP commands on standard input, but produce no replies -
2608         all errors are reported by sending messages. */
2609         case 'S':
2610           if (!*argrest)
2611             smtp_input = smtp_batched_input = receiving_message = TRUE;
2612           else badarg = TRUE;
2613           break;
2614
2615         /* -bs: Read SMTP commands on standard input and produce SMTP replies
2616         on standard output. */
2617         case 's':
2618           if (!*argrest) smtp_input = receiving_message = TRUE;
2619           else badarg = TRUE;
2620           break;
2621
2622         /* -bt: address testing mode */
2623         case 't':
2624           if (!*argrest)
2625             f.address_test_mode = checking = f.log_testing_mode = TRUE;
2626           else badarg = TRUE;
2627           break;
2628
2629         /* -bv: verify addresses */
2630         case 'v':
2631           if (!*argrest)
2632             verify_address_mode = checking = f.log_testing_mode = TRUE;
2633
2634         /* -bvs: verify sender addresses */
2635
2636           else if (Ustrcmp(argrest, "s") == 0)
2637             {
2638             verify_address_mode = checking = f.log_testing_mode = TRUE;
2639             verify_as_sender = TRUE;
2640             }
2641           else badarg = TRUE;
2642           break;
2643
2644         /* -bV: Print version string and support details */
2645         case 'V':
2646           if (!*argrest)
2647             {
2648             printf("Exim version %s #%s built %s\n", version_string,
2649               version_cnumber, version_date);
2650             printf("%s\n", CS version_copyright);
2651             version_printed = TRUE;
2652             show_whats_supported(TRUE);
2653             f.log_testing_mode = TRUE;
2654             }
2655           else badarg = TRUE;
2656           break;
2657
2658         /* -bw: inetd wait mode, accept a listening socket as stdin */
2659         case 'w':
2660           f.inetd_wait_mode = TRUE;
2661           f.background_daemon = FALSE;
2662           f.daemon_listen = f.daemon_scion = TRUE;
2663           if (*argrest)
2664             if ((inetd_wait_timeout = readconf_readtime(argrest, 0, FALSE)) <= 0)
2665               exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
2666           break;
2667
2668         default:
2669           badarg = TRUE;
2670           break;
2671         }
2672       break;
2673       }
2674
2675
2676     /* -C: change configuration file list; ignore if it isn't really
2677     a change! Enforce a prefix check if required. */
2678
2679     case 'C':
2680     if (!*argrest)
2681       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
2682     if (Ustrcmp(config_main_filelist, argrest) != 0)
2683       {
2684       #ifdef ALT_CONFIG_PREFIX
2685       int sep = 0;
2686       int len = Ustrlen(ALT_CONFIG_PREFIX);
2687       const uschar *list = argrest;
2688       uschar *filename;
2689       /* The argv is untainted, so big_buffer (also untainted) is ok to use */
2690       while((filename = string_nextinlist(&list, &sep, big_buffer,
2691              big_buffer_size)))
2692         if (  (  Ustrlen(filename) < len
2693               || Ustrncmp(filename, ALT_CONFIG_PREFIX, len) != 0
2694               || Ustrstr(filename, "/../") != NULL
2695               )
2696            && (Ustrcmp(filename, "/dev/null") != 0 || real_uid != root_uid)
2697            )
2698           exim_fail("-C Permission denied\n");
2699       #endif
2700       if (real_uid != root_uid)
2701         {
2702         #ifdef TRUSTED_CONFIG_LIST
2703
2704         if (real_uid != exim_uid
2705             #ifdef CONFIGURE_OWNER
2706             && real_uid != config_uid
2707             #endif
2708             )
2709           f.trusted_config = FALSE;
2710         else
2711           {
2712           FILE *trust_list = Ufopen(TRUSTED_CONFIG_LIST, "rb");
2713           if (trust_list)
2714             {
2715             struct stat statbuf;
2716
2717             if (fstat(fileno(trust_list), &statbuf) != 0 ||
2718                 (statbuf.st_uid != root_uid        /* owner not root */
2719                  #ifdef CONFIGURE_OWNER
2720                  && statbuf.st_uid != config_uid   /* owner not the special one */
2721                  #endif
2722                    ) ||                            /* or */
2723                 (statbuf.st_gid != root_gid        /* group not root */
2724                  #ifdef CONFIGURE_GROUP
2725                  && statbuf.st_gid != config_gid   /* group not the special one */
2726                  #endif
2727                  && (statbuf.st_mode & 020) != 0   /* group writeable */
2728                    ) ||                            /* or */
2729                 (statbuf.st_mode & 2) != 0)        /* world writeable */
2730               {
2731               f.trusted_config = FALSE;
2732               fclose(trust_list);
2733               }
2734             else
2735               {
2736               /* Well, the trust list at least is up to scratch... */
2737               rmark reset_point;
2738               uschar *trusted_configs[32];
2739               int nr_configs = 0;
2740               int i = 0;
2741               int old_pool = store_pool;
2742               store_pool = POOL_MAIN;
2743
2744               reset_point = store_mark();
2745               while (Ufgets(big_buffer, big_buffer_size, trust_list))
2746                 {
2747                 uschar * start = big_buffer, * nl;
2748                 if (Uskip_whitespace(&start) != '/')
2749                   continue;
2750                 if ((nl = Ustrchr(start, '\n')))
2751                   *nl = '\0';
2752                 trusted_configs[nr_configs++] = string_copy(start);
2753                 if (nr_configs == nelem(trusted_configs))
2754                   break;
2755                 }
2756               fclose(trust_list);
2757
2758               if (nr_configs)
2759                 {
2760                 int sep = 0;
2761                 const uschar *list = argrest;
2762                 uschar *filename;
2763                 while (f.trusted_config && (filename = string_nextinlist(&list,
2764                         &sep, big_buffer, big_buffer_size)))
2765                   {
2766                   for (i=0; i < nr_configs; i++)
2767                     if (Ustrcmp(filename, trusted_configs[i]) == 0)
2768                       break;
2769                   if (i == nr_configs)
2770                     {
2771                     f.trusted_config = FALSE;
2772                     break;
2773                     }
2774                   }
2775                 }
2776               else      /* No valid prefixes found in trust_list file. */
2777                 f.trusted_config = FALSE;
2778               store_reset(reset_point);
2779               store_pool = old_pool;
2780               }
2781             }
2782           else          /* Could not open trust_list file. */
2783             f.trusted_config = FALSE;
2784           }
2785       #else
2786         /* Not root; don't trust config */
2787         f.trusted_config = FALSE;
2788       #endif
2789         }
2790
2791       config_main_filelist = argrest;
2792       f.config_changed = TRUE;
2793       }
2794     break;
2795
2796
2797     /* -D: set up a macro definition */
2798
2799     case 'D':
2800 #ifdef DISABLE_D_OPTION
2801       exim_fail("exim: -D is not available in this Exim binary\n");
2802 #else
2803       {
2804       int ptr = 0;
2805       macro_item * m;
2806       uschar name[24];
2807       const uschar * s = argrest;
2808
2809       opt_D_used = TRUE;
2810       Uskip_whitespace(&s);
2811
2812       if (*s < 'A' || *s > 'Z')
2813         exim_fail("exim: macro name set by -D must start with "
2814           "an upper case letter\n");
2815
2816       while (isalnum(*s) || *s == '_')
2817         {
2818         if (ptr < sizeof(name)-1) name[ptr++] = *s;
2819         s++;
2820         }
2821       name[ptr] = 0;
2822       if (ptr == 0) { badarg = TRUE; break; }
2823       if (Uskip_whitespace(&s))
2824         {
2825         if (*s++ != '=') { badarg = TRUE; break; }
2826         Uskip_whitespace(&s);
2827         }
2828
2829       for (m = macros_user; m; m = m->next)
2830         if (Ustrcmp(m->name, name) == 0)
2831           exim_fail("exim: duplicated -D in command line\n");
2832
2833       m = macro_create(name, s, TRUE);
2834
2835       if (clmacro_count >= MAX_CLMACROS)
2836         exim_fail("exim: too many -D options on command line\n");
2837       clmacros[clmacro_count++] =
2838         string_sprintf("-D%s=%s", m->name, m->replacement);
2839       }
2840     #endif
2841     break;
2842
2843     case 'd':
2844
2845     /* -dropcr: Set this option.  Now a no-op, retained for compatibility only. */
2846
2847     if (Ustrcmp(argrest, "ropcr") == 0)
2848       {
2849       /* drop_cr = TRUE; */
2850       }
2851
2852     /* -dp: Set up a debug pretrigger buffer with given size. */
2853
2854     else if (Ustrcmp(argrest, "p") == 0)
2855       if (++i >= argc)
2856         badarg = TRUE;
2857       else
2858         debug_pretrigger_setup(argv[i]);
2859
2860     /* -dt: Set a debug trigger selector */
2861
2862     else if (Ustrncmp(argrest, "t=", 2) == 0)
2863       dtrigger_selector = (unsigned int) Ustrtol(argrest + 2, NULL, 0);
2864
2865     /* -d: Set debug level (see also -v below).
2866     If -dd is used, debugging subprocesses of the daemon is disabled. */
2867
2868     else
2869       {
2870       /* Use an intermediate variable so that we don't set debugging while
2871       decoding the debugging bits. */
2872
2873       unsigned int selector = D_default;
2874       debug_selector = 0;
2875       debug_file = NULL;
2876       if (*argrest == 'd')
2877         {
2878         f.debug_daemon = TRUE;
2879         argrest++;
2880         }
2881       if (*argrest)
2882         decode_bits(&selector, 1, debug_notall, argrest,
2883           debug_options, debug_options_count, US"debug", 0);
2884       debug_selector = selector;
2885       }
2886     break;
2887
2888
2889     /* -E: This is a local error message. This option is not intended for
2890     external use at all, but is not restricted to trusted callers because it
2891     does no harm (just suppresses certain error messages) and if Exim is run
2892     not setuid root it won't always be trusted when it generates error
2893     messages using this option. If there is a message id following -E, point
2894     message_reference at it, for logging. */
2895
2896     case 'E':
2897     f.local_error_message = TRUE;
2898     if (mac_ismsgid(argrest)) message_reference = argrest;
2899     break;
2900
2901
2902     /* -ex: The vacation program calls sendmail with the undocumented "-eq"
2903     option, so it looks as if historically the -oex options are also callable
2904     without the leading -o. So we have to accept them. Before the switch,
2905     anything starting -oe has been converted to -e. Exim does not support all
2906     of the sendmail error options. */
2907
2908     case 'e':
2909     if (Ustrcmp(argrest, "e") == 0)
2910       {
2911       arg_error_handling = ERRORS_SENDER;
2912       errors_sender_rc = EXIT_SUCCESS;
2913       }
2914     else if (Ustrcmp(argrest, "m") == 0) arg_error_handling = ERRORS_SENDER;
2915     else if (Ustrcmp(argrest, "p") == 0) arg_error_handling = ERRORS_STDERR;
2916     else if (Ustrcmp(argrest, "q") == 0) arg_error_handling = ERRORS_STDERR;
2917     else if (Ustrcmp(argrest, "w") == 0) arg_error_handling = ERRORS_SENDER;
2918     else badarg = TRUE;
2919     break;
2920
2921
2922     /* -F: Set sender's full name, used instead of the gecos entry from
2923     the password file. Since users can usually alter their gecos entries,
2924     there's no security involved in using this instead. The data can follow
2925     the -F or be in the next argument. */
2926
2927     case 'F':
2928     if (!*argrest)
2929       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
2930     originator_name = string_copy_taint(
2931                   exim_str_fail_toolong(argrest, EXIM_HUMANNAME_MAX, "-F"),
2932                   GET_TAINTED);
2933     f.sender_name_forced = TRUE;
2934     break;
2935
2936
2937     /* -f: Set sender's address - this value is only actually used if Exim is
2938     run by a trusted user, or if untrusted_set_sender is set and matches the
2939     address, except that the null address can always be set by any user. The
2940     test for this happens later, when the value given here is ignored when not
2941     permitted. For an untrusted user, the actual sender is still put in Sender:
2942     if it doesn't match the From: header (unless no_local_from_check is set).
2943     The data can follow the -f or be in the next argument. The -r switch is an
2944     obsolete form of -f but since there appear to be programs out there that
2945     use anything that sendmail has ever supported, better accept it - the
2946     synonymizing is done before the switch above.
2947
2948     At this stage, we must allow domain literal addresses, because we don't
2949     know what the setting of allow_domain_literals is yet. Ditto for trailing
2950     dots and strip_trailing_dot. */
2951
2952     case 'f':
2953       {
2954       int dummy_start, dummy_end;
2955       uschar *errmess;
2956       if (!*argrest)
2957         if (i+1 < argc) argrest = argv[++i]; else { badarg = TRUE; break; }
2958       (void) exim_str_fail_toolong(argrest, EXIM_DISPLAYMAIL_MAX, "-f");
2959       if (!*argrest)
2960         {
2961         uschar * s = store_get(1, GET_UNTAINTED);       /* Ensure writeable memory */
2962         *s = '\0';
2963         sender_address = s;
2964         }
2965       else
2966         {
2967         const uschar * temp = argrest + Ustrlen(argrest) - 1;
2968         while (temp >= argrest && isspace(*temp)) temp--;
2969         if (temp >= argrest && *temp == '.') f_end_dot = TRUE;
2970         allow_domain_literals = TRUE;
2971         strip_trailing_dot = TRUE;
2972 #ifdef SUPPORT_I18N
2973         allow_utf8_domains = TRUE;
2974 #endif
2975         if (!(sender_address = parse_extract_address(argrest, &errmess,
2976                   &dummy_start, &dummy_end, &sender_address_domain, TRUE)))
2977           exim_fail("exim: bad -f address \"%s\": %s\n", argrest, errmess);
2978
2979         sender_address = string_copy_taint(sender_address, GET_TAINTED);
2980 #ifdef SUPPORT_I18N
2981         message_smtputf8 =  string_is_utf8(sender_address);
2982         allow_utf8_domains = FALSE;
2983 #endif
2984         allow_domain_literals = FALSE;
2985         strip_trailing_dot = FALSE;
2986         }
2987       f.sender_address_forced = TRUE;
2988       }
2989     break;
2990
2991     /* -G: sendmail invocation to specify that it's a gateway submission and
2992     sendmail may complain about problems instead of fixing them.
2993     We make it equivalent to an ACL "control = suppress_local_fixups" and do
2994     not at this time complain about problems. */
2995
2996     case 'G':
2997     flag_G = TRUE;
2998     break;
2999
3000     /* -h: Set the hop count for an incoming message. Exim does not currently
3001     support this; it always computes it by counting the Received: headers.
3002     To put it in will require a change to the spool header file format. */
3003
3004     case 'h':
3005     if (!*argrest)
3006       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
3007     if (!isdigit(*argrest)) badarg = TRUE;
3008     break;
3009
3010
3011     /* -i: Set flag so dot doesn't end non-SMTP input (same as -oi, seems
3012     not to be documented for sendmail but mailx (at least) uses it) */
3013
3014     case 'i':
3015     if (!*argrest) f.dot_ends = FALSE; else badarg = TRUE;
3016     break;
3017
3018
3019     /* -L: set the identifier used for syslog; equivalent to setting
3020     syslog_processname in the config file, but needs to be an admin option. */
3021
3022     case 'L':
3023     if (!*argrest)
3024       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
3025     if ((sz = Ustrlen(argrest)) > 32)
3026       exim_fail("exim: the -L syslog name is too long: \"%s\"\n", argrest);
3027     if (sz < 1)
3028       exim_fail("exim: the -L syslog name is too short\n");
3029     cmdline_syslog_name = string_copy_taint(argrest, GET_TAINTED);
3030     break;
3031
3032     case 'M':
3033     receiving_message = FALSE;
3034
3035     /* -MC:  continue delivery of another message via an existing open
3036     file descriptor. This option is used for an internal call by the
3037     smtp transport when there is a pending message waiting to go to an
3038     address to which it has got a connection. Five subsequent arguments are
3039     required: transport name, host name, IP address, sequence number, and
3040     message_id. Transports may decline to create new processes if the sequence
3041     number gets too big. The channel is stdin. This (-MC) must be the last
3042     argument. There's a subsequent check that the real-uid is privileged.
3043
3044     If we are running in the test harness. delay for a bit, to let the process
3045     that set this one up complete. This makes for repeatability of the logging,
3046     etc. output. */
3047
3048     if (Ustrcmp(argrest, "C") == 0)
3049       {
3050       union sockaddr_46 interface_sock;
3051       EXIM_SOCKLEN_T size = sizeof(interface_sock);
3052
3053       if (argc != i + 6)
3054         exim_fail("exim: too many or too few arguments after -MC\n");
3055
3056       if (msg_action_arg >= 0)
3057         exim_fail("exim: incompatible arguments\n");
3058
3059       continue_transport = string_copy_taint(
3060         exim_str_fail_toolong(argv[++i], EXIM_DRIVERNAME_MAX, "-C internal transport"),
3061         GET_TAINTED);
3062       continue_hostname = string_copy_taint(
3063         exim_str_fail_toolong(argv[++i], EXIM_HOSTNAME_MAX, "-C internal hostname"),
3064         GET_TAINTED);
3065       continue_host_address = string_copy_taint(
3066         exim_str_fail_toolong(argv[++i], EXIM_IPADDR_MAX, "-C internal hostaddr"),
3067         GET_TAINTED);
3068       continue_sequence = Uatoi(argv[++i]);
3069       msg_action = MSG_DELIVER;
3070       msg_action_arg = ++i;
3071       forced_delivery = TRUE;
3072       queue_run_pid = passed_qr_pid;
3073       queue_run_pipe = passed_qr_pipe;
3074
3075       if (!mac_ismsgid(argv[i]))
3076         exim_fail("exim: malformed message id %s after -MC option\n",
3077           argv[i]);
3078
3079       /* Set up $sending_ip_address and $sending_port, unless proxied */
3080
3081       if (!continue_proxy_cipher)
3082         if (getsockname(fileno(stdin), (struct sockaddr *)(&interface_sock),
3083             &size) == 0)
3084           sending_ip_address = host_ntoa(-1, &interface_sock, NULL,
3085             &sending_port);
3086         else
3087           exim_fail("exim: getsockname() failed after -MC option: %s\n",
3088             strerror(errno));
3089
3090       testharness_pause_ms(500);
3091       break;
3092       }
3093
3094     else if (*argrest == 'C' && argrest[1] && !argrest[2])
3095       {
3096       switch(argrest[1])
3097         {
3098     /* -MCA: set the smtp_authenticated flag; this is useful only when it
3099     precedes -MC (see above). The flag indicates that the host to which
3100     Exim is connected has accepted an AUTH sequence. */
3101
3102         case 'A': f.smtp_authenticated = TRUE; break;
3103
3104     /* -MCD: set the smtp_use_dsn flag; this indicates that the host
3105        that exim is connected to supports the esmtp extension DSN */
3106
3107         case 'D': smtp_peer_options |= OPTION_DSN; break;
3108
3109     /* -MCd: for debug, set a process-purpose string */
3110
3111         case 'd': if (++i < argc)
3112                     process_purpose = string_copy_taint(
3113                       exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-MCd"),
3114                       GET_TAINTED);
3115                   else badarg = TRUE;
3116                   break;
3117
3118     /* -MCG: set the queue name, to a non-default value. Arguably, anything
3119        from the commandline should be tainted - but we will need an untainted
3120        value for the spoolfile when doing a -odi delivery process. */
3121
3122         case 'G': if (++i < argc) queue_name = string_copy_taint(
3123                       exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-MCG"),
3124                       GET_UNTAINTED);
3125                   else badarg = TRUE;
3126                   break;
3127
3128     /* -MCK: the peer offered CHUNKING.  Must precede -MC */
3129
3130         case 'K': smtp_peer_options |= OPTION_CHUNKING; break;
3131
3132 #ifndef DISABLE_ESMTP_LIMITS
3133     /* -MCL: peer used LIMITS RCPTMAX and/or RCPTDOMAINMAX */
3134         case 'L': if (++i < argc) continue_limit_mail = Uatoi(argv[i]);
3135                   else badarg = TRUE;
3136                   if (++i < argc) continue_limit_rcpt = Uatoi(argv[i]);
3137                   else badarg = TRUE;
3138                   if (++i < argc) continue_limit_rcptdom = Uatoi(argv[i]);
3139                   else badarg = TRUE;
3140                   break;
3141 #endif
3142
3143     /* -MCP: set the smtp_use_pipelining flag; this is useful only when
3144     it preceded -MC (see above) */
3145
3146         case 'P': smtp_peer_options |= OPTION_PIPE; break;
3147
3148 #ifdef SUPPORT_SOCKS
3149     /* -MCp: Socks proxy in use; nearside IP, port, external IP, port */
3150         case 'p': proxy_session = TRUE;
3151                   if (++i < argc)
3152                     {
3153                     proxy_local_address = string_copy_taint(argv[i], GET_TAINTED);
3154                     if (++i < argc)
3155                       {
3156                       proxy_local_port = Uatoi(argv[i]);
3157                       if (++i < argc)
3158                         {
3159                         proxy_external_address = string_copy_taint(argv[i], GET_TAINTED);
3160                         if (++i < argc)
3161                           {
3162                           proxy_external_port = Uatoi(argv[i]);
3163                           break;
3164                     } } } }
3165                   badarg = TRUE;
3166                   break;
3167 #endif
3168     /* -MCQ: pass on the pid of the queue-running process that started
3169     this chain of deliveries and the fd of its synchronizing pipe; this
3170     is useful only when it precedes -MC (see above) */
3171
3172         case 'Q': if (++i < argc) passed_qr_pid = (pid_t)(Uatol(argv[i]));
3173                   else badarg = TRUE;
3174                   if (++i < argc) passed_qr_pipe = (int)(Uatol(argv[i]));
3175                   else badarg = TRUE;
3176                   break;
3177
3178     /* -MCq: do a quota check on the given recipient for the given size
3179     of message.  Separate from -MC. */
3180         case 'q': rcpt_verify_quota = TRUE;
3181                   if (++i < argc) message_size = Uatoi(argv[i]);
3182                   else badarg = TRUE;
3183                   break;
3184
3185     /* -MCS: set the smtp_use_size flag; this is useful only when it
3186     precedes -MC (see above) */
3187
3188         case 'S': smtp_peer_options |= OPTION_SIZE; break;
3189
3190 #ifndef DISABLE_TLS
3191     /* -MCs: used with -MCt; SNI was sent */
3192     /* -MCr: ditto, DANE */
3193
3194         case 'r':
3195         case 's': if (++i < argc)
3196                     {
3197                     continue_proxy_sni = string_copy_taint(
3198                       exim_str_fail_toolong(argv[i], EXIM_HOSTNAME_MAX, "-MCr/-MCs"),
3199                       GET_TAINTED);
3200                     if (argrest[1] == 'r') continue_proxy_dane = TRUE;
3201                     }
3202                   else badarg = TRUE;
3203                   break;
3204
3205     /* -MCt: similar to -MCT below but the connection is still open
3206     via a proxy process which handles the TLS context and coding.
3207     Require three arguments for the proxied local address and port,
3208     and the TLS cipher. */
3209
3210         case 't': if (++i < argc)
3211                     sending_ip_address = string_copy_taint(
3212                       exim_str_fail_toolong(argv[i], EXIM_IPADDR_MAX, "-MCt IP"),
3213                       GET_TAINTED);
3214                   else badarg = TRUE;
3215                   if (++i < argc)
3216                     sending_port = (int)(Uatol(argv[i]));
3217                   else badarg = TRUE;
3218                   if (++i < argc)
3219                     continue_proxy_cipher = string_copy_taint(
3220                       exim_str_fail_toolong(argv[i], EXIM_CIPHERNAME_MAX, "-MCt cipher"),
3221                       GET_TAINTED);
3222                   else badarg = TRUE;
3223                   /*FALLTHROUGH*/
3224
3225     /* -MCT: set the tls_offered flag; this is useful only when it
3226     precedes -MC (see above). The flag indicates that the host to which
3227     Exim is connected has offered TLS support. */
3228
3229         case 'T': smtp_peer_options |= OPTION_TLS; break;
3230 #endif
3231
3232         default:  badarg = TRUE; break;
3233         }
3234       break;
3235       }
3236
3237     /* -M[x]: various operations on the following list of message ids:
3238        -M    deliver the messages, ignoring next retry times and thawing
3239        -Mc   deliver the messages, checking next retry times, no thawing
3240        -Mf   freeze the messages
3241        -Mg   give up on the messages
3242        -Mt   thaw the messages
3243        -Mrm  remove the messages
3244     In the above cases, this must be the last option. There are also the
3245     following options which are followed by a single message id, and which
3246     act on that message. Some of them use the "recipient" addresses as well.
3247        -Mar  add recipient(s)
3248        -MG   move to a different queue
3249        -Mmad mark all recipients delivered
3250        -Mmd  mark recipients(s) delivered
3251        -Mes  edit sender
3252        -Mset load a message for use with -be
3253        -Mvb  show body
3254        -Mvc  show copy (of whole message, in RFC 2822 format)
3255        -Mvh  show header
3256        -Mvl  show log
3257     */
3258
3259     else if (!*argrest)
3260       {
3261       msg_action = MSG_DELIVER;
3262       forced_delivery = f.deliver_force_thaw = TRUE;
3263       }
3264     else if (Ustrcmp(argrest, "ar") == 0)
3265       {
3266       msg_action = MSG_ADD_RECIPIENT;
3267       one_msg_action = TRUE;
3268       }
3269     else if (Ustrcmp(argrest, "c") == 0)  msg_action = MSG_DELIVER;
3270     else if (Ustrcmp(argrest, "es") == 0)
3271       {
3272       msg_action = MSG_EDIT_SENDER;
3273       one_msg_action = TRUE;
3274       }
3275     else if (Ustrcmp(argrest, "f") == 0)  msg_action = MSG_FREEZE;
3276     else if (Ustrcmp(argrest, "g") == 0)
3277       {
3278       msg_action = MSG_DELIVER;
3279       deliver_give_up = TRUE;
3280       }
3281    else if (Ustrcmp(argrest, "G") == 0)
3282       {
3283       msg_action = MSG_SETQUEUE;
3284       queue_name_dest = string_copy_taint(
3285         exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3286                               EXIM_DRIVERNAME_MAX, "-MG"),
3287         GET_TAINTED);
3288       }
3289     else if (Ustrcmp(argrest, "mad") == 0) msg_action = MSG_MARK_ALL_DELIVERED;
3290     else if (Ustrcmp(argrest, "md") == 0)
3291       {
3292       msg_action = MSG_MARK_DELIVERED;
3293       one_msg_action = TRUE;
3294       }
3295     else if (Ustrcmp(argrest, "rm") == 0) msg_action = MSG_REMOVE;
3296     else if (Ustrcmp(argrest, "set") == 0)
3297       {
3298       msg_action = MSG_LOAD;
3299       one_msg_action = TRUE;
3300       }
3301     else if (Ustrcmp(argrest, "t") == 0)  msg_action = MSG_THAW;
3302     else if (Ustrcmp(argrest, "vb") == 0)
3303       {
3304       msg_action = MSG_SHOW_BODY;
3305       one_msg_action = TRUE;
3306       }
3307     else if (Ustrcmp(argrest, "vc") == 0)
3308       {
3309       msg_action = MSG_SHOW_COPY;
3310       one_msg_action = TRUE;
3311       }
3312     else if (Ustrcmp(argrest, "vh") == 0)
3313       {
3314       msg_action = MSG_SHOW_HEADER;
3315       one_msg_action = TRUE;
3316       }
3317     else if (Ustrcmp(argrest, "vl") == 0)
3318       {
3319       msg_action = MSG_SHOW_LOG;
3320       one_msg_action = TRUE;
3321       }
3322     else { badarg = TRUE; break; }
3323
3324     /* All the -Mxx options require at least one message id. */
3325
3326     msg_action_arg = i + 1;
3327     if (msg_action_arg >= argc)
3328       exim_fail("exim: no message ids given after %s option\n", arg);
3329
3330     /* Some require only message ids to follow */
3331
3332     if (!one_msg_action)
3333       {
3334       for (int j = msg_action_arg; j < argc; j++) if (!mac_ismsgid(argv[j]))
3335         exim_fail("exim: malformed message id %s after %s option\n",
3336           argv[j], arg);
3337       goto END_ARG;   /* Remaining args are ids */
3338       }
3339
3340     /* Others require only one message id, possibly followed by addresses,
3341     which will be handled as normal arguments. */
3342
3343     else
3344       {
3345       if (!mac_ismsgid(argv[msg_action_arg]))
3346         exim_fail("exim: malformed message id %s after %s option\n",
3347           argv[msg_action_arg], arg);
3348       i++;
3349       }
3350     break;
3351
3352
3353     /* Some programs seem to call the -om option without the leading o;
3354     for sendmail it askes for "me too". Exim always does this. */
3355
3356     case 'm':
3357     if (*argrest) badarg = TRUE;
3358     break;
3359
3360
3361     /* -N: don't do delivery - a debugging option that stops transports doing
3362     their thing. It implies debugging at the D_v level. */
3363
3364     case 'N':
3365     if (!*argrest)
3366       {
3367       f.dont_deliver = TRUE;
3368       debug_selector |= D_v;
3369       debug_file = stderr;
3370       }
3371     else badarg = TRUE;
3372     break;
3373
3374
3375     /* -n: This means "don't alias" in sendmail, apparently.
3376     For normal invocations, it has no effect.
3377     It may affect some other options. */
3378
3379     case 'n':
3380     flag_n = TRUE;
3381     break;
3382
3383     /* -O: Just ignore it. In sendmail, apparently -O option=value means set
3384     option to the specified value. This form uses long names. We need to handle
3385     -O option=value and -Ooption=value. */
3386
3387     case 'O':
3388     if (!*argrest)
3389       if (++i >= argc)
3390         exim_fail("exim: string expected after -O\n");
3391     break;
3392
3393     case 'o':
3394     switch (*argrest++)
3395       {
3396       /* -oA: Set an argument for the bi command (sendmail's "alternate alias
3397       file" option). */
3398       case 'A':
3399         if (!*(alias_arg = argrest))
3400           if (i+1 < argc) alias_arg = argv[++i];
3401           else exim_fail("exim: string expected after -oA\n");
3402         break;
3403
3404       /* -oB: Set a connection message max value for remote deliveries */
3405       case 'B':
3406         {
3407         const uschar * p = argrest;
3408         if (!*p)
3409           if (i+1 < argc && isdigit((argv[i+1][0])))
3410             p = argv[++i];
3411           else
3412             {
3413             connection_max_messages = 1;
3414             p = NULL;
3415             }
3416
3417         if (p)
3418           {
3419           if (!isdigit(*p))
3420             exim_fail("exim: number expected after -oB\n");
3421           connection_max_messages = Uatoi(p);
3422           }
3423         }
3424         break;
3425
3426       /* -odb: background delivery */
3427
3428       case 'd':
3429         if (Ustrcmp(argrest, "b") == 0)
3430           {
3431           f.synchronous_delivery = FALSE;
3432           arg_queue_only = FALSE;
3433           queue_only_set = TRUE;
3434           }
3435
3436       /* -odd: testsuite-only: add no inter-process delays */
3437
3438         else if (Ustrcmp(argrest, "d") == 0)
3439           f.testsuite_delays = FALSE;
3440
3441       /* -odf: foreground delivery (smail-compatible option); same effect as
3442          -odi: interactive (synchronous) delivery (sendmail-compatible option)
3443       */
3444
3445         else if (Ustrcmp(argrest, "f") == 0 || Ustrcmp(argrest, "i") == 0)
3446           {
3447           f.synchronous_delivery = TRUE;
3448           arg_queue_only = FALSE;
3449           queue_only_set = TRUE;
3450           }
3451
3452       /* -odq: queue only */
3453
3454         else if (Ustrcmp(argrest, "q") == 0)
3455           {
3456           f.synchronous_delivery = FALSE;
3457           arg_queue_only = TRUE;
3458           queue_only_set = TRUE;
3459           }
3460
3461       /* -odqs: queue SMTP only - do local deliveries and remote routing,
3462       but no remote delivery */
3463
3464         else if (Ustrcmp(argrest, "qs") == 0)
3465           {
3466           f.queue_smtp = TRUE;
3467           arg_queue_only = FALSE;
3468           queue_only_set = TRUE;
3469           }
3470         else badarg = TRUE;
3471         break;
3472
3473       /* -oex: Sendmail error flags. As these are also accepted without the
3474       leading -o prefix, for compatibility with vacation and other callers,
3475       they are handled with -e above. */
3476
3477       /* -oi:     Set flag so dot doesn't end non-SMTP input (same as -i)
3478          -oitrue: Another sendmail syntax for the same */
3479
3480       case 'i':
3481         if (!*argrest || Ustrcmp(argrest, "true") == 0)
3482           f.dot_ends = FALSE;
3483         else badarg = TRUE;
3484         break;
3485
3486     /* -oM*: Set various characteristics for an incoming message; actually
3487     acted on for trusted callers only. */
3488
3489       case 'M':
3490         {
3491         if (i+1 >= argc)
3492           exim_fail("exim: data expected after -oM%s\n", argrest);
3493
3494         /* -oMa: Set sender host address */
3495
3496         if (Ustrcmp(argrest, "a") == 0)
3497           sender_host_address = string_copy_taint(
3498             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3499                                   EXIM_IPADDR_MAX, "-oMa"), GET_TAINTED);
3500
3501         /* -oMaa: Set authenticator name */
3502
3503         else if (Ustrcmp(argrest, "aa") == 0)
3504           sender_host_authenticated = string_copy_taint(
3505             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3506                                   EXIM_DRIVERNAME_MAX, "-oMaa"), GET_TAINTED);
3507
3508         /* -oMas: setting authenticated sender */
3509
3510         else if (Ustrcmp(argrest, "as") == 0)
3511           authenticated_sender = string_copy_taint(
3512             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3513                                   EXIM_EMAILADDR_MAX, "-oMas"), GET_TAINTED);
3514
3515         /* -oMai: setting authenticated id */
3516
3517         else if (Ustrcmp(argrest, "ai") == 0)
3518           authenticated_id = string_copy_taint(
3519             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3520                                   EXIM_EMAILADDR_MAX, "-oMai"), GET_TAINTED);
3521
3522         /* -oMi: Set incoming interface address */
3523
3524         else if (Ustrcmp(argrest, "i") == 0)
3525           interface_address = string_copy_taint(
3526             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3527                                   EXIM_IPADDR_MAX, "-oMi"), GET_TAINTED);
3528
3529         /* -oMm: Message reference */
3530
3531         else if (Ustrcmp(argrest, "m") == 0)
3532           {
3533           if (!mac_ismsgid(argv[i+1]))
3534               exim_fail("-oMm must be a valid message ID\n");
3535           if (!f.trusted_config)
3536               exim_fail("-oMm must be called by a trusted user/config\n");
3537             message_reference = next_argv(argv, &i, argc, arg);
3538           }
3539
3540         /* -oMr: Received protocol */
3541
3542         else if (Ustrcmp(argrest, "r") == 0)
3543
3544           if (received_protocol)
3545             exim_fail("received_protocol is set already\n");
3546           else
3547             if (++i >= argc) badarg = TRUE;
3548             else
3549               received_protocol = string_copy_taint(
3550                 exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-oMr"),
3551                 GET_TAINTED);
3552
3553         /* -oMs: Set sender host name */
3554
3555         else if (Ustrcmp(argrest, "s") == 0)
3556           if (++i >= argc) badarg = TRUE;
3557           else
3558             sender_host_name = string_copy_taint(
3559               exim_str_fail_toolong(argv[i], EXIM_HOSTNAME_MAX, "-oMs"),
3560               GET_TAINTED);
3561
3562         /* -oMt: Set sender ident */
3563
3564         else if (Ustrcmp(argrest, "t") == 0)
3565           if (++i >= argc) badarg = TRUE;
3566           else
3567             {
3568             sender_ident_set = TRUE;
3569             sender_ident = string_copy_taint(
3570               exim_str_fail_toolong(argv[i], EXIM_IDENTUSER_MAX, "-oMt"),
3571               GET_TAINTED);
3572             }
3573
3574         /* Else a bad argument */
3575
3576         else
3577           badarg = TRUE;
3578         }
3579         break;
3580
3581       /* -om: Me-too flag for aliases. Exim always does this. Some programs
3582       seem to call this as -m (undocumented), so that is also accepted (see
3583       above). */
3584       /* -oo: An ancient flag for old-style addresses which still seems to
3585       crop up in some calls (see in SCO). */
3586
3587       case 'm':
3588       case 'o':
3589         if (*argrest) badarg = TRUE;
3590         break;
3591
3592       /* -oP <name>: set pid file path for daemon
3593          -oPX:       delete pid file of daemon */
3594
3595       case 'P':
3596         if (!f.running_in_test_harness && real_uid != root_uid && real_uid != exim_uid)
3597           exim_fail("exim: only uid=%d or uid=%d can use -oP and -oPX "
3598                     "(uid=%d euid=%d | %d)\n",
3599                     root_uid, exim_uid, getuid(), geteuid(), real_uid);
3600         if (!*argrest)
3601           if (++i < argc) override_pid_file_path = argv[i];
3602           else badarg = TRUE;
3603         else if (Ustrcmp(argrest, "X") == 0) delete_pid_file();
3604         else badarg = TRUE;
3605         break;
3606
3607
3608       /* -or <n>: set timeout for non-SMTP acceptance
3609          -os <n>: set timeout for SMTP acceptance */
3610
3611       case 'r':
3612       case 's':
3613         {
3614         int * tp = argrest[-1] == 'r'
3615           ? &arg_receive_timeout : &arg_smtp_receive_timeout;
3616         if (*argrest)
3617           *tp = readconf_readtime(argrest, 0, FALSE);
3618         else if (i+1 < argc)
3619           *tp = readconf_readtime(argv[++i], 0, FALSE);
3620
3621         if (*tp < 0)
3622           exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
3623         }
3624         break;
3625
3626       /* -oX <list>: Override local_interfaces and/or default daemon ports */
3627       /* Limits: Is there a real limit we want here?  1024 is very arbitrary. */
3628
3629       case 'X':
3630         if (*argrest || ++i >= argc) badarg = TRUE;
3631         else override_local_interfaces = string_copy_taint(
3632           exim_str_fail_toolong(argv[i], 1024, "-oX"), GET_TAINTED);
3633         break;
3634
3635       /* -oY: Override creation of daemon notifier socket */
3636
3637       case 'Y':
3638         if (*argrest) badarg = TRUE;
3639         else f.notifier_socket_en = FALSE;
3640         break;
3641
3642       /* Unknown -o argument */
3643
3644       default:
3645         badarg = TRUE;
3646       }
3647     break;
3648
3649
3650     /* -ps: force Perl startup; -pd force delayed Perl startup */
3651
3652     case 'p':
3653     #ifdef EXIM_PERL
3654     if (*argrest == 's' && argrest[1] == 0)
3655       {
3656       perl_start_option = 1;
3657       break;
3658       }
3659     if (*argrest == 'd' && argrest[1] == 0)
3660       {
3661       perl_start_option = -1;
3662       break;
3663       }
3664     #endif
3665
3666     /* -panythingelse is taken as the Sendmail-compatible argument -prval:sval,
3667     which sets the host protocol and host name */
3668
3669     if (!*argrest)
3670       argrest = next_argv(argv, &i, argc, arg);
3671
3672     if (*argrest)
3673       {
3674       uschar * hn = Ustrchr(argrest, ':');
3675
3676       if (received_protocol)
3677         exim_fail("received_protocol is set already\n");
3678
3679       if (!hn)
3680         received_protocol = string_copy_taint(
3681           exim_str_fail_toolong(argrest, EXIM_DRIVERNAME_MAX, "-p<protocol>"),
3682           GET_TAINTED);
3683       else
3684         {
3685         (void) exim_str_fail_toolong(argrest, (EXIM_DRIVERNAME_MAX+1+EXIM_HOSTNAME_MAX), "-p<protocol>:<host>");
3686         received_protocol = string_copyn_taint(argrest, hn - argrest, GET_TAINTED);
3687         sender_host_name = string_copy_taint(hn + 1, GET_TAINTED);
3688         }
3689       }
3690     break;
3691
3692     /* -q:  set up queue runs */
3693
3694     case 'q':
3695       {
3696       BOOL two_stage, first_del, force, thaw = FALSE, local;
3697
3698       receiving_message = FALSE;
3699
3700       /* -qq...: Do queue runs in a 2-stage manner */
3701
3702       if ((two_stage = *argrest == 'q'))
3703         argrest++;
3704
3705       /* -qi...: Do only first (initial) deliveries */
3706
3707       if ((first_del = *argrest == 'i'))
3708         argrest++;
3709
3710       /* -qf...: Run the queue, forcing deliveries
3711          -qff..: Ditto, forcing thawing as well */
3712
3713       if ((force = *argrest == 'f'))
3714         if ((thaw = *++argrest == 'f'))
3715           argrest++;
3716
3717       /* -q[f][f]l...: Run the queue only on local deliveries */
3718
3719       if ((local = *argrest == 'l'))
3720         argrest++;
3721
3722       /* -q[f][f][l][G<name>]... Work on the named queue */
3723
3724       if (*argrest == 'G')
3725         {
3726         int i;
3727         for (argrest++, i = 0; argrest[i] && argrest[i] != '/'; ) i++;
3728         exim_len_fail_toolong(i, EXIM_DRIVERNAME_MAX, "-q*G<name>");
3729         queue_name = string_copyn(argrest, i);
3730         argrest += i;
3731         if (*argrest == '/') argrest++;
3732         }
3733
3734       /* -q[f][f][l][G<name>]: Run the queue, optionally forced, optionally local
3735       only, optionally named, optionally starting from a given message id. */
3736
3737       if (!(list_queue || count_queue))
3738         {
3739         qrunner * q;
3740
3741         if (  !*argrest
3742            && (i + 1 >= argc || argv[i+1][0] == '-' || mac_ismsgid(argv[i+1])))
3743           {
3744           q = alloc_onetime_qrunner();
3745           if (i+1 < argc && mac_ismsgid(argv[i+1]))
3746             start_queue_run_id = string_copy_taint(argv[++i], GET_TAINTED);
3747           if (i+1 < argc && mac_ismsgid(argv[i+1]))
3748             stop_queue_run_id = string_copy_taint(argv[++i], GET_TAINTED);
3749           }
3750
3751       /* -q[f][f][l][G<name>/]<n>: Run the queue at regular intervals, optionally
3752       forced, optionally local only, optionally named. */
3753
3754         else
3755           {
3756           int intvl;
3757           const uschar * s;
3758
3759           if (*argrest) s = argrest;
3760           else if (++i < argc) { badarg = TRUE; break; }
3761           else s = argv[i];
3762
3763           if ((intvl = readconf_readtime(s, 0, FALSE)) <= 0)
3764             exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
3765
3766           for (qrunner * qq = qrunners; qq; qq = qq->next)
3767             if (  queue_name && qq->name && Ustrcmp(queue_name, qq->name) == 0
3768                || !queue_name && !qq->name)
3769               exim_fail("exim: queue-runner specified more than once\n");
3770
3771           q = alloc_qrunner();
3772           q->interval = intvl;
3773           }
3774
3775         q->name = *queue_name ? queue_name : NULL;      /* will be NULL for the default queue */
3776         q->queue_run_force = force;
3777         q->deliver_force_thaw = thaw;
3778         q->queue_run_first_delivery = first_del;
3779         q->queue_run_local = local;
3780         q->queue_2stage = two_stage;
3781         }
3782
3783       break;
3784       }
3785
3786
3787     case 'R':   /* Synonymous with -qR... */
3788     case 'S':   /* Synonymous with -qS... */
3789       {
3790       const uschar * tainted_selectstr;
3791       uschar * s;
3792
3793       receiving_message = FALSE;
3794
3795     /* -Rf:   As -R (below) but force all deliveries,
3796        -Rff:  Ditto, but also thaw all frozen messages,
3797        -Rr:   String is regex
3798        -Rrf:  Regex and force
3799        -Rrff: Regex and force and thaw
3800
3801        -S...: Like -R but works on sender.
3802
3803     in all cases provided there are no further characters in this
3804     argument. */
3805
3806       if (!qrunners) alloc_onetime_qrunner();
3807       qrunners->queue_2stage = f.queue_2stage;
3808       if (*argrest)
3809         for (int i = 0; i < nelem(rsopts); i++)
3810           if (Ustrcmp(argrest, rsopts[i]) == 0)
3811             {
3812             if (i != 2) qrunners->queue_run_force = TRUE;
3813             if (i >= 2)
3814               if (switchchar == 'R')
3815                 f.deliver_selectstring_regex = TRUE;
3816               else
3817                 f.deliver_selectstring_sender_regex = TRUE;
3818             if (i == 1 || i == 4) qrunners->deliver_force_thaw = TRUE;
3819             argrest += Ustrlen(rsopts[i]);
3820             }
3821
3822     /* -R or -S: Set string to match in addresses for forced queue run to
3823     pick out particular messages. */
3824
3825       /* Avoid attacks from people providing very long strings, and do so before
3826       we make copies. */
3827       if (*argrest)
3828         tainted_selectstr = argrest;
3829       else if (i+1 < argc)
3830         tainted_selectstr = argv[++i];
3831       else
3832         exim_fail("exim: string expected after %s\n", switchchar == 'R' ? "-R" : "-S");
3833
3834       s = string_copy_taint(
3835         exim_str_fail_toolong(tainted_selectstr, EXIM_EMAILADDR_MAX, "-R"),
3836         GET_TAINTED);
3837
3838       if (switchchar == 'R')
3839         deliver_selectstring = s;
3840       else
3841         deliver_selectstring_sender = s;
3842       }
3843     break;
3844
3845
3846     /* -r: an obsolete synonym for -f (see above) */
3847
3848     /* -Tqt is an option that is exclusively for use by the testing suite.
3849     It is not recognized in other circumstances. It allows for the setting up
3850     of explicit "queue times" so that various warning/retry things can be
3851     tested. Otherwise variability of clock ticks etc. cause problems. */
3852
3853     case 'T':
3854     if (f.running_in_test_harness && Ustrcmp(argrest, "qt") == 0 && ++i < argc)
3855       fudged_queue_times = string_copy_taint(argv[i], GET_TAINTED);
3856     else badarg = TRUE;
3857     break;
3858
3859
3860     /* -t: Set flag to extract recipients from body of message. */
3861
3862     case 't':
3863     if (!*argrest) extract_recipients = TRUE;
3864
3865     /* -ti: Set flag to extract recipients from body of message, and also
3866     specify that dot does not end the message. */
3867
3868     else if (Ustrcmp(argrest, "i") == 0)
3869       {
3870       extract_recipients = TRUE;
3871       f.dot_ends = FALSE;
3872       }
3873
3874     /* -tls-on-connect: don't wait for STARTTLS (for old clients) */
3875
3876     #ifndef DISABLE_TLS
3877     else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_in.on_connect = TRUE;
3878     #endif
3879
3880     else badarg = TRUE;
3881     break;
3882
3883
3884     /* -U: This means "initial user submission" in sendmail, apparently. The
3885     doc claims that in future sendmail may refuse syntactically invalid
3886     messages instead of fixing them. For the moment, we just ignore it. */
3887
3888     case 'U':
3889     break;
3890
3891
3892     /* -v: verify things - this is a very low-level debugging */
3893
3894     case 'v':
3895     if (!*argrest)
3896       {
3897       debug_selector |= D_v;
3898       debug_file = stderr;
3899       }
3900     else badarg = TRUE;
3901     break;
3902
3903
3904     /* -x: AIX uses this to indicate some fancy 8-bit character stuff:
3905
3906       The -x flag tells the sendmail command that mail from a local
3907       mail program has National Language Support (NLS) extended characters
3908       in the body of the mail item. The sendmail command can send mail with
3909       extended NLS characters across networks that normally corrupts these
3910       8-bit characters.
3911
3912     As Exim is 8-bit clean, it just ignores this flag. */
3913
3914     case 'x':
3915     if (*argrest) badarg = TRUE;
3916     break;
3917
3918     /* -X: in sendmail: takes one parameter, logfile, and sends debugging
3919     logs to that file.  We swallow the parameter and otherwise ignore it. */
3920
3921     case 'X':
3922     if (!*argrest)
3923       if (++i >= argc)
3924         exim_fail("exim: string expected after -X\n");
3925     break;
3926
3927     /* -z: a line of text to log */
3928
3929     case 'z':
3930     if (!*argrest)
3931       if (++i < argc)
3932         log_oneline = string_copy_taint(
3933           exim_str_fail_toolong(argv[i], 2048, "-z logtext"),
3934           GET_TAINTED);
3935       else
3936         exim_fail("exim: file name expected after %s\n", argv[i-1]);
3937     break;
3938
3939     /* All other initial characters are errors */
3940
3941     default:
3942     badarg = TRUE;
3943     break;
3944     }         /* End of high-level switch statement */
3945
3946   /* Failed to recognize the option, or syntax error */
3947
3948   if (badarg)
3949     exim_fail("exim abandoned: unknown, malformed, or incomplete "
3950       "option %s\n", arg);
3951   }
3952
3953
3954 /* If -R or -S have been specified without -q, assume a single queue run. */
3955
3956  if ((deliver_selectstring || deliver_selectstring_sender) && !qrunners)
3957   alloc_onetime_qrunner();
3958
3959
3960 END_ARG:
3961  store_pool = old_pool;
3962  }
3963
3964 /* If usage_wanted is set we call the usage function - which never returns */
3965 if (usage_wanted) exim_usage(called_as);
3966
3967 /* Arguments have been processed. Check for incompatibilities. */
3968 if (  (  (smtp_input || extract_recipients || recipients_arg < argc)
3969       && (  f.daemon_listen || qrunners || bi_option
3970          || test_retry_arg >= 0 || test_rewrite_arg >= 0
3971          || filter_test != FTEST_NONE
3972          || msg_action_arg > 0 && !one_msg_action
3973       )  )
3974    || (  msg_action_arg > 0
3975       && (  f.daemon_listen || is_multiple_qrun() || list_options
3976          || checking && msg_action != MSG_LOAD
3977          || bi_option || test_retry_arg >= 0 || test_rewrite_arg >= 0
3978       )  )
3979    || (  (f.daemon_listen || is_multiple_qrun())
3980       && (  sender_address || list_options || list_queue || checking
3981          || bi_option
3982       )  )
3983    || f.daemon_listen && is_onetime_qrun()
3984    || f.inetd_wait_mode && qrunners
3985    || (  list_options
3986       && (  checking || smtp_input || extract_recipients
3987          || filter_test != FTEST_NONE || bi_option
3988       )  )
3989    || (  verify_address_mode
3990       && (  f.address_test_mode || smtp_input || extract_recipients
3991          || filter_test != FTEST_NONE || bi_option
3992       )  )
3993    || (  f.address_test_mode
3994       && (  smtp_input || extract_recipients || filter_test != FTEST_NONE
3995          || bi_option
3996       )  )
3997    || (  smtp_input
3998       && (sender_address || filter_test != FTEST_NONE || extract_recipients)
3999       )
4000    || deliver_selectstring && !qrunners
4001    || msg_action == MSG_LOAD && (!expansion_test || expansion_test_message)
4002    )
4003   exim_fail("exim: incompatible command-line options or arguments\n");
4004
4005 /* If debugging is set up, set the file and the file descriptor to pass on to
4006 child processes. It should, of course, be 2 for stderr. Also, force the daemon
4007 to run in the foreground. */
4008
4009 if (debug_selector != 0)
4010   {
4011   debug_file = stderr;
4012   debug_fd = fileno(debug_file);
4013   f.background_daemon = FALSE;
4014   testharness_pause_ms(100);   /* lets caller finish */
4015   if (debug_selector != D_v)    /* -v only doesn't show this */
4016     {
4017     debug_printf("Exim version %s uid=%ld gid=%ld pid=%d D=%x\n",
4018       version_string, (long int)real_uid, (long int)real_gid, (int)getpid(),
4019       debug_selector);
4020     if (!version_printed)
4021       show_whats_supported(FALSE);
4022     }
4023   }
4024
4025 /* When started with root privilege, ensure that the limits on the number of
4026 open files and the number of processes (where that is accessible) are
4027 sufficiently large, or are unset, in case Exim has been called from an
4028 environment where the limits are screwed down. Not all OS have the ability to
4029 change some of these limits. */
4030
4031 if (unprivileged)
4032   {
4033   DEBUG(D_any) debug_print_ids(US"Exim has no root privilege:");
4034   }
4035 else
4036   {
4037   struct rlimit rlp;
4038
4039 #ifdef RLIMIT_NOFILE
4040   if (getrlimit(RLIMIT_NOFILE, &rlp) < 0)
4041     {
4042     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NOFILE) failed: %s",
4043       strerror(errno));
4044     rlp.rlim_cur = rlp.rlim_max = 0;
4045     }
4046
4047   /* I originally chose 1000 as a nice big number that was unlikely to
4048   be exceeded. It turns out that some older OS have a fixed upper limit of
4049   256. */
4050
4051   if (rlp.rlim_cur < 1000)
4052     {
4053     rlp.rlim_cur = rlp.rlim_max = 1000;
4054     if (setrlimit(RLIMIT_NOFILE, &rlp) < 0)
4055       {
4056       rlp.rlim_cur = rlp.rlim_max = 256;
4057       if (setrlimit(RLIMIT_NOFILE, &rlp) < 0)
4058         log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NOFILE) failed: %s",
4059           strerror(errno));
4060       }
4061     }
4062 #endif
4063
4064 #ifdef RLIMIT_NPROC
4065   if (getrlimit(RLIMIT_NPROC, &rlp) < 0)
4066     {
4067     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NPROC) failed: %s",
4068       strerror(errno));
4069     rlp.rlim_cur = rlp.rlim_max = 0;
4070     }
4071
4072 # ifdef RLIM_INFINITY
4073   if (rlp.rlim_cur != RLIM_INFINITY && rlp.rlim_cur < 1000)
4074     {
4075     rlp.rlim_cur = rlp.rlim_max = RLIM_INFINITY;
4076 # else
4077   if (rlp.rlim_cur < 1000)
4078     {
4079     rlp.rlim_cur = rlp.rlim_max = 1000;
4080 # endif
4081     if (setrlimit(RLIMIT_NPROC, &rlp) < 0)
4082       log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NPROC) failed: %s",
4083         strerror(errno));
4084     }
4085 #endif
4086   }
4087
4088 /* Exim is normally entered as root (but some special configurations are
4089 possible that don't do this). However, it always spins off sub-processes that
4090 set their uid and gid as required for local delivery. We don't want to pass on
4091 any extra groups that root may belong to, so we want to get rid of them all at
4092 this point.
4093
4094 We need to obey setgroups() at this stage, before possibly giving up root
4095 privilege for a changed configuration file, but later on we might need to
4096 check on the additional groups for the admin user privilege - can't do that
4097 till after reading the config, which might specify the exim gid. Therefore,
4098 save the group list here first. */
4099
4100 if ((group_count = getgroups(nelem(group_list), group_list)) < 0)
4101   exim_fail("exim: getgroups() failed: %s\n", strerror(errno));
4102
4103 /* There is a fundamental difference in some BSD systems in the matter of
4104 groups. FreeBSD and BSDI are known to be different; NetBSD and OpenBSD are
4105 known not to be different. On the "different" systems there is a single group
4106 list, and the first entry in it is the current group. On all other versions of
4107 Unix there is a supplementary group list, which is in *addition* to the current
4108 group. Consequently, to get rid of all extraneous groups on a "standard" system
4109 you pass over 0 groups to setgroups(), while on a "different" system you pass
4110 over a single group - the current group, which is always the first group in the
4111 list. Calling setgroups() with zero groups on a "different" system results in
4112 an error return. The following code should cope with both types of system.
4113
4114  Unfortunately, recent MacOS, which should be a FreeBSD, "helpfully" succeeds
4115  the "setgroups() with zero groups" - and changes the egid.
4116  Thanks to that we had to stash the original_egid above, for use below
4117  in the call to exim_setugid().
4118
4119 However, if this process isn't running as root, setgroups() can't be used
4120 since you have to be root to run it, even if throwing away groups.
4121 Except, sigh, for Hurd - where you can.
4122 Not being root here happens only in some unusual configurations. */
4123
4124 if (  !unprivileged
4125 #ifndef OS_SETGROUPS_ZERO_DROPS_ALL
4126    && setgroups(0, NULL) != 0
4127 #endif
4128    && setgroups(1, group_list) != 0)
4129   exim_fail("exim: setgroups() failed: %s\n", strerror(errno));
4130
4131 /* If the configuration file name has been altered by an argument on the
4132 command line (either a new file name or a macro definition) and the caller is
4133 not root, or if this is a filter testing run, remove any setuid privilege the
4134 program has and run as the underlying user.
4135
4136 The exim user is locked out of this, which severely restricts the use of -C
4137 for some purposes.
4138
4139 Otherwise, set the real ids to the effective values (should be root unless run
4140 from inetd, which it can either be root or the exim uid, if one is configured).
4141
4142 There is a private mechanism for bypassing some of this, in order to make it
4143 possible to test lots of configurations automatically, without having either to
4144 recompile each time, or to patch in an actual configuration file name and other
4145 values (such as the path name). If running in the test harness, pretend that
4146 configuration file changes and macro definitions haven't happened. */
4147
4148 if ((                                            /* EITHER */
4149     (!f.trusted_config ||                          /* Config changed, or */
4150      !macros_trusted(opt_D_used)) &&             /*  impermissible macros and */
4151     real_uid != root_uid &&                      /* Not root, and */
4152     !f.running_in_test_harness                     /* Not fudged */
4153     ) ||                                         /*   OR   */
4154     expansion_test                               /* expansion testing */
4155     ||                                           /*   OR   */
4156     filter_test != FTEST_NONE)                   /* Filter testing */
4157   {
4158   setgroups(group_count, group_list);
4159   exim_setugid(real_uid, real_gid, FALSE,
4160     US"-C, -D, -be or -bf forces real uid");
4161   removed_privilege = TRUE;
4162
4163   /* In the normal case when Exim is called like this, stderr is available
4164   and should be used for any logging information because attempts to write
4165   to the log will usually fail. To arrange this, we unset really_exim. However,
4166   if no stderr is available there is no point - we might as well have a go
4167   at the log (if it fails, syslog will be written).
4168
4169   Note that if the invoker is Exim, the logs remain available. Messing with
4170   this causes unlogged successful deliveries.  */
4171
4172   if (log_stderr && real_uid != exim_uid)
4173     f.really_exim = FALSE;
4174   }
4175
4176 /* Privilege is to be retained for the moment. It may be dropped later,
4177 depending on the job that this Exim process has been asked to do. For now, set
4178 the real uid to the effective so that subsequent re-execs of Exim are done by a
4179 privileged user. */
4180
4181 else
4182   exim_setugid(geteuid(), original_egid, FALSE, US"forcing real = effective");
4183
4184 /* If testing a filter, open the file(s) now, before wasting time doing other
4185 setups and reading the message. */
4186
4187 if (filter_test & FTEST_SYSTEM)
4188   if ((filter_sfd = Uopen(filter_test_sfile, O_RDONLY, 0)) < 0)
4189     exim_fail("exim: failed to open %s: %s\n", filter_test_sfile,
4190       strerror(errno));
4191
4192 if (filter_test & FTEST_USER)
4193   if ((filter_ufd = Uopen(filter_test_ufile, O_RDONLY, 0)) < 0)
4194     exim_fail("exim: failed to open %s: %s\n", filter_test_ufile,
4195       strerror(errno));
4196
4197 /* Initialise lookup_list
4198 If debugging, already called above via version reporting.
4199 In either case, we initialise the list of available lookups while running
4200 as root.  All dynamically modules are loaded from a directory which is
4201 hard-coded into the binary and is code which, if not a module, would be
4202 part of Exim already.  Ability to modify the content of the directory
4203 is equivalent to the ability to modify a setuid binary!
4204
4205 This needs to happen before we read the main configuration. */
4206 init_lookup_list();
4207
4208 /*XXX this excrescence could move to the testsuite standard config setup file */
4209 #ifdef SUPPORT_I18N
4210 if (f.running_in_test_harness) smtputf8_advertise_hosts = NULL;
4211 #endif
4212
4213 /* Read the main runtime configuration data; this gives up if there
4214 is a failure. It leaves the configuration file open so that the subsequent
4215 configuration data for delivery can be read if needed.
4216
4217 NOTE: immediately after opening the configuration file we change the working
4218 directory to "/"! Later we change to $spool_directory. We do it there, because
4219 during readconf_main() some expansion takes place already. */
4220
4221 /* Store the initial cwd before we change directories.  Can be NULL if the
4222 dir has already been unlinked. */
4223 initial_cwd = os_getcwd(NULL, 0);
4224 if (!initial_cwd && errno)
4225   exim_fail("exim: getting initial cwd failed: %s\n", strerror(errno));
4226
4227 if (initial_cwd && (strlen(CCS initial_cwd) >= BIG_BUFFER_SIZE))
4228   exim_fail("exim: initial cwd is far too long (%d)\n", Ustrlen(CCS initial_cwd));
4229
4230 /* checking:
4231     -be[m] expansion test        -
4232     -b[fF] filter test           new
4233     -bh[c] host test             -
4234     -bmalware malware_test_file  new
4235     -brt   retry test            new
4236     -brw   rewrite test          new
4237     -bt    address test          -
4238     -bv[s] address verify        -
4239    list_options:
4240     -bP <option> (except -bP config, which sets list_config)
4241
4242 If any of these options is set, we suppress warnings about configuration
4243 issues (currently about tls_advertise_hosts and keep_environment not being
4244 defined) */
4245
4246   {
4247   int old_pool = store_pool;
4248 #ifdef MEASURE_TIMING
4249   struct timeval t0;
4250   (void)gettimeofday(&t0, NULL);
4251 #endif
4252
4253   store_pool = POOL_CONFIG;
4254   readconf_main(checking || list_options);
4255   store_pool = old_pool;
4256
4257 #ifdef MEASURE_TIMING
4258   report_time_since(&t0, US"readconf_main (delta)");
4259 #endif
4260   }
4261
4262 /* Now in directory "/" */
4263
4264 if (cleanup_environment() == FALSE)
4265   log_write(0, LOG_PANIC_DIE, "Can't cleanup environment");
4266
4267
4268 /* If an action on specific messages is requested, or if a daemon or queue
4269 runner is being started, we need to know if Exim was called by an admin user.
4270 This is the case if the real user is root or exim, or if the real group is
4271 exim, or if one of the supplementary groups is exim or a group listed in
4272 admin_groups. We don't fail all message actions immediately if not admin_user,
4273 since some actions can be performed by non-admin users. Instead, set admin_user
4274 for later interrogation. */
4275
4276 if (real_uid == root_uid || real_uid == exim_uid || real_gid == exim_gid)
4277   f.admin_user = TRUE;
4278 else
4279   for (int i = 0; i < group_count && !f.admin_user; i++)
4280     if (group_list[i] == exim_gid)
4281       f.admin_user = TRUE;
4282     else if (admin_groups)
4283       for (int j = 1; j <= (int)admin_groups[0] && !f.admin_user; j++)
4284         if (admin_groups[j] == group_list[i])
4285           f.admin_user = TRUE;
4286
4287 /* Another group of privileged users are the trusted users. These are root,
4288 exim, and any caller matching trusted_users or trusted_groups. Trusted callers
4289 are permitted to specify sender_addresses with -f on the command line, and
4290 other message parameters as well. */
4291
4292 if (real_uid == root_uid || real_uid == exim_uid)
4293   f.trusted_caller = TRUE;
4294 else
4295   {
4296   if (trusted_users)
4297     for (int i = 1; i <= (int)trusted_users[0] && !f.trusted_caller; i++)
4298       if (trusted_users[i] == real_uid)
4299         f.trusted_caller = TRUE;
4300
4301   if (trusted_groups)
4302     for (int i = 1; i <= (int)trusted_groups[0] && !f.trusted_caller; i++)
4303       if (trusted_groups[i] == real_gid)
4304         f.trusted_caller = TRUE;
4305       else for (int j = 0; j < group_count && !f.trusted_caller; j++)
4306         if (trusted_groups[i] == group_list[j])
4307           f.trusted_caller = TRUE;
4308   }
4309
4310 /* At this point, we know if the user is privileged and some command-line
4311 options become possibly impermissible, depending upon the configuration file. */
4312
4313 if (checking && commandline_checks_require_admin && !f.admin_user)
4314   exim_fail("exim: those command-line flags are set to require admin\n");
4315
4316 /* Handle the decoding of logging options. */
4317
4318 decode_bits(log_selector, log_selector_size, log_notall,
4319   log_selector_string, log_options, log_options_count, US"log", 0);
4320
4321 DEBUG(D_any)
4322   {
4323   debug_printf("configuration file is %s\n", config_main_filename);
4324   debug_printf("log selectors =");
4325   for (int i = 0; i < log_selector_size; i++)
4326     debug_printf(" %08x", log_selector[i]);
4327   debug_printf("\n");
4328   }
4329
4330 /* If domain literals are not allowed, check the sender address that was
4331 supplied with -f. Ditto for a stripped trailing dot. */
4332
4333 if (sender_address)
4334   {
4335   if (sender_address[sender_address_domain] == '[' && !allow_domain_literals)
4336     exim_fail("exim: bad -f address \"%s\": domain literals not "
4337       "allowed\n", sender_address);
4338   if (f_end_dot && !strip_trailing_dot)
4339     exim_fail("exim: bad -f address \"%s.\": domain is malformed "
4340       "(trailing dot not allowed)\n", sender_address);
4341   }
4342
4343 /* See if an admin user overrode our logging. */
4344
4345 if (cmdline_syslog_name)
4346   if (f.admin_user)
4347     {
4348     syslog_processname = cmdline_syslog_name;
4349     log_file_path = string_copy(CUS"syslog");
4350     }
4351   else
4352     /* not a panic, non-privileged users should not be able to spam paniclog */
4353     exim_fail(
4354         "exim: you lack sufficient privilege to specify syslog process name\n");
4355
4356 /* Paranoia check of maximum lengths of certain strings. There is a check
4357 on the length of the log file path in log.c, which will come into effect
4358 if there are any calls to write the log earlier than this. However, if we
4359 get this far but the string is very long, it is better to stop now than to
4360 carry on and (e.g.) receive a message and then have to collapse. The call to
4361 log_write() from here will cause the ultimate panic collapse if the complete
4362 file name exceeds the buffer length. */
4363
4364 if (Ustrlen(log_file_path) > 200)
4365   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4366     "log_file_path is longer than 200 chars: aborting");
4367
4368 if (Ustrlen(pid_file_path) > 200)
4369   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4370     "pid_file_path is longer than 200 chars: aborting");
4371
4372 if (Ustrlen(spool_directory) > 200)
4373   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4374     "spool_directory is longer than 200 chars: aborting");
4375
4376 /* Length check on the process name given to syslog for its TAG field,
4377 which is only permitted to be 32 characters or less. See RFC 3164. */
4378
4379 if (Ustrlen(syslog_processname) > 32)
4380   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4381     "syslog_processname is longer than 32 chars: aborting");
4382
4383 if (log_oneline)
4384   if (f.admin_user)
4385     {
4386     log_write(0, LOG_MAIN, "%s", log_oneline);
4387     return EXIT_SUCCESS;
4388     }
4389   else
4390     return EXIT_FAILURE;
4391
4392 /* In some operating systems, the environment variable TMPDIR controls where
4393 temporary files are created; Exim doesn't use these (apart from when delivering
4394 to MBX mailboxes), but called libraries such as DBM libraries may require them.
4395 If TMPDIR is found in the environment, reset it to the value defined in the
4396 EXIM_TMPDIR macro, if this macro is defined.  For backward compatibility this
4397 macro may be called TMPDIR in old "Local/Makefile"s. It's converted to
4398 EXIM_TMPDIR by the build scripts.
4399 */
4400
4401 #ifdef EXIM_TMPDIR
4402   if (environ) for (uschar ** p = USS environ; *p; p++)
4403     if (Ustrncmp(*p, "TMPDIR=", 7) == 0 && Ustrcmp(*p+7, EXIM_TMPDIR) != 0)
4404       {
4405       uschar * newp = store_malloc(Ustrlen(EXIM_TMPDIR) + 8);
4406       sprintf(CS newp, "TMPDIR=%s", EXIM_TMPDIR);
4407       *p = newp;
4408       DEBUG(D_any) debug_printf("reset TMPDIR=%s in environment\n", EXIM_TMPDIR);
4409       }
4410 #endif
4411
4412 /* Timezone handling. If timezone_string is "utc", set a flag to cause all
4413 timestamps to be in UTC (gmtime() is used instead of localtime()). Otherwise,
4414 we may need to get rid of a bogus timezone setting. This can arise when Exim is
4415 called by a user who has set the TZ variable. This then affects the timestamps
4416 in log files and in Received: headers, and any created Date: header lines. The
4417 required timezone is settable in the configuration file, so nothing can be done
4418 about this earlier - but hopefully nothing will normally be logged earlier than
4419 this. We have to make a new environment if TZ is wrong, but don't bother if
4420 timestamps_utc is set, because then all times are in UTC anyway. */
4421
4422 if (timezone_string && strcmpic(timezone_string, US"UTC") == 0)
4423   f.timestamps_utc = TRUE;
4424 else
4425   {
4426   uschar *envtz = US getenv("TZ");
4427   if (envtz
4428       ? !timezone_string || Ustrcmp(timezone_string, envtz) != 0
4429       : timezone_string != NULL
4430      )
4431     {
4432     uschar **p = USS environ;
4433     uschar **new;
4434     uschar **newp;
4435     int count = 0;
4436     if (environ) while (*p++) count++;
4437     if (!envtz) count++;
4438     newp = new = store_malloc(sizeof(uschar *) * (count + 1));
4439     if (environ) for (p = USS environ; *p; p++)
4440       if (Ustrncmp(*p, "TZ=", 3) != 0) *newp++ = *p;
4441     if (timezone_string)
4442       {
4443       *newp = store_malloc(Ustrlen(timezone_string) + 4);
4444       sprintf(CS *newp++, "TZ=%s", timezone_string);
4445       }
4446     *newp = NULL;
4447     environ = CSS new;
4448     tzset();
4449     DEBUG(D_any) debug_printf("Reset TZ to %s: time is %s\n", timezone_string,
4450       tod_stamp(tod_log));
4451     }
4452   }
4453
4454 /* Handle the case when we have removed the setuid privilege because of -C or
4455 -D. This means that the caller of Exim was not root.
4456
4457 There is a problem if we were running as the Exim user. The sysadmin may
4458 expect this case to retain privilege because "the binary was called by the
4459 Exim user", but it hasn't, because either the -D option set macros, or the
4460 -C option set a non-trusted configuration file. There are two possibilities:
4461
4462   (1) If deliver_drop_privilege is set, Exim is not going to re-exec in order
4463       to do message deliveries. Thus, the fact that it is running as a
4464       non-privileged user is plausible, and might be wanted in some special
4465       configurations. However, really_exim will have been set false when
4466       privilege was dropped, to stop Exim trying to write to its normal log
4467       files. Therefore, re-enable normal log processing, assuming the sysadmin
4468       has set up the log directory correctly.
4469
4470   (2) If deliver_drop_privilege is not set, the configuration won't work as
4471       apparently intended, and so we log a panic message. In order to retain
4472       root for -C or -D, the caller must either be root or be invoking a
4473       trusted configuration file (when deliver_drop_privilege is false). */
4474
4475 if (  removed_privilege
4476    && (!f.trusted_config || opt_D_used)
4477    && real_uid == exim_uid)
4478   if (deliver_drop_privilege)
4479     f.really_exim = TRUE; /* let logging work normally */
4480   else
4481     log_write(0, LOG_MAIN|LOG_PANIC,
4482       "exim user lost privilege for using %s option",
4483       f.trusted_config? "-D" : "-C");
4484
4485 /* Start up Perl interpreter if Perl support is configured and there is a
4486 perl_startup option, and the configuration or the command line specifies
4487 initializing starting. Note that the global variables are actually called
4488 opt_perl_xxx to avoid clashing with perl's namespace (perl_*). */
4489
4490 #ifdef EXIM_PERL
4491 if (perl_start_option != 0)
4492   opt_perl_at_start = (perl_start_option > 0);
4493 if (opt_perl_at_start && opt_perl_startup != NULL)
4494   {
4495   uschar *errstr;
4496   DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
4497   if ((errstr = init_perl(opt_perl_startup)))
4498     exim_fail("exim: error in perl_startup code: %s\n", errstr);
4499   opt_perl_started = TRUE;
4500   }
4501 #endif /* EXIM_PERL */
4502
4503 /* Log the arguments of the call if the configuration file said so. This is
4504 a debugging feature for finding out what arguments certain MUAs actually use.
4505 Don't attempt it if logging is disabled, or if listing variables or if
4506 verifying/testing addresses or expansions. */
4507
4508 if (  (debug_selector & D_any  ||  LOGGING(arguments))
4509    && f.really_exim && !list_options && !checking)
4510   {
4511   uschar *p = big_buffer;
4512   Ustrcpy(p, US"cwd= (failed)");
4513
4514   if (!initial_cwd)
4515     p += 13;
4516   else
4517     {
4518     p += 4;
4519     snprintf(CS p, big_buffer_size - (p - big_buffer), "%s", CCS initial_cwd);
4520     p += Ustrlen(CCS p);
4521     }
4522
4523   (void)string_format(p, big_buffer_size - (p - big_buffer), " %d args:", argc);
4524   while (*p) p++;
4525   for (int i = 0; i < argc; i++)
4526     {
4527     int len = Ustrlen(argv[i]);
4528     const uschar *printing;
4529     uschar *quote;
4530     if (p + len + 8 >= big_buffer + big_buffer_size)
4531       {
4532       Ustrcpy(p, US" ...");
4533       log_write(0, LOG_MAIN, "%s", big_buffer);
4534       Ustrcpy(big_buffer, US"...");
4535       p = big_buffer + 3;
4536       }
4537     printing = string_printing(argv[i]);
4538     if (!*printing) quote = US"\"";
4539     else
4540       {
4541       const uschar *pp = printing;
4542       quote = US"";
4543       while (*pp) if (isspace(*pp++)) { quote = US"\""; break; }
4544       }
4545     p += sprintf(CS p, " %s%.*s%s", quote, (int)(big_buffer_size -
4546       (p - big_buffer) - 4), printing, quote);
4547     }
4548
4549   if (LOGGING(arguments))
4550     log_write(0, LOG_MAIN, "%s", big_buffer);
4551   else
4552     debug_printf("%s\n", big_buffer);
4553   }
4554
4555 /* Set the working directory to be the top-level spool directory. We don't rely
4556 on this in the code, which always uses fully qualified names, but it's useful
4557 for core dumps etc. Don't complain if it fails - the spool directory might not
4558 be generally accessible and calls with the -C option (and others) have lost
4559 privilege by now. Before the chdir, we try to ensure that the directory exists.
4560 */
4561
4562 if (Uchdir(spool_directory) != 0)
4563   {
4564   (void) directory_make(spool_directory, US"", SPOOL_DIRECTORY_MODE, FALSE);
4565   (void) Uchdir(spool_directory);
4566   }
4567
4568 /* Handle calls with the -bi option. This is a sendmail option to rebuild *the*
4569 alias file. Exim doesn't have such a concept, but this call is screwed into
4570 Sun's YP makefiles. Handle this by calling a configured script, as the real
4571 user who called Exim. The -oA option can be used to pass an argument to the
4572 script. */
4573
4574 if (bi_option)
4575   {
4576   (void) fclose(config_file);
4577   if (bi_command && *bi_command)
4578     {
4579     int i = 0;
4580     const uschar * argv[3];
4581     argv[i++] = bi_command;     /* nonexpanded option so assume untainted */
4582     if (alias_arg) argv[i++] = alias_arg;
4583     argv[i++] = NULL;
4584
4585     setgroups(group_count, group_list);
4586     exim_setugid(real_uid, real_gid, FALSE, US"running bi_command");
4587
4588     DEBUG(D_exec) debug_printf("exec '%.256s' %s%.256s%s\n", argv[0],
4589       argv[1] ? "'" : "", argv[1] ? argv[1] : US"", argv[1] ? "'" : "");
4590
4591     execv(CS argv[0], (char *const *)argv);
4592     exim_fail("exim: exec '%s' failed: %s\n", argv[0], strerror(errno));
4593     }
4594   else
4595     {
4596     DEBUG(D_any) debug_printf("-bi used but bi_command not set; exiting\n");
4597     exit(EXIT_SUCCESS);
4598     }
4599   }
4600
4601 /* We moved the admin/trusted check to be immediately after reading the
4602 configuration file.  We leave these prints here to ensure that syslog setup,
4603 logfile setup, and so on has already happened. */
4604
4605 if (f.trusted_caller) DEBUG(D_any) debug_printf("trusted user\n");
4606 if (f.admin_user) DEBUG(D_any) debug_printf("admin user\n");
4607
4608 /* Only an admin user may start the daemon or force a queue run in the default
4609 configuration, but the queue run restriction can be relaxed. Only an admin
4610 user may request that a message be returned to its sender forthwith. Only an
4611 admin user may specify a debug level greater than D_v (because it might show
4612 passwords, etc. in lookup queries). Only an admin user may request a queue
4613 count. Only an admin user can use the test interface to scan for email
4614 (because Exim will be in the spool dir and able to look at mails). */
4615
4616 if (!f.admin_user)
4617   {
4618   BOOL debugset = (debug_selector & ~D_v) != 0;
4619   if (  deliver_give_up || f.daemon_listen || malware_test_file
4620      || count_queue && queue_list_requires_admin
4621      || list_queue && queue_list_requires_admin
4622      || qrunners && prod_requires_admin
4623      || queue_name_dest && prod_requires_admin
4624      || debugset && !f.running_in_test_harness
4625      )
4626     exim_fail("exim:%s permission denied; not admin\n",
4627               debugset ? " debugging" : "");
4628   }
4629
4630 /* If the real user is not root or the exim uid, the argument for passing
4631 in an open TCP/IP connection for another message is not permitted, nor is
4632 running with the -N option for any delivery action, unless this call to exim is
4633 one that supplied an input message, or we are using a patched exim for
4634 regression testing. */
4635
4636 if (  real_uid != root_uid && real_uid != exim_uid
4637    && (  continue_hostname
4638       || (  f.dont_deliver
4639          && (qrunners || f.daemon_listen || msg_action_arg > 0)
4640       )  )
4641    && !f.running_in_test_harness
4642    )
4643   exim_fail("exim: Permission denied; not exim user or root\n");
4644
4645 /* If the caller is not trusted, certain arguments are ignored when running for
4646 real, but are permitted when checking things (-be, -bv, -bt, -bh, -bf, -bF).
4647 Note that authority for performing certain actions on messages is tested in the
4648 queue_action() function. */
4649
4650 if (!f.trusted_caller && !checking)
4651   {
4652   sender_host_name = sender_host_address = interface_address =
4653     sender_ident = received_protocol = NULL;
4654   sender_host_port = interface_port = 0;
4655   sender_host_authenticated = authenticated_sender = authenticated_id = NULL;
4656   }
4657
4658 /* If a sender host address is set, extract the optional port number off the
4659 end of it and check its syntax. Do the same thing for the interface address.
4660 Exim exits if the syntax is bad. */
4661
4662 else
4663   {
4664   if (sender_host_address)
4665     sender_host_port = check_port(sender_host_address);
4666   if (interface_address)
4667     interface_port = check_port(interface_address);
4668   }
4669
4670 /* If the caller is trusted, then they can use -G to suppress_local_fixups. */
4671 if (flag_G)
4672   {
4673   if (f.trusted_caller)
4674     {
4675     f.suppress_local_fixups = f.suppress_local_fixups_default = TRUE;
4676     DEBUG(D_acl) debug_printf("suppress_local_fixups forced on by -G\n");
4677     }
4678   else
4679     exim_fail("exim: permission denied (-G requires a trusted user)\n");
4680   }
4681
4682 /* If an SMTP message is being received check to see if the standard input is a
4683 TCP/IP socket. If it is, we assume that Exim was called from inetd if the
4684 caller is root or the Exim user, or if the port is a privileged one. Otherwise,
4685 barf. */
4686
4687 if (smtp_input)
4688   {
4689   union sockaddr_46 inetd_sock;
4690   EXIM_SOCKLEN_T size = sizeof(inetd_sock);
4691   if (getpeername(0, (struct sockaddr *)(&inetd_sock), &size) == 0)
4692     {
4693     int family = ((struct sockaddr *)(&inetd_sock))->sa_family;
4694     if (family == AF_INET || family == AF_INET6)
4695       {
4696       union sockaddr_46 interface_sock;
4697       size = sizeof(interface_sock);
4698
4699       if (getsockname(0, (struct sockaddr *)(&interface_sock), &size) == 0)
4700         interface_address = host_ntoa(-1, &interface_sock, NULL,
4701           &interface_port);
4702
4703       if (host_is_tls_on_connect_port(interface_port)) tls_in.on_connect = TRUE;
4704
4705       if (real_uid == root_uid || real_uid == exim_uid || interface_port < 1024)
4706         {
4707         f.is_inetd = TRUE;
4708         sender_host_address = host_ntoa(-1, (struct sockaddr *)(&inetd_sock),
4709           NULL, &sender_host_port);
4710         if (mua_wrapper) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Input from "
4711           "inetd is not supported when mua_wrapper is set");
4712         }
4713       else
4714         exim_fail(
4715           "exim: Permission denied (unprivileged user, unprivileged port)\n");
4716       }
4717     }
4718   }
4719
4720 /* If the load average is going to be needed while receiving a message, get it
4721 now for those OS that require the first call to os_getloadavg() to be done as
4722 root. There will be further calls later for each message received. */
4723
4724 #ifdef LOAD_AVG_NEEDS_ROOT
4725 if (  receiving_message
4726    && (queue_only_load >= 0 || (f.is_inetd && smtp_load_reserve >= 0)))
4727   load_average = OS_GETLOADAVG();
4728 #endif
4729
4730 /* The queue_only configuration option can be overridden by -odx on the command
4731 line, except that if queue_only_override is false, queue_only cannot be unset
4732 from the command line. */
4733
4734 if (queue_only_set && (queue_only_override || arg_queue_only))
4735   queue_only = arg_queue_only;
4736
4737 /* The receive_timeout and smtp_receive_timeout options can be overridden by
4738 -or and -os. */
4739
4740 if (arg_receive_timeout >= 0) receive_timeout = arg_receive_timeout;
4741 if (arg_smtp_receive_timeout >= 0)
4742   smtp_receive_timeout = arg_smtp_receive_timeout;
4743
4744 /* If Exim was started with root privilege, unless we have already removed the
4745 root privilege above as a result of -C, -D, -be, -bf or -bF, remove it now
4746 except when starting the daemon or doing some kind of delivery or address
4747 testing (-bt). These are the only cases when root need to be retained. We run
4748 as exim for -bv and -bh. However, if deliver_drop_privilege is set, root is
4749 retained only for starting the daemon. We always do the initgroups() in this
4750 situation (controlled by the TRUE below), in order to be as close as possible
4751 to the state Exim usually runs in. */
4752
4753 if (  !unprivileged                             /* originally had root AND */
4754    && !removed_privilege                        /* still got root AND      */
4755    && !f.daemon_listen                          /* not starting the daemon */
4756    && (!qrunners || is_onetime_qrun())          /* (either kind of daemon) */
4757    && (                                         /*    AND EITHER           */
4758          deliver_drop_privilege                 /* requested unprivileged  */
4759       || (                                      /*       OR                */
4760             !qrunners                           /* not running the queue   */
4761          && (  msg_action_arg < 0               /*       and               */
4762             || msg_action != MSG_DELIVER        /* not delivering          */
4763             )                                   /*       and               */
4764          && (!checking || !f.address_test_mode) /* not address checking    */
4765          && !rcpt_verify_quota                  /* and not quota checking  */
4766    )  )  )
4767   exim_setugid(exim_uid, exim_gid, TRUE, US"privilege not needed");
4768
4769 /* When we are retaining a privileged uid, we still change to the exim gid. */
4770
4771 else
4772   {
4773   int rv;
4774   DEBUG(D_any) debug_printf("dropping to exim gid; retaining priv uid\n");
4775   rv = setgid(exim_gid);
4776   /* Impact of failure is that some stuff might end up with an incorrect group.
4777   We track this for failures from root, since any attempt to change privilege
4778   by root should succeed and failures should be examined.  For non-root,
4779   there's no security risk.  For me, it's { exim -bV } on a just-built binary,
4780   no need to complain then. */
4781   if (rv == -1)
4782     if (!(unprivileged || removed_privilege))
4783       exim_fail("exim: changing group failed: %s\n", strerror(errno));
4784     else
4785       {
4786       DEBUG(D_any) debug_printf("changing group to %ld failed: %s\n",
4787           (long int)exim_gid, strerror(errno));
4788       }
4789   }
4790
4791 /* Handle a request to scan a file for malware */
4792 if (malware_test_file)
4793   {
4794 #ifdef WITH_CONTENT_SCAN
4795   int result;
4796   set_process_info("scanning file for malware");
4797   if ((result = malware_in_file(malware_test_file)) == FAIL)
4798     {
4799     printf("No malware found.\n");
4800     exim_exit(EXIT_SUCCESS);
4801     }
4802   if (result != OK)
4803     {
4804     printf("Malware lookup returned non-okay/fail: %d\n", result);
4805     exim_exit(EXIT_FAILURE);
4806     }
4807   if (malware_name)
4808     printf("Malware found: %s\n", malware_name);
4809   else
4810     printf("Malware scan detected malware of unknown name.\n");
4811 #else
4812   printf("Malware scanning not enabled at compile time.\n");
4813 #endif
4814   exim_exit(EXIT_FAILURE);
4815   }
4816
4817 /* Handle a request to list the delivery queue */
4818
4819 if (list_queue)
4820   {
4821   set_process_info("listing the queue");
4822   queue_list(list_queue_option, argv + recipients_arg, argc - recipients_arg);
4823   exim_exit(EXIT_SUCCESS);
4824   }
4825
4826 /* Handle a request to count the delivery queue */
4827
4828 if (count_queue)
4829   {
4830   set_process_info("counting the queue");
4831   fprintf(stdout, "%u\n", queue_count());
4832   exim_exit(EXIT_SUCCESS);
4833   }
4834
4835 /* Handle actions on specific messages, except for the force delivery and
4836 message load actions, which are done below. Some actions take a whole list of
4837 message ids, which are known to continue up to the end of the arguments. Others
4838 take a single message id and then operate on the recipients list. */
4839
4840 if (msg_action_arg > 0 && msg_action != MSG_DELIVER && msg_action != MSG_LOAD)
4841   {
4842   int yield = EXIT_SUCCESS;
4843   set_process_info("acting on specified messages");
4844
4845   /* ACL definitions may be needed when removing a message (-Mrm) because
4846   event_action gets expanded */
4847
4848   if (msg_action == MSG_REMOVE)
4849     {
4850     int old_pool = store_pool;
4851     store_pool = POOL_CONFIG;
4852     readconf_rest();
4853     store_pool = old_pool;
4854     store_writeprotect(POOL_CONFIG);
4855     }
4856
4857   if (!one_msg_action)
4858     {
4859     for (i = msg_action_arg; i < argc; i++)
4860       if (!queue_action(argv[i], msg_action, NULL, 0, 0))
4861         yield = EXIT_FAILURE;
4862     switch (msg_action)
4863       {
4864       case MSG_REMOVE: case MSG_FREEZE: case MSG_THAW: break;
4865       default: printf("\n"); break;
4866       }
4867     }
4868
4869   else if (!queue_action(argv[msg_action_arg], msg_action, argv, argc,
4870     recipients_arg)) yield = EXIT_FAILURE;
4871   exim_exit(yield);
4872   }
4873
4874 /* We used to set up here to skip reading the ACL section, on
4875  (msg_action_arg > 0 || (is_onetime_qrun() && !f.daemon_listen)
4876 Now, since the intro of the ${acl } expansion, ACL definitions may be
4877 needed in transports so we lost the optimisation. */
4878
4879   {
4880   int old_pool = store_pool;
4881 #ifdef MEASURE_TIMING
4882   struct timeval t0;
4883   (void)gettimeofday(&t0, NULL);
4884 #endif
4885
4886   store_pool = POOL_CONFIG;
4887   readconf_rest();
4888   store_pool = old_pool;
4889
4890   /* -be can add macro definitions, needing to link to the macro structure
4891   chain.  Otherwise, make the memory used for config data readonly. */
4892
4893   if (!expansion_test)
4894     store_writeprotect(POOL_CONFIG);
4895
4896 #ifdef MEASURE_TIMING
4897   report_time_since(&t0, US"readconf_rest (delta)");
4898 #endif
4899   }
4900
4901 /* Handle a request to check quota */
4902 if (rcpt_verify_quota)
4903   if (real_uid != root_uid && real_uid != exim_uid)
4904     exim_fail("exim: Permission denied\n");
4905   else if (recipients_arg >= argc)
4906     exim_fail("exim: missing recipient for quota check\n");
4907   else
4908     {
4909     verify_quota(US argv[recipients_arg]);      /*XXX we lose track of const here */
4910     exim_exit(EXIT_SUCCESS);
4911     }
4912
4913 /* Handle the -brt option. This is for checking out retry configurations.
4914 The next three arguments are a domain name or a complete address, and
4915 optionally two error numbers. All it does is to call the function that
4916 scans the retry configuration data. */
4917
4918 if (test_retry_arg >= 0)
4919   {
4920   retry_config *yield;
4921   int basic_errno = 0;
4922   int more_errno = 0;
4923   const uschar *s1, *s2;
4924
4925   if (test_retry_arg >= argc)
4926     {
4927     printf("-brt needs a domain or address argument\n");
4928     exim_exit(EXIT_FAILURE);
4929     }
4930   s1 = exim_str_fail_toolong(argv[test_retry_arg++], EXIM_EMAILADDR_MAX, "-brt");
4931   s2 = NULL;
4932
4933   /* If the first argument contains no @ and no . it might be a local user
4934   or it might be a single-component name. Treat as a domain. */
4935
4936   if (Ustrchr(s1, '@') == NULL && Ustrchr(s1, '.') == NULL)
4937     {
4938     printf("Warning: \"%s\" contains no '@' and no '.' characters. It is "
4939       "being \ntreated as a one-component domain, not as a local part.\n\n",
4940       s1);
4941     }
4942
4943   /* There may be an optional second domain arg. */
4944
4945   if (test_retry_arg < argc && Ustrchr(argv[test_retry_arg], '.') != NULL)
4946     s2 = exim_str_fail_toolong(argv[test_retry_arg++], EXIM_DOMAINNAME_MAX, "-brt 2nd");
4947
4948   /* The final arg is an error name */
4949
4950   if (test_retry_arg < argc)
4951     {
4952     const uschar *ss = exim_str_fail_toolong(argv[test_retry_arg], EXIM_DRIVERNAME_MAX, "-brt 3rd");
4953     uschar *error =
4954       readconf_retry_error(ss, ss + Ustrlen(ss), &basic_errno, &more_errno);
4955     if (error != NULL)
4956       {
4957       printf("%s\n", CS error);
4958       return EXIT_FAILURE;
4959       }
4960
4961     /* For the {MAIL,RCPT,DATA}_4xx errors, a value of 255 means "any", and a
4962     code > 100 as an error is for matching codes to the decade. Turn them into
4963     a real error code, off the decade. */
4964
4965     if (basic_errno == ERRNO_MAIL4XX ||
4966         basic_errno == ERRNO_RCPT4XX ||
4967         basic_errno == ERRNO_DATA4XX)
4968       {
4969       int code = (more_errno >> 8) & 255;
4970       if (code == 255)
4971         more_errno = (more_errno & 0xffff00ff) | (21 << 8);
4972       else if (code > 100)
4973         more_errno = (more_errno & 0xffff00ff) | ((code - 96) << 8);
4974       }
4975     }
4976
4977   if (!(yield = retry_find_config(s1, s2, basic_errno, more_errno)))
4978     printf("No retry information found\n");
4979   else
4980     {
4981     more_errno = yield->more_errno;
4982     printf("Retry rule: %s  ", yield->pattern);
4983
4984     if (yield->basic_errno == ERRNO_EXIMQUOTA)
4985       {
4986       printf("quota%s%s  ",
4987         (more_errno > 0)? "_" : "",
4988         (more_errno > 0)? readconf_printtime(more_errno) : US"");
4989       }
4990     else if (yield->basic_errno == ECONNREFUSED)
4991       {
4992       printf("refused%s%s  ",
4993         (more_errno > 0)? "_" : "",
4994         (more_errno == 'M')? "MX" :
4995         (more_errno == 'A')? "A" : "");
4996       }
4997     else if (yield->basic_errno == ETIMEDOUT)
4998       {
4999       printf("timeout");
5000       if ((more_errno & RTEF_CTOUT) != 0) printf("_connect");
5001       more_errno &= 255;
5002       if (more_errno != 0) printf("_%s",
5003         (more_errno == 'M')? "MX" : "A");
5004       printf("  ");
5005       }
5006     else if (yield->basic_errno == ERRNO_AUTHFAIL)
5007       printf("auth_failed  ");
5008     else printf("*  ");
5009
5010     for (retry_rule * r = yield->rules; r; r = r->next)
5011       {
5012       printf("%c,%s", r->rule, readconf_printtime(r->timeout)); /* Do not */
5013       printf(",%s", readconf_printtime(r->p1));                 /* amalgamate */
5014       if (r->rule == 'G')
5015         {
5016         int x = r->p2;
5017         int f = x % 1000;
5018         int d = 100;
5019         printf(",%d.", x/1000);
5020         do
5021           {
5022           printf("%d", f/d);
5023           f %= d;
5024           d /= 10;
5025           }
5026         while (f != 0);
5027         }
5028       printf("; ");
5029       }
5030
5031     printf("\n");
5032     }
5033   exim_exit(EXIT_SUCCESS);
5034   }
5035
5036 /* Handle a request to list one or more configuration options */
5037 /* If -n was set, we suppress some information */
5038
5039 if (list_options)
5040   {
5041   BOOL fail = FALSE;
5042   set_process_info("listing variables");
5043   if (recipients_arg >= argc)
5044     fail = !readconf_print(US"all", NULL, flag_n);
5045   else for (i = recipients_arg; i < argc; i++)
5046     {
5047     if (i < argc - 1 &&
5048         (Ustrcmp(argv[i], "router") == 0 ||
5049          Ustrcmp(argv[i], "transport") == 0 ||
5050          Ustrcmp(argv[i], "authenticator") == 0 ||
5051          Ustrcmp(argv[i], "macro") == 0 ||
5052          Ustrcmp(argv[i], "environment") == 0))
5053       {
5054       fail |= !readconf_print(exim_str_fail_toolong(argv[i+1], EXIM_DRIVERNAME_MAX, "-bP name"), argv[i], flag_n);
5055       i++;
5056       }
5057     else
5058       fail = !readconf_print(exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-bP item"), NULL, flag_n);
5059     }
5060   exim_exit(fail ? EXIT_FAILURE : EXIT_SUCCESS);
5061   }
5062
5063 if (list_config)
5064   {
5065   set_process_info("listing config");
5066   exim_exit(readconf_print(US"config", NULL, flag_n)
5067                 ? EXIT_SUCCESS : EXIT_FAILURE);
5068   }
5069
5070
5071 /* Initialise subsystems as required. */
5072
5073 tcp_init();
5074
5075 /* Handle a request to deliver one or more messages that are already on the
5076 queue. Values of msg_action other than MSG_DELIVER and MSG_LOAD are dealt with
5077 above. MSG_LOAD is handled with -be (which is the only time it applies) below.
5078
5079 Delivery of specific messages is typically used for a small number when
5080 prodding by hand (when the option forced_delivery will be set) or when
5081 re-execing to regain root privilege. Each message delivery must happen in a
5082 separate process, so we fork a process for each one, and run them sequentially
5083 so that debugging output doesn't get intertwined, and to avoid spawning too
5084 many processes if a long list is given. However, don't fork for the last one;
5085 this saves a process in the common case when Exim is called to deliver just one
5086 message. */
5087
5088 if (msg_action_arg > 0 && msg_action != MSG_LOAD)
5089   {
5090   if (prod_requires_admin && !f.admin_user)
5091     {
5092     fprintf(stderr, "exim: Permission denied\n");
5093     exim_exit(EXIT_FAILURE);
5094     }
5095   set_process_info("delivering specified messages");
5096   if (deliver_give_up) forced_delivery = f.deliver_force_thaw = TRUE;
5097   for (i = msg_action_arg; i < argc; i++)
5098     {
5099     int status;
5100     pid_t pid;
5101     /*XXX This use of argv[i] for msg_id should really be tainted, but doing
5102     that runs into a later copy into the untainted global message_id[] */
5103     /*XXX Do we need a length limit check here? */
5104     if (i == argc - 1)
5105       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
5106     else if ((pid = exim_fork(US"cmdline-delivery")) == 0)
5107       {
5108       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
5109       exim_underbar_exit(EXIT_SUCCESS);
5110       }
5111     else if (pid < 0)
5112       {
5113       fprintf(stderr, "failed to fork delivery process for %s: %s\n", argv[i],
5114         strerror(errno));
5115       exim_exit(EXIT_FAILURE);
5116       }
5117     else wait(&status);
5118     }
5119   exim_exit(EXIT_SUCCESS);
5120   }
5121
5122
5123 /* If only a single queue run is requested, without SMTP listening, we can just
5124 turn into a queue runner, with an optional starting message id. */
5125
5126 if (is_onetime_qrun() && !f.daemon_listen)
5127   {
5128   single_queue_run(qrunners, start_queue_run_id, stop_queue_run_id);
5129   exim_exit(EXIT_SUCCESS);
5130   }
5131
5132
5133 /* Find the login name of the real user running this process. This is always
5134 needed when receiving a message, because it is written into the spool file. It
5135 may also be used to construct a from: or a sender: header, and in this case we
5136 need the user's full name as well, so save a copy of it, checked for RFC822
5137 syntax and munged if necessary, if it hasn't previously been set by the -F
5138 argument. We may try to get the passwd entry more than once, in case NIS or
5139 other delays are in evidence. Save the home directory for use in filter testing
5140 (only). */
5141
5142 for (i = 0;;)
5143   {
5144   if ((pw = getpwuid(real_uid)) != NULL)
5145     {
5146     originator_login = string_copy(US pw->pw_name);
5147     originator_home = string_copy(US pw->pw_dir);
5148
5149     /* If user name has not been set by -F, set it from the passwd entry
5150     unless -f has been used to set the sender address by a trusted user. */
5151
5152     if (!originator_name)
5153       {
5154       if (!sender_address || (!f.trusted_caller && filter_test == FTEST_NONE))
5155         {
5156         uschar *name = US pw->pw_gecos;
5157         uschar *amp = Ustrchr(name, '&');
5158         uschar buffer[256];
5159
5160         /* Most Unix specify that a '&' character in the gecos field is
5161         replaced by a copy of the login name, and some even specify that
5162         the first character should be upper cased, so that's what we do. */
5163
5164         if (amp)
5165           {
5166           int loffset;
5167           string_format(buffer, sizeof(buffer), "%.*s%n%s%s",
5168             (int)(amp - name), name, &loffset, originator_login, amp + 1);
5169           buffer[loffset] = toupper(buffer[loffset]);
5170           name = buffer;
5171           }
5172
5173         /* If a pattern for matching the gecos field was supplied, apply
5174         it and then expand the name string. */
5175
5176         GET_OPTION("gecos_pattern");
5177         GET_OPTION("gecos_name");
5178         if (gecos_pattern && gecos_name)
5179           {
5180           const pcre2_code *re;
5181           re = regex_must_compile(gecos_pattern, MCS_NOFLAGS, TRUE); /* Use malloc */
5182
5183           if (regex_match_and_setup(re, name, 0, -1))
5184             {
5185             uschar *new_name = expand_string(gecos_name);
5186             expand_nmax = -1;
5187             if (new_name)
5188               {
5189               DEBUG(D_receive) debug_printf("user name \"%s\" extracted from "
5190                 "gecos field \"%s\"\n", new_name, name);
5191               name = new_name;
5192               }
5193             else DEBUG(D_receive) debug_printf("failed to expand gecos_name string "
5194               "\"%s\": %s\n", gecos_name, expand_string_message);
5195             }
5196           else DEBUG(D_receive) debug_printf("gecos_pattern \"%s\" did not match "
5197             "gecos field \"%s\"\n", gecos_pattern, name);
5198           store_free((void *)re);
5199           }
5200         originator_name = string_copy(name);
5201         }
5202
5203       /* A trusted caller has used -f but not -F */
5204
5205       else originator_name = US"";
5206       }
5207
5208     /* Break the retry loop */
5209
5210     break;
5211     }
5212
5213   if (++i > finduser_retries) break;
5214   sleep(1);
5215   }
5216
5217 /* If we cannot get a user login, log the incident and give up, unless the
5218 configuration specifies something to use. When running in the test harness,
5219 any setting of unknown_login overrides the actual name. */
5220
5221 if (!originator_login || f.running_in_test_harness)
5222   {
5223   GET_OPTION("unknown_login");
5224   if (unknown_login)
5225     {
5226     originator_login = expand_string(unknown_login);
5227     if (!originator_name && unknown_username)
5228       originator_name = expand_string(unknown_username);
5229     if (!originator_name) originator_name = US"";
5230     }
5231   if (!originator_login)
5232     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to get user name for uid %d",
5233       (int)real_uid);
5234   }
5235
5236 /* Ensure that the user name is in a suitable form for use as a "phrase" in an
5237 RFC822 address.*/
5238
5239 originator_name = US parse_fix_phrase(originator_name, Ustrlen(originator_name));
5240
5241 /* If a message is created by this call of Exim, the uid/gid of its originator
5242 are those of the caller. These values are overridden if an existing message is
5243 read in from the spool. */
5244
5245 originator_uid = real_uid;
5246 originator_gid = real_gid;
5247
5248 DEBUG(D_receive) debug_printf("originator: uid=%d gid=%d login=%s name=%s\n",
5249   (int)originator_uid, (int)originator_gid, originator_login, originator_name);
5250
5251 /* Run in daemon and/or queue-running mode. The function daemon_go() never
5252 returns. We leave this till here so that the originator_ fields are available
5253 for incoming messages via the daemon. The daemon cannot be run in mua_wrapper
5254 mode. */
5255
5256 if (f.daemon_listen || f.inetd_wait_mode || is_multiple_qrun())
5257   {
5258   if (mua_wrapper)
5259     {
5260     fprintf(stderr, "Daemon cannot be run when mua_wrapper is set\n");
5261     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Daemon cannot be run when "
5262       "mua_wrapper is set");
5263     }
5264
5265 # ifndef DISABLE_TLS
5266   /* This also checks that the library linkage is working and we can call
5267   routines in it, so call even if tls_require_ciphers is unset */
5268     {
5269 # ifdef MEASURE_TIMING
5270     struct timeval t0;
5271     (void)gettimeofday(&t0, NULL);
5272 # endif
5273     if (!tls_dropprivs_validate_require_cipher(FALSE))
5274       exim_exit(EXIT_FAILURE);
5275 # ifdef MEASURE_TIMING
5276     report_time_since(&t0, US"validate_ciphers (delta)");
5277 # endif
5278     }
5279 #endif
5280
5281   daemon_go();
5282   }
5283
5284 /* If the sender ident has not been set (by a trusted caller) set it to
5285 the caller. This will get overwritten below for an inetd call. If a trusted
5286 caller has set it empty, unset it. */
5287
5288 if (!sender_ident) sender_ident = originator_login;
5289 else if (!*sender_ident) sender_ident = NULL;
5290
5291 /* Handle the -brw option, which is for checking out rewriting rules. Cause log
5292 writes (on errors) to go to stderr instead. Can't do this earlier, as want the
5293 originator_* variables set. */
5294
5295 if (test_rewrite_arg >= 0)
5296   {
5297   f.really_exim = FALSE;
5298   if (test_rewrite_arg >= argc)
5299     {
5300     printf("-brw needs an address argument\n");
5301     exim_exit(EXIT_FAILURE);
5302     }
5303   rewrite_test(exim_str_fail_toolong(argv[test_rewrite_arg], EXIM_EMAILADDR_MAX, "-brw"));
5304   exim_exit(EXIT_SUCCESS);
5305   }
5306
5307 /* A locally-supplied message is considered to be coming from a local user
5308 unless a trusted caller supplies a sender address with -f, or is passing in the
5309 message via SMTP (inetd invocation or otherwise). */
5310
5311 if (  !sender_address && !smtp_input
5312    || !f.trusted_caller && filter_test == FTEST_NONE)
5313   {
5314   f.sender_local = TRUE;
5315
5316   /* A trusted caller can supply authenticated_sender and authenticated_id
5317   via -oMas and -oMai and if so, they will already be set. Otherwise, force
5318   defaults except when host checking. */
5319
5320   if (!authenticated_sender && !host_checking)
5321     authenticated_sender = string_sprintf("%s@%s", originator_login,
5322       qualify_domain_sender);
5323   if (!authenticated_id && !host_checking)
5324     authenticated_id = originator_login;
5325   }
5326
5327 /* Trusted callers are always permitted to specify the sender address.
5328 Untrusted callers may specify it if it matches untrusted_set_sender, or if what
5329 is specified is the empty address. However, if a trusted caller does not
5330 specify a sender address for SMTP input, we leave sender_address unset. This
5331 causes the MAIL commands to be honoured. */
5332
5333 if (  !smtp_input && !sender_address
5334    || !receive_check_set_sender(sender_address))
5335   {
5336   /* Either the caller is not permitted to set a general sender, or this is
5337   non-SMTP input and the trusted caller has not set a sender. If there is no
5338   sender, or if a sender other than <> is set, override with the originator's
5339   login (which will get qualified below), except when checking things. */
5340
5341   if (  !sender_address                  /* No sender_address set */
5342      ||                                  /*         OR            */
5343        (sender_address[0] != 0 &&        /* Non-empty sender address, AND */
5344        !checking))                       /* Not running tests, including filter tests */
5345     {
5346     sender_address = originator_login;
5347     f.sender_address_forced = FALSE;
5348     sender_address_domain = 0;
5349     }
5350   }
5351
5352 /* Remember whether an untrusted caller set the sender address */
5353
5354 f.sender_set_untrusted = sender_address != originator_login && !f.trusted_caller;
5355
5356 /* Ensure that the sender address is fully qualified unless it is the empty
5357 address, which indicates an error message, or doesn't exist (root caller, smtp
5358 interface, no -f argument). */
5359
5360 if (sender_address && *sender_address && sender_address_domain == 0)
5361   sender_address = string_sprintf("%s@%s", local_part_quote(sender_address),
5362     qualify_domain_sender);
5363
5364 DEBUG(D_receive) debug_printf("sender address = %s\n", sender_address);
5365
5366 /* Handle a request to verify a list of addresses, or test them for delivery.
5367 This must follow the setting of the sender address, since routers can be
5368 predicated upon the sender. If no arguments are given, read addresses from
5369 stdin. Set debug_level to at least D_v to get full output for address testing.
5370 */
5371
5372 if (verify_address_mode || f.address_test_mode)
5373   {
5374   int exit_value = 0;
5375   int flags = vopt_qualify;
5376
5377   if (verify_address_mode)
5378     {
5379     if (!verify_as_sender) flags |= vopt_is_recipient;
5380     DEBUG(D_verify) debug_print_ids(US"Verifying:");
5381     }
5382
5383   else
5384     {
5385     flags |= vopt_is_recipient;
5386     debug_selector |= D_v;
5387     debug_file = stderr;
5388     debug_fd = fileno(debug_file);
5389     DEBUG(D_verify) debug_print_ids(US"Address testing:");
5390     }
5391
5392   if (recipients_arg < argc)
5393     while (recipients_arg < argc)
5394       {
5395       /* Supplied addresses are tainted since they come from a user */
5396       uschar * s = string_copy_taint(
5397         exim_str_fail_toolong(argv[recipients_arg++], EXIM_DISPLAYMAIL_MAX, "address verification"),
5398         GET_TAINTED);
5399       while (*s)
5400         {
5401         BOOL finished = FALSE;
5402         uschar *ss = parse_find_address_end(s, FALSE);
5403         if (*ss == ',') *ss = 0; else finished = TRUE;
5404         test_address(s, flags, &exit_value);
5405         s = ss;
5406         if (!finished)
5407           while (*++s == ',' || isspace(*s)) ;
5408         }
5409       }
5410
5411   else for (;;)
5412     {
5413     uschar * s = get_stdinput(NULL, NULL);
5414     if (!s) break;
5415     test_address(string_copy_taint(
5416         exim_str_fail_toolong(s, EXIM_DISPLAYMAIL_MAX, "address verification (stdin)"),
5417         GET_TAINTED),
5418       flags, &exit_value);
5419     }
5420
5421   route_tidyup();
5422   exim_exit(exit_value);
5423   }
5424
5425 /* Handle expansion checking. Either expand items on the command line, or read
5426 from stdin if there aren't any. If -Mset was specified, load the message so
5427 that its variables can be used, but restrict this facility to admin users.
5428 Otherwise, if -bem was used, read a message from stdin. */
5429
5430 if (expansion_test)
5431   {
5432   dns_init(FALSE, FALSE, FALSE);
5433   if (msg_action_arg > 0 && msg_action == MSG_LOAD)
5434     {
5435     uschar * spoolname;
5436     if (!f.admin_user)
5437       exim_fail("exim: permission denied\n");
5438     message_id = US exim_str_fail_toolong(argv[msg_action_arg], MESSAGE_ID_LENGTH, "message-id");
5439     /* Checking the length of the ID is sufficient to validate it.
5440     Get an untainted version so file opens can be done. */
5441     message_id = string_copy_taint(message_id, GET_UNTAINTED);
5442
5443     spoolname = string_sprintf("%s-H", message_id);
5444     if ((deliver_datafile = spool_open_datafile(message_id)) < 0)
5445       printf ("Failed to load message datafile %s\n", message_id);
5446     if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
5447       printf ("Failed to load message %s\n", message_id);
5448     }
5449
5450   /* Read a test message from a file. We fudge it up to be on stdin, saving
5451   stdin itself for later reading of expansion strings. */
5452
5453   else if (expansion_test_message)
5454     {
5455     uschar * rme = expand_string(recipients_max);
5456     int save_stdin = dup(0);
5457     int fd = Uopen(expansion_test_message, O_RDONLY, 0);
5458     if (fd < 0)
5459       exim_fail("exim: failed to open %s: %s\n", expansion_test_message,
5460         strerror(errno));
5461     (void) dup2(fd, 0);
5462     filter_test = FTEST_USER;      /* Fudge to make it look like filter test */
5463     message_ended = END_NOTENDED;
5464     recipients_max_expanded = atoi(CCS rme);
5465     read_message_body(receive_msg(extract_recipients));
5466     message_linecount += body_linecount;
5467     (void)dup2(save_stdin, 0);
5468     (void)close(save_stdin);
5469     clearerr(stdin);               /* Required by Darwin */
5470     }
5471
5472   /* Only admin users may see config-file macros this way */
5473
5474   if (!f.admin_user) macros_user = macros = mlast = NULL;
5475
5476   /* Allow $recipients for this testing */
5477
5478   f.enable_dollar_recipients = TRUE;
5479
5480   /* Expand command line items */
5481
5482   if (recipients_arg < argc)
5483     while (recipients_arg < argc)
5484       expansion_test_line(exim_str_fail_toolong(argv[recipients_arg++], EXIM_EMAILADDR_MAX, "recipient"));
5485
5486   /* Read stdin */
5487
5488   else
5489     {
5490     char *(*fn_readline)(const char *) = NULL;
5491     void (*fn_addhist)(const char *) = NULL;
5492     uschar * s;
5493
5494 #ifdef USE_READLINE
5495     void *dlhandle = set_readline(&fn_readline, &fn_addhist);
5496 #endif
5497
5498     while (s = get_stdinput(fn_readline, fn_addhist))
5499       expansion_test_line(s);
5500
5501 #ifdef USE_READLINE
5502     if (dlhandle) dlclose(dlhandle);
5503 #endif
5504     }
5505
5506   /* The data file will be open after -Mset */
5507
5508   if (deliver_datafile >= 0)
5509     {
5510     (void)close(deliver_datafile);
5511     deliver_datafile = -1;
5512     }
5513
5514   exim_exit(EXIT_SUCCESS);
5515   }
5516
5517
5518 /* The active host name is normally the primary host name, but it can be varied
5519 for hosts that want to play several parts at once. We need to ensure that it is
5520 set for host checking, and for receiving messages. */
5521
5522 smtp_active_hostname = primary_hostname;
5523 GET_OPTION("smtp_active_hostname");
5524 if (raw_active_hostname)
5525   {
5526   uschar * nah = expand_string(raw_active_hostname);
5527   if (!nah)
5528     {
5529     if (!f.expand_string_forcedfail)
5530       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand \"%s\" "
5531         "(smtp_active_hostname): %s", raw_active_hostname,
5532         expand_string_message);
5533     }
5534   else if (nah[0]) smtp_active_hostname = nah;
5535   }
5536
5537 /* Handle host checking: this facility mocks up an incoming SMTP call from a
5538 given IP address so that the blocking and relay configuration can be tested.
5539 Unless a sender_ident was set by -oMt, we discard it (the default is the
5540 caller's login name). An RFC 1413 call is made only if we are running in the
5541 test harness and an incoming interface and both ports are specified, because
5542 there is no TCP/IP call to find the ident for. */
5543
5544 if (host_checking)
5545   {
5546   int x[4];
5547   int size;
5548
5549   if (!sender_ident_set)
5550     {
5551     sender_ident = NULL;
5552     if (f.running_in_test_harness && sender_host_port
5553        && interface_address && interface_port)
5554       verify_get_ident(1223);           /* note hardwired port number */
5555     }
5556
5557   /* In case the given address is a non-canonical IPv6 address, canonicalize
5558   it. Use the compressed form for IPv6. */
5559
5560   size = host_aton(sender_host_address, x);
5561   sender_host_address = store_get(48, GET_UNTAINTED);  /* large enough for full IPv6 */
5562   if (size == 1)
5563     (void) host_nmtoa(size, x, -1, sender_host_address, ':');
5564   else
5565     (void) ipv6_nmtoa(x, sender_host_address);
5566
5567   /* Now set up for testing */
5568
5569   host_build_sender_fullhost();
5570   smtp_input = TRUE;
5571   smtp_in = stdin;
5572   smtp_out = stdout;
5573   f.sender_local = FALSE;
5574   f.sender_host_notsocket = TRUE;
5575   debug_file = stderr;
5576   debug_fd = fileno(debug_file);
5577   fprintf(stdout, "\n**** SMTP testing session as if from host %s\n"
5578     "**** but without any ident (RFC 1413) callback.\n"
5579     "**** This is not for real!\n\n",
5580       sender_host_address);
5581
5582   set_connection_id();
5583   memset(sender_host_cache, 0, sizeof(sender_host_cache));
5584   if (verify_check_host(&hosts_connection_nolog) == OK)
5585     {
5586     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
5587     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_no_mail);
5588     }
5589   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
5590
5591   /* NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,
5592   because a log line has already been written for all its failure exists
5593   (usually "connection refused: <reason>") and writing another one is
5594   unnecessary clutter. */
5595
5596   if (smtp_start_session())
5597     {
5598     rmark reset_point;
5599     for (; (reset_point = store_mark()); store_reset(reset_point))
5600       {
5601       if (smtp_setup_msg() <= 0) break;
5602       if (!receive_msg(FALSE)) break;
5603
5604       return_path = sender_address = NULL;
5605       dnslist_domain = dnslist_matched = NULL;
5606 #ifndef DISABLE_DKIM
5607       dkim_cur_signer = NULL;
5608 #endif
5609       acl_var_m = NULL;
5610       deliver_localpart_orig = NULL;
5611       deliver_domain_orig = NULL;
5612       callout_address = sending_ip_address = NULL;
5613       deliver_localpart_data = deliver_domain_data =
5614       recipient_data = sender_data = NULL;
5615       sender_rate = sender_rate_limit = sender_rate_period = NULL;
5616       }
5617     smtp_log_no_mail();
5618     }
5619   exim_exit(EXIT_SUCCESS);
5620   }
5621
5622
5623 /* Arrange for message reception if recipients or SMTP were specified;
5624 otherwise complain unless a version print (-bV) happened or this is a filter
5625 verification test or info dump.
5626 In the former case, show the configuration file name. */
5627
5628 if (recipients_arg >= argc && !extract_recipients && !smtp_input)
5629   {
5630   if (version_printed)
5631     {
5632     if (Ustrchr(config_main_filelist, ':'))
5633       printf("Configuration file search path is %s\n", config_main_filelist);
5634     printf("Configuration file is %s\n", config_main_filename);
5635     return EXIT_SUCCESS;
5636     }
5637
5638   if (info_flag != CMDINFO_NONE)
5639     {
5640     show_exim_information(info_flag, info_stdout ? stdout : stderr);
5641     return info_stdout ? EXIT_SUCCESS : EXIT_FAILURE;
5642     }
5643
5644   if (filter_test == FTEST_NONE)
5645     exim_usage(called_as);
5646   }
5647
5648
5649 /* If mua_wrapper is set, Exim is being used to turn an MUA that submits on the
5650 standard input into an MUA that submits to a smarthost over TCP/IP. We know
5651 that we are not called from inetd, because that is rejected above. The
5652 following configuration settings are forced here:
5653
5654   (1) Synchronous delivery (-odi)
5655   (2) Errors to stderr (-oep == -oeq)
5656   (3) No parallel remote delivery
5657   (4) Unprivileged delivery
5658
5659 We don't force overall queueing options because there are several of them;
5660 instead, queueing is avoided below when mua_wrapper is set. However, we do need
5661 to override any SMTP queueing. */
5662
5663 if (mua_wrapper)
5664   {
5665   f.synchronous_delivery = TRUE;
5666   arg_error_handling = ERRORS_STDERR;
5667   remote_max_parallel = 1;
5668   deliver_drop_privilege = TRUE;
5669   f.queue_smtp = FALSE;
5670   queue_smtp_domains = NULL;
5671 #ifdef SUPPORT_I18N
5672   message_utf8_downconvert = -1;        /* convert-if-needed */
5673 #endif
5674   }
5675
5676
5677 /* Prepare to accept one or more new messages on the standard input. When a
5678 message has been read, its id is returned in message_id[]. If doing immediate
5679 delivery, we fork a delivery process for each received message, except for the
5680 last one, where we can save a process switch.
5681
5682 It is only in non-smtp mode that error_handling is allowed to be changed from
5683 its default of ERRORS_SENDER by argument. (Idle thought: are any of the
5684 sendmail error modes other than -oem ever actually used? Later: yes.) */
5685
5686 if (!smtp_input) error_handling = arg_error_handling;
5687
5688 /* If this is an inetd call, ensure that stderr is closed to prevent panic
5689 logging being sent down the socket and make an identd call to get the
5690 sender_ident. */
5691
5692 else if (f.is_inetd)
5693   {
5694   (void)fclose(stderr);
5695   exim_nullstd();                       /* Re-open to /dev/null */
5696   verify_get_ident(IDENT_PORT);
5697   host_build_sender_fullhost();
5698   set_process_info("handling incoming connection from %s via inetd",
5699     sender_fullhost);
5700   }
5701
5702 /* If the sender host address has been set, build sender_fullhost if it hasn't
5703 already been done (which it will have been for inetd). This caters for the
5704 case when it is forced by -oMa. However, we must flag that it isn't a socket,
5705 so that the test for IP options is skipped for -bs input. */
5706
5707 if (sender_host_address && !sender_fullhost)
5708   {
5709   host_build_sender_fullhost();
5710   set_process_info("handling incoming connection from %s via -oMa",
5711     sender_fullhost);
5712   f.sender_host_notsocket = TRUE;
5713   }
5714
5715 /* Otherwise, set the sender host as unknown except for inetd calls. This
5716 prevents host checking in the case of -bs not from inetd and also for -bS. */
5717
5718 else if (!f.is_inetd) f.sender_host_unknown = TRUE;
5719
5720 /* If stdout does not exist, then dup stdin to stdout. This can happen
5721 if exim is started from inetd. In this case fd 0 will be set to the socket,
5722 but fd 1 will not be set. This also happens for passed SMTP channels. */
5723
5724 if (fstat(1, &statbuf) < 0) (void)dup2(0, 1);
5725
5726 /* Set up the incoming protocol name and the state of the program. Root is
5727 allowed to force received protocol via the -oMr option above. If we have come
5728 via inetd, the process info has already been set up. We don't set
5729 received_protocol here for smtp input, as it varies according to
5730 batch/HELO/EHLO/AUTH/TLS. */
5731
5732 if (smtp_input)
5733   {
5734   if (!f.is_inetd) set_process_info("accepting a local %sSMTP message from <%s>",
5735     smtp_batched_input? "batched " : "",
5736     sender_address ? sender_address : originator_login);
5737   }
5738 else
5739   {
5740   int old_pool = store_pool;
5741   store_pool = POOL_PERM;
5742   if (!received_protocol)
5743     received_protocol = string_sprintf("local%s", called_as);
5744   store_pool = old_pool;
5745   set_process_info("accepting a local non-SMTP message from <%s>",
5746     sender_address);
5747   }
5748
5749 /* Initialize the session_local_queue-only flag (this will be ignored if
5750 mua_wrapper is set) */
5751
5752 queue_check_only();
5753 session_local_queue_only = queue_only;
5754
5755 /* For non-SMTP and for batched SMTP input, check that there is enough space on
5756 the spool if so configured. On failure, we must not attempt to send an error
5757 message! (For interactive SMTP, the check happens at MAIL FROM and an SMTP
5758 error code is given.) */
5759
5760 if ((!smtp_input || smtp_batched_input) && !receive_check_fs(0))
5761   exim_fail("exim: insufficient disk space\n");
5762
5763 /* If this is smtp input of any kind, real or batched, handle the start of the
5764 SMTP session.
5765
5766 NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,
5767 because a log line has already been written for all its failure exists
5768 (usually "connection refused: <reason>") and writing another one is
5769 unnecessary clutter. */
5770
5771 set_connection_id();
5772 if (smtp_input)
5773   {
5774   smtp_in = stdin;
5775   smtp_out = stdout;
5776   memset(sender_host_cache, 0, sizeof(sender_host_cache));
5777   if (verify_check_host(&hosts_connection_nolog) == OK)
5778     {
5779     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
5780     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_no_mail);
5781     }
5782   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
5783   if (!smtp_start_session())
5784     {
5785     mac_smtp_fflush();
5786     exim_exit(EXIT_SUCCESS);
5787     }
5788   }
5789
5790 /* Otherwise, set up the input size limit here and set no stdin stdio buffer
5791 (we handle buferring so as to have visibility of fill level). */
5792
5793 else
5794   {
5795   GET_OPTION("message_size_limit");
5796   thismessage_size_limit = expand_string_integer(message_size_limit, TRUE);
5797   if (expand_string_message)
5798     if (thismessage_size_limit == -1)
5799       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand "
5800         "message_size_limit: %s", expand_string_message);
5801     else
5802       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "invalid value for "
5803         "message_size_limit: %s", expand_string_message);
5804
5805   setvbuf(stdin, NULL, _IONBF, 0);
5806   }
5807
5808 /* Loop for several messages when reading SMTP input. If we fork any child
5809 processes, we don't want to wait for them unless synchronous delivery is
5810 requested, so set SIGCHLD to SIG_IGN in that case. This is not necessarily the
5811 same as SIG_DFL, despite the fact that documentation often lists the default as
5812 "ignore". This is a confusing area. This is what I know:
5813
5814 At least on some systems (e.g. Solaris), just setting SIG_IGN causes child
5815 processes that complete simply to go away without ever becoming defunct. You
5816 can't then wait for them - but we don't want to wait for them in the
5817 non-synchronous delivery case. However, this behaviour of SIG_IGN doesn't
5818 happen for all OS (e.g. *BSD is different).
5819
5820 But that's not the end of the story. Some (many? all?) systems have the
5821 SA_NOCLDWAIT option for sigaction(). This requests the behaviour that Solaris
5822 has by default, so it seems that the difference is merely one of default
5823 (compare restarting vs non-restarting signals).
5824
5825 To cover all cases, Exim sets SIG_IGN with SA_NOCLDWAIT here if it can. If not,
5826 it just sets SIG_IGN. To be on the safe side it also calls waitpid() at the end
5827 of the loop below. Paranoia rules.
5828
5829 February 2003: That's *still* not the end of the story. There are now versions
5830 of Linux (where SIG_IGN does work) that are picky. If, having set SIG_IGN, a
5831 process then calls waitpid(), a grumble is written to the system log, because
5832 this is logically inconsistent. In other words, it doesn't like the paranoia.
5833 As a consequence of this, the waitpid() below is now excluded if we are sure
5834 that SIG_IGN works. */
5835
5836 if (!f.synchronous_delivery)
5837   {
5838 #ifdef SA_NOCLDWAIT
5839   struct sigaction act;
5840   act.sa_handler = SIG_IGN;
5841   sigemptyset(&(act.sa_mask));
5842   act.sa_flags = SA_NOCLDWAIT;
5843   sigaction(SIGCHLD, &act, NULL);
5844 #else
5845   signal(SIGCHLD, SIG_IGN);
5846 #endif
5847   }
5848
5849 /* Save the current store pool point, for resetting at the start of
5850 each message, and save the real sender address, if any. */
5851
5852 real_sender_address = sender_address;
5853
5854 /* Loop to receive messages; receive_msg() returns TRUE if there are more
5855 messages to be read (SMTP input), or FALSE otherwise (not SMTP, or SMTP channel
5856 collapsed). */
5857
5858 for (BOOL more = TRUE; more; )
5859   {
5860   rmark reset_point = store_mark();
5861   message_id[0] = 0;
5862
5863   /* Handle the SMTP case; call smtp_setup_mst() to deal with the initial SMTP
5864   input and build the recipients list, before calling receive_msg() to read the
5865   message proper. Whatever sender address is given in the SMTP transaction is
5866   often ignored for local senders - we use the actual sender, which is normally
5867   either the underlying user running this process or a -f argument provided by
5868   a trusted caller. It is saved in real_sender_address. The test for whether to
5869   accept the SMTP sender is encapsulated in receive_check_set_sender(). */
5870
5871   if (smtp_input)
5872     {
5873     int rc;
5874     if ((rc = smtp_setup_msg()) > 0)
5875       {
5876       if (   real_sender_address
5877           && !receive_check_set_sender(sender_address))
5878         {
5879         sender_address = raw_sender = real_sender_address;
5880         sender_address_unrewritten = NULL;
5881         }
5882
5883       /* For batched SMTP, we have to run the acl_not_smtp_start ACL, since it
5884       isn't really SMTP, so no other ACL will run until the acl_not_smtp one at
5885       the very end. The result of the ACL is ignored (as for other non-SMTP
5886       messages). It is run for its potential side effects. */
5887
5888       if (smtp_batched_input)
5889         {
5890         GET_OPTION("acl_not_smtp_start");
5891         if (acl_not_smtp_start)
5892           {
5893           uschar * user_msg, * log_msg;
5894           f.enable_dollar_recipients = TRUE;
5895           (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
5896             &user_msg, &log_msg);
5897           f.enable_dollar_recipients = FALSE;
5898           }
5899         }
5900
5901       /* Now get the data for the message */
5902
5903       more = receive_msg(extract_recipients);
5904       if (!message_id[0])
5905         {
5906         cancel_cutthrough_connection(TRUE, US"receive dropped");
5907         if (more) goto MORELOOP;
5908         smtp_log_no_mail();               /* Log no mail if configured */
5909         exim_exit(EXIT_FAILURE);
5910         }
5911       }
5912     else
5913       {
5914       cancel_cutthrough_connection(TRUE, US"message setup dropped");
5915       smtp_log_no_mail();               /* Log no mail if configured */
5916       exim_exit(rc ? EXIT_FAILURE : EXIT_SUCCESS);
5917       }
5918     }
5919
5920   /* In the non-SMTP case, we have all the information from the command
5921   line, but must process it in case it is in the more general RFC822
5922   format, and in any case, to detect syntax errors. Also, it appears that
5923   the use of comma-separated lists as single arguments is common, so we
5924   had better support them. */
5925
5926   else
5927     {
5928     uschar * rme = expand_string(recipients_max);
5929     int rcount = 0, count = argc - recipients_arg;
5930     const uschar ** list = argv + recipients_arg;
5931
5932     recipients_max_expanded = atoi(CCS rme);
5933
5934     /* These options cannot be changed dynamically for non-SMTP messages */
5935
5936     f.active_local_sender_retain = local_sender_retain;
5937     f.active_local_from_check = local_from_check;
5938
5939     /* Save before any rewriting */
5940
5941     raw_sender = string_copy(sender_address);
5942
5943     /* Loop for each argument (supplied by user hence tainted) */
5944
5945     for (int i = 0; i < count; i++)
5946       {
5947       int start, end, domain;
5948       uschar * errmess;
5949       /* There can be multiple addresses, so EXIM_DISPLAYMAIL_MAX (tuned for 1) is too short.
5950       We'll still want to cap it to something, just in case. */
5951       uschar * s = string_copy_taint(
5952         exim_str_fail_toolong(list[i], BIG_BUFFER_SIZE, "address argument"),
5953         GET_TAINTED);
5954
5955       /* Loop for each comma-separated address */
5956
5957       while (*s)
5958         {
5959         BOOL finished = FALSE;
5960         uschar * recipient;
5961         uschar * ss = parse_find_address_end(s, FALSE);
5962
5963         if (*ss == ',') *ss = 0; else finished = TRUE;
5964
5965         /* Check max recipients - if -t was used, these aren't recipients */
5966
5967         if (  recipients_max_expanded > 0 && ++rcount > recipients_max_expanded
5968            && !extract_recipients)
5969           {
5970           DEBUG(D_all) debug_printf("excess reipients (max %d)\n",
5971             recipients_max_expanded);
5972
5973           if (error_handling == ERRORS_STDERR)
5974             {
5975             fprintf(stderr, "exim: too many recipients\n");
5976             exim_exit(EXIT_FAILURE);
5977             }
5978           else
5979             return
5980               moan_to_sender(ERRMESS_TOOMANYRECIP, NULL, NULL, stdin, TRUE)?
5981                 errors_sender_rc : EXIT_FAILURE;
5982           }
5983
5984 #ifdef SUPPORT_I18N
5985         {
5986         BOOL b = allow_utf8_domains;
5987         allow_utf8_domains = TRUE;
5988 #endif
5989         recipient =
5990           parse_extract_address(s, &errmess, &start, &end, &domain, FALSE);
5991
5992 #ifdef SUPPORT_I18N
5993         if (recipient)
5994           if (string_is_utf8(recipient)) message_smtputf8 = TRUE;
5995           else allow_utf8_domains = b;
5996         }
5997 #else
5998         ;
5999 #endif
6000         if (domain == 0 && !f.allow_unqualified_recipient)
6001           {
6002           recipient = NULL;
6003           errmess = US"unqualified recipient address not allowed";
6004           }
6005
6006         if (!recipient)
6007           {
6008           DEBUG(D_all) debug_printf("bad recipient address \"%s\": %s\n",
6009             string_printing(list[i]), errmess);
6010
6011           if (error_handling == ERRORS_STDERR)
6012             {
6013             fprintf(stderr, "exim: bad recipient address \"%s\": %s\n",
6014               string_printing(list[i]), errmess);
6015             exim_exit(EXIT_FAILURE);
6016             }
6017           else
6018             {
6019             error_block eblock;
6020             eblock.next = NULL;
6021             eblock.text1 = string_printing(list[i]);
6022             eblock.text2 = errmess;
6023             return
6024               moan_to_sender(ERRMESS_BADARGADDRESS, &eblock, NULL, stdin, TRUE)?
6025                 errors_sender_rc : EXIT_FAILURE;
6026             }
6027           }
6028
6029         receive_add_recipient(string_copy_taint(recipient, GET_TAINTED), -1);
6030         s = ss;
6031         if (!finished)
6032           while (*++s && (*s == ',' || isspace(*s)));
6033         }
6034       }
6035
6036     /* Show the recipients when debugging */
6037
6038     DEBUG(D_receive)
6039       {
6040       if (sender_address) debug_printf("Sender: %s\n", sender_address);
6041       if (recipients_list)
6042         {
6043         debug_printf("Recipients:\n");
6044         for (int i = 0; i < recipients_count; i++)
6045           debug_printf("  %s\n", recipients_list[i].address);
6046         }
6047       }
6048
6049     /* Run the acl_not_smtp_start ACL if required. The result of the ACL is
6050     ignored; rejecting here would just add complication, and it can just as
6051     well be done later. Allow $recipients to be visible in the ACL. */
6052
6053     GET_OPTION("acl_not_smtp_start");
6054     if (acl_not_smtp_start)
6055       {
6056       uschar * user_msg, * log_msg;
6057       f.enable_dollar_recipients = TRUE;
6058       (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
6059         &user_msg, &log_msg);
6060       f.enable_dollar_recipients = FALSE;
6061       }
6062
6063     /* Pause for a while waiting for input.  If none received in that time,
6064     close the logfile, if we had one open; then if we wait for a long-running
6065     datasource (months, in one use-case) log rotation will not leave us holding
6066     the file copy. */
6067
6068     if (!receive_timeout)
6069       if (poll_one_fd(0, POLLIN, 30*60*1000) == 0)      /* 30 minutes */
6070         mainlog_close();
6071
6072     /* Read the data for the message. If filter_test is not FTEST_NONE, this
6073     will just read the headers for the message, and not write anything onto the
6074     spool. */
6075
6076     message_ended = END_NOTENDED;
6077     more = receive_msg(extract_recipients);
6078
6079     /* more is always FALSE here (not SMTP message) when reading a message
6080     for real; when reading the headers of a message for filter testing,
6081     it is TRUE if the headers were terminated by '.' and FALSE otherwise. */
6082
6083     if (!message_id[0]) exim_exit(EXIT_FAILURE);
6084     }  /* Non-SMTP message reception */
6085
6086   /* If this is a filter testing run, there are headers in store, but
6087   no message on the spool. Run the filtering code in testing mode, setting
6088   the domain to the qualify domain and the local part to the current user,
6089   unless they have been set by options. The prefix and suffix are left unset
6090   unless specified. The the return path is set to to the sender unless it has
6091   already been set from a return-path header in the message. */
6092
6093   if (filter_test != FTEST_NONE)
6094     {
6095     deliver_domain = ftest_domain ? ftest_domain : qualify_domain_recipient;
6096     deliver_domain_orig = deliver_domain;
6097     deliver_localpart = ftest_localpart ? US ftest_localpart : originator_login;
6098     deliver_localpart_orig = deliver_localpart;
6099     deliver_localpart_prefix = US ftest_prefix;
6100     deliver_localpart_suffix = US ftest_suffix;
6101     deliver_home = originator_home;
6102
6103     if (!return_path)
6104       {
6105       printf("Return-path copied from sender\n");
6106       return_path = string_copy(sender_address);
6107       }
6108     else
6109       printf("Return-path = %s\n", (return_path[0] == 0)? US"<>" : return_path);
6110     printf("Sender      = %s\n", (sender_address[0] == 0)? US"<>" : sender_address);
6111
6112     receive_add_recipient(
6113       string_sprintf("%s%s%s@%s",
6114         ftest_prefix ? ftest_prefix : US"",
6115         deliver_localpart,
6116         ftest_suffix ? ftest_suffix : US"",
6117         deliver_domain), -1);
6118
6119     printf("Recipient   = %s\n", recipients_list[0].address);
6120     if (ftest_prefix) printf("Prefix    = %s\n", ftest_prefix);
6121     if (ftest_suffix) printf("Suffix    = %s\n", ftest_suffix);
6122
6123     if (chdir("/"))   /* Get away from wherever the user is running this from */
6124       {
6125       DEBUG(D_receive) debug_printf("chdir(\"/\") failed\n");
6126       exim_exit(EXIT_FAILURE);
6127       }
6128
6129     /* Now we run either a system filter test, or a user filter test, or both.
6130     In the latter case, headers added by the system filter will persist and be
6131     available to the user filter. We need to copy the filter variables
6132     explicitly. */
6133
6134     if (filter_test & FTEST_SYSTEM)
6135       if (!filter_runtest(filter_sfd, filter_test_sfile, TRUE, more))
6136         exim_exit(EXIT_FAILURE);
6137
6138     memcpy(filter_sn, filter_n, sizeof(filter_sn));
6139
6140     if (filter_test & FTEST_USER)
6141       if (!filter_runtest(filter_ufd, filter_test_ufile, FALSE, more))
6142         exim_exit(EXIT_FAILURE);
6143
6144     exim_exit(EXIT_SUCCESS);
6145     }
6146
6147   /* Else act on the result of message reception. We should not get here unless
6148   message_id[0] is non-zero. If queue_only is set, session_local_queue_only
6149   will be TRUE. If it is not, check on the number of messages received in this
6150   connection. */
6151
6152   if (  !session_local_queue_only
6153      && smtp_accept_queue_per_connection > 0
6154      && receive_messagecount > smtp_accept_queue_per_connection)
6155     {
6156     session_local_queue_only = TRUE;
6157     queue_only_reason = 2;
6158     }
6159
6160   /* Initialize local_queue_only from session_local_queue_only. If it is false,
6161   and queue_only_load is set, check that the load average is below it. If it is
6162   not, set local_queue_only TRUE. If queue_only_load_latch is true (the
6163   default), we put the whole session into queue_only mode. It then remains this
6164   way for any subsequent messages on the same SMTP connection. This is a
6165   deliberate choice; even though the load average may fall, it doesn't seem
6166   right to deliver later messages on the same call when not delivering earlier
6167   ones. However, there are odd cases where this is not wanted, so this can be
6168   changed by setting queue_only_load_latch false. */
6169
6170   if (!(local_queue_only = session_local_queue_only) && queue_only_load >= 0)
6171     if ((local_queue_only = (load_average = OS_GETLOADAVG()) > queue_only_load))
6172       {
6173       queue_only_reason = 3;
6174       if (queue_only_load_latch) session_local_queue_only = TRUE;
6175       }
6176
6177   /* If running as an MUA wrapper, all queueing options and freezing options
6178   are ignored. */
6179
6180   if (mua_wrapper)
6181     local_queue_only = f.queue_only_policy = f.deliver_freeze = FALSE;
6182
6183   /* Log the queueing here, when it will get a message id attached, but
6184   not if queue_only is set (case 0). Case 1 doesn't happen here (too many
6185   connections). */
6186
6187   if (local_queue_only)
6188     {
6189     cancel_cutthrough_connection(TRUE, US"no delivery; queueing");
6190     switch(queue_only_reason)
6191       {
6192       case 2:
6193         log_write(L_delay_delivery,
6194                 LOG_MAIN, "no immediate delivery: more than %d messages "
6195           "received in one connection", smtp_accept_queue_per_connection);
6196         break;
6197
6198       case 3:
6199         log_write(L_delay_delivery,
6200                 LOG_MAIN, "no immediate delivery: load average %.2f",
6201                 (double)load_average/1000.0);
6202       break;
6203       }
6204     }
6205
6206   else if (f.queue_only_policy || f.deliver_freeze)
6207     cancel_cutthrough_connection(TRUE, US"no delivery; queueing");
6208
6209   /* Else do the delivery unless the ACL or local_scan() called for queue only
6210   or froze the message. Always deliver in a separate process. A fork failure is
6211   not a disaster, as the delivery will eventually happen on a subsequent queue
6212   run. The search cache must be tidied before the fork, as the parent will
6213   do it before exiting. The child will trigger a lookup failure and
6214   thereby defer the delivery if it tries to use (for example) a cached ldap
6215   connection that the parent has called unbind on. */
6216
6217   else
6218     {
6219     pid_t pid;
6220     search_tidyup();
6221
6222     if ((pid = exim_fork(US"local-accept-delivery")) == 0)
6223       {
6224       int rc;
6225       close_unwanted();      /* Close unwanted file descriptors and TLS */
6226       exim_nullstd();        /* Ensure std{in,out,err} exist */
6227
6228       /* Re-exec Exim if we need to regain privilege (note: in mua_wrapper
6229       mode, deliver_drop_privilege is forced TRUE). */
6230
6231       if (geteuid() != root_uid && !deliver_drop_privilege && !unprivileged)
6232         {
6233         delivery_re_exec(CEE_EXEC_EXIT);
6234         /* Control does not return here. */
6235         }
6236
6237       /* No need to re-exec */
6238
6239       rc = deliver_message(message_id, FALSE, FALSE);
6240       search_tidyup();
6241       exim_underbar_exit(!mua_wrapper || rc == DELIVER_MUA_SUCCEEDED
6242         ? EXIT_SUCCESS : EXIT_FAILURE);
6243       }
6244
6245     if (pid < 0)
6246       {
6247       cancel_cutthrough_connection(TRUE, US"delivery fork failed");
6248       log_write(0, LOG_MAIN|LOG_PANIC, "failed to fork automatic delivery "
6249         "process: %s", strerror(errno));
6250       }
6251     else
6252       {
6253       release_cutthrough_connection(US"msg passed for delivery");
6254
6255       /* In the parent, wait if synchronous delivery is required. This will
6256       always be the case in MUA wrapper mode. */
6257
6258       if (f.synchronous_delivery)
6259         {
6260         int status;
6261         while (wait(&status) != pid);
6262         if ((status & 0x00ff) != 0)
6263           log_write(0, LOG_MAIN|LOG_PANIC,
6264             "process %d crashed with signal %d while delivering %s",
6265             (int)pid, status & 0x00ff, message_id);
6266         if (mua_wrapper && (status & 0xffff) != 0) exim_exit(EXIT_FAILURE);
6267         }
6268       }
6269     }
6270
6271   /* The loop will repeat if more is TRUE. If we do not know know that the OS
6272   automatically reaps children (see comments above the loop), clear away any
6273   finished subprocesses here, in case there are lots of messages coming in
6274   from the same source. */
6275
6276 #ifndef SIG_IGN_WORKS
6277   while (waitpid(-1, NULL, WNOHANG) > 0);
6278 #endif
6279
6280 MORELOOP:
6281   return_path = sender_address = NULL;
6282   authenticated_sender = NULL;
6283   deliver_localpart_orig = NULL;
6284   deliver_domain_orig = NULL;
6285   deliver_host = deliver_host_address = NULL;
6286   dnslist_domain = dnslist_matched = NULL;
6287 #ifdef WITH_CONTENT_SCAN
6288   malware_name = NULL;
6289   regex_vars_clear();
6290 #endif
6291   callout_address = NULL;
6292   sending_ip_address = NULL;
6293   deliver_localpart_data = deliver_domain_data =
6294   recipient_data = sender_data = NULL;
6295   acl_var_m = NULL;
6296   lookup_value = NULL;                            /* Can be set by ACL */
6297
6298   store_reset(reset_point);
6299   }
6300
6301 exim_exit(EXIT_SUCCESS);   /* Never returns */
6302 return 0;                  /* To stop compiler warning */
6303 }
6304
6305
6306 /* End of exim.c */
6307 /* vi: aw ai sw=2
6308 */