src/src/exim.c

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