src/src/exim.c

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