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