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 if (isupper(big_buffer[0]))
1810   {
1811   if (macro_read_assignment(big_buffer))
1812     printf("Defined macro '%s'\n", mlast->name);
1813   }
1814 else if (Ustrncmp(big_buffer, "set,t ", 6) == 0)
1815   printf("%s\n", acl_standalone_setvar(big_buffer+6, TRUE));
1816 else if (Ustrncmp(big_buffer, "set ", 4) == 0)
1817   printf("%s\n", acl_standalone_setvar(big_buffer+4, FALSE));
1818 else
1819   if ((s = expand_string(big_buffer))) printf("%s\n", CS s);
1820   else printf("Failed: %s\n", expand_string_message);
1821 }
1822
1823
1824
1825 /*************************************************
1826 *          Queue-runner operations               *
1827 *************************************************/
1828
1829 /* Prefix a new qrunner descriptor to the qrunners list */
1830
1831 static qrunner *
1832 alloc_qrunner(void)
1833 {
1834 qrunner * q = qrunners;
1835 qrunners = store_get(sizeof(qrunner), GET_UNTAINTED);
1836 memset(qrunners, 0, sizeof(qrunner));           /* default queue, zero interval */
1837 qrunners->next = q;
1838 qrunners->next_tick = time(NULL);               /* run right away */
1839 return qrunners;
1840 }
1841
1842 static qrunner *
1843 alloc_onetime_qrunner(void)
1844 {
1845 qrunners = store_get_perm(sizeof(qrunner), GET_UNTAINTED);
1846 memset(qrunners, 0, sizeof(qrunner));           /* default queue, zero interval */
1847 qrunners->next_tick = time(NULL);               /* run right away */
1848 qrunners->run_max = 1;
1849 return qrunners;
1850 }
1851
1852
1853 /*************************************************
1854 *          Entry point and high-level code       *
1855 *************************************************/
1856
1857 /* Entry point for the Exim mailer. Analyse the arguments and arrange to take
1858 the appropriate action. All the necessary functions are present in the one
1859 binary. I originally thought one should split it up, but it turns out that so
1860 much of the apparatus is needed in each chunk that one might as well just have
1861 it all available all the time, which then makes the coding easier as well.
1862
1863 Arguments:
1864   argc      count of entries in argv
1865   argv      argument strings, with argv[0] being the program name
1866
1867 Returns:    EXIT_SUCCESS if terminated successfully
1868             EXIT_FAILURE otherwise, except when a message has been sent
1869               to the sender, and -oee was given
1870 */
1871
1872 int
1873 main(int argc, char ** cargv)
1874 {
1875 const uschar ** argv = CUSS cargv;
1876 int  arg_receive_timeout = -1;
1877 int  arg_smtp_receive_timeout = -1;
1878 int  arg_error_handling = error_handling;
1879 int  filter_sfd = -1;
1880 int  filter_ufd = -1;
1881 int  group_count;
1882 int  i, rv;
1883 int  list_queue_option = QL_BASIC;
1884 int  msg_action = 0;
1885 int  msg_action_arg = -1;
1886 int  namelen = argv[0] ? Ustrlen(argv[0]) : 0;
1887 int  queue_only_reason = 0;
1888 #ifdef EXIM_PERL
1889 int  perl_start_option = 0;
1890 #endif
1891 int  recipients_arg = argc;
1892 int  sender_address_domain = 0;
1893 int  test_retry_arg = -1;
1894 int  test_rewrite_arg = -1;
1895 gid_t original_egid;
1896 BOOL arg_queue_only = FALSE;
1897 BOOL bi_option = FALSE;
1898 BOOL checking = FALSE;
1899 BOOL count_queue = FALSE;
1900 BOOL expansion_test = FALSE;
1901 BOOL extract_recipients = FALSE;
1902 BOOL flag_G = FALSE;
1903 BOOL flag_n = FALSE;
1904 BOOL forced_delivery = FALSE;
1905 BOOL f_end_dot = FALSE;
1906 BOOL deliver_give_up = FALSE;
1907 BOOL list_queue = FALSE;
1908 BOOL list_options = FALSE;
1909 BOOL list_config = FALSE;
1910 BOOL local_queue_only;
1911 BOOL one_msg_action = FALSE;
1912 BOOL opt_D_used = FALSE;
1913 BOOL queue_only_set = FALSE;
1914 BOOL receiving_message = TRUE;
1915 BOOL sender_ident_set = FALSE;
1916 BOOL session_local_queue_only;
1917 BOOL unprivileged;
1918 BOOL removed_privilege = FALSE;
1919 BOOL usage_wanted = FALSE;
1920 BOOL verify_address_mode = FALSE;
1921 BOOL verify_as_sender = FALSE;
1922 BOOL rcpt_verify_quota = FALSE;
1923 BOOL version_printed = FALSE;
1924 const uschar * alias_arg = NULL;
1925 const uschar * called_as = US"";
1926 const uschar * cmdline_syslog_name = NULL;
1927 const uschar * start_queue_run_id = NULL;
1928 const uschar * stop_queue_run_id = NULL;
1929 const uschar * expansion_test_message = NULL;
1930 const uschar * ftest_domain = NULL;
1931 const uschar * ftest_localpart = NULL;
1932 const uschar * ftest_prefix = NULL;
1933 const uschar * ftest_suffix = NULL;
1934 uschar * log_oneline = NULL;
1935 const uschar * malware_test_file = NULL;
1936 const uschar * real_sender_address;
1937 uschar * originator_home = US"/";
1938 size_t sz;
1939
1940 struct passwd *pw;
1941 struct stat statbuf;
1942 pid_t passed_qr_pid = (pid_t)0;
1943 int passed_qr_pipe = -1;
1944 gid_t group_list[EXIM_GROUPLIST_SIZE];
1945
1946 /* For the -bI: flag */
1947 enum commandline_info info_flag = CMDINFO_NONE;
1948 BOOL info_stdout = FALSE;
1949
1950 /* Possible options for -R and -S */
1951
1952 static uschar *rsopts[] = { US"f", US"ff", US"r", US"rf", US"rff" };
1953
1954 /* Need to define this in case we need to change the environment in order
1955 to get rid of a bogus time zone. We have to make it char rather than uschar
1956 because some OS define it in /usr/include/unistd.h. */
1957
1958 extern char **environ;
1959
1960 #ifdef MEASURE_TIMING
1961 (void)gettimeofday(&timestamp_startup, NULL);
1962 #endif
1963
1964 store_init();   /* Initialise the memory allocation susbsystem */
1965 pcre_init();    /* Set up memory handling for pcre */
1966
1967 /* If the Exim user and/or group and/or the configuration file owner/group were
1968 defined by ref:name at build time, we must now find the actual uid/gid values.
1969 This is a feature to make the lives of binary distributors easier. */
1970
1971 #ifdef EXIM_USERNAME
1972 if (route_finduser(US EXIM_USERNAME, &pw, &exim_uid))
1973   {
1974   if (exim_uid == 0)
1975     exim_fail("exim: refusing to run with uid 0 for \"%s\"\n", EXIM_USERNAME);
1976
1977   /* If ref:name uses a number as the name, route_finduser() returns
1978   TRUE with exim_uid set and pw coerced to NULL. */
1979   if (pw)
1980     exim_gid = pw->pw_gid;
1981 #ifndef EXIM_GROUPNAME
1982   else
1983     exim_fail(
1984         "exim: ref:name should specify a usercode, not a group.\n"
1985         "exim: can't let you get away with it unless you also specify a group.\n");
1986 #endif
1987   }
1988 else
1989   exim_fail("exim: failed to find uid for user name \"%s\"\n", EXIM_USERNAME);
1990 #endif
1991
1992 #ifdef EXIM_GROUPNAME
1993 if (!route_findgroup(US EXIM_GROUPNAME, &exim_gid))
1994   exim_fail("exim: failed to find gid for group name \"%s\"\n", EXIM_GROUPNAME);
1995 #endif
1996
1997 #ifdef CONFIGURE_OWNERNAME
1998 if (!route_finduser(US CONFIGURE_OWNERNAME, NULL, &config_uid))
1999   exim_fail("exim: failed to find uid for user name \"%s\"\n",
2000     CONFIGURE_OWNERNAME);
2001 #endif
2002
2003 /* We default the system_filter_user to be the Exim run-time user, as a
2004 sane non-root value. */
2005 system_filter_uid = exim_uid;
2006
2007 #ifdef CONFIGURE_GROUPNAME
2008 if (!route_findgroup(US CONFIGURE_GROUPNAME, &config_gid))
2009   exim_fail("exim: failed to find gid for group name \"%s\"\n",
2010     CONFIGURE_GROUPNAME);
2011 #endif
2012
2013 /* In the Cygwin environment, some initialization used to need doing.
2014 It was fudged in by means of this macro; now no longer but we'll leave
2015 it in case of others. */
2016
2017 #ifdef OS_INIT
2018 OS_INIT
2019 #endif
2020
2021 /* Check a field which is patched when we are running Exim within its
2022 testing harness; do a fast initial check, and then the whole thing. */
2023
2024 f.running_in_test_harness =
2025   *running_status == '<' && Ustrcmp(running_status, "<<<testing>>>") == 0;
2026 if (f.running_in_test_harness)
2027   debug_store = TRUE;
2028
2029 /* Protect against abusive argv[0] */
2030 if (!argv[0] || !argc) exim_fail("exim: executable name required\n");
2031 exim_str_fail_toolong(argv[0], PATH_MAX, "argv[0]");
2032
2033 /* The C standard says that the equivalent of setlocale(LC_ALL, "C") is obeyed
2034 at the start of a program; however, it seems that some environments do not
2035 follow this. A "strange" locale can affect the formatting of timestamps, so we
2036 make quite sure. */
2037
2038 setlocale(LC_ALL, "C");
2039
2040 /* Get the offset between CLOCK_MONOTONIC/CLOCK_BOOTTIME and wallclock */
2041
2042 #ifdef _POSIX_MONOTONIC_CLOCK
2043 exim_clock_init();
2044 #endif
2045
2046 /* Set up the default handler for timing using alarm(). */
2047
2048 os_non_restarting_signal(SIGALRM, sigalrm_handler);
2049
2050 /* Ensure we have a buffer for constructing log entries. Use malloc directly,
2051 because store_malloc writes a log entry on failure. */
2052
2053 if (!(log_buffer = US malloc(LOG_BUFFER_SIZE)))
2054   exim_fail("exim: failed to get store for log buffer\n");
2055
2056 /* Initialize the default log options. */
2057
2058 bits_set(log_selector, log_selector_size, log_default);
2059
2060 /* Set log_stderr to stderr, provided that stderr exists. This gets reset to
2061 NULL when the daemon is run and the file is closed. We have to use this
2062 indirection, because some systems don't allow writing to the variable "stderr".
2063 */
2064
2065 if (fstat(fileno(stderr), &statbuf) >= 0) log_stderr = stderr;
2066
2067 /* Ensure there is a big buffer for temporary use in several places. It is put
2068 in malloc store so that it can be freed for enlargement if necessary. */
2069
2070 big_buffer = store_malloc(big_buffer_size);
2071
2072 /* Set up the handler for the data request signal, and set the initial
2073 descriptive text. */
2074
2075 process_info = store_get(PROCESS_INFO_SIZE, GET_TAINTED);
2076 set_process_info("initializing");
2077 os_restarting_signal(SIGUSR1, usr1_handler);            /* exiwhat */
2078 #ifdef SA_SIGINFO
2079   {
2080   struct sigaction act = { .sa_sigaction = segv_handler, .sa_flags = SA_RESETHAND | SA_SIGINFO };
2081   sigaction(SIGSEGV, &act, NULL);
2082   }
2083 #else
2084 signal(SIGSEGV, segv_handler);                          /* log faults */
2085 #endif
2086
2087 /* If running in a dockerized environment, the TERM signal is only
2088 delegated to the PID 1 if we request it by setting an signal handler */
2089
2090 if (getpid() == 1) signal(SIGTERM, term_handler);
2091
2092 /* SIGHUP is used to get the daemon to reconfigure. It gets set as appropriate
2093 in the daemon code. For the rest of Exim's uses, we ignore it. */
2094
2095 signal(SIGHUP, SIG_IGN);
2096
2097 /* We don't want to die on pipe errors as the code is written to handle
2098 the write error instead. */
2099
2100 signal(SIGPIPE, SIG_IGN);
2101
2102 /* Under some circumstance on some OS, Exim can get called with SIGCHLD
2103 set to SIG_IGN. This causes subprocesses that complete before the parent
2104 process waits for them not to hang around, so when Exim calls wait(), nothing
2105 is there. The wait() code has been made robust against this, but let's ensure
2106 that SIGCHLD is set to SIG_DFL, because it's tidier to wait and get a process
2107 ending status. We use sigaction rather than plain signal() on those OS where
2108 SA_NOCLDWAIT exists, because we want to be sure it is turned off. (There was a
2109 problem on AIX with this.) */
2110
2111 #ifdef SA_NOCLDWAIT
2112   {
2113   struct sigaction act;
2114   act.sa_handler = SIG_DFL;
2115   sigemptyset(&(act.sa_mask));
2116   act.sa_flags = 0;
2117   sigaction(SIGCHLD, &act, NULL);
2118   }
2119 #else
2120 signal(SIGCHLD, SIG_DFL);
2121 #endif
2122
2123 /* Save the arguments for use if we re-exec exim as a daemon after receiving
2124 SIGHUP. */
2125
2126 sighup_argv = argv;
2127
2128 /* Set up the version number. Set up the leading 'E' for the external form of
2129 message ids, set the pointer to the internal form, and initialize it to
2130 indicate no message being processed. */
2131
2132 version_init();
2133 message_id_option[0] = '-';
2134 message_id_external = message_id_option + 1;
2135 message_id_external[0] = 'E';
2136 message_id = message_id_external + 1;
2137 message_id[0] = 0;
2138
2139 /* Set the umask to zero so that any files Exim creates using open() are
2140 created with the modes that it specifies. NOTE: Files created with fopen() have
2141 a problem, which was not recognized till rather late (February 2006). With this
2142 umask, such files will be world writeable. (They are all content scanning files
2143 in the spool directory, which isn't world-accessible, so this is not a
2144 disaster, but it's untidy.) I don't want to change this overall setting,
2145 however, because it will interact badly with the open() calls. Instead, there's
2146 now a function called modefopen() that fiddles with the umask while calling
2147 fopen(). */
2148
2149 (void)umask(0);
2150
2151 /* Precompile the regular expression for matching a message id. Keep this in
2152 step with the code that generates ids in the accept.c module. We need to do
2153 this here, because the -M options check their arguments for syntactic validity
2154 using mac_ismsgid, which uses this. */
2155
2156 regex_ismsgid =
2157   regex_must_compile(US"^(?:"
2158           "[^\\W_]{" str(MESSAGE_ID_TIME_LEN) "}"
2159           "-[^\\W_]{" str(MESSAGE_ID_PID_LEN) "}"
2160           "-[^\\W_]{" str(MESSAGE_ID_SUBTIME_LEN) "}"
2161         "|"
2162           "(?:[^\\W_]{6}-){2}[^\\W_]{2}"                /* old ID format */
2163         ")$",
2164     MCS_NOFLAGS, TRUE);
2165
2166 /* Precompile the regular expression that is used for matching an SMTP error
2167 code, possibly extended, at the start of an error message. Note that the
2168 terminating whitespace character is included. */
2169
2170 regex_smtp_code =
2171   regex_must_compile(US"^\\d\\d\\d\\s(?:\\d\\.\\d\\d?\\d?\\.\\d\\d?\\d?\\s)?",
2172     MCS_NOFLAGS, TRUE);
2173
2174 #ifdef WHITELIST_D_MACROS
2175 /* Precompile the regular expression used to filter the content of macros
2176 given to -D for permissibility. */
2177
2178 regex_whitelisted_macro =
2179   regex_must_compile(US"^[A-Za-z0-9_/.-]*$", MCS_NOFLAGS, TRUE);
2180 #endif
2181
2182 /* If the program is called as "mailq" treat it as equivalent to "exim -bp";
2183 this seems to be a generally accepted convention, since one finds symbolic
2184 links called "mailq" in standard OS configurations. */
2185
2186 if ((namelen == 5 && Ustrcmp(argv[0], "mailq") == 0) ||
2187     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/mailq", 6) == 0))
2188   {
2189   list_queue = TRUE;
2190   receiving_message = FALSE;
2191   called_as = US"-mailq";
2192   }
2193
2194 /* If the program is called as "rmail" treat it as equivalent to
2195 "exim -i -oee", thus allowing UUCP messages to be input using non-SMTP mode,
2196 i.e. preventing a single dot on a line from terminating the message, and
2197 returning with zero return code, even in cases of error (provided an error
2198 message has been sent). */
2199
2200 if ((namelen == 5 && Ustrcmp(argv[0], "rmail") == 0) ||
2201     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rmail", 6) == 0))
2202   {
2203   f.dot_ends = FALSE;
2204   called_as = US"-rmail";
2205   errors_sender_rc = EXIT_SUCCESS;
2206   }
2207
2208 /* If the program is called as "rsmtp" treat it as equivalent to "exim -bS";
2209 this is a smail convention. */
2210
2211 if ((namelen == 5 && Ustrcmp(argv[0], "rsmtp") == 0) ||
2212     (namelen  > 5 && Ustrncmp(argv[0] + namelen - 6, "/rsmtp", 6) == 0))
2213   {
2214   smtp_input = smtp_batched_input = TRUE;
2215   called_as = US"-rsmtp";
2216   }
2217
2218 /* If the program is called as "runq" treat it as equivalent to "exim -q";
2219 this is a smail convention. */
2220
2221 if ((namelen == 4 && Ustrcmp(argv[0], "runq") == 0) ||
2222     (namelen  > 4 && Ustrncmp(argv[0] + namelen - 5, "/runq", 5) == 0))
2223   {
2224   alloc_onetime_qrunner();
2225   receiving_message = FALSE;
2226   called_as = US"-runq";
2227   }
2228
2229 /* If the program is called as "newaliases" treat it as equivalent to
2230 "exim -bi"; this is a sendmail convention. */
2231
2232 if ((namelen == 10 && Ustrcmp(argv[0], "newaliases") == 0) ||
2233     (namelen  > 10 && Ustrncmp(argv[0] + namelen - 11, "/newaliases", 11) == 0))
2234   {
2235   bi_option = TRUE;
2236   receiving_message = FALSE;
2237   called_as = US"-newaliases";
2238   }
2239
2240 /* Save the original effective uid for a couple of uses later. It should
2241 normally be root, but in some esoteric environments it may not be. */
2242
2243 original_euid = geteuid();
2244 original_egid = getegid();
2245
2246 /* Get the real uid and gid. If the caller is root, force the effective uid/gid
2247 to be the same as the real ones. This makes a difference only if Exim is setuid
2248 (or setgid) to something other than root, which could be the case in some
2249 special configurations. */
2250
2251 real_uid = getuid();
2252 real_gid = getgid();
2253
2254 if (real_uid == root_uid)
2255   {
2256   if ((rv = setgid(real_gid)))
2257     exim_fail("exim: setgid(%ld) failed: %s\n",
2258         (long int)real_gid, strerror(errno));
2259   if ((rv = setuid(real_uid)))
2260     exim_fail("exim: setuid(%ld) failed: %s\n",
2261         (long int)real_uid, strerror(errno));
2262   }
2263
2264 /* If neither the original real uid nor the original euid was root, Exim is
2265 running in an unprivileged state. */
2266
2267 unprivileged = (real_uid != root_uid && original_euid != root_uid);
2268
2269 /* For most of the args-parsing we need to use permanent pool memory */
2270  {
2271  int old_pool = store_pool;
2272  store_pool = POOL_PERM;
2273
2274 /* Scan the program's arguments. Some can be dealt with right away; others are
2275 simply recorded for checking and handling afterwards. Do a high-level switch
2276 on the second character (the one after '-'), to save some effort. */
2277
2278  for (i = 1; i < argc; i++)
2279   {
2280   BOOL badarg = FALSE;
2281   const uschar * arg = argv[i];
2282   const uschar * argrest;
2283   uschar switchchar;
2284
2285   /* An argument not starting with '-' is the start of a recipients list;
2286   break out of the options-scanning loop. */
2287
2288   if (arg[0] != '-')
2289     {
2290     recipients_arg = i;
2291     break;
2292     }
2293
2294   /* An option consisting of -- terminates the options */
2295
2296   if (Ustrcmp(arg, "--") == 0)
2297     {
2298     recipients_arg = i + 1;
2299     break;
2300     }
2301
2302   /* Handle flagged options */
2303
2304   switchchar = arg[1];
2305   argrest = arg+2;
2306
2307   /* Make all -ex options synonymous with -oex arguments, since that
2308   is assumed by various callers. Also make -qR options synonymous with -R
2309   options, as that seems to be required as well. Allow for -qqR too, and
2310   the same for -S options. */
2311
2312   if (Ustrncmp(arg+1, "oe", 2) == 0 ||
2313       Ustrncmp(arg+1, "qR", 2) == 0 ||
2314       Ustrncmp(arg+1, "qS", 2) == 0)
2315     {
2316     switchchar = arg[2];
2317     argrest++;
2318     }
2319   else if (Ustrncmp(arg+1, "qqR", 3) == 0 || Ustrncmp(arg+1, "qqS", 3) == 0)
2320     {
2321     switchchar = arg[3];
2322     argrest += 2;
2323     f.queue_2stage = TRUE;
2324     }
2325
2326   /* Make -r synonymous with -f, since it is a documented alias */
2327
2328   else if (arg[1] == 'r') switchchar = 'f';
2329
2330   /* Make -ov synonymous with -v */
2331
2332   else if (Ustrcmp(arg, "-ov") == 0)
2333     {
2334     switchchar = 'v';
2335     argrest++;
2336     }
2337
2338   /* deal with --option_aliases */
2339   else if (switchchar == '-')
2340     {
2341     if (Ustrcmp(argrest, "help") == 0)
2342       {
2343       usage_wanted = TRUE;
2344       break;
2345       }
2346     else if (Ustrcmp(argrest, "version") == 0)
2347       {
2348       switchchar = 'b';
2349       argrest = US"V";
2350       }
2351     }
2352
2353   /* High-level switch on active initial letter */
2354
2355   switch(switchchar)
2356     {
2357
2358     /* sendmail uses -Ac and -Am to control which .cf file is used;
2359     we ignore them. */
2360     case 'A':
2361     if (!*argrest) { badarg = TRUE; break; }
2362     else
2363       {
2364       BOOL ignore = FALSE;
2365       switch (*argrest)
2366         {
2367         case 'c':
2368         case 'm':
2369           if (*(argrest + 1) == '\0')
2370             ignore = TRUE;
2371           break;
2372         }
2373       if (!ignore) badarg = TRUE;
2374       }
2375     break;
2376
2377     /* -Btype is a sendmail option for 7bit/8bit setting. Exim is 8-bit clean
2378     so has no need of it. */
2379
2380     case 'B':
2381     if (!*argrest) i++;       /* Skip over the type */
2382     break;
2383
2384
2385     case 'b':
2386       {
2387       receiving_message = FALSE;    /* Reset TRUE for -bm, -bS, -bs below */
2388
2389       switch (*argrest++)
2390         {
2391         /* -bd:  Run in daemon mode, awaiting SMTP connections.
2392            -bdf: Ditto, but in the foreground.
2393         */
2394         case 'd':
2395           f.daemon_listen = f.daemon_scion = TRUE;
2396           if (*argrest == 'f') f.background_daemon = FALSE;
2397           else if (*argrest) badarg = TRUE;
2398           break;
2399
2400         /* -be:  Run in expansion test mode
2401            -bem: Ditto, but read a message from a file first
2402         */
2403         case 'e':
2404           expansion_test = checking = TRUE;
2405           if (*argrest == 'm')
2406             {
2407             if (++i >= argc) { badarg = TRUE; break; }
2408             expansion_test_message = argv[i];
2409             argrest++;
2410             }
2411           if (*argrest) badarg = TRUE;
2412           break;
2413
2414         /* -bF:  Run system filter test */
2415         case 'F':
2416           filter_test |= checking = FTEST_SYSTEM;
2417           if (*argrest) badarg = TRUE;
2418           else if (++i < argc) filter_test_sfile = argv[i];
2419           else exim_fail("exim: file name expected after %s\n", argv[i-1]);
2420           break;
2421
2422         /* -bf:  Run user filter test
2423            -bfd: Set domain for filter testing
2424            -bfl: Set local part for filter testing
2425            -bfp: Set prefix for filter testing
2426            -bfs: Set suffix for filter testing
2427         */
2428         case 'f':
2429           if (!*argrest)
2430             {
2431             filter_test |= checking = FTEST_USER;
2432             if (++i < argc) filter_test_ufile = argv[i];
2433             else exim_fail("exim: file name expected after %s\n", argv[i-1]);
2434             }
2435           else
2436             {
2437             if (++i >= argc)
2438               exim_fail("exim: string expected after %s\n", arg);
2439             if (Ustrcmp(argrest, "d") == 0) ftest_domain = exim_str_fail_toolong(argv[i], EXIM_DOMAINNAME_MAX, "-bfd");
2440             else if (Ustrcmp(argrest, "l") == 0) ftest_localpart = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfl");
2441             else if (Ustrcmp(argrest, "p") == 0) ftest_prefix = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfp");
2442             else if (Ustrcmp(argrest, "s") == 0) ftest_suffix = exim_str_fail_toolong(argv[i], EXIM_LOCALPART_MAX, "-bfs");
2443             else badarg = TRUE;
2444             }
2445           break;
2446
2447         /* -bh: Host checking - an IP address must follow. */
2448         case 'h':
2449           if (  (!*argrest || Ustrcmp(argrest, "c") == 0)
2450              && ++i < argc)
2451             {
2452             sender_host_address = string_copy_taint(
2453                   exim_str_fail_toolong(argv[i], EXIM_IPADDR_MAX, "-bh"),
2454                   GET_TAINTED);
2455             host_checking = checking = f.log_testing_mode = TRUE;
2456             f.host_checking_callout = *argrest == 'c';
2457             message_logs = FALSE;
2458             }
2459           else
2460             badarg = TRUE;
2461           break;
2462
2463         /* -bi: This option is used by sendmail to initialize *the* alias file,
2464         though it has the -oA option to specify a different file. Exim has no
2465         concept of *the* alias file, but since Sun's YP make script calls
2466         sendmail this way, some support must be provided. */
2467         case 'i':
2468           if (!*argrest) bi_option = TRUE;
2469           else badarg = TRUE;
2470           break;
2471
2472         /* -bI: provide information, of the type to follow after a colon.
2473         This is an Exim flag. */
2474         case 'I':
2475           if (Ustrlen(argrest) >= 1 && *argrest == ':')
2476             {
2477             const uschar * p = argrest+1;
2478             info_flag = CMDINFO_HELP;
2479             if (Ustrlen(p))
2480               if (strcmpic(p, CUS"sieve") == 0)
2481                 {
2482                 info_flag = CMDINFO_SIEVE;
2483                 info_stdout = TRUE;
2484                 }
2485               else if (strcmpic(p, CUS"dscp") == 0)
2486                 {
2487                 info_flag = CMDINFO_DSCP;
2488                 info_stdout = TRUE;
2489                 }
2490               else if (strcmpic(p, CUS"help") == 0)
2491                 info_stdout = TRUE;
2492             }
2493           else badarg = TRUE;
2494           break;
2495
2496         /* -bm: Accept and deliver message - the default option. Reinstate
2497         receiving_message, which got turned off for all -b options.
2498            -bmalware: test the filename given for malware */
2499         case 'm':
2500           if (!*argrest) receiving_message = TRUE;
2501           else if (Ustrcmp(argrest, "alware") == 0)
2502             {
2503             if (++i >= argc) { badarg = TRUE; break; }
2504             checking = TRUE;
2505             malware_test_file = argv[i];
2506             }
2507           else badarg = TRUE;
2508           break;
2509
2510         /* -bnq: For locally originating messages, do not qualify unqualified
2511         addresses. In the envelope, this causes errors; in header lines they
2512         just get left. */
2513         case 'n':
2514           if (Ustrcmp(argrest, "q") == 0)
2515             {
2516             f.allow_unqualified_sender = FALSE;
2517             f.allow_unqualified_recipient = FALSE;
2518             }
2519           else badarg = TRUE;
2520           break;
2521
2522         /* -bpxx: List the contents of the mail queue, in various forms. If
2523         the option is -bpc, just a queue count is needed. Otherwise, if the
2524         first letter after p is r, then order is random. */
2525         case 'p':
2526           if (*argrest == 'c')
2527             {
2528             count_queue = TRUE;
2529             if (*++argrest) badarg = TRUE;
2530             break;
2531             }
2532
2533           if (*argrest == 'r')
2534             list_queue_option = QL_UNSORTED, argrest++;
2535           else
2536             list_queue_option = QL_BASIC;
2537
2538           list_queue = TRUE;
2539
2540           /* -bp: List the contents of the mail queue, top-level only */
2541
2542           if (!*argrest) {}
2543
2544           /* -bpu: List the contents of the mail queue, top-level undelivered */
2545
2546           else if (Ustrcmp(argrest, "u") == 0) list_queue_option |= QL_UNDELIVERED_ONLY;
2547
2548           /* -bpa: List the contents of the mail queue, including all delivered */
2549
2550           else if (Ustrcmp(argrest, "a") == 0) list_queue_option |= QL_PLUS_GENERATED;
2551
2552           /* -bpi: List only message IDs */
2553
2554           else if (Ustrcmp(argrest, "i") == 0) list_queue_option |= QL_MSGID_ONLY;
2555
2556           /* Unknown after -bp[r] */
2557
2558           else badarg = TRUE;
2559           break;
2560
2561
2562         /* -bP: List the configuration variables given as the address list.
2563         Force -v, so configuration errors get displayed. */
2564         case 'P':
2565
2566           /* -bP config: we need to setup here, because later,
2567           when list_options is checked, the config is read already */
2568           if (*argrest)
2569             badarg = TRUE;
2570           else if (argv[i+1] && Ustrcmp(argv[i+1], "config") == 0)
2571             {
2572             list_config = TRUE;
2573             readconf_save_config(version_string);
2574             }
2575           else
2576             {
2577             list_options = TRUE;
2578             debug_selector |= D_v;
2579             debug_file = stderr;
2580             }
2581           break;
2582
2583         /* -brt: Test retry configuration lookup */
2584         case 'r':
2585           if (Ustrcmp(argrest, "t") == 0)
2586             {
2587             checking = TRUE;
2588             test_retry_arg = i + 1;
2589             goto END_ARG;
2590             }
2591
2592           /* -brw: Test rewrite configuration */
2593
2594           else if (Ustrcmp(argrest, "w") == 0)
2595             {
2596             checking = TRUE;
2597             test_rewrite_arg = i + 1;
2598             goto END_ARG;
2599             }
2600           else badarg = TRUE;
2601           break;
2602
2603         /* -bS: Read SMTP commands on standard input, but produce no replies -
2604         all errors are reported by sending messages. */
2605         case 'S':
2606           if (!*argrest)
2607             smtp_input = smtp_batched_input = receiving_message = TRUE;
2608           else badarg = TRUE;
2609           break;
2610
2611         /* -bs: Read SMTP commands on standard input and produce SMTP replies
2612         on standard output. */
2613         case 's':
2614           if (!*argrest) smtp_input = receiving_message = TRUE;
2615           else badarg = TRUE;
2616           break;
2617
2618         /* -bt: address testing mode */
2619         case 't':
2620           if (!*argrest)
2621             f.address_test_mode = checking = f.log_testing_mode = TRUE;
2622           else badarg = TRUE;
2623           break;
2624
2625         /* -bv: verify addresses */
2626         case 'v':
2627           if (!*argrest)
2628             verify_address_mode = checking = f.log_testing_mode = TRUE;
2629
2630         /* -bvs: verify sender addresses */
2631
2632           else if (Ustrcmp(argrest, "s") == 0)
2633             {
2634             verify_address_mode = checking = f.log_testing_mode = TRUE;
2635             verify_as_sender = TRUE;
2636             }
2637           else badarg = TRUE;
2638           break;
2639
2640         /* -bV: Print version string and support details */
2641         case 'V':
2642           if (!*argrest)
2643             {
2644             printf("Exim version %s #%s built %s\n", version_string,
2645               version_cnumber, version_date);
2646             printf("%s\n", CS version_copyright);
2647             version_printed = TRUE;
2648             show_whats_supported(TRUE);
2649             f.log_testing_mode = TRUE;
2650             }
2651           else badarg = TRUE;
2652           break;
2653
2654         /* -bw: inetd wait mode, accept a listening socket as stdin */
2655         case 'w':
2656           f.inetd_wait_mode = TRUE;
2657           f.background_daemon = FALSE;
2658           f.daemon_listen = f.daemon_scion = TRUE;
2659           if (*argrest)
2660             if ((inetd_wait_timeout = readconf_readtime(argrest, 0, FALSE)) <= 0)
2661               exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
2662           break;
2663
2664         default:
2665           badarg = TRUE;
2666           break;
2667         }
2668       break;
2669       }
2670
2671
2672     /* -C: change configuration file list; ignore if it isn't really
2673     a change! Enforce a prefix check if required. */
2674
2675     case 'C':
2676     if (!*argrest)
2677       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
2678     if (Ustrcmp(config_main_filelist, argrest) != 0)
2679       {
2680       #ifdef ALT_CONFIG_PREFIX
2681       int sep = 0;
2682       int len = Ustrlen(ALT_CONFIG_PREFIX);
2683       const uschar *list = argrest;
2684       uschar *filename;
2685       /* The argv is untainted, so big_buffer (also untainted) is ok to use */
2686       while((filename = string_nextinlist(&list, &sep, big_buffer,
2687              big_buffer_size)))
2688         if (  (  Ustrlen(filename) < len
2689               || Ustrncmp(filename, ALT_CONFIG_PREFIX, len) != 0
2690               || Ustrstr(filename, "/../") != NULL
2691               )
2692            && (Ustrcmp(filename, "/dev/null") != 0 || real_uid != root_uid)
2693            )
2694           exim_fail("-C Permission denied\n");
2695       #endif
2696       if (real_uid != root_uid)
2697         {
2698         #ifdef TRUSTED_CONFIG_LIST
2699
2700         if (real_uid != exim_uid
2701             #ifdef CONFIGURE_OWNER
2702             && real_uid != config_uid
2703             #endif
2704             )
2705           f.trusted_config = FALSE;
2706         else
2707           {
2708           FILE *trust_list = Ufopen(TRUSTED_CONFIG_LIST, "rb");
2709           if (trust_list)
2710             {
2711             struct stat statbuf;
2712
2713             if (fstat(fileno(trust_list), &statbuf) != 0 ||
2714                 (statbuf.st_uid != root_uid        /* owner not root */
2715                  #ifdef CONFIGURE_OWNER
2716                  && statbuf.st_uid != config_uid   /* owner not the special one */
2717                  #endif
2718                    ) ||                            /* or */
2719                 (statbuf.st_gid != root_gid        /* group not root */
2720                  #ifdef CONFIGURE_GROUP
2721                  && statbuf.st_gid != config_gid   /* group not the special one */
2722                  #endif
2723                  && (statbuf.st_mode & 020) != 0   /* group writeable */
2724                    ) ||                            /* or */
2725                 (statbuf.st_mode & 2) != 0)        /* world writeable */
2726               {
2727               f.trusted_config = FALSE;
2728               fclose(trust_list);
2729               }
2730             else
2731               {
2732               /* Well, the trust list at least is up to scratch... */
2733               rmark reset_point;
2734               uschar *trusted_configs[32];
2735               int nr_configs = 0;
2736               int i = 0;
2737               int old_pool = store_pool;
2738               store_pool = POOL_MAIN;
2739
2740               reset_point = store_mark();
2741               while (Ufgets(big_buffer, big_buffer_size, trust_list))
2742                 {
2743                 uschar * start = big_buffer, * nl;
2744                 if (Uskip_whitespace(&start) != '/')
2745                   continue;
2746                 if ((nl = Ustrchr(start, '\n')))
2747                   *nl = '\0';
2748                 trusted_configs[nr_configs++] = string_copy(start);
2749                 if (nr_configs == nelem(trusted_configs))
2750                   break;
2751                 }
2752               fclose(trust_list);
2753
2754               if (nr_configs)
2755                 {
2756                 int sep = 0;
2757                 const uschar *list = argrest;
2758                 uschar *filename;
2759                 while (f.trusted_config && (filename = string_nextinlist(&list,
2760                         &sep, big_buffer, big_buffer_size)))
2761                   {
2762                   for (i=0; i < nr_configs; i++)
2763                     if (Ustrcmp(filename, trusted_configs[i]) == 0)
2764                       break;
2765                   if (i == nr_configs)
2766                     {
2767                     f.trusted_config = FALSE;
2768                     break;
2769                     }
2770                   }
2771                 }
2772               else      /* No valid prefixes found in trust_list file. */
2773                 f.trusted_config = FALSE;
2774               store_reset(reset_point);
2775               store_pool = old_pool;
2776               }
2777             }
2778           else          /* Could not open trust_list file. */
2779             f.trusted_config = FALSE;
2780           }
2781       #else
2782         /* Not root; don't trust config */
2783         f.trusted_config = FALSE;
2784       #endif
2785         }
2786
2787       config_main_filelist = argrest;
2788       f.config_changed = TRUE;
2789       }
2790     break;
2791
2792
2793     /* -D: set up a macro definition */
2794
2795     case 'D':
2796 #ifdef DISABLE_D_OPTION
2797       exim_fail("exim: -D is not available in this Exim binary\n");
2798 #else
2799       {
2800       int ptr = 0;
2801       macro_item * m;
2802       uschar name[24];
2803       const uschar * s = argrest;
2804
2805       opt_D_used = TRUE;
2806       Uskip_whitespace(&s);
2807
2808       if (*s < 'A' || *s > 'Z')
2809         exim_fail("exim: macro name set by -D must start with "
2810           "an upper case letter\n");
2811
2812       while (isalnum(*s) || *s == '_')
2813         {
2814         if (ptr < sizeof(name)-1) name[ptr++] = *s;
2815         s++;
2816         }
2817       name[ptr] = 0;
2818       if (ptr == 0) { badarg = TRUE; break; }
2819       if (Uskip_whitespace(&s))
2820         {
2821         if (*s++ != '=') { badarg = TRUE; break; }
2822         Uskip_whitespace(&s);
2823         }
2824
2825       for (m = macros_user; m; m = m->next)
2826         if (Ustrcmp(m->name, name) == 0)
2827           exim_fail("exim: duplicated -D in command line\n");
2828
2829       m = macro_create(name, s, TRUE);
2830
2831       if (clmacro_count >= MAX_CLMACROS)
2832         exim_fail("exim: too many -D options on command line\n");
2833       clmacros[clmacro_count++] =
2834         string_sprintf("-D%s=%s", m->name, m->replacement);
2835       }
2836     #endif
2837     break;
2838
2839     case 'd':
2840
2841     /* -dropcr: Set this option.  Now a no-op, retained for compatibility only. */
2842
2843     if (Ustrcmp(argrest, "ropcr") == 0)
2844       {
2845       /* drop_cr = TRUE; */
2846       }
2847
2848     /* -dp: Set up a debug pretrigger buffer with given size. */
2849
2850     else if (Ustrcmp(argrest, "p") == 0)
2851       if (++i >= argc)
2852         badarg = TRUE;
2853       else
2854         debug_pretrigger_setup(argv[i]);
2855
2856     /* -dt: Set a debug trigger selector */
2857
2858     else if (Ustrncmp(argrest, "t=", 2) == 0)
2859       dtrigger_selector = (unsigned int) Ustrtol(argrest + 2, NULL, 0);
2860
2861     /* -d: Set debug level (see also -v below).
2862     If -dd is used, debugging subprocesses of the daemon is disabled. */
2863
2864     else
2865       {
2866       /* Use an intermediate variable so that we don't set debugging while
2867       decoding the debugging bits. */
2868
2869       unsigned int selector = D_default;
2870       debug_selector = 0;
2871       debug_file = NULL;
2872       if (*argrest == 'd')
2873         {
2874         f.debug_daemon = TRUE;
2875         argrest++;
2876         }
2877       if (*argrest)
2878         decode_bits(&selector, 1, debug_notall, argrest,
2879           debug_options, debug_options_count, US"debug", 0);
2880       debug_selector = selector;
2881       }
2882     break;
2883
2884
2885     /* -E: This is a local error message. This option is not intended for
2886     external use at all, but is not restricted to trusted callers because it
2887     does no harm (just suppresses certain error messages) and if Exim is run
2888     not setuid root it won't always be trusted when it generates error
2889     messages using this option. If there is a message id following -E, point
2890     message_reference at it, for logging. */
2891
2892     case 'E':
2893     f.local_error_message = TRUE;
2894     if (mac_ismsgid(argrest)) message_reference = argrest;
2895     break;
2896
2897
2898     /* -ex: The vacation program calls sendmail with the undocumented "-eq"
2899     option, so it looks as if historically the -oex options are also callable
2900     without the leading -o. So we have to accept them. Before the switch,
2901     anything starting -oe has been converted to -e. Exim does not support all
2902     of the sendmail error options. */
2903
2904     case 'e':
2905     if (Ustrcmp(argrest, "e") == 0)
2906       {
2907       arg_error_handling = ERRORS_SENDER;
2908       errors_sender_rc = EXIT_SUCCESS;
2909       }
2910     else if (Ustrcmp(argrest, "m") == 0) arg_error_handling = ERRORS_SENDER;
2911     else if (Ustrcmp(argrest, "p") == 0) arg_error_handling = ERRORS_STDERR;
2912     else if (Ustrcmp(argrest, "q") == 0) arg_error_handling = ERRORS_STDERR;
2913     else if (Ustrcmp(argrest, "w") == 0) arg_error_handling = ERRORS_SENDER;
2914     else badarg = TRUE;
2915     break;
2916
2917
2918     /* -F: Set sender's full name, used instead of the gecos entry from
2919     the password file. Since users can usually alter their gecos entries,
2920     there's no security involved in using this instead. The data can follow
2921     the -F or be in the next argument. */
2922
2923     case 'F':
2924     if (!*argrest)
2925       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
2926     originator_name = string_copy_taint(
2927                   exim_str_fail_toolong(argrest, EXIM_HUMANNAME_MAX, "-F"),
2928                   GET_TAINTED);
2929     f.sender_name_forced = TRUE;
2930     break;
2931
2932
2933     /* -f: Set sender's address - this value is only actually used if Exim is
2934     run by a trusted user, or if untrusted_set_sender is set and matches the
2935     address, except that the null address can always be set by any user. The
2936     test for this happens later, when the value given here is ignored when not
2937     permitted. For an untrusted user, the actual sender is still put in Sender:
2938     if it doesn't match the From: header (unless no_local_from_check is set).
2939     The data can follow the -f or be in the next argument. The -r switch is an
2940     obsolete form of -f but since there appear to be programs out there that
2941     use anything that sendmail has ever supported, better accept it - the
2942     synonymizing is done before the switch above.
2943
2944     At this stage, we must allow domain literal addresses, because we don't
2945     know what the setting of allow_domain_literals is yet. Ditto for trailing
2946     dots and strip_trailing_dot. */
2947
2948     case 'f':
2949       {
2950       int dummy_start, dummy_end;
2951       uschar *errmess;
2952       if (!*argrest)
2953         if (i+1 < argc) argrest = argv[++i]; else { badarg = TRUE; break; }
2954       (void) exim_str_fail_toolong(argrest, EXIM_DISPLAYMAIL_MAX, "-f");
2955       if (!*argrest)
2956         {
2957         uschar * s = store_get(1, GET_UNTAINTED);       /* Ensure writeable memory */
2958         *s = '\0';
2959         sender_address = s;
2960         }
2961       else
2962         {
2963         const uschar * temp = argrest + Ustrlen(argrest) - 1;
2964         while (temp >= argrest && isspace(*temp)) temp--;
2965         if (temp >= argrest && *temp == '.') f_end_dot = TRUE;
2966         allow_domain_literals = TRUE;
2967         strip_trailing_dot = TRUE;
2968 #ifdef SUPPORT_I18N
2969         allow_utf8_domains = TRUE;
2970 #endif
2971         if (!(sender_address = parse_extract_address(argrest, &errmess,
2972                   &dummy_start, &dummy_end, &sender_address_domain, TRUE)))
2973           exim_fail("exim: bad -f address \"%s\": %s\n", argrest, errmess);
2974
2975         sender_address = string_copy_taint(sender_address, GET_TAINTED);
2976 #ifdef SUPPORT_I18N
2977         message_smtputf8 =  string_is_utf8(sender_address);
2978         allow_utf8_domains = FALSE;
2979 #endif
2980         allow_domain_literals = FALSE;
2981         strip_trailing_dot = FALSE;
2982         }
2983       f.sender_address_forced = TRUE;
2984       }
2985     break;
2986
2987     /* -G: sendmail invocation to specify that it's a gateway submission and
2988     sendmail may complain about problems instead of fixing them.
2989     We make it equivalent to an ACL "control = suppress_local_fixups" and do
2990     not at this time complain about problems. */
2991
2992     case 'G':
2993     flag_G = TRUE;
2994     break;
2995
2996     /* -h: Set the hop count for an incoming message. Exim does not currently
2997     support this; it always computes it by counting the Received: headers.
2998     To put it in will require a change to the spool header file format. */
2999
3000     case 'h':
3001     if (!*argrest)
3002       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
3003     if (!isdigit(*argrest)) badarg = TRUE;
3004     break;
3005
3006
3007     /* -i: Set flag so dot doesn't end non-SMTP input (same as -oi, seems
3008     not to be documented for sendmail but mailx (at least) uses it) */
3009
3010     case 'i':
3011     if (!*argrest) f.dot_ends = FALSE; else badarg = TRUE;
3012     break;
3013
3014
3015     /* -L: set the identifier used for syslog; equivalent to setting
3016     syslog_processname in the config file, but needs to be an admin option. */
3017
3018     case 'L':
3019     if (!*argrest)
3020       if (++i < argc) argrest = argv[i]; else { badarg = TRUE; break; }
3021     if ((sz = Ustrlen(argrest)) > 32)
3022       exim_fail("exim: the -L syslog name is too long: \"%s\"\n", argrest);
3023     if (sz < 1)
3024       exim_fail("exim: the -L syslog name is too short\n");
3025     cmdline_syslog_name = string_copy_taint(argrest, GET_TAINTED);
3026     break;
3027
3028     case 'M':
3029     receiving_message = FALSE;
3030
3031     /* -MC:  continue delivery of another message via an existing open
3032     file descriptor. This option is used for an internal call by the
3033     smtp transport when there is a pending message waiting to go to an
3034     address to which it has got a connection. Five subsequent arguments are
3035     required: transport name, host name, IP address, sequence number, and
3036     message_id. Transports may decline to create new processes if the sequence
3037     number gets too big. The channel is stdin. This (-MC) must be the last
3038     argument. There's a subsequent check that the real-uid is privileged.
3039
3040     If we are running in the test harness. delay for a bit, to let the process
3041     that set this one up complete. This makes for repeatability of the logging,
3042     etc. output. */
3043
3044     if (Ustrcmp(argrest, "C") == 0)
3045       {
3046       union sockaddr_46 interface_sock;
3047       EXIM_SOCKLEN_T size = sizeof(interface_sock);
3048
3049       if (argc != i + 6)
3050         exim_fail("exim: too many or too few arguments after -MC\n");
3051
3052       if (msg_action_arg >= 0)
3053         exim_fail("exim: incompatible arguments\n");
3054
3055       continue_transport = string_copy_taint(
3056         exim_str_fail_toolong(argv[++i], EXIM_DRIVERNAME_MAX, "-C internal transport"),
3057         GET_TAINTED);
3058       continue_hostname = string_copy_taint(
3059         exim_str_fail_toolong(argv[++i], EXIM_HOSTNAME_MAX, "-C internal hostname"),
3060         GET_TAINTED);
3061       continue_host_address = string_copy_taint(
3062         exim_str_fail_toolong(argv[++i], EXIM_IPADDR_MAX, "-C internal hostaddr"),
3063         GET_TAINTED);
3064       continue_sequence = Uatoi(argv[++i]);
3065       msg_action = MSG_DELIVER;
3066       msg_action_arg = ++i;
3067       forced_delivery = TRUE;
3068       queue_run_pid = passed_qr_pid;
3069       queue_run_pipe = passed_qr_pipe;
3070
3071       if (!mac_ismsgid(argv[i]))
3072         exim_fail("exim: malformed message id %s after -MC option\n",
3073           argv[i]);
3074
3075       /* Set up $sending_ip_address and $sending_port, unless proxied */
3076
3077       if (!continue_proxy_cipher)
3078         if (getsockname(fileno(stdin), (struct sockaddr *)(&interface_sock),
3079             &size) == 0)
3080           sending_ip_address = host_ntoa(-1, &interface_sock, NULL,
3081             &sending_port);
3082         else
3083           exim_fail("exim: getsockname() failed after -MC option: %s\n",
3084             strerror(errno));
3085
3086       testharness_pause_ms(500);
3087       break;
3088       }
3089
3090     else if (*argrest == 'C' && argrest[1] && !argrest[2])
3091       {
3092       switch(argrest[1])
3093         {
3094     /* -MCA: set the smtp_authenticated flag; this is useful only when it
3095     precedes -MC (see above). The flag indicates that the host to which
3096     Exim is connected has accepted an AUTH sequence. */
3097
3098         case 'A': f.smtp_authenticated = TRUE; break;
3099
3100     /* -MCD: set the smtp_use_dsn flag; this indicates that the host
3101        that exim is connected to supports the esmtp extension DSN */
3102
3103         case 'D': smtp_peer_options |= OPTION_DSN; break;
3104
3105     /* -MCd: for debug, set a process-purpose string */
3106
3107         case 'd': if (++i < argc)
3108                     process_purpose = string_copy_taint(
3109                       exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-MCd"),
3110                       GET_TAINTED);
3111                   else badarg = TRUE;
3112                   break;
3113
3114     /* -MCG: set the queue name, to a non-default value. Arguably, anything
3115        from the commandline should be tainted - but we will need an untainted
3116        value for the spoolfile when doing a -odi delivery process. */
3117
3118         case 'G': if (++i < argc) queue_name = string_copy_taint(
3119                       exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-MCG"),
3120                       GET_UNTAINTED);
3121                   else badarg = TRUE;
3122                   break;
3123
3124     /* -MCK: the peer offered CHUNKING.  Must precede -MC */
3125
3126         case 'K': smtp_peer_options |= OPTION_CHUNKING; break;
3127
3128 #ifndef DISABLE_ESMTP_LIMITS
3129     /* -MCL: peer used LIMITS RCPTMAX and/or RCPTDOMAINMAX */
3130         case 'L': if (++i < argc) continue_limit_mail = Uatoi(argv[i]);
3131                   else badarg = TRUE;
3132                   if (++i < argc) continue_limit_rcpt = Uatoi(argv[i]);
3133                   else badarg = TRUE;
3134                   if (++i < argc) continue_limit_rcptdom = Uatoi(argv[i]);
3135                   else badarg = TRUE;
3136                   break;
3137 #endif
3138
3139     /* -MCP: set the smtp_use_pipelining flag; this is useful only when
3140     it preceded -MC (see above) */
3141
3142         case 'P': smtp_peer_options |= OPTION_PIPE; break;
3143
3144 #ifdef SUPPORT_SOCKS
3145     /* -MCp: Socks proxy in use; nearside IP, port, external IP, port */
3146         case 'p': proxy_session = TRUE;
3147                   if (++i < argc)
3148                     {
3149                     proxy_local_address = string_copy_taint(argv[i], GET_TAINTED);
3150                     if (++i < argc)
3151                       {
3152                       proxy_local_port = Uatoi(argv[i]);
3153                       if (++i < argc)
3154                         {
3155                         proxy_external_address = string_copy_taint(argv[i], GET_TAINTED);
3156                         if (++i < argc)
3157                           {
3158                           proxy_external_port = Uatoi(argv[i]);
3159                           break;
3160                     } } } }
3161                   badarg = TRUE;
3162                   break;
3163 #endif
3164     /* -MCQ: pass on the pid of the queue-running process that started
3165     this chain of deliveries and the fd of its synchronizing pipe; this
3166     is useful only when it precedes -MC (see above) */
3167
3168         case 'Q': if (++i < argc) passed_qr_pid = (pid_t)(Uatol(argv[i]));
3169                   else badarg = TRUE;
3170                   if (++i < argc) passed_qr_pipe = (int)(Uatol(argv[i]));
3171                   else badarg = TRUE;
3172                   break;
3173
3174     /* -MCq: do a quota check on the given recipient for the given size
3175     of message.  Separate from -MC. */
3176         case 'q': rcpt_verify_quota = TRUE;
3177                   if (++i < argc) message_size = Uatoi(argv[i]);
3178                   else badarg = TRUE;
3179                   break;
3180
3181     /* -MCS: set the smtp_use_size flag; this is useful only when it
3182     precedes -MC (see above) */
3183
3184         case 'S': smtp_peer_options |= OPTION_SIZE; break;
3185
3186 #ifndef DISABLE_TLS
3187     /* -MCs: used with -MCt; SNI was sent */
3188     /* -MCr: ditto, DANE */
3189
3190         case 'r':
3191         case 's': if (++i < argc)
3192                     {
3193                     continue_proxy_sni = string_copy_taint(
3194                       exim_str_fail_toolong(argv[i], EXIM_HOSTNAME_MAX, "-MCr/-MCs"),
3195                       GET_TAINTED);
3196                     if (argrest[1] == 'r') continue_proxy_dane = TRUE;
3197                     }
3198                   else badarg = TRUE;
3199                   break;
3200
3201     /* -MCt: similar to -MCT below but the connection is still open
3202     via a proxy process which handles the TLS context and coding.
3203     Require three arguments for the proxied local address and port,
3204     and the TLS cipher. */
3205
3206         case 't': if (++i < argc)
3207                     sending_ip_address = string_copy_taint(
3208                       exim_str_fail_toolong(argv[i], EXIM_IPADDR_MAX, "-MCt IP"),
3209                       GET_TAINTED);
3210                   else badarg = TRUE;
3211                   if (++i < argc)
3212                     sending_port = (int)(Uatol(argv[i]));
3213                   else badarg = TRUE;
3214                   if (++i < argc)
3215                     continue_proxy_cipher = string_copy_taint(
3216                       exim_str_fail_toolong(argv[i], EXIM_CIPHERNAME_MAX, "-MCt cipher"),
3217                       GET_TAINTED);
3218                   else badarg = TRUE;
3219                   /*FALLTHROUGH*/
3220
3221     /* -MCT: set the tls_offered flag; this is useful only when it
3222     precedes -MC (see above). The flag indicates that the host to which
3223     Exim is connected has offered TLS support. */
3224
3225         case 'T': smtp_peer_options |= OPTION_TLS; break;
3226 #endif
3227
3228         default:  badarg = TRUE; break;
3229         }
3230       break;
3231       }
3232
3233     /* -M[x]: various operations on the following list of message ids:
3234        -M    deliver the messages, ignoring next retry times and thawing
3235        -Mc   deliver the messages, checking next retry times, no thawing
3236        -Mf   freeze the messages
3237        -Mg   give up on the messages
3238        -Mt   thaw the messages
3239        -Mrm  remove the messages
3240     In the above cases, this must be the last option. There are also the
3241     following options which are followed by a single message id, and which
3242     act on that message. Some of them use the "recipient" addresses as well.
3243        -Mar  add recipient(s)
3244        -MG   move to a different queue
3245        -Mmad mark all recipients delivered
3246        -Mmd  mark recipients(s) delivered
3247        -Mes  edit sender
3248        -Mset load a message for use with -be
3249        -Mvb  show body
3250        -Mvc  show copy (of whole message, in RFC 2822 format)
3251        -Mvh  show header
3252        -Mvl  show log
3253     */
3254
3255     else if (!*argrest)
3256       {
3257       msg_action = MSG_DELIVER;
3258       forced_delivery = f.deliver_force_thaw = TRUE;
3259       }
3260     else if (Ustrcmp(argrest, "ar") == 0)
3261       {
3262       msg_action = MSG_ADD_RECIPIENT;
3263       one_msg_action = TRUE;
3264       }
3265     else if (Ustrcmp(argrest, "c") == 0)  msg_action = MSG_DELIVER;
3266     else if (Ustrcmp(argrest, "es") == 0)
3267       {
3268       msg_action = MSG_EDIT_SENDER;
3269       one_msg_action = TRUE;
3270       }
3271     else if (Ustrcmp(argrest, "f") == 0)  msg_action = MSG_FREEZE;
3272     else if (Ustrcmp(argrest, "g") == 0)
3273       {
3274       msg_action = MSG_DELIVER;
3275       deliver_give_up = TRUE;
3276       }
3277    else if (Ustrcmp(argrest, "G") == 0)
3278       {
3279       msg_action = MSG_SETQUEUE;
3280       queue_name_dest = string_copy_taint(
3281         exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3282                               EXIM_DRIVERNAME_MAX, "-MG"),
3283         GET_TAINTED);
3284       }
3285     else if (Ustrcmp(argrest, "mad") == 0) msg_action = MSG_MARK_ALL_DELIVERED;
3286     else if (Ustrcmp(argrest, "md") == 0)
3287       {
3288       msg_action = MSG_MARK_DELIVERED;
3289       one_msg_action = TRUE;
3290       }
3291     else if (Ustrcmp(argrest, "rm") == 0) msg_action = MSG_REMOVE;
3292     else if (Ustrcmp(argrest, "set") == 0)
3293       {
3294       msg_action = MSG_LOAD;
3295       one_msg_action = TRUE;
3296       }
3297     else if (Ustrcmp(argrest, "t") == 0)  msg_action = MSG_THAW;
3298     else if (Ustrcmp(argrest, "vb") == 0)
3299       {
3300       msg_action = MSG_SHOW_BODY;
3301       one_msg_action = TRUE;
3302       }
3303     else if (Ustrcmp(argrest, "vc") == 0)
3304       {
3305       msg_action = MSG_SHOW_COPY;
3306       one_msg_action = TRUE;
3307       }
3308     else if (Ustrcmp(argrest, "vh") == 0)
3309       {
3310       msg_action = MSG_SHOW_HEADER;
3311       one_msg_action = TRUE;
3312       }
3313     else if (Ustrcmp(argrest, "vl") == 0)
3314       {
3315       msg_action = MSG_SHOW_LOG;
3316       one_msg_action = TRUE;
3317       }
3318     else { badarg = TRUE; break; }
3319
3320     /* All the -Mxx options require at least one message id. */
3321
3322     msg_action_arg = i + 1;
3323     if (msg_action_arg >= argc)
3324       exim_fail("exim: no message ids given after %s option\n", arg);
3325
3326     /* Some require only message ids to follow */
3327
3328     if (!one_msg_action)
3329       {
3330       for (int j = msg_action_arg; j < argc; j++) if (!mac_ismsgid(argv[j]))
3331         exim_fail("exim: malformed message id %s after %s option\n",
3332           argv[j], arg);
3333       goto END_ARG;   /* Remaining args are ids */
3334       }
3335
3336     /* Others require only one message id, possibly followed by addresses,
3337     which will be handled as normal arguments. */
3338
3339     else
3340       {
3341       if (!mac_ismsgid(argv[msg_action_arg]))
3342         exim_fail("exim: malformed message id %s after %s option\n",
3343           argv[msg_action_arg], arg);
3344       i++;
3345       }
3346     break;
3347
3348
3349     /* Some programs seem to call the -om option without the leading o;
3350     for sendmail it askes for "me too". Exim always does this. */
3351
3352     case 'm':
3353     if (*argrest) badarg = TRUE;
3354     break;
3355
3356
3357     /* -N: don't do delivery - a debugging option that stops transports doing
3358     their thing. It implies debugging at the D_v level. */
3359
3360     case 'N':
3361     if (!*argrest)
3362       {
3363       f.dont_deliver = TRUE;
3364       debug_selector |= D_v;
3365       debug_file = stderr;
3366       }
3367     else badarg = TRUE;
3368     break;
3369
3370
3371     /* -n: This means "don't alias" in sendmail, apparently.
3372     For normal invocations, it has no effect.
3373     It may affect some other options. */
3374
3375     case 'n':
3376     flag_n = TRUE;
3377     break;
3378
3379     /* -O: Just ignore it. In sendmail, apparently -O option=value means set
3380     option to the specified value. This form uses long names. We need to handle
3381     -O option=value and -Ooption=value. */
3382
3383     case 'O':
3384     if (!*argrest)
3385       if (++i >= argc)
3386         exim_fail("exim: string expected after -O\n");
3387     break;
3388
3389     case 'o':
3390     switch (*argrest++)
3391       {
3392       /* -oA: Set an argument for the bi command (sendmail's "alternate alias
3393       file" option). */
3394       case 'A':
3395         if (!*(alias_arg = argrest))
3396           if (i+1 < argc) alias_arg = argv[++i];
3397           else exim_fail("exim: string expected after -oA\n");
3398         break;
3399
3400       /* -oB: Set a connection message max value for remote deliveries */
3401       case 'B':
3402         {
3403         const uschar * p = argrest;
3404         if (!*p)
3405           if (i+1 < argc && isdigit((argv[i+1][0])))
3406             p = argv[++i];
3407           else
3408             {
3409             connection_max_messages = 1;
3410             p = NULL;
3411             }
3412
3413         if (p)
3414           {
3415           if (!isdigit(*p))
3416             exim_fail("exim: number expected after -oB\n");
3417           connection_max_messages = Uatoi(p);
3418           }
3419         }
3420         break;
3421
3422       /* -odb: background delivery */
3423
3424       case 'd':
3425         if (Ustrcmp(argrest, "b") == 0)
3426           {
3427           f.synchronous_delivery = FALSE;
3428           arg_queue_only = FALSE;
3429           queue_only_set = TRUE;
3430           }
3431
3432       /* -odd: testsuite-only: add no inter-process delays */
3433
3434         else if (Ustrcmp(argrest, "d") == 0)
3435           f.testsuite_delays = FALSE;
3436
3437       /* -odf: foreground delivery (smail-compatible option); same effect as
3438          -odi: interactive (synchronous) delivery (sendmail-compatible option)
3439       */
3440
3441         else if (Ustrcmp(argrest, "f") == 0 || Ustrcmp(argrest, "i") == 0)
3442           {
3443           f.synchronous_delivery = TRUE;
3444           arg_queue_only = FALSE;
3445           queue_only_set = TRUE;
3446           }
3447
3448       /* -odq: queue only */
3449
3450         else if (Ustrcmp(argrest, "q") == 0)
3451           {
3452           f.synchronous_delivery = FALSE;
3453           arg_queue_only = TRUE;
3454           queue_only_set = TRUE;
3455           }
3456
3457       /* -odqs: queue SMTP only - do local deliveries and remote routing,
3458       but no remote delivery */
3459
3460         else if (Ustrcmp(argrest, "qs") == 0)
3461           {
3462           f.queue_smtp = TRUE;
3463           arg_queue_only = FALSE;
3464           queue_only_set = TRUE;
3465           }
3466         else badarg = TRUE;
3467         break;
3468
3469       /* -oex: Sendmail error flags. As these are also accepted without the
3470       leading -o prefix, for compatibility with vacation and other callers,
3471       they are handled with -e above. */
3472
3473       /* -oi:     Set flag so dot doesn't end non-SMTP input (same as -i)
3474          -oitrue: Another sendmail syntax for the same */
3475
3476       case 'i':
3477         if (!*argrest || Ustrcmp(argrest, "true") == 0)
3478           f.dot_ends = FALSE;
3479         else badarg = TRUE;
3480         break;
3481
3482     /* -oM*: Set various characteristics for an incoming message; actually
3483     acted on for trusted callers only. */
3484
3485       case 'M':
3486         {
3487         if (i+1 >= argc)
3488           exim_fail("exim: data expected after -oM%s\n", argrest);
3489
3490         /* -oMa: Set sender host address */
3491
3492         if (Ustrcmp(argrest, "a") == 0)
3493           sender_host_address = string_copy_taint(
3494             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3495                                   EXIM_IPADDR_MAX, "-oMa"), GET_TAINTED);
3496
3497         /* -oMaa: Set authenticator name */
3498
3499         else if (Ustrcmp(argrest, "aa") == 0)
3500           sender_host_authenticated = string_copy_taint(
3501             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3502                                   EXIM_DRIVERNAME_MAX, "-oMaa"), GET_TAINTED);
3503
3504         /* -oMas: setting authenticated sender */
3505
3506         else if (Ustrcmp(argrest, "as") == 0)
3507           authenticated_sender = string_copy_taint(
3508             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3509                                   EXIM_EMAILADDR_MAX, "-oMas"), GET_TAINTED);
3510
3511         /* -oMai: setting authenticated id */
3512
3513         else if (Ustrcmp(argrest, "ai") == 0)
3514           authenticated_id = string_copy_taint(
3515             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3516                                   EXIM_EMAILADDR_MAX, "-oMai"), GET_TAINTED);
3517
3518         /* -oMi: Set incoming interface address */
3519
3520         else if (Ustrcmp(argrest, "i") == 0)
3521           interface_address = string_copy_taint(
3522             exim_str_fail_toolong(next_argv(argv, &i, argc, arg),
3523                                   EXIM_IPADDR_MAX, "-oMi"), GET_TAINTED);
3524
3525         /* -oMm: Message reference */
3526
3527         else if (Ustrcmp(argrest, "m") == 0)
3528           {
3529           if (!mac_ismsgid(argv[i+1]))
3530               exim_fail("-oMm must be a valid message ID\n");
3531           if (!f.trusted_config)
3532               exim_fail("-oMm must be called by a trusted user/config\n");
3533             message_reference = next_argv(argv, &i, argc, arg);
3534           }
3535
3536         /* -oMr: Received protocol */
3537
3538         else if (Ustrcmp(argrest, "r") == 0)
3539
3540           if (received_protocol)
3541             exim_fail("received_protocol is set already\n");
3542           else
3543             if (++i >= argc) badarg = TRUE;
3544             else
3545               received_protocol = string_copy_taint(
3546                 exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-oMr"),
3547                 GET_TAINTED);
3548
3549         /* -oMs: Set sender host name */
3550
3551         else if (Ustrcmp(argrest, "s") == 0)
3552           if (++i >= argc) badarg = TRUE;
3553           else
3554             sender_host_name = string_copy_taint(
3555               exim_str_fail_toolong(argv[i], EXIM_HOSTNAME_MAX, "-oMs"),
3556               GET_TAINTED);
3557
3558         /* -oMt: Set sender ident */
3559
3560         else if (Ustrcmp(argrest, "t") == 0)
3561           if (++i >= argc) badarg = TRUE;
3562           else
3563             {
3564             sender_ident_set = TRUE;
3565             sender_ident = string_copy_taint(
3566               exim_str_fail_toolong(argv[i], EXIM_IDENTUSER_MAX, "-oMt"),
3567               GET_TAINTED);
3568             }
3569
3570         /* Else a bad argument */
3571
3572         else
3573           badarg = TRUE;
3574         }
3575         break;
3576
3577       /* -om: Me-too flag for aliases. Exim always does this. Some programs
3578       seem to call this as -m (undocumented), so that is also accepted (see
3579       above). */
3580       /* -oo: An ancient flag for old-style addresses which still seems to
3581       crop up in some calls (see in SCO). */
3582
3583       case 'm':
3584       case 'o':
3585         if (*argrest) badarg = TRUE;
3586         break;
3587
3588       /* -oP <name>: set pid file path for daemon
3589          -oPX:       delete pid file of daemon */
3590
3591       case 'P':
3592         if (!f.running_in_test_harness && real_uid != root_uid && real_uid != exim_uid)
3593           exim_fail("exim: only uid=%d or uid=%d can use -oP and -oPX "
3594                     "(uid=%d euid=%d | %d)\n",
3595                     root_uid, exim_uid, getuid(), geteuid(), real_uid);
3596         if (!*argrest)
3597           if (++i < argc) override_pid_file_path = argv[i];
3598           else badarg = TRUE;
3599         else if (Ustrcmp(argrest, "X") == 0) delete_pid_file();
3600         else badarg = TRUE;
3601         break;
3602
3603
3604       /* -or <n>: set timeout for non-SMTP acceptance
3605          -os <n>: set timeout for SMTP acceptance */
3606
3607       case 'r':
3608       case 's':
3609         {
3610         int * tp = argrest[-1] == 'r'
3611           ? &arg_receive_timeout : &arg_smtp_receive_timeout;
3612         if (*argrest)
3613           *tp = readconf_readtime(argrest, 0, FALSE);
3614         else if (i+1 < argc)
3615           *tp = readconf_readtime(argv[++i], 0, FALSE);
3616
3617         if (*tp < 0)
3618           exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
3619         }
3620         break;
3621
3622       /* -oX <list>: Override local_interfaces and/or default daemon ports */
3623       /* Limits: Is there a real limit we want here?  1024 is very arbitrary. */
3624
3625       case 'X':
3626         if (*argrest || ++i >= argc) badarg = TRUE;
3627         else override_local_interfaces = string_copy_taint(
3628           exim_str_fail_toolong(argv[i], 1024, "-oX"), GET_TAINTED);
3629         break;
3630
3631       /* -oY: Override creation of daemon notifier socket */
3632
3633       case 'Y':
3634         if (*argrest) badarg = TRUE;
3635         else f.notifier_socket_en = FALSE;
3636         break;
3637
3638       /* Unknown -o argument */
3639
3640       default:
3641         badarg = TRUE;
3642       }
3643     break;
3644
3645
3646     /* -ps: force Perl startup; -pd force delayed Perl startup */
3647
3648     case 'p':
3649     #ifdef EXIM_PERL
3650     if (*argrest == 's' && argrest[1] == 0)
3651       {
3652       perl_start_option = 1;
3653       break;
3654       }
3655     if (*argrest == 'd' && argrest[1] == 0)
3656       {
3657       perl_start_option = -1;
3658       break;
3659       }
3660     #endif
3661
3662     /* -panythingelse is taken as the Sendmail-compatible argument -prval:sval,
3663     which sets the host protocol and host name */
3664
3665     if (!*argrest)
3666       argrest = next_argv(argv, &i, argc, arg);
3667
3668     if (*argrest)
3669       {
3670       uschar * hn = Ustrchr(argrest, ':');
3671
3672       if (received_protocol)
3673         exim_fail("received_protocol is set already\n");
3674
3675       if (!hn)
3676         received_protocol = string_copy_taint(
3677           exim_str_fail_toolong(argrest, EXIM_DRIVERNAME_MAX, "-p<protocol>"),
3678           GET_TAINTED);
3679       else
3680         {
3681         (void) exim_str_fail_toolong(argrest, (EXIM_DRIVERNAME_MAX+1+EXIM_HOSTNAME_MAX), "-p<protocol>:<host>");
3682         received_protocol = string_copyn_taint(argrest, hn - argrest, GET_TAINTED);
3683         sender_host_name = string_copy_taint(hn + 1, GET_TAINTED);
3684         }
3685       }
3686     break;
3687
3688     /* -q:  set up queue runs */
3689
3690     case 'q':
3691       {
3692       BOOL two_stage, first_del, force, thaw = FALSE, local;
3693
3694       receiving_message = FALSE;
3695
3696       /* -qq...: Do queue runs in a 2-stage manner */
3697
3698       if ((two_stage = *argrest == 'q'))
3699         argrest++;
3700
3701       /* -qi...: Do only first (initial) deliveries */
3702
3703       if ((first_del = *argrest == 'i'))
3704         argrest++;
3705
3706       /* -qf...: Run the queue, forcing deliveries
3707          -qff..: Ditto, forcing thawing as well */
3708
3709       if ((force = *argrest == 'f'))
3710         if ((thaw = *++argrest == 'f'))
3711           argrest++;
3712
3713       /* -q[f][f]l...: Run the queue only on local deliveries */
3714
3715       if ((local = *argrest == 'l'))
3716         argrest++;
3717
3718       /* -q[f][f][l][G<name>]... Work on the named queue */
3719
3720       if (*argrest == 'G')
3721         {
3722         int i;
3723         for (argrest++, i = 0; argrest[i] && argrest[i] != '/'; ) i++;
3724         exim_len_fail_toolong(i, EXIM_DRIVERNAME_MAX, "-q*G<name>");
3725         queue_name = string_copyn(argrest, i);
3726         argrest += i;
3727         if (*argrest == '/') argrest++;
3728         }
3729
3730       /* -q[f][f][l][G<name>]: Run the queue, optionally forced, optionally local
3731       only, optionally named, optionally starting from a given message id. */
3732
3733       if (!(list_queue || count_queue))
3734         {
3735         qrunner * q;
3736
3737         if (  !*argrest
3738            && (i + 1 >= argc || argv[i+1][0] == '-' || mac_ismsgid(argv[i+1])))
3739           {
3740           q = alloc_onetime_qrunner();
3741           if (i+1 < argc && mac_ismsgid(argv[i+1]))
3742             start_queue_run_id = string_copy_taint(argv[++i], GET_TAINTED);
3743           if (i+1 < argc && mac_ismsgid(argv[i+1]))
3744             stop_queue_run_id = string_copy_taint(argv[++i], GET_TAINTED);
3745           }
3746
3747       /* -q[f][f][l][G<name>/]<n>: Run the queue at regular intervals, optionally
3748       forced, optionally local only, optionally named. */
3749
3750         else
3751           {
3752           int intvl;
3753           const uschar * s;
3754
3755           if (*argrest) s = argrest;
3756           else if (++i < argc) { badarg = TRUE; break; }
3757           else s = argv[i];
3758
3759           if ((intvl = readconf_readtime(s, 0, FALSE)) <= 0)
3760             exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
3761
3762           for (qrunner * qq = qrunners; qq; qq = qq->next)
3763             if (  queue_name && qq->name && Ustrcmp(queue_name, qq->name) == 0
3764                || !queue_name && !qq->name)
3765               exim_fail("exim: queue-runner specified more than once\n");
3766
3767           q = alloc_qrunner();
3768           q->interval = intvl;
3769           }
3770
3771         q->name = *queue_name ? queue_name : NULL;      /* will be NULL for the default queue */
3772         q->queue_run_force = force;
3773         q->deliver_force_thaw = thaw;
3774         q->queue_run_first_delivery = first_del;
3775         q->queue_run_local = local;
3776         q->queue_2stage = two_stage;
3777         }
3778
3779       break;
3780       }
3781
3782
3783     case 'R':   /* Synonymous with -qR... */
3784     case 'S':   /* Synonymous with -qS... */
3785       {
3786       const uschar * tainted_selectstr;
3787       uschar * s;
3788
3789       receiving_message = FALSE;
3790
3791     /* -Rf:   As -R (below) but force all deliveries,
3792        -Rff:  Ditto, but also thaw all frozen messages,
3793        -Rr:   String is regex
3794        -Rrf:  Regex and force
3795        -Rrff: Regex and force and thaw
3796
3797        -S...: Like -R but works on sender.
3798
3799     in all cases provided there are no further characters in this
3800     argument. */
3801
3802       if (!qrunners) alloc_onetime_qrunner();
3803       qrunners->queue_2stage = f.queue_2stage;
3804       if (*argrest)
3805         for (int i = 0; i < nelem(rsopts); i++)
3806           if (Ustrcmp(argrest, rsopts[i]) == 0)
3807             {
3808             if (i != 2) qrunners->queue_run_force = TRUE;
3809             if (i >= 2)
3810               if (switchchar == 'R')
3811                 f.deliver_selectstring_regex = TRUE;
3812               else
3813                 f.deliver_selectstring_sender_regex = TRUE;
3814             if (i == 1 || i == 4) qrunners->deliver_force_thaw = TRUE;
3815             argrest += Ustrlen(rsopts[i]);
3816             }
3817
3818     /* -R or -S: Set string to match in addresses for forced queue run to
3819     pick out particular messages. */
3820
3821       /* Avoid attacks from people providing very long strings, and do so before
3822       we make copies. */
3823       if (*argrest)
3824         tainted_selectstr = argrest;
3825       else if (i+1 < argc)
3826         tainted_selectstr = argv[++i];
3827       else
3828         exim_fail("exim: string expected after %s\n", switchchar == 'R' ? "-R" : "-S");
3829
3830       s = string_copy_taint(
3831         exim_str_fail_toolong(tainted_selectstr, EXIM_EMAILADDR_MAX, "-R"),
3832         GET_TAINTED);
3833
3834       if (switchchar == 'R')
3835         deliver_selectstring = s;
3836       else
3837         deliver_selectstring_sender = s;
3838       }
3839     break;
3840
3841
3842     /* -r: an obsolete synonym for -f (see above) */
3843
3844     /* -Tqt is an option that is exclusively for use by the testing suite.
3845     It is not recognized in other circumstances. It allows for the setting up
3846     of explicit "queue times" so that various warning/retry things can be
3847     tested. Otherwise variability of clock ticks etc. cause problems. */
3848
3849     case 'T':
3850     if (f.running_in_test_harness && Ustrcmp(argrest, "qt") == 0 && ++i < argc)
3851       fudged_queue_times = string_copy_taint(argv[i], GET_TAINTED);
3852     else badarg = TRUE;
3853     break;
3854
3855
3856     /* -t: Set flag to extract recipients from body of message. */
3857
3858     case 't':
3859     if (!*argrest) extract_recipients = TRUE;
3860
3861     /* -ti: Set flag to extract recipients from body of message, and also
3862     specify that dot does not end the message. */
3863
3864     else if (Ustrcmp(argrest, "i") == 0)
3865       {
3866       extract_recipients = TRUE;
3867       f.dot_ends = FALSE;
3868       }
3869
3870     /* -tls-on-connect: don't wait for STARTTLS (for old clients) */
3871
3872     #ifndef DISABLE_TLS
3873     else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_in.on_connect = TRUE;
3874     #endif
3875
3876     else badarg = TRUE;
3877     break;
3878
3879
3880     /* -U: This means "initial user submission" in sendmail, apparently. The
3881     doc claims that in future sendmail may refuse syntactically invalid
3882     messages instead of fixing them. For the moment, we just ignore it. */
3883
3884     case 'U':
3885     break;
3886
3887
3888     /* -v: verify things - this is a very low-level debugging */
3889
3890     case 'v':
3891     if (!*argrest)
3892       {
3893       debug_selector |= D_v;
3894       debug_file = stderr;
3895       }
3896     else badarg = TRUE;
3897     break;
3898
3899
3900     /* -x: AIX uses this to indicate some fancy 8-bit character stuff:
3901
3902       The -x flag tells the sendmail command that mail from a local
3903       mail program has National Language Support (NLS) extended characters
3904       in the body of the mail item. The sendmail command can send mail with
3905       extended NLS characters across networks that normally corrupts these
3906       8-bit characters.
3907
3908     As Exim is 8-bit clean, it just ignores this flag. */
3909
3910     case 'x':
3911     if (*argrest) badarg = TRUE;
3912     break;
3913
3914     /* -X: in sendmail: takes one parameter, logfile, and sends debugging
3915     logs to that file.  We swallow the parameter and otherwise ignore it. */
3916
3917     case 'X':
3918     if (!*argrest)
3919       if (++i >= argc)
3920         exim_fail("exim: string expected after -X\n");
3921     break;
3922
3923     /* -z: a line of text to log */
3924
3925     case 'z':
3926     if (!*argrest)
3927       if (++i < argc)
3928         log_oneline = string_copy_taint(
3929           exim_str_fail_toolong(argv[i], 2048, "-z logtext"),
3930           GET_TAINTED);
3931       else
3932         exim_fail("exim: file name expected after %s\n", argv[i-1]);
3933     break;
3934
3935     /* All other initial characters are errors */
3936
3937     default:
3938     badarg = TRUE;
3939     break;
3940     }         /* End of high-level switch statement */
3941
3942   /* Failed to recognize the option, or syntax error */
3943
3944   if (badarg)
3945     exim_fail("exim abandoned: unknown, malformed, or incomplete "
3946       "option %s\n", arg);
3947   }
3948
3949
3950 /* If -R or -S have been specified without -q, assume a single queue run. */
3951
3952  if ((deliver_selectstring || deliver_selectstring_sender) && !qrunners)
3953   alloc_onetime_qrunner();
3954
3955
3956 END_ARG:
3957  store_pool = old_pool;
3958  }
3959
3960 /* If usage_wanted is set we call the usage function - which never returns */
3961 if (usage_wanted) exim_usage(called_as);
3962
3963 /* Arguments have been processed. Check for incompatibilities. */
3964 if (  (  (smtp_input || extract_recipients || recipients_arg < argc)
3965       && (  f.daemon_listen || qrunners || bi_option
3966          || test_retry_arg >= 0 || test_rewrite_arg >= 0
3967          || filter_test != FTEST_NONE
3968          || msg_action_arg > 0 && !one_msg_action
3969       )  )
3970    || (  msg_action_arg > 0
3971       && (  f.daemon_listen || is_multiple_qrun() || list_options
3972          || checking && msg_action != MSG_LOAD
3973          || bi_option || test_retry_arg >= 0 || test_rewrite_arg >= 0
3974       )  )
3975    || (  (f.daemon_listen || is_multiple_qrun())
3976       && (  sender_address || list_options || list_queue || checking
3977          || bi_option
3978       )  )
3979    || f.daemon_listen && is_onetime_qrun()
3980    || f.inetd_wait_mode && qrunners
3981    || (  list_options
3982       && (  checking || smtp_input || extract_recipients
3983          || filter_test != FTEST_NONE || bi_option
3984       )  )
3985    || (  verify_address_mode
3986       && (  f.address_test_mode || smtp_input || extract_recipients
3987          || filter_test != FTEST_NONE || bi_option
3988       )  )
3989    || (  f.address_test_mode
3990       && (  smtp_input || extract_recipients || filter_test != FTEST_NONE
3991          || bi_option
3992       )  )
3993    || (  smtp_input
3994       && (sender_address || filter_test != FTEST_NONE || extract_recipients)
3995       )
3996    || deliver_selectstring && !qrunners
3997    || msg_action == MSG_LOAD && (!expansion_test || expansion_test_message)
3998    )
3999   exim_fail("exim: incompatible command-line options or arguments\n");
4000
4001 /* If debugging is set up, set the file and the file descriptor to pass on to
4002 child processes. It should, of course, be 2 for stderr. Also, force the daemon
4003 to run in the foreground. */
4004
4005 if (debug_selector != 0)
4006   {
4007   debug_file = stderr;
4008   debug_fd = fileno(debug_file);
4009   f.background_daemon = FALSE;
4010   testharness_pause_ms(100);   /* lets caller finish */
4011   if (debug_selector != D_v)    /* -v only doesn't show this */
4012     {
4013     debug_printf("Exim version %s uid=%ld gid=%ld pid=%d D=%x\n",
4014       version_string, (long int)real_uid, (long int)real_gid, (int)getpid(),
4015       debug_selector);
4016     if (!version_printed)
4017       show_whats_supported(FALSE);
4018     }
4019   }
4020
4021 /* When started with root privilege, ensure that the limits on the number of
4022 open files and the number of processes (where that is accessible) are
4023 sufficiently large, or are unset, in case Exim has been called from an
4024 environment where the limits are screwed down. Not all OS have the ability to
4025 change some of these limits. */
4026
4027 if (unprivileged)
4028   {
4029   DEBUG(D_any) debug_print_ids(US"Exim has no root privilege:");
4030   }
4031 else
4032   {
4033   struct rlimit rlp;
4034
4035 #ifdef RLIMIT_NOFILE
4036   if (getrlimit(RLIMIT_NOFILE, &rlp) < 0)
4037     {
4038     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NOFILE) failed: %s",
4039       strerror(errno));
4040     rlp.rlim_cur = rlp.rlim_max = 0;
4041     }
4042
4043   /* I originally chose 1000 as a nice big number that was unlikely to
4044   be exceeded. It turns out that some older OS have a fixed upper limit of
4045   256. */
4046
4047   if (rlp.rlim_cur < 1000)
4048     {
4049     rlp.rlim_cur = rlp.rlim_max = 1000;
4050     if (setrlimit(RLIMIT_NOFILE, &rlp) < 0)
4051       {
4052       rlp.rlim_cur = rlp.rlim_max = 256;
4053       if (setrlimit(RLIMIT_NOFILE, &rlp) < 0)
4054         log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NOFILE) failed: %s",
4055           strerror(errno));
4056       }
4057     }
4058 #endif
4059
4060 #ifdef RLIMIT_NPROC
4061   if (getrlimit(RLIMIT_NPROC, &rlp) < 0)
4062     {
4063     log_write(0, LOG_MAIN|LOG_PANIC, "getrlimit(RLIMIT_NPROC) failed: %s",
4064       strerror(errno));
4065     rlp.rlim_cur = rlp.rlim_max = 0;
4066     }
4067
4068 # ifdef RLIM_INFINITY
4069   if (rlp.rlim_cur != RLIM_INFINITY && rlp.rlim_cur < 1000)
4070     {
4071     rlp.rlim_cur = rlp.rlim_max = RLIM_INFINITY;
4072 # else
4073   if (rlp.rlim_cur < 1000)
4074     {
4075     rlp.rlim_cur = rlp.rlim_max = 1000;
4076 # endif
4077     if (setrlimit(RLIMIT_NPROC, &rlp) < 0)
4078       log_write(0, LOG_MAIN|LOG_PANIC, "setrlimit(RLIMIT_NPROC) failed: %s",
4079         strerror(errno));
4080     }
4081 #endif
4082   }
4083
4084 /* Exim is normally entered as root (but some special configurations are
4085 possible that don't do this). However, it always spins off sub-processes that
4086 set their uid and gid as required for local delivery. We don't want to pass on
4087 any extra groups that root may belong to, so we want to get rid of them all at
4088 this point.
4089
4090 We need to obey setgroups() at this stage, before possibly giving up root
4091 privilege for a changed configuration file, but later on we might need to
4092 check on the additional groups for the admin user privilege - can't do that
4093 till after reading the config, which might specify the exim gid. Therefore,
4094 save the group list here first. */
4095
4096 if ((group_count = getgroups(nelem(group_list), group_list)) < 0)
4097   exim_fail("exim: getgroups() failed: %s\n", strerror(errno));
4098
4099 /* There is a fundamental difference in some BSD systems in the matter of
4100 groups. FreeBSD and BSDI are known to be different; NetBSD and OpenBSD are
4101 known not to be different. On the "different" systems there is a single group
4102 list, and the first entry in it is the current group. On all other versions of
4103 Unix there is a supplementary group list, which is in *addition* to the current
4104 group. Consequently, to get rid of all extraneous groups on a "standard" system
4105 you pass over 0 groups to setgroups(), while on a "different" system you pass
4106 over a single group - the current group, which is always the first group in the
4107 list. Calling setgroups() with zero groups on a "different" system results in
4108 an error return. The following code should cope with both types of system.
4109
4110  Unfortunately, recent MacOS, which should be a FreeBSD, "helpfully" succeeds
4111  the "setgroups() with zero groups" - and changes the egid.
4112  Thanks to that we had to stash the original_egid above, for use below
4113  in the call to exim_setugid().
4114
4115 However, if this process isn't running as root, setgroups() can't be used
4116 since you have to be root to run it, even if throwing away groups.
4117 Except, sigh, for Hurd - where you can.
4118 Not being root here happens only in some unusual configurations. */
4119
4120 if (  !unprivileged
4121 #ifndef OS_SETGROUPS_ZERO_DROPS_ALL
4122    && setgroups(0, NULL) != 0
4123 #endif
4124    && setgroups(1, group_list) != 0)
4125   exim_fail("exim: setgroups() failed: %s\n", strerror(errno));
4126
4127 /* If the configuration file name has been altered by an argument on the
4128 command line (either a new file name or a macro definition) and the caller is
4129 not root, or if this is a filter testing run, remove any setuid privilege the
4130 program has and run as the underlying user.
4131
4132 The exim user is locked out of this, which severely restricts the use of -C
4133 for some purposes.
4134
4135 Otherwise, set the real ids to the effective values (should be root unless run
4136 from inetd, which it can either be root or the exim uid, if one is configured).
4137
4138 There is a private mechanism for bypassing some of this, in order to make it
4139 possible to test lots of configurations automatically, without having either to
4140 recompile each time, or to patch in an actual configuration file name and other
4141 values (such as the path name). If running in the test harness, pretend that
4142 configuration file changes and macro definitions haven't happened. */
4143
4144 if ((                                            /* EITHER */
4145     (!f.trusted_config ||                          /* Config changed, or */
4146      !macros_trusted(opt_D_used)) &&             /*  impermissible macros and */
4147     real_uid != root_uid &&                      /* Not root, and */
4148     !f.running_in_test_harness                     /* Not fudged */
4149     ) ||                                         /*   OR   */
4150     expansion_test                               /* expansion testing */
4151     ||                                           /*   OR   */
4152     filter_test != FTEST_NONE)                   /* Filter testing */
4153   {
4154   setgroups(group_count, group_list);
4155   exim_setugid(real_uid, real_gid, FALSE,
4156     US"-C, -D, -be or -bf forces real uid");
4157   removed_privilege = TRUE;
4158
4159   /* In the normal case when Exim is called like this, stderr is available
4160   and should be used for any logging information because attempts to write
4161   to the log will usually fail. To arrange this, we unset really_exim. However,
4162   if no stderr is available there is no point - we might as well have a go
4163   at the log (if it fails, syslog will be written).
4164
4165   Note that if the invoker is Exim, the logs remain available. Messing with
4166   this causes unlogged successful deliveries.  */
4167
4168   if (log_stderr && real_uid != exim_uid)
4169     f.really_exim = FALSE;
4170   }
4171
4172 /* Privilege is to be retained for the moment. It may be dropped later,
4173 depending on the job that this Exim process has been asked to do. For now, set
4174 the real uid to the effective so that subsequent re-execs of Exim are done by a
4175 privileged user. */
4176
4177 else
4178   exim_setugid(geteuid(), original_egid, FALSE, US"forcing real = effective");
4179
4180 /* If testing a filter, open the file(s) now, before wasting time doing other
4181 setups and reading the message. */
4182
4183 if (filter_test & FTEST_SYSTEM)
4184   if ((filter_sfd = Uopen(filter_test_sfile, O_RDONLY, 0)) < 0)
4185     exim_fail("exim: failed to open %s: %s\n", filter_test_sfile,
4186       strerror(errno));
4187
4188 if (filter_test & FTEST_USER)
4189   if ((filter_ufd = Uopen(filter_test_ufile, O_RDONLY, 0)) < 0)
4190     exim_fail("exim: failed to open %s: %s\n", filter_test_ufile,
4191       strerror(errno));
4192
4193 /* Initialise lookup_list
4194 If debugging, already called above via version reporting.
4195 In either case, we initialise the list of available lookups while running
4196 as root.  All dynamically modules are loaded from a directory which is
4197 hard-coded into the binary and is code which, if not a module, would be
4198 part of Exim already.  Ability to modify the content of the directory
4199 is equivalent to the ability to modify a setuid binary!
4200
4201 This needs to happen before we read the main configuration. */
4202 init_lookup_list();
4203
4204 /*XXX this excrescence could move to the testsuite standard config setup file */
4205 #ifdef SUPPORT_I18N
4206 if (f.running_in_test_harness) smtputf8_advertise_hosts = NULL;
4207 #endif
4208
4209 /* Read the main runtime configuration data; this gives up if there
4210 is a failure. It leaves the configuration file open so that the subsequent
4211 configuration data for delivery can be read if needed.
4212
4213 NOTE: immediately after opening the configuration file we change the working
4214 directory to "/"! Later we change to $spool_directory. We do it there, because
4215 during readconf_main() some expansion takes place already. */
4216
4217 /* Store the initial cwd before we change directories.  Can be NULL if the
4218 dir has already been unlinked. */
4219 initial_cwd = os_getcwd(NULL, 0);
4220 if (!initial_cwd && errno)
4221   exim_fail("exim: getting initial cwd failed: %s\n", strerror(errno));
4222
4223 if (initial_cwd && (strlen(CCS initial_cwd) >= BIG_BUFFER_SIZE))
4224   exim_fail("exim: initial cwd is far too long (%d)\n", Ustrlen(CCS initial_cwd));
4225
4226 /* checking:
4227     -be[m] expansion test        -
4228     -b[fF] filter test           new
4229     -bh[c] host test             -
4230     -bmalware malware_test_file  new
4231     -brt   retry test            new
4232     -brw   rewrite test          new
4233     -bt    address test          -
4234     -bv[s] address verify        -
4235    list_options:
4236     -bP <option> (except -bP config, which sets list_config)
4237
4238 If any of these options is set, we suppress warnings about configuration
4239 issues (currently about tls_advertise_hosts and keep_environment not being
4240 defined) */
4241
4242   {
4243   int old_pool = store_pool;
4244 #ifdef MEASURE_TIMING
4245   struct timeval t0;
4246   (void)gettimeofday(&t0, NULL);
4247 #endif
4248
4249   store_pool = POOL_CONFIG;
4250   readconf_main(checking || list_options);
4251   store_pool = old_pool;
4252
4253 #ifdef MEASURE_TIMING
4254   report_time_since(&t0, US"readconf_main (delta)");
4255 #endif
4256   }
4257
4258 /* Now in directory "/" */
4259
4260 if (cleanup_environment() == FALSE)
4261   log_write(0, LOG_PANIC_DIE, "Can't cleanup environment");
4262
4263
4264 /* If an action on specific messages is requested, or if a daemon or queue
4265 runner is being started, we need to know if Exim was called by an admin user.
4266 This is the case if the real user is root or exim, or if the real group is
4267 exim, or if one of the supplementary groups is exim or a group listed in
4268 admin_groups. We don't fail all message actions immediately if not admin_user,
4269 since some actions can be performed by non-admin users. Instead, set admin_user
4270 for later interrogation. */
4271
4272 if (real_uid == root_uid || real_uid == exim_uid || real_gid == exim_gid)
4273   f.admin_user = TRUE;
4274 else
4275   for (int i = 0; i < group_count && !f.admin_user; i++)
4276     if (group_list[i] == exim_gid)
4277       f.admin_user = TRUE;
4278     else if (admin_groups)
4279       for (int j = 1; j <= (int)admin_groups[0] && !f.admin_user; j++)
4280         if (admin_groups[j] == group_list[i])
4281           f.admin_user = TRUE;
4282
4283 /* Another group of privileged users are the trusted users. These are root,
4284 exim, and any caller matching trusted_users or trusted_groups. Trusted callers
4285 are permitted to specify sender_addresses with -f on the command line, and
4286 other message parameters as well. */
4287
4288 if (real_uid == root_uid || real_uid == exim_uid)
4289   f.trusted_caller = TRUE;
4290 else
4291   {
4292   if (trusted_users)
4293     for (int i = 1; i <= (int)trusted_users[0] && !f.trusted_caller; i++)
4294       if (trusted_users[i] == real_uid)
4295         f.trusted_caller = TRUE;
4296
4297   if (trusted_groups)
4298     for (int i = 1; i <= (int)trusted_groups[0] && !f.trusted_caller; i++)
4299       if (trusted_groups[i] == real_gid)
4300         f.trusted_caller = TRUE;
4301       else for (int j = 0; j < group_count && !f.trusted_caller; j++)
4302         if (trusted_groups[i] == group_list[j])
4303           f.trusted_caller = TRUE;
4304   }
4305
4306 /* At this point, we know if the user is privileged and some command-line
4307 options become possibly impermissible, depending upon the configuration file. */
4308
4309 if (checking && commandline_checks_require_admin && !f.admin_user)
4310   exim_fail("exim: those command-line flags are set to require admin\n");
4311
4312 /* Handle the decoding of logging options. */
4313
4314 decode_bits(log_selector, log_selector_size, log_notall,
4315   log_selector_string, log_options, log_options_count, US"log", 0);
4316
4317 DEBUG(D_any)
4318   {
4319   debug_printf("configuration file is %s\n", config_main_filename);
4320   debug_printf("log selectors =");
4321   for (int i = 0; i < log_selector_size; i++)
4322     debug_printf(" %08x", log_selector[i]);
4323   debug_printf("\n");
4324   }
4325
4326 /* If domain literals are not allowed, check the sender address that was
4327 supplied with -f. Ditto for a stripped trailing dot. */
4328
4329 if (sender_address)
4330   {
4331   if (sender_address[sender_address_domain] == '[' && !allow_domain_literals)
4332     exim_fail("exim: bad -f address \"%s\": domain literals not "
4333       "allowed\n", sender_address);
4334   if (f_end_dot && !strip_trailing_dot)
4335     exim_fail("exim: bad -f address \"%s.\": domain is malformed "
4336       "(trailing dot not allowed)\n", sender_address);
4337   }
4338
4339 /* See if an admin user overrode our logging. */
4340
4341 if (cmdline_syslog_name)
4342   if (f.admin_user)
4343     {
4344     syslog_processname = cmdline_syslog_name;
4345     log_file_path = string_copy(CUS"syslog");
4346     }
4347   else
4348     /* not a panic, non-privileged users should not be able to spam paniclog */
4349     exim_fail(
4350         "exim: you lack sufficient privilege to specify syslog process name\n");
4351
4352 /* Paranoia check of maximum lengths of certain strings. There is a check
4353 on the length of the log file path in log.c, which will come into effect
4354 if there are any calls to write the log earlier than this. However, if we
4355 get this far but the string is very long, it is better to stop now than to
4356 carry on and (e.g.) receive a message and then have to collapse. The call to
4357 log_write() from here will cause the ultimate panic collapse if the complete
4358 file name exceeds the buffer length. */
4359
4360 if (Ustrlen(log_file_path) > 200)
4361   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4362     "log_file_path is longer than 200 chars: aborting");
4363
4364 if (Ustrlen(pid_file_path) > 200)
4365   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4366     "pid_file_path is longer than 200 chars: aborting");
4367
4368 if (Ustrlen(spool_directory) > 200)
4369   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4370     "spool_directory is longer than 200 chars: aborting");
4371
4372 /* Length check on the process name given to syslog for its TAG field,
4373 which is only permitted to be 32 characters or less. See RFC 3164. */
4374
4375 if (Ustrlen(syslog_processname) > 32)
4376   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
4377     "syslog_processname is longer than 32 chars: aborting");
4378
4379 if (log_oneline)
4380   if (f.admin_user)
4381     {
4382     log_write(0, LOG_MAIN, "%s", log_oneline);
4383     return EXIT_SUCCESS;
4384     }
4385   else
4386     return EXIT_FAILURE;
4387
4388 /* In some operating systems, the environment variable TMPDIR controls where
4389 temporary files are created; Exim doesn't use these (apart from when delivering
4390 to MBX mailboxes), but called libraries such as DBM libraries may require them.
4391 If TMPDIR is found in the environment, reset it to the value defined in the
4392 EXIM_TMPDIR macro, if this macro is defined.  For backward compatibility this
4393 macro may be called TMPDIR in old "Local/Makefile"s. It's converted to
4394 EXIM_TMPDIR by the build scripts.
4395 */
4396
4397 #ifdef EXIM_TMPDIR
4398   if (environ) for (uschar ** p = USS environ; *p; p++)
4399     if (Ustrncmp(*p, "TMPDIR=", 7) == 0 && Ustrcmp(*p+7, EXIM_TMPDIR) != 0)
4400       {
4401       uschar * newp = store_malloc(Ustrlen(EXIM_TMPDIR) + 8);
4402       sprintf(CS newp, "TMPDIR=%s", EXIM_TMPDIR);
4403       *p = newp;
4404       DEBUG(D_any) debug_printf("reset TMPDIR=%s in environment\n", EXIM_TMPDIR);
4405       }
4406 #endif
4407
4408 /* Timezone handling. If timezone_string is "utc", set a flag to cause all
4409 timestamps to be in UTC (gmtime() is used instead of localtime()). Otherwise,
4410 we may need to get rid of a bogus timezone setting. This can arise when Exim is
4411 called by a user who has set the TZ variable. This then affects the timestamps
4412 in log files and in Received: headers, and any created Date: header lines. The
4413 required timezone is settable in the configuration file, so nothing can be done
4414 about this earlier - but hopefully nothing will normally be logged earlier than
4415 this. We have to make a new environment if TZ is wrong, but don't bother if
4416 timestamps_utc is set, because then all times are in UTC anyway. */
4417
4418 if (timezone_string && strcmpic(timezone_string, US"UTC") == 0)
4419   f.timestamps_utc = TRUE;
4420 else
4421   {
4422   uschar *envtz = US getenv("TZ");
4423   if (envtz
4424       ? !timezone_string || Ustrcmp(timezone_string, envtz) != 0
4425       : timezone_string != NULL
4426      )
4427     {
4428     uschar **p = USS environ;
4429     uschar **new;
4430     uschar **newp;
4431     int count = 0;
4432     if (environ) while (*p++) count++;
4433     if (!envtz) count++;
4434     newp = new = store_malloc(sizeof(uschar *) * (count + 1));
4435     if (environ) for (p = USS environ; *p; p++)
4436       if (Ustrncmp(*p, "TZ=", 3) != 0) *newp++ = *p;
4437     if (timezone_string)
4438       {
4439       *newp = store_malloc(Ustrlen(timezone_string) + 4);
4440       sprintf(CS *newp++, "TZ=%s", timezone_string);
4441       }
4442     *newp = NULL;
4443     environ = CSS new;
4444     tzset();
4445     DEBUG(D_any) debug_printf("Reset TZ to %s: time is %s\n", timezone_string,
4446       tod_stamp(tod_log));
4447     }
4448   }
4449
4450 /* Handle the case when we have removed the setuid privilege because of -C or
4451 -D. This means that the caller of Exim was not root.
4452
4453 There is a problem if we were running as the Exim user. The sysadmin may
4454 expect this case to retain privilege because "the binary was called by the
4455 Exim user", but it hasn't, because either the -D option set macros, or the
4456 -C option set a non-trusted configuration file. There are two possibilities:
4457
4458   (1) If deliver_drop_privilege is set, Exim is not going to re-exec in order
4459       to do message deliveries. Thus, the fact that it is running as a
4460       non-privileged user is plausible, and might be wanted in some special
4461       configurations. However, really_exim will have been set false when
4462       privilege was dropped, to stop Exim trying to write to its normal log
4463       files. Therefore, re-enable normal log processing, assuming the sysadmin
4464       has set up the log directory correctly.
4465
4466   (2) If deliver_drop_privilege is not set, the configuration won't work as
4467       apparently intended, and so we log a panic message. In order to retain
4468       root for -C or -D, the caller must either be root or be invoking a
4469       trusted configuration file (when deliver_drop_privilege is false). */
4470
4471 if (  removed_privilege
4472    && (!f.trusted_config || opt_D_used)
4473    && real_uid == exim_uid)
4474   if (deliver_drop_privilege)
4475     f.really_exim = TRUE; /* let logging work normally */
4476   else
4477     log_write(0, LOG_MAIN|LOG_PANIC,
4478       "exim user lost privilege for using %s option",
4479       f.trusted_config? "-D" : "-C");
4480
4481 /* Start up Perl interpreter if Perl support is configured and there is a
4482 perl_startup option, and the configuration or the command line specifies
4483 initializing starting. Note that the global variables are actually called
4484 opt_perl_xxx to avoid clashing with perl's namespace (perl_*). */
4485
4486 #ifdef EXIM_PERL
4487 if (perl_start_option != 0)
4488   opt_perl_at_start = (perl_start_option > 0);
4489 if (opt_perl_at_start && opt_perl_startup != NULL)
4490   {
4491   uschar *errstr;
4492   DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
4493   if ((errstr = init_perl(opt_perl_startup)))
4494     exim_fail("exim: error in perl_startup code: %s\n", errstr);
4495   opt_perl_started = TRUE;
4496   }
4497 #endif /* EXIM_PERL */
4498
4499 /* Log the arguments of the call if the configuration file said so. This is
4500 a debugging feature for finding out what arguments certain MUAs actually use.
4501 Don't attempt it if logging is disabled, or if listing variables or if
4502 verifying/testing addresses or expansions. */
4503
4504 if (  (debug_selector & D_any  ||  LOGGING(arguments))
4505    && f.really_exim && !list_options && !checking)
4506   {
4507   uschar *p = big_buffer;
4508   Ustrcpy(p, US"cwd= (failed)");
4509
4510   if (!initial_cwd)
4511     p += 13;
4512   else
4513     {
4514     p += 4;
4515     snprintf(CS p, big_buffer_size - (p - big_buffer), "%s", CCS initial_cwd);
4516     p += Ustrlen(CCS p);
4517     }
4518
4519   (void)string_format(p, big_buffer_size - (p - big_buffer), " %d args:", argc);
4520   while (*p) p++;
4521   for (int i = 0; i < argc; i++)
4522     {
4523     int len = Ustrlen(argv[i]);
4524     const uschar *printing;
4525     uschar *quote;
4526     if (p + len + 8 >= big_buffer + big_buffer_size)
4527       {
4528       Ustrcpy(p, US" ...");
4529       log_write(0, LOG_MAIN, "%s", big_buffer);
4530       Ustrcpy(big_buffer, US"...");
4531       p = big_buffer + 3;
4532       }
4533     printing = string_printing(argv[i]);
4534     if (!*printing) quote = US"\"";
4535     else
4536       {
4537       const uschar *pp = printing;
4538       quote = US"";
4539       while (*pp) if (isspace(*pp++)) { quote = US"\""; break; }
4540       }
4541     p += sprintf(CS p, " %s%.*s%s", quote, (int)(big_buffer_size -
4542       (p - big_buffer) - 4), printing, quote);
4543     }
4544
4545   if (LOGGING(arguments))
4546     log_write(0, LOG_MAIN, "%s", big_buffer);
4547   else
4548     debug_printf("%s\n", big_buffer);
4549   }
4550
4551 /* Set the working directory to be the top-level spool directory. We don't rely
4552 on this in the code, which always uses fully qualified names, but it's useful
4553 for core dumps etc. Don't complain if it fails - the spool directory might not
4554 be generally accessible and calls with the -C option (and others) have lost
4555 privilege by now. Before the chdir, we try to ensure that the directory exists.
4556 */
4557
4558 if (Uchdir(spool_directory) != 0)
4559   {
4560   (void) directory_make(spool_directory, US"", SPOOL_DIRECTORY_MODE, FALSE);
4561   (void) Uchdir(spool_directory);
4562   }
4563
4564 /* Handle calls with the -bi option. This is a sendmail option to rebuild *the*
4565 alias file. Exim doesn't have such a concept, but this call is screwed into
4566 Sun's YP makefiles. Handle this by calling a configured script, as the real
4567 user who called Exim. The -oA option can be used to pass an argument to the
4568 script. */
4569
4570 if (bi_option)
4571   {
4572   (void) fclose(config_file);
4573   if (bi_command && *bi_command)
4574     {
4575     int i = 0;
4576     const uschar * argv[3];
4577     argv[i++] = bi_command;     /* nonexpanded option so assume untainted */
4578     if (alias_arg) argv[i++] = alias_arg;
4579     argv[i++] = NULL;
4580
4581     setgroups(group_count, group_list);
4582     exim_setugid(real_uid, real_gid, FALSE, US"running bi_command");
4583
4584     DEBUG(D_exec) debug_printf("exec '%.256s' %s%.256s%s\n", argv[0],
4585       argv[1] ? "'" : "", argv[1] ? argv[1] : US"", argv[1] ? "'" : "");
4586
4587     execv(CS argv[0], (char *const *)argv);
4588     exim_fail("exim: exec '%s' failed: %s\n", argv[0], strerror(errno));
4589     }
4590   else
4591     {
4592     DEBUG(D_any) debug_printf("-bi used but bi_command not set; exiting\n");
4593     exit(EXIT_SUCCESS);
4594     }
4595   }
4596
4597 /* We moved the admin/trusted check to be immediately after reading the
4598 configuration file.  We leave these prints here to ensure that syslog setup,
4599 logfile setup, and so on has already happened. */
4600
4601 if (f.trusted_caller) DEBUG(D_any) debug_printf("trusted user\n");
4602 if (f.admin_user) DEBUG(D_any) debug_printf("admin user\n");
4603
4604 /* Only an admin user may start the daemon or force a queue run in the default
4605 configuration, but the queue run restriction can be relaxed. Only an admin
4606 user may request that a message be returned to its sender forthwith. Only an
4607 admin user may specify a debug level greater than D_v (because it might show
4608 passwords, etc. in lookup queries). Only an admin user may request a queue
4609 count. Only an admin user can use the test interface to scan for email
4610 (because Exim will be in the spool dir and able to look at mails). */
4611
4612 if (!f.admin_user)
4613   {
4614   BOOL debugset = (debug_selector & ~D_v) != 0;
4615   if (  deliver_give_up || f.daemon_listen || malware_test_file
4616      || count_queue && queue_list_requires_admin
4617      || list_queue && queue_list_requires_admin
4618      || qrunners && prod_requires_admin
4619      || queue_name_dest && prod_requires_admin
4620      || debugset && !f.running_in_test_harness
4621      )
4622     exim_fail("exim:%s permission denied; not admin\n",
4623               debugset ? " debugging" : "");
4624   }
4625
4626 /* If the real user is not root or the exim uid, the argument for passing
4627 in an open TCP/IP connection for another message is not permitted, nor is
4628 running with the -N option for any delivery action, unless this call to exim is
4629 one that supplied an input message, or we are using a patched exim for
4630 regression testing. */
4631
4632 if (  real_uid != root_uid && real_uid != exim_uid
4633    && (  continue_hostname
4634       || (  f.dont_deliver
4635          && (qrunners || f.daemon_listen || msg_action_arg > 0)
4636       )  )
4637    && !f.running_in_test_harness
4638    )
4639   exim_fail("exim: Permission denied; not exim user or root\n");
4640
4641 /* If the caller is not trusted, certain arguments are ignored when running for
4642 real, but are permitted when checking things (-be, -bv, -bt, -bh, -bf, -bF).
4643 Note that authority for performing certain actions on messages is tested in the
4644 queue_action() function. */
4645
4646 if (!f.trusted_caller && !checking)
4647   {
4648   sender_host_name = sender_host_address = interface_address =
4649     sender_ident = received_protocol = NULL;
4650   sender_host_port = interface_port = 0;
4651   sender_host_authenticated = authenticated_sender = authenticated_id = NULL;
4652   }
4653
4654 /* If a sender host address is set, extract the optional port number off the
4655 end of it and check its syntax. Do the same thing for the interface address.
4656 Exim exits if the syntax is bad. */
4657
4658 else
4659   {
4660   if (sender_host_address)
4661     sender_host_port = check_port(sender_host_address);
4662   if (interface_address)
4663     interface_port = check_port(interface_address);
4664   }
4665
4666 /* If the caller is trusted, then they can use -G to suppress_local_fixups. */
4667 if (flag_G)
4668   {
4669   if (f.trusted_caller)
4670     {
4671     f.suppress_local_fixups = f.suppress_local_fixups_default = TRUE;
4672     DEBUG(D_acl) debug_printf("suppress_local_fixups forced on by -G\n");
4673     }
4674   else
4675     exim_fail("exim: permission denied (-G requires a trusted user)\n");
4676   }
4677
4678 /* If an SMTP message is being received check to see if the standard input is a
4679 TCP/IP socket. If it is, we assume that Exim was called from inetd if the
4680 caller is root or the Exim user, or if the port is a privileged one. Otherwise,
4681 barf. */
4682
4683 if (smtp_input)
4684   {
4685   union sockaddr_46 inetd_sock;
4686   EXIM_SOCKLEN_T size = sizeof(inetd_sock);
4687   if (getpeername(0, (struct sockaddr *)(&inetd_sock), &size) == 0)
4688     {
4689     int family = ((struct sockaddr *)(&inetd_sock))->sa_family;
4690     if (family == AF_INET || family == AF_INET6)
4691       {
4692       union sockaddr_46 interface_sock;
4693       size = sizeof(interface_sock);
4694
4695       if (getsockname(0, (struct sockaddr *)(&interface_sock), &size) == 0)
4696         interface_address = host_ntoa(-1, &interface_sock, NULL,
4697           &interface_port);
4698
4699       if (host_is_tls_on_connect_port(interface_port)) tls_in.on_connect = TRUE;
4700
4701       if (real_uid == root_uid || real_uid == exim_uid || interface_port < 1024)
4702         {
4703         f.is_inetd = TRUE;
4704         sender_host_address = host_ntoa(-1, (struct sockaddr *)(&inetd_sock),
4705           NULL, &sender_host_port);
4706         if (mua_wrapper) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Input from "
4707           "inetd is not supported when mua_wrapper is set");
4708         }
4709       else
4710         exim_fail(
4711           "exim: Permission denied (unprivileged user, unprivileged port)\n");
4712       }
4713     }
4714   }
4715
4716 /* If the load average is going to be needed while receiving a message, get it
4717 now for those OS that require the first call to os_getloadavg() to be done as
4718 root. There will be further calls later for each message received. */
4719
4720 #ifdef LOAD_AVG_NEEDS_ROOT
4721 if (  receiving_message
4722    && (queue_only_load >= 0 || (f.is_inetd && smtp_load_reserve >= 0)))
4723   load_average = OS_GETLOADAVG();
4724 #endif
4725
4726 /* The queue_only configuration option can be overridden by -odx on the command
4727 line, except that if queue_only_override is false, queue_only cannot be unset
4728 from the command line. */
4729
4730 if (queue_only_set && (queue_only_override || arg_queue_only))
4731   queue_only = arg_queue_only;
4732
4733 /* The receive_timeout and smtp_receive_timeout options can be overridden by
4734 -or and -os. */
4735
4736 if (arg_receive_timeout >= 0) receive_timeout = arg_receive_timeout;
4737 if (arg_smtp_receive_timeout >= 0)
4738   smtp_receive_timeout = arg_smtp_receive_timeout;
4739
4740 /* If Exim was started with root privilege, unless we have already removed the
4741 root privilege above as a result of -C, -D, -be, -bf or -bF, remove it now
4742 except when starting the daemon or doing some kind of delivery or address
4743 testing (-bt). These are the only cases when root need to be retained. We run
4744 as exim for -bv and -bh. However, if deliver_drop_privilege is set, root is
4745 retained only for starting the daemon. We always do the initgroups() in this
4746 situation (controlled by the TRUE below), in order to be as close as possible
4747 to the state Exim usually runs in. */
4748
4749 if (  !unprivileged                             /* originally had root AND */
4750    && !removed_privilege                        /* still got root AND      */
4751    && !f.daemon_listen                          /* not starting the daemon */
4752    && (!qrunners || is_onetime_qrun())          /* (either kind of daemon) */
4753    && (                                         /*    AND EITHER           */
4754          deliver_drop_privilege                 /* requested unprivileged  */
4755       || (                                      /*       OR                */
4756             !qrunners                           /* not running the queue   */
4757          && (  msg_action_arg < 0               /*       and               */
4758             || msg_action != MSG_DELIVER        /* not delivering          */
4759             )                                   /*       and               */
4760          && (!checking || !f.address_test_mode) /* not address checking    */
4761          && !rcpt_verify_quota                  /* and not quota checking  */
4762    )  )  )
4763   exim_setugid(exim_uid, exim_gid, TRUE, US"privilege not needed");
4764
4765 /* When we are retaining a privileged uid, we still change to the exim gid. */
4766
4767 else
4768   {
4769   int rv;
4770   DEBUG(D_any) debug_printf("dropping to exim gid; retaining priv uid\n");
4771   rv = setgid(exim_gid);
4772   /* Impact of failure is that some stuff might end up with an incorrect group.
4773   We track this for failures from root, since any attempt to change privilege
4774   by root should succeed and failures should be examined.  For non-root,
4775   there's no security risk.  For me, it's { exim -bV } on a just-built binary,
4776   no need to complain then. */
4777   if (rv == -1)
4778     if (!(unprivileged || removed_privilege))
4779       exim_fail("exim: changing group failed: %s\n", strerror(errno));
4780     else
4781       {
4782       DEBUG(D_any) debug_printf("changing group to %ld failed: %s\n",
4783           (long int)exim_gid, strerror(errno));
4784       }
4785   }
4786
4787 /* Handle a request to scan a file for malware */
4788 if (malware_test_file)
4789   {
4790 #ifdef WITH_CONTENT_SCAN
4791   int result;
4792   set_process_info("scanning file for malware");
4793   if ((result = malware_in_file(malware_test_file)) == FAIL)
4794     {
4795     printf("No malware found.\n");
4796     exim_exit(EXIT_SUCCESS);
4797     }
4798   if (result != OK)
4799     {
4800     printf("Malware lookup returned non-okay/fail: %d\n", result);
4801     exim_exit(EXIT_FAILURE);
4802     }
4803   if (malware_name)
4804     printf("Malware found: %s\n", malware_name);
4805   else
4806     printf("Malware scan detected malware of unknown name.\n");
4807 #else
4808   printf("Malware scanning not enabled at compile time.\n");
4809 #endif
4810   exim_exit(EXIT_FAILURE);
4811   }
4812
4813 /* Handle a request to list the delivery queue */
4814
4815 if (list_queue)
4816   {
4817   set_process_info("listing the queue");
4818   queue_list(list_queue_option, argv + recipients_arg, argc - recipients_arg);
4819   exim_exit(EXIT_SUCCESS);
4820   }
4821
4822 /* Handle a request to count the delivery queue */
4823
4824 if (count_queue)
4825   {
4826   set_process_info("counting the queue");
4827   fprintf(stdout, "%u\n", queue_count());
4828   exim_exit(EXIT_SUCCESS);
4829   }
4830
4831 /* Handle actions on specific messages, except for the force delivery and
4832 message load actions, which are done below. Some actions take a whole list of
4833 message ids, which are known to continue up to the end of the arguments. Others
4834 take a single message id and then operate on the recipients list. */
4835
4836 if (msg_action_arg > 0 && msg_action != MSG_DELIVER && msg_action != MSG_LOAD)
4837   {
4838   int yield = EXIT_SUCCESS;
4839   set_process_info("acting on specified messages");
4840
4841   /* ACL definitions may be needed when removing a message (-Mrm) because
4842   event_action gets expanded */
4843
4844   if (msg_action == MSG_REMOVE)
4845     {
4846     int old_pool = store_pool;
4847     store_pool = POOL_CONFIG;
4848     readconf_rest();
4849     store_pool = old_pool;
4850     store_writeprotect(POOL_CONFIG);
4851     }
4852
4853   if (!one_msg_action)
4854     {
4855     for (i = msg_action_arg; i < argc; i++)
4856       if (!queue_action(argv[i], msg_action, NULL, 0, 0))
4857         yield = EXIT_FAILURE;
4858     switch (msg_action)
4859       {
4860       case MSG_REMOVE: case MSG_FREEZE: case MSG_THAW: break;
4861       default: printf("\n"); break;
4862       }
4863     }
4864
4865   else if (!queue_action(argv[msg_action_arg], msg_action, argv, argc,
4866     recipients_arg)) yield = EXIT_FAILURE;
4867   exim_exit(yield);
4868   }
4869
4870 /* We used to set up here to skip reading the ACL section, on
4871  (msg_action_arg > 0 || (is_onetime_qrun() && !f.daemon_listen)
4872 Now, since the intro of the ${acl } expansion, ACL definitions may be
4873 needed in transports so we lost the optimisation. */
4874
4875   {
4876   int old_pool = store_pool;
4877 #ifdef MEASURE_TIMING
4878   struct timeval t0;
4879   (void)gettimeofday(&t0, NULL);
4880 #endif
4881
4882   store_pool = POOL_CONFIG;
4883   readconf_rest();
4884   store_pool = old_pool;
4885
4886   /* -be can add macro definitions, needing to link to the macro structure
4887   chain.  Otherwise, make the memory used for config data readonly. */
4888
4889   if (!expansion_test)
4890     store_writeprotect(POOL_CONFIG);
4891
4892 #ifdef MEASURE_TIMING
4893   report_time_since(&t0, US"readconf_rest (delta)");
4894 #endif
4895   }
4896
4897 /* Handle a request to check quota */
4898 if (rcpt_verify_quota)
4899   if (real_uid != root_uid && real_uid != exim_uid)
4900     exim_fail("exim: Permission denied\n");
4901   else if (recipients_arg >= argc)
4902     exim_fail("exim: missing recipient for quota check\n");
4903   else
4904     {
4905     verify_quota(US argv[recipients_arg]);      /*XXX we lose track of const here */
4906     exim_exit(EXIT_SUCCESS);
4907     }
4908
4909 /* Handle the -brt option. This is for checking out retry configurations.
4910 The next three arguments are a domain name or a complete address, and
4911 optionally two error numbers. All it does is to call the function that
4912 scans the retry configuration data. */
4913
4914 if (test_retry_arg >= 0)
4915   {
4916   retry_config *yield;
4917   int basic_errno = 0;
4918   int more_errno = 0;
4919   const uschar *s1, *s2;
4920
4921   if (test_retry_arg >= argc)
4922     {
4923     printf("-brt needs a domain or address argument\n");
4924     exim_exit(EXIT_FAILURE);
4925     }
4926   s1 = exim_str_fail_toolong(argv[test_retry_arg++], EXIM_EMAILADDR_MAX, "-brt");
4927   s2 = NULL;
4928
4929   /* If the first argument contains no @ and no . it might be a local user
4930   or it might be a single-component name. Treat as a domain. */
4931
4932   if (Ustrchr(s1, '@') == NULL && Ustrchr(s1, '.') == NULL)
4933     {
4934     printf("Warning: \"%s\" contains no '@' and no '.' characters. It is "
4935       "being \ntreated as a one-component domain, not as a local part.\n\n",
4936       s1);
4937     }
4938
4939   /* There may be an optional second domain arg. */
4940
4941   if (test_retry_arg < argc && Ustrchr(argv[test_retry_arg], '.') != NULL)
4942     s2 = exim_str_fail_toolong(argv[test_retry_arg++], EXIM_DOMAINNAME_MAX, "-brt 2nd");
4943
4944   /* The final arg is an error name */
4945
4946   if (test_retry_arg < argc)
4947     {
4948     const uschar *ss = exim_str_fail_toolong(argv[test_retry_arg], EXIM_DRIVERNAME_MAX, "-brt 3rd");
4949     uschar *error =
4950       readconf_retry_error(ss, ss + Ustrlen(ss), &basic_errno, &more_errno);
4951     if (error != NULL)
4952       {
4953       printf("%s\n", CS error);
4954       return EXIT_FAILURE;
4955       }
4956
4957     /* For the {MAIL,RCPT,DATA}_4xx errors, a value of 255 means "any", and a
4958     code > 100 as an error is for matching codes to the decade. Turn them into
4959     a real error code, off the decade. */
4960
4961     if (basic_errno == ERRNO_MAIL4XX ||
4962         basic_errno == ERRNO_RCPT4XX ||
4963         basic_errno == ERRNO_DATA4XX)
4964       {
4965       int code = (more_errno >> 8) & 255;
4966       if (code == 255)
4967         more_errno = (more_errno & 0xffff00ff) | (21 << 8);
4968       else if (code > 100)
4969         more_errno = (more_errno & 0xffff00ff) | ((code - 96) << 8);
4970       }
4971     }
4972
4973   if (!(yield = retry_find_config(s1, s2, basic_errno, more_errno)))
4974     printf("No retry information found\n");
4975   else
4976     {
4977     more_errno = yield->more_errno;
4978     printf("Retry rule: %s  ", yield->pattern);
4979
4980     if (yield->basic_errno == ERRNO_EXIMQUOTA)
4981       {
4982       printf("quota%s%s  ",
4983         (more_errno > 0)? "_" : "",
4984         (more_errno > 0)? readconf_printtime(more_errno) : US"");
4985       }
4986     else if (yield->basic_errno == ECONNREFUSED)
4987       {
4988       printf("refused%s%s  ",
4989         (more_errno > 0)? "_" : "",
4990         (more_errno == 'M')? "MX" :
4991         (more_errno == 'A')? "A" : "");
4992       }
4993     else if (yield->basic_errno == ETIMEDOUT)
4994       {
4995       printf("timeout");
4996       if ((more_errno & RTEF_CTOUT) != 0) printf("_connect");
4997       more_errno &= 255;
4998       if (more_errno != 0) printf("_%s",
4999         (more_errno == 'M')? "MX" : "A");
5000       printf("  ");
5001       }
5002     else if (yield->basic_errno == ERRNO_AUTHFAIL)
5003       printf("auth_failed  ");
5004     else printf("*  ");
5005
5006     for (retry_rule * r = yield->rules; r; r = r->next)
5007       {
5008       printf("%c,%s", r->rule, readconf_printtime(r->timeout)); /* Do not */
5009       printf(",%s", readconf_printtime(r->p1));                 /* amalgamate */
5010       if (r->rule == 'G')
5011         {
5012         int x = r->p2;
5013         int f = x % 1000;
5014         int d = 100;
5015         printf(",%d.", x/1000);
5016         do
5017           {
5018           printf("%d", f/d);
5019           f %= d;
5020           d /= 10;
5021           }
5022         while (f != 0);
5023         }
5024       printf("; ");
5025       }
5026
5027     printf("\n");
5028     }
5029   exim_exit(EXIT_SUCCESS);
5030   }
5031
5032 /* Handle a request to list one or more configuration options */
5033 /* If -n was set, we suppress some information */
5034
5035 if (list_options)
5036   {
5037   BOOL fail = FALSE;
5038   set_process_info("listing variables");
5039   if (recipients_arg >= argc)
5040     fail = !readconf_print(US"all", NULL, flag_n);
5041   else for (i = recipients_arg; i < argc; i++)
5042     {
5043     if (i < argc - 1 &&
5044         (Ustrcmp(argv[i], "router") == 0 ||
5045          Ustrcmp(argv[i], "transport") == 0 ||
5046          Ustrcmp(argv[i], "authenticator") == 0 ||
5047          Ustrcmp(argv[i], "macro") == 0 ||
5048          Ustrcmp(argv[i], "environment") == 0))
5049       {
5050       fail |= !readconf_print(exim_str_fail_toolong(argv[i+1], EXIM_DRIVERNAME_MAX, "-bP name"), argv[i], flag_n);
5051       i++;
5052       }
5053     else
5054       fail = !readconf_print(exim_str_fail_toolong(argv[i], EXIM_DRIVERNAME_MAX, "-bP item"), NULL, flag_n);
5055     }
5056   exim_exit(fail ? EXIT_FAILURE : EXIT_SUCCESS);
5057   }
5058
5059 if (list_config)
5060   {
5061   set_process_info("listing config");
5062   exim_exit(readconf_print(US"config", NULL, flag_n)
5063                 ? EXIT_SUCCESS : EXIT_FAILURE);
5064   }
5065
5066
5067 /* Initialise subsystems as required. */
5068
5069 tcp_init();
5070
5071 /* Handle a request to deliver one or more messages that are already on the
5072 queue. Values of msg_action other than MSG_DELIVER and MSG_LOAD are dealt with
5073 above. MSG_LOAD is handled with -be (which is the only time it applies) below.
5074
5075 Delivery of specific messages is typically used for a small number when
5076 prodding by hand (when the option forced_delivery will be set) or when
5077 re-execing to regain root privilege. Each message delivery must happen in a
5078 separate process, so we fork a process for each one, and run them sequentially
5079 so that debugging output doesn't get intertwined, and to avoid spawning too
5080 many processes if a long list is given. However, don't fork for the last one;
5081 this saves a process in the common case when Exim is called to deliver just one
5082 message. */
5083
5084 if (msg_action_arg > 0 && msg_action != MSG_LOAD)
5085   {
5086   if (prod_requires_admin && !f.admin_user)
5087     {
5088     fprintf(stderr, "exim: Permission denied\n");
5089     exim_exit(EXIT_FAILURE);
5090     }
5091   set_process_info("delivering specified messages");
5092   if (deliver_give_up) forced_delivery = f.deliver_force_thaw = TRUE;
5093   for (i = msg_action_arg; i < argc; i++)
5094     {
5095     int status;
5096     pid_t pid;
5097     /*XXX This use of argv[i] for msg_id should really be tainted, but doing
5098     that runs into a later copy into the untainted global message_id[] */
5099     /*XXX Do we need a length limit check here? */
5100     if (i == argc - 1)
5101       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
5102     else if ((pid = exim_fork(US"cmdline-delivery")) == 0)
5103       {
5104       (void)deliver_message(argv[i], forced_delivery, deliver_give_up);
5105       exim_underbar_exit(EXIT_SUCCESS);
5106       }
5107     else if (pid < 0)
5108       {
5109       fprintf(stderr, "failed to fork delivery process for %s: %s\n", argv[i],
5110         strerror(errno));
5111       exim_exit(EXIT_FAILURE);
5112       }
5113     else wait(&status);
5114     }
5115   exim_exit(EXIT_SUCCESS);
5116   }
5117
5118
5119 /* If only a single queue run is requested, without SMTP listening, we can just
5120 turn into a queue runner, with an optional starting message id. */
5121
5122 if (is_onetime_qrun() && !f.daemon_listen)
5123   {
5124   single_queue_run(qrunners, start_queue_run_id, stop_queue_run_id);
5125   exim_exit(EXIT_SUCCESS);
5126   }
5127
5128
5129 /* Find the login name of the real user running this process. This is always
5130 needed when receiving a message, because it is written into the spool file. It
5131 may also be used to construct a from: or a sender: header, and in this case we
5132 need the user's full name as well, so save a copy of it, checked for RFC822
5133 syntax and munged if necessary, if it hasn't previously been set by the -F
5134 argument. We may try to get the passwd entry more than once, in case NIS or
5135 other delays are in evidence. Save the home directory for use in filter testing
5136 (only). */
5137
5138 for (i = 0;;)
5139   {
5140   if ((pw = getpwuid(real_uid)) != NULL)
5141     {
5142     originator_login = string_copy(US pw->pw_name);
5143     originator_home = string_copy(US pw->pw_dir);
5144
5145     /* If user name has not been set by -F, set it from the passwd entry
5146     unless -f has been used to set the sender address by a trusted user. */
5147
5148     if (!originator_name)
5149       {
5150       if (!sender_address || (!f.trusted_caller && filter_test == FTEST_NONE))
5151         {
5152         uschar *name = US pw->pw_gecos;
5153         uschar *amp = Ustrchr(name, '&');
5154         uschar buffer[256];
5155
5156         /* Most Unix specify that a '&' character in the gecos field is
5157         replaced by a copy of the login name, and some even specify that
5158         the first character should be upper cased, so that's what we do. */
5159
5160         if (amp)
5161           {
5162           int loffset;
5163           string_format(buffer, sizeof(buffer), "%.*s%n%s%s",
5164             (int)(amp - name), name, &loffset, originator_login, amp + 1);
5165           buffer[loffset] = toupper(buffer[loffset]);
5166           name = buffer;
5167           }
5168
5169         /* If a pattern for matching the gecos field was supplied, apply
5170         it and then expand the name string. */
5171
5172         GET_OPTION("gecos_pattern");
5173         GET_OPTION("gecos_name");
5174         if (gecos_pattern && gecos_name)
5175           {
5176           const pcre2_code *re;
5177           re = regex_must_compile(gecos_pattern, MCS_NOFLAGS, TRUE); /* Use malloc */
5178
5179           if (regex_match_and_setup(re, name, 0, -1))
5180             {
5181             uschar *new_name = expand_string(gecos_name);
5182             expand_nmax = -1;
5183             if (new_name)
5184               {
5185               DEBUG(D_receive) debug_printf("user name \"%s\" extracted from "
5186                 "gecos field \"%s\"\n", new_name, name);
5187               name = new_name;
5188               }
5189             else DEBUG(D_receive) debug_printf("failed to expand gecos_name string "
5190               "\"%s\": %s\n", gecos_name, expand_string_message);
5191             }
5192           else DEBUG(D_receive) debug_printf("gecos_pattern \"%s\" did not match "
5193             "gecos field \"%s\"\n", gecos_pattern, name);
5194           store_free((void *)re);
5195           }
5196         originator_name = string_copy(name);
5197         }
5198
5199       /* A trusted caller has used -f but not -F */
5200
5201       else originator_name = US"";
5202       }
5203
5204     /* Break the retry loop */
5205
5206     break;
5207     }
5208
5209   if (++i > finduser_retries) break;
5210   sleep(1);
5211   }
5212
5213 /* If we cannot get a user login, log the incident and give up, unless the
5214 configuration specifies something to use. When running in the test harness,
5215 any setting of unknown_login overrides the actual name. */
5216
5217 if (!originator_login || f.running_in_test_harness)
5218   {
5219   GET_OPTION("unknown_login");
5220   if (unknown_login)
5221     {
5222     originator_login = expand_string(unknown_login);
5223     if (!originator_name && unknown_username)
5224       originator_name = expand_string(unknown_username);
5225     if (!originator_name) originator_name = US"";
5226     }
5227   if (!originator_login)
5228     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to get user name for uid %d",
5229       (int)real_uid);
5230   }
5231
5232 /* Ensure that the user name is in a suitable form for use as a "phrase" in an
5233 RFC822 address.*/
5234
5235 originator_name = US parse_fix_phrase(originator_name, Ustrlen(originator_name));
5236
5237 /* If a message is created by this call of Exim, the uid/gid of its originator
5238 are those of the caller. These values are overridden if an existing message is
5239 read in from the spool. */
5240
5241 originator_uid = real_uid;
5242 originator_gid = real_gid;
5243
5244 DEBUG(D_receive) debug_printf("originator: uid=%d gid=%d login=%s name=%s\n",
5245   (int)originator_uid, (int)originator_gid, originator_login, originator_name);
5246
5247 /* Run in daemon and/or queue-running mode. The function daemon_go() never
5248 returns. We leave this till here so that the originator_ fields are available
5249 for incoming messages via the daemon. The daemon cannot be run in mua_wrapper
5250 mode. */
5251
5252 if (f.daemon_listen || f.inetd_wait_mode || is_multiple_qrun())
5253   {
5254   if (mua_wrapper)
5255     {
5256     fprintf(stderr, "Daemon cannot be run when mua_wrapper is set\n");
5257     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Daemon cannot be run when "
5258       "mua_wrapper is set");
5259     }
5260
5261 # ifndef DISABLE_TLS
5262   /* This also checks that the library linkage is working and we can call
5263   routines in it, so call even if tls_require_ciphers is unset */
5264     {
5265 # ifdef MEASURE_TIMING
5266     struct timeval t0;
5267     (void)gettimeofday(&t0, NULL);
5268 # endif
5269     if (!tls_dropprivs_validate_require_cipher(FALSE))
5270       exim_exit(EXIT_FAILURE);
5271 # ifdef MEASURE_TIMING
5272     report_time_since(&t0, US"validate_ciphers (delta)");
5273 # endif
5274     }
5275 #endif
5276
5277   daemon_go();
5278   }
5279
5280 /* If the sender ident has not been set (by a trusted caller) set it to
5281 the caller. This will get overwritten below for an inetd call. If a trusted
5282 caller has set it empty, unset it. */
5283
5284 if (!sender_ident) sender_ident = originator_login;
5285 else if (!*sender_ident) sender_ident = NULL;
5286
5287 /* Handle the -brw option, which is for checking out rewriting rules. Cause log
5288 writes (on errors) to go to stderr instead. Can't do this earlier, as want the
5289 originator_* variables set. */
5290
5291 if (test_rewrite_arg >= 0)
5292   {
5293   f.really_exim = FALSE;
5294   if (test_rewrite_arg >= argc)
5295     {
5296     printf("-brw needs an address argument\n");
5297     exim_exit(EXIT_FAILURE);
5298     }
5299   rewrite_test(exim_str_fail_toolong(argv[test_rewrite_arg], EXIM_EMAILADDR_MAX, "-brw"));
5300   exim_exit(EXIT_SUCCESS);
5301   }
5302
5303 /* A locally-supplied message is considered to be coming from a local user
5304 unless a trusted caller supplies a sender address with -f, or is passing in the
5305 message via SMTP (inetd invocation or otherwise). */
5306
5307 if (  !sender_address && !smtp_input
5308    || !f.trusted_caller && filter_test == FTEST_NONE)
5309   {
5310   f.sender_local = TRUE;
5311
5312   /* A trusted caller can supply authenticated_sender and authenticated_id
5313   via -oMas and -oMai and if so, they will already be set. Otherwise, force
5314   defaults except when host checking. */
5315
5316   if (!authenticated_sender && !host_checking)
5317     authenticated_sender = string_sprintf("%s@%s", originator_login,
5318       qualify_domain_sender);
5319   if (!authenticated_id && !host_checking)
5320     authenticated_id = originator_login;
5321   }
5322
5323 /* Trusted callers are always permitted to specify the sender address.
5324 Untrusted callers may specify it if it matches untrusted_set_sender, or if what
5325 is specified is the empty address. However, if a trusted caller does not
5326 specify a sender address for SMTP input, we leave sender_address unset. This
5327 causes the MAIL commands to be honoured. */
5328
5329 if (  !smtp_input && !sender_address
5330    || !receive_check_set_sender(sender_address))
5331   {
5332   /* Either the caller is not permitted to set a general sender, or this is
5333   non-SMTP input and the trusted caller has not set a sender. If there is no
5334   sender, or if a sender other than <> is set, override with the originator's
5335   login (which will get qualified below), except when checking things. */
5336
5337   if (  !sender_address                  /* No sender_address set */
5338      ||                                  /*         OR            */
5339        (sender_address[0] != 0 &&        /* Non-empty sender address, AND */
5340        !checking))                       /* Not running tests, including filter tests */
5341     {
5342     sender_address = originator_login;
5343     f.sender_address_forced = FALSE;
5344     sender_address_domain = 0;
5345     }
5346   }
5347
5348 /* Remember whether an untrusted caller set the sender address */
5349
5350 f.sender_set_untrusted = sender_address != originator_login && !f.trusted_caller;
5351
5352 /* Ensure that the sender address is fully qualified unless it is the empty
5353 address, which indicates an error message, or doesn't exist (root caller, smtp
5354 interface, no -f argument). */
5355
5356 if (sender_address && *sender_address && sender_address_domain == 0)
5357   sender_address = string_sprintf("%s@%s", local_part_quote(sender_address),
5358     qualify_domain_sender);
5359
5360 DEBUG(D_receive) debug_printf("sender address = %s\n", sender_address);
5361
5362 /* Handle a request to verify a list of addresses, or test them for delivery.
5363 This must follow the setting of the sender address, since routers can be
5364 predicated upon the sender. If no arguments are given, read addresses from
5365 stdin. Set debug_level to at least D_v to get full output for address testing.
5366 */
5367
5368 if (verify_address_mode || f.address_test_mode)
5369   {
5370   int exit_value = 0;
5371   int flags = vopt_qualify;
5372
5373   if (verify_address_mode)
5374     {
5375     if (!verify_as_sender) flags |= vopt_is_recipient;
5376     DEBUG(D_verify) debug_print_ids(US"Verifying:");
5377     }
5378
5379   else
5380     {
5381     flags |= vopt_is_recipient;
5382     debug_selector |= D_v;
5383     debug_file = stderr;
5384     debug_fd = fileno(debug_file);
5385     DEBUG(D_verify) debug_print_ids(US"Address testing:");
5386     }
5387
5388   if (recipients_arg < argc)
5389     while (recipients_arg < argc)
5390       {
5391       /* Supplied addresses are tainted since they come from a user */
5392       uschar * s = string_copy_taint(
5393         exim_str_fail_toolong(argv[recipients_arg++], EXIM_DISPLAYMAIL_MAX, "address verification"),
5394         GET_TAINTED);
5395       while (*s)
5396         {
5397         BOOL finished = FALSE;
5398         uschar *ss = parse_find_address_end(s, FALSE);
5399         if (*ss == ',') *ss = 0; else finished = TRUE;
5400         test_address(s, flags, &exit_value);
5401         s = ss;
5402         if (!finished)
5403           while (*++s == ',' || isspace(*s)) ;
5404         }
5405       }
5406
5407   else for (;;)
5408     {
5409     uschar * s = get_stdinput(NULL, NULL);
5410     if (!s) break;
5411     test_address(string_copy_taint(
5412         exim_str_fail_toolong(s, EXIM_DISPLAYMAIL_MAX, "address verification (stdin)"),
5413         GET_TAINTED),
5414       flags, &exit_value);
5415     }
5416
5417   route_tidyup();
5418   exim_exit(exit_value);
5419   }
5420
5421 /* Handle expansion checking. Either expand items on the command line, or read
5422 from stdin if there aren't any. If -Mset was specified, load the message so
5423 that its variables can be used, but restrict this facility to admin users.
5424 Otherwise, if -bem was used, read a message from stdin. */
5425
5426 if (expansion_test)
5427   {
5428   dns_init(FALSE, FALSE, FALSE);
5429   if (msg_action_arg > 0 && msg_action == MSG_LOAD)
5430     {
5431     uschar * spoolname;
5432     if (!f.admin_user)
5433       exim_fail("exim: permission denied\n");
5434     message_id = US exim_str_fail_toolong(argv[msg_action_arg], MESSAGE_ID_LENGTH, "message-id");
5435     /* Checking the length of the ID is sufficient to validate it.
5436     Get an untainted version so file opens can be done. */
5437     message_id = string_copy_taint(message_id, GET_UNTAINTED);
5438
5439     spoolname = string_sprintf("%s-H", message_id);
5440     if ((deliver_datafile = spool_open_datafile(message_id)) < 0)
5441       printf ("Failed to load message datafile %s\n", message_id);
5442     if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
5443       printf ("Failed to load message %s\n", message_id);
5444     }
5445
5446   /* Read a test message from a file. We fudge it up to be on stdin, saving
5447   stdin itself for later reading of expansion strings. */
5448
5449   else if (expansion_test_message)
5450     {
5451     uschar * rme = expand_string(recipients_max);
5452     int save_stdin = dup(0);
5453     int fd = Uopen(expansion_test_message, O_RDONLY, 0);
5454     if (fd < 0)
5455       exim_fail("exim: failed to open %s: %s\n", expansion_test_message,
5456         strerror(errno));
5457     (void) dup2(fd, 0);
5458     filter_test = FTEST_USER;      /* Fudge to make it look like filter test */
5459     message_ended = END_NOTENDED;
5460     recipients_max_expanded = atoi(CCS rme);
5461     read_message_body(receive_msg(extract_recipients));
5462     message_linecount += body_linecount;
5463     (void)dup2(save_stdin, 0);
5464     (void)close(save_stdin);
5465     clearerr(stdin);               /* Required by Darwin */
5466     }
5467
5468   /* Only admin users may see config-file macros this way */
5469
5470   if (!f.admin_user) macros_user = macros = mlast = NULL;
5471
5472   /* Allow $recipients for this testing */
5473
5474   f.enable_dollar_recipients = TRUE;
5475
5476   /* Expand command line items */
5477
5478   if (recipients_arg < argc)
5479     while (recipients_arg < argc)
5480       expansion_test_line(exim_str_fail_toolong(argv[recipients_arg++], EXIM_EMAILADDR_MAX, "recipient"));
5481
5482   /* Read stdin */
5483
5484   else
5485     {
5486     char *(*fn_readline)(const char *) = NULL;
5487     void (*fn_addhist)(const char *) = NULL;
5488     uschar * s;
5489
5490 #ifdef USE_READLINE
5491     void *dlhandle = set_readline(&fn_readline, &fn_addhist);
5492 #endif
5493
5494     while (s = get_stdinput(fn_readline, fn_addhist))
5495       expansion_test_line(s);
5496
5497 #ifdef USE_READLINE
5498     if (dlhandle) dlclose(dlhandle);
5499 #endif
5500     }
5501
5502   /* The data file will be open after -Mset */
5503
5504   if (deliver_datafile >= 0)
5505     {
5506     (void)close(deliver_datafile);
5507     deliver_datafile = -1;
5508     }
5509
5510   exim_exit(EXIT_SUCCESS);
5511   }
5512
5513
5514 /* The active host name is normally the primary host name, but it can be varied
5515 for hosts that want to play several parts at once. We need to ensure that it is
5516 set for host checking, and for receiving messages. */
5517
5518 smtp_active_hostname = primary_hostname;
5519 GET_OPTION("smtp_active_hostname");
5520 if (raw_active_hostname)
5521   {
5522   uschar * nah = expand_string(raw_active_hostname);
5523   if (!nah)
5524     {
5525     if (!f.expand_string_forcedfail)
5526       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand \"%s\" "
5527         "(smtp_active_hostname): %s", raw_active_hostname,
5528         expand_string_message);
5529     }
5530   else if (nah[0]) smtp_active_hostname = nah;
5531   }
5532
5533 /* Handle host checking: this facility mocks up an incoming SMTP call from a
5534 given IP address so that the blocking and relay configuration can be tested.
5535 Unless a sender_ident was set by -oMt, we discard it (the default is the
5536 caller's login name). An RFC 1413 call is made only if we are running in the
5537 test harness and an incoming interface and both ports are specified, because
5538 there is no TCP/IP call to find the ident for. */
5539
5540 if (host_checking)
5541   {
5542   int x[4];
5543   int size;
5544
5545   if (!sender_ident_set)
5546     {
5547     sender_ident = NULL;
5548     if (f.running_in_test_harness && sender_host_port
5549        && interface_address && interface_port)
5550       verify_get_ident(1223);           /* note hardwired port number */
5551     }
5552
5553   /* In case the given address is a non-canonical IPv6 address, canonicalize
5554   it. Use the compressed form for IPv6. */
5555
5556   size = host_aton(sender_host_address, x);
5557   sender_host_address = store_get(48, GET_UNTAINTED);  /* large enough for full IPv6 */
5558   if (size == 1)
5559     (void) host_nmtoa(size, x, -1, sender_host_address, ':');
5560   else
5561     (void) ipv6_nmtoa(x, sender_host_address);
5562
5563   /* Now set up for testing */
5564
5565   host_build_sender_fullhost();
5566   smtp_input = TRUE;
5567   smtp_in = stdin;
5568   smtp_out = stdout;
5569   f.sender_local = FALSE;
5570   f.sender_host_notsocket = TRUE;
5571   debug_file = stderr;
5572   debug_fd = fileno(debug_file);
5573   fprintf(stdout, "\n**** SMTP testing session as if from host %s\n"
5574     "**** but without any ident (RFC 1413) callback.\n"
5575     "**** This is not for real!\n\n",
5576       sender_host_address);
5577
5578   set_connection_id();
5579   memset(sender_host_cache, 0, sizeof(sender_host_cache));
5580   if (verify_check_host(&hosts_connection_nolog) == OK)
5581     {
5582     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
5583     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_no_mail);
5584     }
5585   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
5586
5587   /* NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,
5588   because a log line has already been written for all its failure exists
5589   (usually "connection refused: <reason>") and writing another one is
5590   unnecessary clutter. */
5591
5592   if (smtp_start_session())
5593     {
5594     rmark reset_point;
5595     for (; (reset_point = store_mark()); store_reset(reset_point))
5596       {
5597       if (smtp_setup_msg() <= 0) break;
5598       if (!receive_msg(FALSE)) break;
5599
5600       return_path = sender_address = NULL;
5601       dnslist_domain = dnslist_matched = NULL;
5602 #ifndef DISABLE_DKIM
5603       dkim_cur_signer = NULL;
5604 #endif
5605       acl_var_m = NULL;
5606       deliver_localpart_orig = NULL;
5607       deliver_domain_orig = NULL;
5608       callout_address = sending_ip_address = NULL;
5609       deliver_localpart_data = deliver_domain_data =
5610       recipient_data = sender_data = NULL;
5611       sender_rate = sender_rate_limit = sender_rate_period = NULL;
5612       }
5613     smtp_log_no_mail();
5614     }
5615   exim_exit(EXIT_SUCCESS);
5616   }
5617
5618
5619 /* Arrange for message reception if recipients or SMTP were specified;
5620 otherwise complain unless a version print (-bV) happened or this is a filter
5621 verification test or info dump.
5622 In the former case, show the configuration file name. */
5623
5624 if (recipients_arg >= argc && !extract_recipients && !smtp_input)
5625   {
5626   if (version_printed)
5627     {
5628     if (Ustrchr(config_main_filelist, ':'))
5629       printf("Configuration file search path is %s\n", config_main_filelist);
5630     printf("Configuration file is %s\n", config_main_filename);
5631     return EXIT_SUCCESS;
5632     }
5633
5634   if (info_flag != CMDINFO_NONE)
5635     {
5636     show_exim_information(info_flag, info_stdout ? stdout : stderr);
5637     return info_stdout ? EXIT_SUCCESS : EXIT_FAILURE;
5638     }
5639
5640   if (filter_test == FTEST_NONE)
5641     exim_usage(called_as);
5642   }
5643
5644
5645 /* If mua_wrapper is set, Exim is being used to turn an MUA that submits on the
5646 standard input into an MUA that submits to a smarthost over TCP/IP. We know
5647 that we are not called from inetd, because that is rejected above. The
5648 following configuration settings are forced here:
5649
5650   (1) Synchronous delivery (-odi)
5651   (2) Errors to stderr (-oep == -oeq)
5652   (3) No parallel remote delivery
5653   (4) Unprivileged delivery
5654
5655 We don't force overall queueing options because there are several of them;
5656 instead, queueing is avoided below when mua_wrapper is set. However, we do need
5657 to override any SMTP queueing. */
5658
5659 if (mua_wrapper)
5660   {
5661   f.synchronous_delivery = TRUE;
5662   arg_error_handling = ERRORS_STDERR;
5663   remote_max_parallel = 1;
5664   deliver_drop_privilege = TRUE;
5665   f.queue_smtp = FALSE;
5666   queue_smtp_domains = NULL;
5667 #ifdef SUPPORT_I18N
5668   message_utf8_downconvert = -1;        /* convert-if-needed */
5669 #endif
5670   }
5671
5672
5673 /* Prepare to accept one or more new messages on the standard input. When a
5674 message has been read, its id is returned in message_id[]. If doing immediate
5675 delivery, we fork a delivery process for each received message, except for the
5676 last one, where we can save a process switch.
5677
5678 It is only in non-smtp mode that error_handling is allowed to be changed from
5679 its default of ERRORS_SENDER by argument. (Idle thought: are any of the
5680 sendmail error modes other than -oem ever actually used? Later: yes.) */
5681
5682 if (!smtp_input) error_handling = arg_error_handling;
5683
5684 /* If this is an inetd call, ensure that stderr is closed to prevent panic
5685 logging being sent down the socket and make an identd call to get the
5686 sender_ident. */
5687
5688 else if (f.is_inetd)
5689   {
5690   (void)fclose(stderr);
5691   exim_nullstd();                       /* Re-open to /dev/null */
5692   verify_get_ident(IDENT_PORT);
5693   host_build_sender_fullhost();
5694   set_process_info("handling incoming connection from %s via inetd",
5695     sender_fullhost);
5696   }
5697
5698 /* If the sender host address has been set, build sender_fullhost if it hasn't
5699 already been done (which it will have been for inetd). This caters for the
5700 case when it is forced by -oMa. However, we must flag that it isn't a socket,
5701 so that the test for IP options is skipped for -bs input. */
5702
5703 if (sender_host_address && !sender_fullhost)
5704   {
5705   host_build_sender_fullhost();
5706   set_process_info("handling incoming connection from %s via -oMa",
5707     sender_fullhost);
5708   f.sender_host_notsocket = TRUE;
5709   }
5710
5711 /* Otherwise, set the sender host as unknown except for inetd calls. This
5712 prevents host checking in the case of -bs not from inetd and also for -bS. */
5713
5714 else if (!f.is_inetd) f.sender_host_unknown = TRUE;
5715
5716 /* If stdout does not exist, then dup stdin to stdout. This can happen
5717 if exim is started from inetd. In this case fd 0 will be set to the socket,
5718 but fd 1 will not be set. This also happens for passed SMTP channels. */
5719
5720 if (fstat(1, &statbuf) < 0) (void)dup2(0, 1);
5721
5722 /* Set up the incoming protocol name and the state of the program. Root is
5723 allowed to force received protocol via the -oMr option above. If we have come
5724 via inetd, the process info has already been set up. We don't set
5725 received_protocol here for smtp input, as it varies according to
5726 batch/HELO/EHLO/AUTH/TLS. */
5727
5728 if (smtp_input)
5729   {
5730   if (!f.is_inetd) set_process_info("accepting a local %sSMTP message from <%s>",
5731     smtp_batched_input? "batched " : "",
5732     sender_address ? sender_address : originator_login);
5733   }
5734 else
5735   {
5736   int old_pool = store_pool;
5737   store_pool = POOL_PERM;
5738   if (!received_protocol)
5739     received_protocol = string_sprintf("local%s", called_as);
5740   store_pool = old_pool;
5741   set_process_info("accepting a local non-SMTP message from <%s>",
5742     sender_address);
5743   }
5744
5745 /* Initialize the session_local_queue-only flag (this will be ignored if
5746 mua_wrapper is set) */
5747
5748 queue_check_only();
5749 session_local_queue_only = queue_only;
5750
5751 /* For non-SMTP and for batched SMTP input, check that there is enough space on
5752 the spool if so configured. On failure, we must not attempt to send an error
5753 message! (For interactive SMTP, the check happens at MAIL FROM and an SMTP
5754 error code is given.) */
5755
5756 if ((!smtp_input || smtp_batched_input) && !receive_check_fs(0))
5757   exim_fail("exim: insufficient disk space\n");
5758
5759 /* If this is smtp input of any kind, real or batched, handle the start of the
5760 SMTP session.
5761
5762 NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,
5763 because a log line has already been written for all its failure exists
5764 (usually "connection refused: <reason>") and writing another one is
5765 unnecessary clutter. */
5766
5767 set_connection_id();
5768 if (smtp_input)
5769   {
5770   smtp_in = stdin;
5771   smtp_out = stdout;
5772   memset(sender_host_cache, 0, sizeof(sender_host_cache));
5773   if (verify_check_host(&hosts_connection_nolog) == OK)
5774     {
5775     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_connection);
5776     BIT_CLEAR(log_selector, log_selector_size, Li_smtp_no_mail);
5777     }
5778   log_write(L_smtp_connection, LOG_MAIN, "%s", smtp_get_connection_info());
5779   if (!smtp_start_session())
5780     {
5781     mac_smtp_fflush();
5782     exim_exit(EXIT_SUCCESS);
5783     }
5784   }
5785
5786 /* Otherwise, set up the input size limit here and set no stdin stdio buffer
5787 (we handle buferring so as to have visibility of fill level). */
5788
5789 else
5790   {
5791   GET_OPTION("message_size_limit");
5792   thismessage_size_limit = expand_string_integer(message_size_limit, TRUE);
5793   if (expand_string_message)
5794     if (thismessage_size_limit == -1)
5795       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand "
5796         "message_size_limit: %s", expand_string_message);
5797     else
5798       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "invalid value for "
5799         "message_size_limit: %s", expand_string_message);
5800
5801   setvbuf(stdin, NULL, _IONBF, 0);
5802   }
5803
5804 /* Loop for several messages when reading SMTP input. If we fork any child
5805 processes, we don't want to wait for them unless synchronous delivery is
5806 requested, so set SIGCHLD to SIG_IGN in that case. This is not necessarily the
5807 same as SIG_DFL, despite the fact that documentation often lists the default as
5808 "ignore". This is a confusing area. This is what I know:
5809
5810 At least on some systems (e.g. Solaris), just setting SIG_IGN causes child
5811 processes that complete simply to go away without ever becoming defunct. You
5812 can't then wait for them - but we don't want to wait for them in the
5813 non-synchronous delivery case. However, this behaviour of SIG_IGN doesn't
5814 happen for all OS (e.g. *BSD is different).
5815
5816 But that's not the end of the story. Some (many? all?) systems have the
5817 SA_NOCLDWAIT option for sigaction(). This requests the behaviour that Solaris
5818 has by default, so it seems that the difference is merely one of default
5819 (compare restarting vs non-restarting signals).
5820
5821 To cover all cases, Exim sets SIG_IGN with SA_NOCLDWAIT here if it can. If not,
5822 it just sets SIG_IGN. To be on the safe side it also calls waitpid() at the end
5823 of the loop below. Paranoia rules.
5824
5825 February 2003: That's *still* not the end of the story. There are now versions
5826 of Linux (where SIG_IGN does work) that are picky. If, having set SIG_IGN, a
5827 process then calls waitpid(), a grumble is written to the system log, because
5828 this is logically inconsistent. In other words, it doesn't like the paranoia.
5829 As a consequence of this, the waitpid() below is now excluded if we are sure
5830 that SIG_IGN works. */
5831
5832 if (!f.synchronous_delivery)
5833   {
5834 #ifdef SA_NOCLDWAIT
5835   struct sigaction act;
5836   act.sa_handler = SIG_IGN;
5837   sigemptyset(&(act.sa_mask));
5838   act.sa_flags = SA_NOCLDWAIT;
5839   sigaction(SIGCHLD, &act, NULL);
5840 #else
5841   signal(SIGCHLD, SIG_IGN);
5842 #endif
5843   }
5844
5845 /* Save the current store pool point, for resetting at the start of
5846 each message, and save the real sender address, if any. */
5847
5848 real_sender_address = sender_address;
5849
5850 /* Loop to receive messages; receive_msg() returns TRUE if there are more
5851 messages to be read (SMTP input), or FALSE otherwise (not SMTP, or SMTP channel
5852 collapsed). */
5853
5854 for (BOOL more = TRUE; more; )
5855   {
5856   rmark reset_point = store_mark();
5857   message_id[0] = 0;
5858
5859   /* Handle the SMTP case; call smtp_setup_mst() to deal with the initial SMTP
5860   input and build the recipients list, before calling receive_msg() to read the
5861   message proper. Whatever sender address is given in the SMTP transaction is
5862   often ignored for local senders - we use the actual sender, which is normally
5863   either the underlying user running this process or a -f argument provided by
5864   a trusted caller. It is saved in real_sender_address. The test for whether to
5865   accept the SMTP sender is encapsulated in receive_check_set_sender(). */
5866
5867   if (smtp_input)
5868     {
5869     int rc;
5870     if ((rc = smtp_setup_msg()) > 0)
5871       {
5872       if (   real_sender_address
5873           && !receive_check_set_sender(sender_address))
5874         {
5875         sender_address = raw_sender = real_sender_address;
5876         sender_address_unrewritten = NULL;
5877         }
5878
5879       /* For batched SMTP, we have to run the acl_not_smtp_start ACL, since it
5880       isn't really SMTP, so no other ACL will run until the acl_not_smtp one at
5881       the very end. The result of the ACL is ignored (as for other non-SMTP
5882       messages). It is run for its potential side effects. */
5883
5884       if (smtp_batched_input)
5885         {
5886         GET_OPTION("acl_not_smtp_start");
5887         if (acl_not_smtp_start)
5888           {
5889           uschar * user_msg, * log_msg;
5890           f.enable_dollar_recipients = TRUE;
5891           (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
5892             &user_msg, &log_msg);
5893           f.enable_dollar_recipients = FALSE;
5894           }
5895         }
5896
5897       /* Now get the data for the message */
5898
5899       more = receive_msg(extract_recipients);
5900       if (!message_id[0])
5901         {
5902         cancel_cutthrough_connection(TRUE, US"receive dropped");
5903         if (more) goto MORELOOP;
5904         smtp_log_no_mail();               /* Log no mail if configured */
5905         exim_exit(EXIT_FAILURE);
5906         }
5907       }
5908     else
5909       {
5910       cancel_cutthrough_connection(TRUE, US"message setup dropped");
5911       smtp_log_no_mail();               /* Log no mail if configured */
5912       exim_exit(rc ? EXIT_FAILURE : EXIT_SUCCESS);
5913       }
5914     }
5915
5916   /* In the non-SMTP case, we have all the information from the command
5917   line, but must process it in case it is in the more general RFC822
5918   format, and in any case, to detect syntax errors. Also, it appears that
5919   the use of comma-separated lists as single arguments is common, so we
5920   had better support them. */
5921
5922   else
5923     {
5924     uschar * rme = expand_string(recipients_max);
5925     int rcount = 0, count = argc - recipients_arg;
5926     const uschar ** list = argv + recipients_arg;
5927
5928     recipients_max_expanded = atoi(CCS rme);
5929
5930     /* These options cannot be changed dynamically for non-SMTP messages */
5931
5932     f.active_local_sender_retain = local_sender_retain;
5933     f.active_local_from_check = local_from_check;
5934
5935     /* Save before any rewriting */
5936
5937     raw_sender = string_copy(sender_address);
5938
5939     /* Loop for each argument (supplied by user hence tainted) */
5940
5941     for (int i = 0; i < count; i++)
5942       {
5943       int start, end, domain;
5944       uschar * errmess;
5945       /* There can be multiple addresses, so EXIM_DISPLAYMAIL_MAX (tuned for 1) is too short.
5946       We'll still want to cap it to something, just in case. */
5947       uschar * s = string_copy_taint(
5948         exim_str_fail_toolong(list[i], BIG_BUFFER_SIZE, "address argument"),
5949         GET_TAINTED);
5950
5951       /* Loop for each comma-separated address */
5952
5953       while (*s)
5954         {
5955         BOOL finished = FALSE;
5956         uschar * recipient;
5957         uschar * ss = parse_find_address_end(s, FALSE);
5958
5959         if (*ss == ',') *ss = 0; else finished = TRUE;
5960
5961         /* Check max recipients - if -t was used, these aren't recipients */
5962
5963         if (  recipients_max_expanded > 0 && ++rcount > recipients_max_expanded
5964            && !extract_recipients)
5965           {
5966           DEBUG(D_all) debug_printf("excess reipients (max %d)\n",
5967             recipients_max_expanded);
5968
5969           if (error_handling == ERRORS_STDERR)
5970             {
5971             fprintf(stderr, "exim: too many recipients\n");
5972             exim_exit(EXIT_FAILURE);
5973             }
5974           else
5975             return
5976               moan_to_sender(ERRMESS_TOOMANYRECIP, NULL, NULL, stdin, TRUE)?
5977                 errors_sender_rc : EXIT_FAILURE;
5978           }
5979
5980 #ifdef SUPPORT_I18N
5981         {
5982         BOOL b = allow_utf8_domains;
5983         allow_utf8_domains = TRUE;
5984 #endif
5985         recipient =
5986           parse_extract_address(s, &errmess, &start, &end, &domain, FALSE);
5987
5988 #ifdef SUPPORT_I18N
5989         if (recipient)
5990           if (string_is_utf8(recipient)) message_smtputf8 = TRUE;
5991           else allow_utf8_domains = b;
5992         }
5993 #else
5994         ;
5995 #endif
5996         if (domain == 0 && !f.allow_unqualified_recipient)
5997           {
5998           recipient = NULL;
5999           errmess = US"unqualified recipient address not allowed";
6000           }
6001
6002         if (!recipient)
6003           {
6004           DEBUG(D_all) debug_printf("bad recipient address \"%s\": %s\n",
6005             string_printing(list[i]), errmess);
6006
6007           if (error_handling == ERRORS_STDERR)
6008             {
6009             fprintf(stderr, "exim: bad recipient address \"%s\": %s\n",
6010               string_printing(list[i]), errmess);
6011             exim_exit(EXIT_FAILURE);
6012             }
6013           else
6014             {
6015             error_block eblock;
6016             eblock.next = NULL;
6017             eblock.text1 = string_printing(list[i]);
6018             eblock.text2 = errmess;
6019             return
6020               moan_to_sender(ERRMESS_BADARGADDRESS, &eblock, NULL, stdin, TRUE)?
6021                 errors_sender_rc : EXIT_FAILURE;
6022             }
6023           }
6024
6025         receive_add_recipient(string_copy_taint(recipient, GET_TAINTED), -1);
6026         s = ss;
6027         if (!finished)
6028           while (*++s && (*s == ',' || isspace(*s)));
6029         }
6030       }
6031
6032     /* Show the recipients when debugging */
6033
6034     DEBUG(D_receive)
6035       {
6036       if (sender_address) debug_printf("Sender: %s\n", sender_address);
6037       if (recipients_list)
6038         {
6039         debug_printf("Recipients:\n");
6040         for (int i = 0; i < recipients_count; i++)
6041           debug_printf("  %s\n", recipients_list[i].address);
6042         }
6043       }
6044
6045     /* Run the acl_not_smtp_start ACL if required. The result of the ACL is
6046     ignored; rejecting here would just add complication, and it can just as
6047     well be done later. Allow $recipients to be visible in the ACL. */
6048
6049     GET_OPTION("acl_not_smtp_start");
6050     if (acl_not_smtp_start)
6051       {
6052       uschar * user_msg, * log_msg;
6053       f.enable_dollar_recipients = TRUE;
6054       (void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
6055         &user_msg, &log_msg);
6056       f.enable_dollar_recipients = FALSE;
6057       }
6058
6059     /* Pause for a while waiting for input.  If none received in that time,
6060     close the logfile, if we had one open; then if we wait for a long-running
6061     datasource (months, in one use-case) log rotation will not leave us holding
6062     the file copy. */
6063
6064     if (!receive_timeout)
6065       if (poll_one_fd(0, POLLIN, 30*60*1000) == 0)      /* 30 minutes */
6066         mainlog_close();
6067
6068     /* Read the data for the message. If filter_test is not FTEST_NONE, this
6069     will just read the headers for the message, and not write anything onto the
6070     spool. */
6071
6072     message_ended = END_NOTENDED;
6073     more = receive_msg(extract_recipients);
6074
6075     /* more is always FALSE here (not SMTP message) when reading a message
6076     for real; when reading the headers of a message for filter testing,
6077     it is TRUE if the headers were terminated by '.' and FALSE otherwise. */
6078
6079     if (!message_id[0]) exim_exit(EXIT_FAILURE);
6080     }  /* Non-SMTP message reception */
6081
6082   /* If this is a filter testing run, there are headers in store, but
6083   no message on the spool. Run the filtering code in testing mode, setting
6084   the domain to the qualify domain and the local part to the current user,
6085   unless they have been set by options. The prefix and suffix are left unset
6086   unless specified. The the return path is set to to the sender unless it has
6087   already been set from a return-path header in the message. */
6088
6089   if (filter_test != FTEST_NONE)
6090     {
6091     deliver_domain = ftest_domain ? ftest_domain : qualify_domain_recipient;
6092     deliver_domain_orig = deliver_domain;
6093     deliver_localpart = ftest_localpart ? US ftest_localpart : originator_login;
6094     deliver_localpart_orig = deliver_localpart;
6095     deliver_localpart_prefix = US ftest_prefix;
6096     deliver_localpart_suffix = US ftest_suffix;
6097     deliver_home = originator_home;
6098
6099     if (!return_path)
6100       {
6101       printf("Return-path copied from sender\n");
6102       return_path = string_copy(sender_address);
6103       }
6104     else
6105       printf("Return-path = %s\n", (return_path[0] == 0)? US"<>" : return_path);
6106     printf("Sender      = %s\n", (sender_address[0] == 0)? US"<>" : sender_address);
6107
6108     receive_add_recipient(
6109       string_sprintf("%s%s%s@%s",
6110         ftest_prefix ? ftest_prefix : US"",
6111         deliver_localpart,
6112         ftest_suffix ? ftest_suffix : US"",
6113         deliver_domain), -1);
6114
6115     printf("Recipient   = %s\n", recipients_list[0].address);
6116     if (ftest_prefix) printf("Prefix    = %s\n", ftest_prefix);
6117     if (ftest_suffix) printf("Suffix    = %s\n", ftest_suffix);
6118
6119     if (chdir("/"))   /* Get away from wherever the user is running this from */
6120       {
6121       DEBUG(D_receive) debug_printf("chdir(\"/\") failed\n");
6122       exim_exit(EXIT_FAILURE);
6123       }
6124
6125     /* Now we run either a system filter test, or a user filter test, or both.
6126     In the latter case, headers added by the system filter will persist and be
6127     available to the user filter. We need to copy the filter variables
6128     explicitly. */
6129
6130     if (filter_test & FTEST_SYSTEM)
6131       if (!filter_runtest(filter_sfd, filter_test_sfile, TRUE, more))
6132         exim_exit(EXIT_FAILURE);
6133
6134     memcpy(filter_sn, filter_n, sizeof(filter_sn));
6135
6136     if (filter_test & FTEST_USER)
6137       if (!filter_runtest(filter_ufd, filter_test_ufile, FALSE, more))
6138         exim_exit(EXIT_FAILURE);
6139
6140     exim_exit(EXIT_SUCCESS);
6141     }
6142
6143   /* Else act on the result of message reception. We should not get here unless
6144   message_id[0] is non-zero. If queue_only is set, session_local_queue_only
6145   will be TRUE. If it is not, check on the number of messages received in this
6146   connection. */
6147
6148   if (  !session_local_queue_only
6149      && smtp_accept_queue_per_connection > 0
6150      && receive_messagecount > smtp_accept_queue_per_connection)
6151     {
6152     session_local_queue_only = TRUE;
6153     queue_only_reason = 2;
6154     }
6155
6156   /* Initialize local_queue_only from session_local_queue_only. If it is false,
6157   and queue_only_load is set, check that the load average is below it. If it is
6158   not, set local_queue_only TRUE. If queue_only_load_latch is true (the
6159   default), we put the whole session into queue_only mode. It then remains this
6160   way for any subsequent messages on the same SMTP connection. This is a
6161   deliberate choice; even though the load average may fall, it doesn't seem
6162   right to deliver later messages on the same call when not delivering earlier
6163   ones. However, there are odd cases where this is not wanted, so this can be
6164   changed by setting queue_only_load_latch false. */
6165
6166   if (!(local_queue_only = session_local_queue_only) && queue_only_load >= 0)
6167     if ((local_queue_only = (load_average = OS_GETLOADAVG()) > queue_only_load))
6168       {
6169       queue_only_reason = 3;
6170       if (queue_only_load_latch) session_local_queue_only = TRUE;
6171       }
6172
6173   /* If running as an MUA wrapper, all queueing options and freezing options
6174   are ignored. */
6175
6176   if (mua_wrapper)
6177     local_queue_only = f.queue_only_policy = f.deliver_freeze = FALSE;
6178
6179   /* Log the queueing here, when it will get a message id attached, but
6180   not if queue_only is set (case 0). Case 1 doesn't happen here (too many
6181   connections). */
6182
6183   if (local_queue_only)
6184     {
6185     cancel_cutthrough_connection(TRUE, US"no delivery; queueing");
6186     switch(queue_only_reason)
6187       {
6188       case 2:
6189         log_write(L_delay_delivery,
6190                 LOG_MAIN, "no immediate delivery: more than %d messages "
6191           "received in one connection", smtp_accept_queue_per_connection);
6192         break;
6193
6194       case 3:
6195         log_write(L_delay_delivery,
6196                 LOG_MAIN, "no immediate delivery: load average %.2f",
6197                 (double)load_average/1000.0);
6198       break;
6199       }
6200     }
6201
6202   else if (f.queue_only_policy || f.deliver_freeze)
6203     cancel_cutthrough_connection(TRUE, US"no delivery; queueing");
6204
6205   /* Else do the delivery unless the ACL or local_scan() called for queue only
6206   or froze the message. Always deliver in a separate process. A fork failure is
6207   not a disaster, as the delivery will eventually happen on a subsequent queue
6208   run. The search cache must be tidied before the fork, as the parent will
6209   do it before exiting. The child will trigger a lookup failure and
6210   thereby defer the delivery if it tries to use (for example) a cached ldap
6211   connection that the parent has called unbind on. */
6212
6213   else
6214     {
6215     pid_t pid;
6216     search_tidyup();
6217
6218     if ((pid = exim_fork(US"local-accept-delivery")) == 0)
6219       {
6220       int rc;
6221       close_unwanted();      /* Close unwanted file descriptors and TLS */
6222       exim_nullstd();        /* Ensure std{in,out,err} exist */
6223
6224       /* Re-exec Exim if we need to regain privilege (note: in mua_wrapper
6225       mode, deliver_drop_privilege is forced TRUE). */
6226
6227       if (geteuid() != root_uid && !deliver_drop_privilege && !unprivileged)
6228         {
6229         delivery_re_exec(CEE_EXEC_EXIT);
6230         /* Control does not return here. */
6231         }
6232
6233       /* No need to re-exec */
6234
6235       rc = deliver_message(message_id, FALSE, FALSE);
6236       search_tidyup();
6237       exim_underbar_exit(!mua_wrapper || rc == DELIVER_MUA_SUCCEEDED
6238         ? EXIT_SUCCESS : EXIT_FAILURE);
6239       }
6240
6241     if (pid < 0)
6242       {
6243       cancel_cutthrough_connection(TRUE, US"delivery fork failed");
6244       log_write(0, LOG_MAIN|LOG_PANIC, "failed to fork automatic delivery "
6245         "process: %s", strerror(errno));
6246       }
6247     else
6248       {
6249       release_cutthrough_connection(US"msg passed for delivery");
6250
6251       /* In the parent, wait if synchronous delivery is required. This will
6252       always be the case in MUA wrapper mode. */
6253
6254       if (f.synchronous_delivery)
6255         {
6256         int status;
6257         while (wait(&status) != pid);
6258         if ((status & 0x00ff) != 0)
6259           log_write(0, LOG_MAIN|LOG_PANIC,
6260             "process %d crashed with signal %d while delivering %s",
6261             (int)pid, status & 0x00ff, message_id);
6262         if (mua_wrapper && (status & 0xffff) != 0) exim_exit(EXIT_FAILURE);
6263         }
6264       }
6265     }
6266
6267   /* The loop will repeat if more is TRUE. If we do not know know that the OS
6268   automatically reaps children (see comments above the loop), clear away any
6269   finished subprocesses here, in case there are lots of messages coming in
6270   from the same source. */
6271
6272 #ifndef SIG_IGN_WORKS
6273   while (waitpid(-1, NULL, WNOHANG) > 0);
6274 #endif
6275
6276 MORELOOP:
6277   return_path = sender_address = NULL;
6278   authenticated_sender = NULL;
6279   deliver_localpart_orig = NULL;
6280   deliver_domain_orig = NULL;
6281   deliver_host = deliver_host_address = NULL;
6282   dnslist_domain = dnslist_matched = NULL;
6283 #ifdef WITH_CONTENT_SCAN
6284   malware_name = NULL;
6285   regex_vars_clear();
6286 #endif
6287   callout_address = NULL;
6288   sending_ip_address = NULL;
6289   deliver_localpart_data = deliver_domain_data =
6290   recipient_data = sender_data = NULL;
6291   acl_var_m = NULL;
6292   lookup_value = NULL;                            /* Can be set by ACL */
6293
6294   store_reset(reset_point);
6295   }
6296
6297 exim_exit(EXIT_SUCCESS);   /* Never returns */
6298 return 0;                  /* To stop compiler warning */
6299 }
6300
6301
6302 /* End of exim.c */
6303 /* vi: aw ai sw=2
6304 */