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