src/src/exim.c

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