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