src/src/exim.c

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