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