src/src/exim.c

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