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