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