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