src/src/exim.c

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