src/src/exim.c

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