src/src/exim.c

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