c376f27c766b6853ff4e1e17a533e45dc45f376e
[users/heiko/exim.git] / src / src / daemon.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Functions concerned with running Exim as a daemon */
10
11
12 #include "exim.h"
13
14
15 /* Structure for holding data for each SMTP connection */
16
17 typedef struct smtp_slot {
18   pid_t pid;                       /* pid of the spawned reception process */
19   uschar *host_address;            /* address of the client host */
20 } smtp_slot;
21
22 /* An empty slot for initializing (Standard C does not allow constructor
23 expressions in assignments except as initializers in declarations). */
24
25 static smtp_slot empty_smtp_slot = { .pid = 0, .host_address = NULL };
26
27
28
29 /*************************************************
30 *               Local static variables           *
31 *************************************************/
32
33 static SIGNAL_BOOL sigchld_seen;
34 static SIGNAL_BOOL sighup_seen;
35 static SIGNAL_BOOL sigterm_seen;
36
37 static int   accept_retry_count = 0;
38 static int   accept_retry_errno;
39 static BOOL  accept_retry_select_failed;
40
41 static int   queue_run_count = 0;
42 static pid_t *queue_pid_slots = NULL;
43 static smtp_slot *smtp_slots = NULL;
44
45 static BOOL  write_pid = TRUE;
46
47
48
49 /*************************************************
50 *             SIGHUP Handler                     *
51 *************************************************/
52
53 /* All this handler does is to set a flag and re-enable the signal.
54
55 Argument: the signal number
56 Returns:  nothing
57 */
58
59 static void
60 sighup_handler(int sig)
61 {
62 sighup_seen = TRUE;
63 signal(SIGHUP, sighup_handler);
64 }
65
66
67
68 /*************************************************
69 *     SIGCHLD handler for main daemon process    *
70 *************************************************/
71
72 /* Don't re-enable the handler here, since we aren't doing the
73 waiting here. If the signal is re-enabled, there will just be an
74 infinite sequence of calls to this handler. The SIGCHLD signal is
75 used just as a means of waking up the daemon so that it notices
76 terminated subprocesses as soon as possible.
77
78 Argument: the signal number
79 Returns:  nothing
80 */
81
82 static void
83 main_sigchld_handler(int sig)
84 {
85 os_non_restarting_signal(SIGCHLD, SIG_DFL);
86 sigchld_seen = TRUE;
87 }
88
89
90 /* SIGTERM handler.  Try to get the damon pif file removed
91 before exiting. */
92
93 static void
94 main_sigterm_handler(int sig)
95 {
96 sigterm_seen = TRUE;
97 }
98
99
100
101
102 /*************************************************
103 *          Unexpected errors in SMTP calls       *
104 *************************************************/
105
106 /* This function just saves a bit of repetitious coding.
107
108 Arguments:
109   log_msg        Text of message to be logged
110   smtp_msg       Text of SMTP error message
111   was_errno      The failing errno
112
113 Returns:         nothing
114 */
115
116 static void
117 never_error(uschar *log_msg, uschar *smtp_msg, int was_errno)
118 {
119 uschar *emsg = was_errno <= 0
120   ? US"" : string_sprintf(": %s", strerror(was_errno));
121 log_write(0, LOG_MAIN|LOG_PANIC, "%s%s", log_msg, emsg);
122 if (smtp_out) smtp_printf("421 %s\r\n", FALSE, smtp_msg);
123 }
124
125
126
127
128 /*************************************************
129 *************************************************/
130
131 static void
132 close_daemon_sockets(int daemon_notifier_fd,
133   int * listen_sockets, int listen_socket_count)
134 {
135 if (daemon_notifier_fd >= 0) (void) close(daemon_notifier_fd);
136 for (int i = 0; i < listen_socket_count; i++) (void) close(listen_sockets[i]);
137 }
138
139
140 /*************************************************
141 *            Handle a connected SMTP call        *
142 *************************************************/
143
144 /* This function is called when an SMTP connection has been accepted.
145 If there are too many, give an error message and close down. Otherwise
146 spin off a sub-process to handle the call. The list of listening sockets
147 is required so that they can be closed in the sub-process. Take care not to
148 leak store in this process - reset the stacking pool at the end.
149
150 Arguments:
151   listen_sockets        sockets which are listening for incoming calls
152   listen_socket_count   count of listening sockets
153   accept_socket         socket of the current accepted call
154   accepted              socket information about the current call
155
156 Returns:            nothing
157 */
158
159 static void
160 handle_smtp_call(int *listen_sockets, int listen_socket_count,
161   int accept_socket, struct sockaddr *accepted)
162 {
163 pid_t pid;
164 union sockaddr_46 interface_sockaddr;
165 EXIM_SOCKLEN_T ifsize = sizeof(interface_sockaddr);
166 int dup_accept_socket = -1;
167 int max_for_this_host = 0;
168 int save_log_selector = *log_selector;
169 gstring * whofrom;
170
171 rmark reset_point = store_mark();
172
173 /* Make the address available in ASCII representation, and also fish out
174 the remote port. */
175
176 sender_host_address = host_ntoa(-1, accepted, NULL, &sender_host_port);
177 DEBUG(D_any) debug_printf("Connection request from %s port %d\n",
178   sender_host_address, sender_host_port);
179
180 /* Set up the output stream, check the socket has duplicated, and set up the
181 input stream. These operations fail only the exceptional circumstances. Note
182 that never_error() won't use smtp_out if it is NULL. */
183
184 if (!(smtp_out = fdopen(accept_socket, "wb")))
185   {
186   never_error(US"daemon: fdopen() for smtp_out failed", US"", errno);
187   goto ERROR_RETURN;
188   }
189
190 if ((dup_accept_socket = dup(accept_socket)) < 0)
191   {
192   never_error(US"daemon: couldn't dup socket descriptor",
193     US"Connection setup failed", errno);
194   goto ERROR_RETURN;
195   }
196
197 if (!(smtp_in = fdopen(dup_accept_socket, "rb")))
198   {
199   never_error(US"daemon: fdopen() for smtp_in failed",
200     US"Connection setup failed", errno);
201   goto ERROR_RETURN;
202   }
203
204 /* Get the data for the local interface address. Panic for most errors, but
205 "connection reset by peer" just means the connection went away. */
206
207 if (getsockname(accept_socket, (struct sockaddr *)(&interface_sockaddr),
208      &ifsize) < 0)
209   {
210   log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
211     "getsockname() failed: %s", strerror(errno));
212   smtp_printf("421 Local problem: getsockname() failed; please try again later\r\n", FALSE);
213   goto ERROR_RETURN;
214   }
215
216 interface_address = host_ntoa(-1, &interface_sockaddr, NULL, &interface_port);
217 DEBUG(D_interface) debug_printf("interface address=%s port=%d\n",
218   interface_address, interface_port);
219
220 /* Build a string identifying the remote host and, if requested, the port and
221 the local interface data. This is for logging; at the end of this function the
222 memory is reclaimed. */
223
224 whofrom = string_append(NULL, 3, "[", sender_host_address, "]");
225
226 if (LOGGING(incoming_port))
227   whofrom = string_fmt_append(whofrom, ":%d", sender_host_port);
228
229 if (LOGGING(incoming_interface))
230   whofrom = string_fmt_append(whofrom, " I=[%s]:%d",
231     interface_address, interface_port);
232
233 (void) string_from_gstring(whofrom);    /* Terminate the newly-built string */
234
235 /* Check maximum number of connections. We do not check for reserved
236 connections or unacceptable hosts here. That is done in the subprocess because
237 it might take some time. */
238
239 if (smtp_accept_max > 0 && smtp_accept_count >= smtp_accept_max)
240   {
241   DEBUG(D_any) debug_printf("rejecting SMTP connection: count=%d max=%d\n",
242     smtp_accept_count, smtp_accept_max);
243   smtp_printf("421 Too many concurrent SMTP connections; "
244     "please try again later.\r\n", FALSE);
245   log_write(L_connection_reject,
246             LOG_MAIN, "Connection from %s refused: too many connections",
247     whofrom->s);
248   goto ERROR_RETURN;
249   }
250
251 /* If a load limit above which only reserved hosts are acceptable is defined,
252 get the load average here, and if there are in fact no reserved hosts, do
253 the test right away (saves a fork). If there are hosts, do the check in the
254 subprocess because it might take time. */
255
256 if (smtp_load_reserve >= 0)
257   {
258   load_average = OS_GETLOADAVG();
259   if (smtp_reserve_hosts == NULL && load_average > smtp_load_reserve)
260     {
261     DEBUG(D_any) debug_printf("rejecting SMTP connection: load average = %.2f\n",
262       (double)load_average/1000.0);
263     smtp_printf("421 Too much load; please try again later.\r\n", FALSE);
264     log_write(L_connection_reject,
265               LOG_MAIN, "Connection from %s refused: load average = %.2f",
266       whofrom->s, (double)load_average/1000.0);
267     goto ERROR_RETURN;
268     }
269   }
270
271 /* Check that one specific host (strictly, IP address) is not hogging
272 resources. This is done here to prevent a denial of service attack by someone
273 forcing you to fork lots of times before denying service. The value of
274 smtp_accept_max_per_host is a string which is expanded. This makes it possible
275 to provide host-specific limits according to $sender_host address, but because
276 this is in the daemon mainline, only fast expansions (such as inline address
277 checks) should be used. The documentation is full of warnings. */
278
279 if (smtp_accept_max_per_host)
280   {
281   uschar *expanded = expand_string(smtp_accept_max_per_host);
282   if (!expanded)
283     {
284     if (!f.expand_string_forcedfail)
285       log_write(0, LOG_MAIN|LOG_PANIC, "expansion of smtp_accept_max_per_host "
286         "failed for %s: %s", whofrom->s, expand_string_message);
287     }
288   /* For speed, interpret a decimal number inline here */
289   else
290     {
291     uschar *s = expanded;
292     while (isdigit(*s))
293       max_for_this_host = max_for_this_host * 10 + *s++ - '0';
294     if (*s)
295       log_write(0, LOG_MAIN|LOG_PANIC, "expansion of smtp_accept_max_per_host "
296         "for %s contains non-digit: %s", whofrom->s, expanded);
297     }
298   }
299
300 /* If we have fewer connections than max_for_this_host, we can skip the tedious
301 per host_address checks. Note that at this stage smtp_accept_count contains the
302 count of *other* connections, not including this one. */
303
304 if (max_for_this_host > 0 && smtp_accept_count >= max_for_this_host)
305   {
306   int host_accept_count = 0;
307   int other_host_count = 0;    /* keep a count of non matches to optimise */
308
309   for (int i = 0; i < smtp_accept_max; ++i)
310     if (smtp_slots[i].host_address)
311       {
312       if (Ustrcmp(sender_host_address, smtp_slots[i].host_address) == 0)
313        host_accept_count++;
314       else
315        other_host_count++;
316
317       /* Testing all these strings is expensive - see if we can drop out
318       early, either by hitting the target, or finding there are not enough
319       connections left to make the target. */
320
321       if (  host_accept_count >= max_for_this_host
322          || smtp_accept_count - other_host_count < max_for_this_host)
323        break;
324       }
325
326   if (host_accept_count >= max_for_this_host)
327     {
328     DEBUG(D_any) debug_printf("rejecting SMTP connection: too many from this "
329       "IP address: count=%d max=%d\n",
330       host_accept_count, max_for_this_host);
331     smtp_printf("421 Too many concurrent SMTP connections "
332       "from this IP address; please try again later.\r\n", FALSE);
333     log_write(L_connection_reject,
334               LOG_MAIN, "Connection from %s refused: too many connections "
335       "from that IP address", whofrom->s);
336     search_tidyup();
337     goto ERROR_RETURN;
338     }
339   }
340
341 /* OK, the connection count checks have been passed. Before we can fork the
342 accepting process, we must first log the connection if requested. This logging
343 used to happen in the subprocess, but doing that means that the value of
344 smtp_accept_count can be out of step by the time it is logged. So we have to do
345 the logging here and accept the performance cost. Note that smtp_accept_count
346 hasn't yet been incremented to take account of this connection.
347
348 In order to minimize the cost (because this is going to happen for every
349 connection), do a preliminary selector test here. This saves ploughing through
350 the generalized logging code each time when the selector is false. If the
351 selector is set, check whether the host is on the list for logging. If not,
352 arrange to unset the selector in the subprocess. */
353
354 if (LOGGING(smtp_connection))
355   {
356   uschar *list = hosts_connection_nolog;
357   memset(sender_host_cache, 0, sizeof(sender_host_cache));
358   if (list != NULL && verify_check_host(&list) == OK)
359     save_log_selector &= ~L_smtp_connection;
360   else
361     log_write(L_smtp_connection, LOG_MAIN, "SMTP connection from %s "
362       "(TCP/IP connection count = %d)", whofrom->s, smtp_accept_count + 1);
363   }
364
365 /* Now we can fork the accepting process; do a lookup tidy, just in case any
366 expansion above did a lookup. */
367
368 search_tidyup();
369 pid = exim_fork(US"daemon-accept");
370
371 /* Handle the child process */
372
373 if (pid == 0)
374   {
375   int queue_only_reason = 0;
376   int old_pool = store_pool;
377   int save_debug_selector = debug_selector;
378   BOOL local_queue_only;
379   BOOL session_local_queue_only;
380   #ifdef SA_NOCLDWAIT
381   struct sigaction act;
382   #endif
383
384   smtp_accept_count++;    /* So that it includes this process */
385
386   /* May have been modified for the subprocess */
387
388   *log_selector = save_log_selector;
389
390   /* Get the local interface address into permanent store */
391
392   store_pool = POOL_PERM;
393   interface_address = string_copy(interface_address);
394   store_pool = old_pool;
395
396   /* Check for a tls-on-connect port */
397
398   if (host_is_tls_on_connect_port(interface_port)) tls_in.on_connect = TRUE;
399
400   /* Expand smtp_active_hostname if required. We do not do this any earlier,
401   because it may depend on the local interface address (indeed, that is most
402   likely what it depends on.) */
403
404   smtp_active_hostname = primary_hostname;
405   if (raw_active_hostname)
406     {
407     uschar * nah = expand_string(raw_active_hostname);
408     if (!nah)
409       {
410       if (!f.expand_string_forcedfail)
411         {
412         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" "
413           "(smtp_active_hostname): %s", raw_active_hostname,
414           expand_string_message);
415         smtp_printf("421 Local configuration error; "
416           "please try again later.\r\n", FALSE);
417         mac_smtp_fflush();
418         search_tidyup();
419         exim_underbar_exit(EXIT_FAILURE);
420         }
421       }
422     else if (*nah) smtp_active_hostname = nah;
423     }
424
425   /* Initialize the queueing flags */
426
427   queue_check_only();
428   session_local_queue_only = queue_only;
429
430   /* Close the listening sockets, and set the SIGCHLD handler to SIG_IGN.
431   We also attempt to set things up so that children are automatically reaped,
432   but just in case this isn't available, there's a paranoid waitpid() in the
433   loop too (except for systems where we are sure it isn't needed). See the more
434   extensive comment before the reception loop in exim.c for a fuller
435   explanation of this logic. */
436
437   close_daemon_sockets(daemon_notifier_fd, listen_sockets, listen_socket_count);
438
439   /* Set FD_CLOEXEC on the SMTP socket. We don't want any rogue child processes
440   to be able to communicate with them, under any circumstances. */
441   (void)fcntl(accept_socket, F_SETFD,
442               fcntl(accept_socket, F_GETFD) | FD_CLOEXEC);
443   (void)fcntl(dup_accept_socket, F_SETFD,
444               fcntl(dup_accept_socket, F_GETFD) | FD_CLOEXEC);
445
446   #ifdef SA_NOCLDWAIT
447   act.sa_handler = SIG_IGN;
448   sigemptyset(&(act.sa_mask));
449   act.sa_flags = SA_NOCLDWAIT;
450   sigaction(SIGCHLD, &act, NULL);
451   #else
452   signal(SIGCHLD, SIG_IGN);
453   #endif
454   signal(SIGTERM, SIG_DFL);
455
456   /* Attempt to get an id from the sending machine via the RFC 1413
457   protocol. We do this in the sub-process in order not to hold up the
458   main process if there is any delay. Then set up the fullhost information
459   in case there is no HELO/EHLO.
460
461   If debugging is enabled only for the daemon, we must turn if off while
462   finding the id, but turn it on again afterwards so that information about the
463   incoming connection is output. */
464
465   if (f.debug_daemon) debug_selector = 0;
466   verify_get_ident(IDENT_PORT);
467   host_build_sender_fullhost();
468   debug_selector = save_debug_selector;
469
470   DEBUG(D_any)
471     debug_printf("Process %d is handling incoming connection from %s\n",
472       (int)getpid(), sender_fullhost);
473
474   /* Now disable debugging permanently if it's required only for the daemon
475   process. */
476
477   if (f.debug_daemon) debug_selector = 0;
478
479   /* If there are too many child processes for immediate delivery,
480   set the session_local_queue_only flag, which is initialized from the
481   configured value and may therefore already be TRUE. Leave logging
482   till later so it will have a message id attached. Note that there is no
483   possibility of re-calculating this per-message, because the value of
484   smtp_accept_count does not change in this subprocess. */
485
486   if (smtp_accept_queue > 0 && smtp_accept_count > smtp_accept_queue)
487     {
488     session_local_queue_only = TRUE;
489     queue_only_reason = 1;
490     }
491
492   /* Handle the start of the SMTP session, then loop, accepting incoming
493   messages from the SMTP connection. The end will come at the QUIT command,
494   when smtp_setup_msg() returns 0. A break in the connection causes the
495   process to die (see accept.c).
496
497   NOTE: We do *not* call smtp_log_no_mail() if smtp_start_session() fails,
498   because a log line has already been written for all its failure exists
499   (usually "connection refused: <reason>") and writing another one is
500   unnecessary clutter. */
501
502   if (!smtp_start_session())
503     {
504     mac_smtp_fflush();
505     search_tidyup();
506     exim_underbar_exit(EXIT_SUCCESS);
507     }
508
509   for (;;)
510     {
511     int rc;
512     message_id[0] = 0;            /* Clear out any previous message_id */
513     reset_point = store_mark();   /* Save current store high water point */
514
515     DEBUG(D_any)
516       debug_printf("Process %d is ready for new message\n", (int)getpid());
517
518     /* Smtp_setup_msg() returns 0 on QUIT or if the call is from an
519     unacceptable host or if an ACL "drop" command was triggered, -1 on
520     connection lost, and +1 on validly reaching DATA. Receive_msg() almost
521     always returns TRUE when smtp_input is true; just retry if no message was
522     accepted (can happen for invalid message parameters). However, it can yield
523     FALSE if the connection was forcibly dropped by the DATA ACL. */
524
525     if ((rc = smtp_setup_msg()) > 0)
526       {
527       BOOL ok = receive_msg(FALSE);
528       search_tidyup();                    /* Close cached databases */
529       if (!ok)                            /* Connection was dropped */
530         {
531         cancel_cutthrough_connection(TRUE, US"receive dropped");
532         mac_smtp_fflush();
533         smtp_log_no_mail();               /* Log no mail if configured */
534         exim_underbar_exit(EXIT_SUCCESS);
535         }
536       if (message_id[0] == 0) continue;   /* No message was accepted */
537       }
538     else
539       {
540       if (smtp_out)
541         {
542         int fd = fileno(smtp_in);
543         uschar buf[128];
544
545         mac_smtp_fflush();
546         /* drain socket, for clean TCP FINs */
547         if (fcntl(fd, F_SETFL, O_NONBLOCK) == 0)
548           for(int i = 16; read(fd, buf, sizeof(buf)) > 0 && i > 0; ) i--;
549         }
550       cancel_cutthrough_connection(TRUE, US"message setup dropped");
551       search_tidyup();
552       smtp_log_no_mail();                 /* Log no mail if configured */
553
554       /*XXX should we pause briefly, hoping that the client will be the
555       active TCP closer hence get the TCP_WAIT endpoint? */
556       DEBUG(D_receive) debug_printf("SMTP>>(close on process exit)\n");
557       exim_underbar_exit(rc ? EXIT_FAILURE : EXIT_SUCCESS);
558       }
559
560     /* Show the recipients when debugging */
561
562     DEBUG(D_receive)
563       {
564       if (sender_address)
565         debug_printf("Sender: %s\n", sender_address);
566       if (recipients_list)
567         {
568         debug_printf("Recipients:\n");
569         for (int i = 0; i < recipients_count; i++)
570           debug_printf("  %s\n", recipients_list[i].address);
571         }
572       }
573
574     /* A message has been accepted. Clean up any previous delivery processes
575     that have completed and are defunct, on systems where they don't go away
576     by themselves (see comments when setting SIG_IGN above). On such systems
577     (if any) these delivery processes hang around after termination until
578     the next message is received. */
579
580     #ifndef SIG_IGN_WORKS
581     while (waitpid(-1, NULL, WNOHANG) > 0);
582     #endif
583
584     /* Reclaim up the store used in accepting this message */
585
586       {
587       int r = receive_messagecount;
588       BOOL q = f.queue_only_policy;
589       smtp_reset(reset_point);
590       reset_point = NULL;
591       f.queue_only_policy = q;
592       receive_messagecount = r;
593       }
594
595     /* If queue_only is set or if there are too many incoming connections in
596     existence, session_local_queue_only will be TRUE. If it is not, check
597     whether we have received too many messages in this session for immediate
598     delivery. */
599
600     if (!session_local_queue_only &&
601         smtp_accept_queue_per_connection > 0 &&
602         receive_messagecount > smtp_accept_queue_per_connection)
603       {
604       session_local_queue_only = TRUE;
605       queue_only_reason = 2;
606       }
607
608     /* Initialize local_queue_only from session_local_queue_only. If it is not
609     true, and queue_only_load is set, check that the load average is below it.
610     If local_queue_only is set by this means, we also set if for the session if
611     queue_only_load_latch is true (the default). This means that, once set,
612     local_queue_only remains set for any subsequent messages on the same SMTP
613     connection. This is a deliberate choice; even though the load average may
614     fall, it doesn't seem right to deliver later messages on the same call when
615     not delivering earlier ones. However, the are special circumstances such as
616     very long-lived connections from scanning appliances where this is not the
617     best strategy. In such cases, queue_only_load_latch should be set false. */
618
619     if (  !(local_queue_only = session_local_queue_only)
620        && queue_only_load >= 0
621        && (local_queue_only = (load_average = OS_GETLOADAVG()) > queue_only_load)
622        )
623       {
624       queue_only_reason = 3;
625       if (queue_only_load_latch) session_local_queue_only = TRUE;
626       }
627
628     /* Log the queueing here, when it will get a message id attached, but
629     not if queue_only is set (case 0). */
630
631     if (local_queue_only) switch(queue_only_reason)
632       {
633       case 1: log_write(L_delay_delivery,
634                 LOG_MAIN, "no immediate delivery: too many connections "
635                 "(%d, max %d)", smtp_accept_count, smtp_accept_queue);
636               break;
637
638       case 2: log_write(L_delay_delivery,
639                 LOG_MAIN, "no immediate delivery: more than %d messages "
640                 "received in one connection", smtp_accept_queue_per_connection);
641               break;
642
643       case 3: log_write(L_delay_delivery,
644                 LOG_MAIN, "no immediate delivery: load average %.2f",
645                 (double)load_average/1000.0);
646               break;
647       }
648
649     /* If a delivery attempt is required, spin off a new process to handle it.
650     If we are not root, we have to re-exec exim unless deliveries are being
651     done unprivileged. */
652
653     else if (  (!f.queue_only_policy || f.queue_smtp)
654             && !f.deliver_freeze)
655       {
656       pid_t dpid;
657
658       /* Before forking, ensure that the C output buffer is flushed. Otherwise
659       anything that it in it will get duplicated, leading to duplicate copies
660       of the pending output. */
661
662       mac_smtp_fflush();
663
664       if ((dpid = exim_fork(US"daemon-accept-delivery")) == 0)
665         {
666         (void)fclose(smtp_in);
667         (void)fclose(smtp_out);
668
669         /* Don't ever molest the parent's SSL connection, but do clean up
670         the data structures if necessary. */
671
672 #ifndef DISABLE_TLS
673         tls_close(NULL, TLS_NO_SHUTDOWN);
674 #endif
675
676         /* Reset SIGHUP and SIGCHLD in the child in both cases. */
677
678         signal(SIGHUP,  SIG_DFL);
679         signal(SIGCHLD, SIG_DFL);
680         signal(SIGTERM, SIG_DFL);
681
682         if (geteuid() != root_uid && !deliver_drop_privilege)
683           {
684           signal(SIGALRM, SIG_DFL);
685           delivery_re_exec(CEE_EXEC_PANIC);
686           /* Control does not return here. */
687           }
688
689         /* No need to re-exec; SIGALRM remains set to the default handler */
690
691         (void) deliver_message(message_id, FALSE, FALSE);
692         search_tidyup();
693         exim_underbar_exit(EXIT_SUCCESS);
694         }
695
696       if (dpid > 0)
697         {
698         release_cutthrough_connection(US"passed for delivery");
699         DEBUG(D_any) debug_printf("forked delivery process %d\n", (int)dpid);
700         }
701       else
702         {
703         cancel_cutthrough_connection(TRUE, US"delivery fork failed");
704         log_write(0, LOG_MAIN|LOG_PANIC, "daemon: delivery process fork "
705           "failed: %s", strerror(errno));
706         }
707       }
708     }
709   }
710
711
712 /* Carrying on in the parent daemon process... Can't do much if the fork
713 failed. Otherwise, keep count of the number of accepting processes and
714 remember the pid for ticking off when the child completes. */
715
716 if (pid < 0)
717   never_error(US"daemon: accept process fork failed", US"Fork failed", errno);
718 else
719   {
720   for (int i = 0; i < smtp_accept_max; ++i)
721     if (smtp_slots[i].pid <= 0)
722       {
723       smtp_slots[i].pid = pid;
724       /* Connection closes come asyncronously, so we cannot stack this store */
725       if (smtp_accept_max_per_host)
726         smtp_slots[i].host_address = string_copy_malloc(sender_host_address);
727       smtp_accept_count++;
728       break;
729       }
730   DEBUG(D_any) debug_printf("%d SMTP accept process%s running\n",
731     smtp_accept_count, smtp_accept_count == 1 ? "" : "es");
732   }
733
734 /* Get here via goto in error cases */
735
736 ERROR_RETURN:
737
738 /* Close the streams associated with the socket which will also close the
739 socket fds in this process. We can't do anything if fclose() fails, but
740 logging brings it to someone's attention. However, "connection reset by peer"
741 isn't really a problem, so skip that one. On Solaris, a dropped connection can
742 manifest itself as a broken pipe, so drop that one too. If the streams don't
743 exist, something went wrong while setting things up. Make sure the socket
744 descriptors are closed, in order to drop the connection. */
745
746 if (smtp_out)
747   {
748   if (fclose(smtp_out) != 0 && errno != ECONNRESET && errno != EPIPE)
749     log_write(0, LOG_MAIN|LOG_PANIC, "daemon: fclose(smtp_out) failed: %s",
750       strerror(errno));
751   smtp_out = NULL;
752   }
753 else (void)close(accept_socket);
754
755 if (smtp_in)
756   {
757   if (fclose(smtp_in) != 0 && errno != ECONNRESET && errno != EPIPE)
758     log_write(0, LOG_MAIN|LOG_PANIC, "daemon: fclose(smtp_in) failed: %s",
759       strerror(errno));
760   smtp_in = NULL;
761   }
762 else (void)close(dup_accept_socket);
763
764 /* Release any store used in this process, including the store used for holding
765 the incoming host address and an expanded active_hostname. */
766
767 log_close_all();
768 interface_address =
769 sender_host_address = NULL;
770 store_reset(reset_point);
771 sender_host_address = NULL;
772 }
773
774
775
776
777 /*************************************************
778 *       Check wildcard listen special cases      *
779 *************************************************/
780
781 /* This function is used when binding and listening on lists of addresses and
782 ports. It tests for special cases of wildcard listening, when IPv4 and IPv6
783 sockets may interact in different ways in different operating systems. It is
784 passed an error number, the list of listening addresses, and the current
785 address. Two checks are available: for a previous wildcard IPv6 address, or for
786 a following wildcard IPv4 address, in both cases on the same port.
787
788 In practice, pairs of wildcard addresses should be adjacent in the address list
789 because they are sorted that way below.
790
791 Arguments:
792   eno            the error number
793   addresses      the list of addresses
794   ipa            the current IP address
795   back           if TRUE, check for previous wildcard IPv6 address
796                  if FALSE, check for a following wildcard IPv4 address
797
798 Returns:         TRUE or FALSE
799 */
800
801 static BOOL
802 check_special_case(int eno, ip_address_item *addresses, ip_address_item *ipa,
803   BOOL back)
804 {
805 ip_address_item *ipa2;
806
807 /* For the "back" case, if the failure was "address in use" for a wildcard IPv4
808 address, seek a previous IPv6 wildcard address on the same port. As it is
809 previous, it must have been successfully bound and be listening. Flag it as a
810 "6 including 4" listener. */
811
812 if (back)
813   {
814   if (eno != EADDRINUSE || ipa->address[0] != 0) return FALSE;
815   for (ipa2 = addresses; ipa2 != ipa; ipa2 = ipa2->next)
816     {
817     if (ipa2->address[1] == 0 && ipa2->port == ipa->port)
818       {
819       ipa2->v6_include_v4 = TRUE;
820       return TRUE;
821       }
822     }
823   }
824
825 /* For the "forward" case, if the current address is a wildcard IPv6 address,
826 we seek a following wildcard IPv4 address on the same port. */
827
828 else
829   {
830   if (ipa->address[0] != ':' || ipa->address[1] != 0) return FALSE;
831   for (ipa2 = ipa->next; ipa2 != NULL; ipa2 = ipa2->next)
832     if (ipa2->address[0] == 0 && ipa->port == ipa2->port) return TRUE;
833   }
834
835 return FALSE;
836 }
837
838
839
840
841 /*************************************************
842 *         Handle terminating subprocesses        *
843 *************************************************/
844
845 /* Handle the termination of child processes. Theoretically, this need be done
846 only when sigchld_seen is TRUE, but rumour has it that some systems lose
847 SIGCHLD signals at busy times, so to be on the safe side, this function is
848 called each time round. It shouldn't be too expensive.
849
850 Arguments:  none
851 Returns:    nothing
852 */
853
854 static void
855 handle_ending_processes(void)
856 {
857 int status;
858 pid_t pid;
859
860 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
861   {
862   DEBUG(D_any)
863     {
864     debug_printf("child %d ended: status=0x%x\n", (int)pid, status);
865 #ifdef WCOREDUMP
866     if (WIFEXITED(status))
867       debug_printf("  normal exit, %d\n", WEXITSTATUS(status));
868     else if (WIFSIGNALED(status))
869       debug_printf("  signal exit, signal %d%s\n", WTERMSIG(status),
870           WCOREDUMP(status) ? " (core dumped)" : "");
871 #endif
872     }
873
874   /* If it's a listening daemon for which we are keeping track of individual
875   subprocesses, deal with an accepting process that has terminated. */
876
877   if (smtp_slots)
878     {
879     int i;
880     for (i = 0; i < smtp_accept_max; i++)
881       if (smtp_slots[i].pid == pid)
882         {
883         if (smtp_slots[i].host_address)
884           store_free(smtp_slots[i].host_address);
885         smtp_slots[i] = empty_smtp_slot;
886         if (--smtp_accept_count < 0) smtp_accept_count = 0;
887         DEBUG(D_any) debug_printf("%d SMTP accept process%s now running\n",
888           smtp_accept_count, (smtp_accept_count == 1)? "" : "es");
889         break;
890         }
891     if (i < smtp_accept_max) continue;  /* Found an accepting process */
892     }
893
894   /* If it wasn't an accepting process, see if it was a queue-runner
895   process that we are tracking. */
896
897   if (queue_pid_slots)
898     {
899     int max = atoi(CS expand_string(queue_run_max));
900     for (int i = 0; i < max; i++)
901       if (queue_pid_slots[i] == pid)
902         {
903         queue_pid_slots[i] = 0;
904         if (--queue_run_count < 0) queue_run_count = 0;
905         DEBUG(D_any) debug_printf("%d queue-runner process%s now running\n",
906           queue_run_count, (queue_run_count == 1)? "" : "es");
907         break;
908         }
909     }
910   }
911 }
912
913
914
915 static void
916 set_pid_file_path(void)
917 {
918 if (override_pid_file_path)
919   pid_file_path = override_pid_file_path;
920
921 if (!*pid_file_path)
922   pid_file_path = string_sprintf("%s/exim-daemon.pid", spool_directory);
923 }
924
925
926 /* Remove the daemon's pidfile.  Note: runs with root privilege,
927 as a direct child of the daemon.  Does not return. */
928
929 void
930 delete_pid_file(void)
931 {
932 uschar * daemon_pid = string_sprintf("%d\n", (int)getppid());
933 FILE * f;
934
935 set_pid_file_path();
936 if ((f = Ufopen(pid_file_path, "rb")))
937   {
938   if (  fgets(CS big_buffer, big_buffer_size, f)
939         && Ustrcmp(daemon_pid, big_buffer) == 0
940      )
941     if (Uunlink(pid_file_path) == 0)
942       {
943       DEBUG(D_any)
944         debug_printf("%s unlink: %s\n", pid_file_path, strerror(errno));
945       }
946     else
947       DEBUG(D_any)
948         debug_printf("unlinked %s\n", pid_file_path);
949   fclose(f);
950   }
951 else
952   DEBUG(D_any)
953     debug_printf("%s\n", string_open_failed("pid file %s", pid_file_path));
954 exim_exit(EXIT_SUCCESS);
955 }
956
957
958 /* Called by the daemon; exec a child to get the pid file deleted
959 since we may require privs for the containing directory */
960
961 static void
962 daemon_die(void)
963 {
964 int pid;
965
966 if (daemon_notifier_fd >= 0)
967   {
968   close(daemon_notifier_fd);
969   daemon_notifier_fd = -1;
970 #ifndef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
971     {
972     uschar * s = expand_string(notifier_socket);
973     DEBUG(D_any) debug_printf("unlinking notifier socket %s\n", s);
974     Uunlink(s);
975     }
976 #endif
977   }
978
979 if (f.running_in_test_harness || write_pid)
980   {
981   if ((pid = exim_fork(US"daemon-del-pidfile")) == 0)
982     {
983     if (override_pid_file_path)
984       (void)child_exec_exim(CEE_EXEC_PANIC, FALSE, NULL, FALSE, 3,
985         "-oP", override_pid_file_path, "-oPX");
986     else
987       (void)child_exec_exim(CEE_EXEC_PANIC, FALSE, NULL, FALSE, 1, "-oPX");
988
989     /* Control never returns here. */
990     }
991   if (pid > 0)
992     child_close(pid, 1);
993   }
994 exim_exit(EXIT_SUCCESS);
995 }
996
997
998 /*************************************************
999 *       Listener socket for local work prompts   *
1000 *************************************************/
1001
1002 static void
1003 daemon_notifier_socket(void)
1004 {
1005 int fd;
1006 const uschar * where;
1007 struct sockaddr_un sa_un = {.sun_family = AF_UNIX};
1008 int len;
1009
1010 if (override_local_interfaces && !override_pid_file_path)
1011   {
1012   DEBUG(D_any)
1013     debug_printf("-oX used without -oP so not creating notifier socket\n");
1014   return;
1015   }
1016
1017 DEBUG(D_any) debug_printf("creating notifier socket\n");
1018
1019 #ifdef SOCK_CLOEXEC
1020 if ((fd = socket(PF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0)
1021   { where = US"socket"; goto bad; }
1022 #else
1023 if ((fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0)
1024   { where = US"socket"; goto bad; }
1025 (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
1026 #endif
1027
1028 #ifdef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
1029 sa_un.sun_path[0] = 0;  /* Abstract local socket addr - Linux-specific? */
1030 len = offsetof(struct sockaddr_un, sun_path) + 1
1031   + snprintf(sa_un.sun_path+1, sizeof(sa_un.sun_path)-1, "%s",
1032               expand_string(notifier_socket));
1033 DEBUG(D_any) debug_printf(" @%s\n", sa_un.sun_path+1);
1034 #else                   /* filesystem-visible and persistent; will neeed removal */
1035 len = offsetof(struct sockaddr_un, sun_path)
1036   + snprintf(sa_un.sun_path, sizeof(sa_un.sun_path), "%s", 
1037               expand_string(notifier_socket));
1038 DEBUG(D_any) debug_printf(" %s\n", sa_un.sun_path);
1039 #endif
1040
1041 if (bind(fd, (const struct sockaddr *)&sa_un, len) < 0)
1042   { where = US"bind"; goto bad; }
1043
1044 #ifdef SO_PASSCRED              /* Linux */
1045 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on)) < 0)
1046   { where = US"SO_PASSCRED"; goto bad2; }
1047 #elif defined(LOCAL_CREDS)      /* FreeBSD-ish */
1048 if (setsockopt(fd, 0, LOCAL_CREDS, &on, sizeof(on)) < 0)
1049   { where = US"LOCAL_CREDS"; goto bad2; }
1050 #endif
1051
1052 /* debug_printf("%s: fd %d\n", __FUNCTION__, fd); */
1053 daemon_notifier_fd = fd;
1054 return;
1055
1056 bad2:
1057 #ifndef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
1058   Uunlink(sa_un.sun_path);
1059 #endif
1060 bad:
1061   log_write(0, LOG_MAIN|LOG_PANIC, "%s %s: %s",
1062     __FUNCTION__, where, strerror(errno));
1063   close(fd);
1064   return;
1065 }
1066
1067
1068 static uschar queuerun_msgid[MESSAGE_ID_LENGTH+1];
1069
1070 /* Return TRUE if a sigalrm should be emulated */
1071 static BOOL
1072 daemon_notification(void)
1073 {
1074 uschar buf[256], cbuf[256];
1075 struct sockaddr_un sa_un;
1076 struct iovec iov = {.iov_base = buf, .iov_len = sizeof(buf)-1};
1077 struct msghdr msg = { .msg_name = &sa_un,
1078                       .msg_namelen = sizeof(sa_un),
1079                       .msg_iov = &iov,
1080                       .msg_iovlen = 1,
1081                       .msg_control = cbuf,
1082                       .msg_controllen = sizeof(cbuf)
1083                     };
1084 ssize_t sz;
1085
1086 buf[sizeof(buf)-1] = 0;
1087 if ((sz = recvmsg(daemon_notifier_fd, &msg, 0)) <= 0) return FALSE;
1088 if (sz >= sizeof(buf)) return FALSE;
1089
1090 #ifdef notdef
1091 debug_printf("addrlen %d\n", msg.msg_namelen);
1092 #endif
1093 DEBUG(D_queue_run) debug_printf("%s from addr '%s%.*s'\n", __FUNCTION__,
1094   *sa_un.sun_path ? "" : "@",
1095   (int)msg.msg_namelen - (*sa_un.sun_path ? 0 : 1),
1096   sa_un.sun_path + (*sa_un.sun_path ? 0 : 1));
1097
1098 /* Refuse to handle the item unless the peer has good credentials */
1099 #ifdef SCM_CREDENTIALS
1100 # define EXIM_SCM_CR_TYPE SCM_CREDENTIALS
1101 #elif defined(LOCAL_CREDS) && defined(SCM_CREDS)
1102 # define EXIM_SCM_CR_TYPE SCM_CREDS
1103 #else
1104         /* The OS has no way to get the creds of the caller (for a unix/datagram socket.
1105         Punt; don't try to check. */
1106 #endif
1107
1108 #ifdef EXIM_SCM_CR_TYPE
1109 for (struct cmsghdr * cp = CMSG_FIRSTHDR(&msg);
1110      cp;
1111      cp = CMSG_NXTHDR(&msg, cp))
1112   if (cp->cmsg_level == SOL_SOCKET && cp->cmsg_type == EXIM_SCM_CR_TYPE)
1113   {
1114 # ifdef SCM_CREDENTIALS                                 /* Linux */
1115   struct ucred * cr = (struct ucred *) CMSG_DATA(cp);
1116   if (cr->uid && cr->uid != exim_uid)
1117     {
1118     DEBUG(D_queue_run) debug_printf("%s: sender creds pid %d uid %d gid %d\n",
1119       __FUNCTION__, (int)cr->pid, (int)cr->uid, (int)cr->gid);
1120     return FALSE;
1121     }
1122 # elif defined(LOCAL_CREDS)                             /* BSD-ish */
1123   struct sockcred * cr = (struct sockcred *) CMSG_DATA(cp);
1124   if (cr->sc_uid && cr->sc_uid != exim_uid)
1125     {
1126     DEBUG(D_queue_run) debug_printf("%s: sender creds pid ??? uid %d gid %d\n",
1127       __FUNCTION__, (int)cr->sc_uid, (int)cr->sc_gid);
1128     return FALSE;
1129     }
1130 # endif
1131   break;
1132   }
1133 #endif
1134
1135 buf[sz] = 0;
1136 switch (buf[0])
1137   {
1138 #ifndef DISABLE_QUEUE_RAMP
1139   case NOTIFY_MSG_QRUN:
1140     /* this should be a message_id */
1141     DEBUG(D_queue_run)
1142       debug_printf("%s: qrunner trigger: %s\n", __FUNCTION__, buf+1);
1143     memcpy(queuerun_msgid, buf+1, MESSAGE_ID_LENGTH+1);
1144     return TRUE;
1145 #endif
1146
1147   case NOTIFY_QUEUE_SIZE_REQ:
1148     {
1149     uschar buf[16];
1150     int len = snprintf(CS buf, sizeof(buf), "%u", queue_count_cached());
1151
1152     DEBUG(D_queue_run)
1153       debug_printf("%s: queue size request: %s\n", __FUNCTION__, buf);
1154
1155     if (sendto(daemon_notifier_fd, buf, len, 0,
1156                 (const struct sockaddr *)&sa_un, msg.msg_namelen) < 0)
1157       log_write(0, LOG_MAIN|LOG_PANIC,
1158         "%s: sendto: %s\n", __FUNCTION__, strerror(errno));
1159     return FALSE;
1160     }
1161   }
1162 return FALSE;
1163 }
1164
1165
1166 /*************************************************
1167 *              Exim Daemon Mainline              *
1168 *************************************************/
1169
1170 /* The daemon can do two jobs, either of which is optional:
1171
1172 (1) Listens for incoming SMTP calls and spawns off a sub-process to handle
1173 each one. This is requested by the -bd option, with -oX specifying the SMTP
1174 port on which to listen (for testing).
1175
1176 (2) Spawns a queue-running process every so often. This is controlled by the
1177 -q option with a an interval time. (If no time is given, a single queue run
1178 is done from the main function, and control doesn't get here.)
1179
1180 Root privilege is required in order to attach to port 25. Some systems require
1181 it when calling socket() rather than bind(). To cope with all cases, we run as
1182 root for both socket() and bind(). Some systems also require root in order to
1183 write to the pid file directory. This function must therefore be called as root
1184 if it is to work properly in all circumstances. Once the socket is bound and
1185 the pid file written, root privilege is given up if there is an exim uid.
1186
1187 There are no arguments to this function, and it never returns. */
1188
1189 void
1190 daemon_go(void)
1191 {
1192 struct passwd *pw;
1193 int *listen_sockets = NULL;
1194 int listen_socket_count = 0;
1195 ip_address_item *addresses = NULL;
1196 time_t last_connection_time = (time_t)0;
1197 int local_queue_run_max = atoi(CS expand_string(queue_run_max));
1198
1199 process_purpose = US"daemon";
1200
1201 /* If any debugging options are set, turn on the D_pid bit so that all
1202 debugging lines get the pid added. */
1203
1204 DEBUG(D_any|D_v) debug_selector |= D_pid;
1205
1206 if (f.inetd_wait_mode)
1207   {
1208   listen_socket_count = 1;
1209   listen_sockets = store_get(sizeof(int), FALSE);
1210   (void) close(3);
1211   if (dup2(0, 3) == -1)
1212     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1213         "failed to dup inetd socket safely away: %s", strerror(errno));
1214
1215   listen_sockets[0] = 3;
1216   (void) close(0);
1217   (void) close(1);
1218   (void) close(2);
1219   exim_nullstd();
1220
1221   if (debug_file == stderr)
1222     {
1223     /* need a call to log_write before call to open debug_file, so that
1224     log.c:file_path has been initialised.  This is unfortunate. */
1225     log_write(0, LOG_MAIN, "debugging Exim in inetd wait mode starting");
1226
1227     fclose(debug_file);
1228     debug_file = NULL;
1229     exim_nullstd(); /* re-open fd2 after we just closed it again */
1230     debug_logging_activate(US"-wait", NULL);
1231     }
1232
1233   DEBUG(D_any) debug_printf("running in inetd wait mode\n");
1234
1235   /* As per below, when creating sockets ourselves, we handle tcp_nodelay for
1236   our own buffering; we assume though that inetd set the socket REUSEADDR. */
1237
1238   if (tcp_nodelay)
1239     if (setsockopt(3, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
1240       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to set socket NODELAY: %s",
1241         strerror(errno));
1242   }
1243
1244
1245 if (f.inetd_wait_mode || f.daemon_listen)
1246   {
1247   /* If any option requiring a load average to be available during the
1248   reception of a message is set, call os_getloadavg() while we are root
1249   for those OS for which this is necessary the first time it is called (in
1250   order to perform an "open" on the kernel memory file). */
1251
1252   #ifdef LOAD_AVG_NEEDS_ROOT
1253   if (queue_only_load >= 0 || smtp_load_reserve >= 0 ||
1254        (deliver_queue_load_max >= 0 && deliver_drop_privilege))
1255     (void)os_getloadavg();
1256   #endif
1257   }
1258
1259
1260 /* Do the preparation for setting up a listener on one or more interfaces, and
1261 possible on various ports. This is controlled by the combination of
1262 local_interfaces (which can set IP addresses and ports) and daemon_smtp_port
1263 (which is a list of default ports to use for those items in local_interfaces
1264 that do not specify a port). The -oX command line option can be used to
1265 override one or both of these options.
1266
1267 If local_interfaces is not set, the default is to listen on all interfaces.
1268 When it is set, it can include "all IPvx interfaces" as an item. This is useful
1269 when different ports are in use.
1270
1271 It turns out that listening on all interfaces is messy in an IPv6 world,
1272 because several different implementation approaches have been taken. This code
1273 is now supposed to work with all of them. The point of difference is whether an
1274 IPv6 socket that is listening on all interfaces will receive incoming IPv4
1275 calls or not. We also have to cope with the case when IPv6 libraries exist, but
1276 there is no IPv6 support in the kernel.
1277
1278 . On Solaris, an IPv6 socket will accept IPv4 calls, and give them as mapped
1279   addresses. However, if an IPv4 socket is also listening on all interfaces,
1280   calls are directed to the appropriate socket.
1281
1282 . On (some versions of) Linux, an IPv6 socket will accept IPv4 calls, and
1283   give them as mapped addresses, but an attempt also to listen on an IPv4
1284   socket on all interfaces causes an error.
1285
1286 . On OpenBSD, an IPv6 socket will not accept IPv4 calls. You have to set up
1287   two sockets if you want to accept both kinds of call.
1288
1289 . FreeBSD is like OpenBSD, but it has the IPV6_V6ONLY socket option, which
1290   can be turned off, to make it behave like the versions of Linux described
1291   above.
1292
1293 . I heard a report that the USAGI IPv6 stack for Linux has implemented
1294   IPV6_V6ONLY.
1295
1296 So, what we do when IPv6 is supported is as follows:
1297
1298  (1) After it is set up, the list of interfaces is scanned for wildcard
1299      addresses. If an IPv6 and an IPv4 wildcard are both found for the same
1300      port, the list is re-arranged so that they are together, with the IPv6
1301      wildcard first.
1302
1303  (2) If the creation of a wildcard IPv6 socket fails, we just log the error and
1304      carry on if an IPv4 wildcard socket for the same port follows later in the
1305      list. This allows Exim to carry on in the case when the kernel has no IPv6
1306      support.
1307
1308  (3) Having created an IPv6 wildcard socket, we try to set IPV6_V6ONLY if that
1309      option is defined. However, if setting fails, carry on regardless (but log
1310      the incident).
1311
1312  (4) If binding or listening on an IPv6 wildcard socket fails, it is a serious
1313      error.
1314
1315  (5) If binding or listening on an IPv4 wildcard socket fails with the error
1316      EADDRINUSE, and a previous interface was an IPv6 wildcard for the same
1317      port (which must have succeeded or we wouldn't have got this far), we
1318      assume we are in the situation where just a single socket is permitted,
1319      and ignore the error.
1320
1321 Phew!
1322
1323 The preparation code decodes options and sets up the relevant data. We do this
1324 first, so that we can return non-zero if there are any syntax errors, and also
1325 write to stderr. */
1326
1327 if (f.daemon_listen && !f.inetd_wait_mode)
1328   {
1329   int *default_smtp_port;
1330   int sep;
1331   int pct = 0;
1332   uschar *s;
1333   const uschar * list;
1334   uschar *local_iface_source = US"local_interfaces";
1335   ip_address_item *ipa;
1336   ip_address_item **pipa;
1337
1338   /* If -oX was used, disable the writing of a pid file unless -oP was
1339   explicitly used to force it. Then scan the string given to -oX. Any items
1340   that contain neither a dot nor a colon are used to override daemon_smtp_port.
1341   Any other items are used to override local_interfaces. */
1342
1343   if (override_local_interfaces)
1344     {
1345     gstring * new_smtp_port = NULL;
1346     gstring * new_local_interfaces = NULL;
1347
1348     if (!override_pid_file_path) write_pid = FALSE;
1349
1350     list = override_local_interfaces;
1351     sep = 0;
1352     while ((s = string_nextinlist(&list, &sep, NULL, 0)))
1353       {
1354       uschar joinstr[4];
1355       gstring ** gp = Ustrpbrk(s, ".:") ? &new_local_interfaces : &new_smtp_port;
1356
1357       if (!*gp)
1358         {
1359         joinstr[0] = sep;
1360         joinstr[1] = ' ';
1361         *gp = string_catn(*gp, US"<", 1);
1362         }
1363
1364       *gp = string_catn(*gp, joinstr, 2);
1365       *gp = string_cat (*gp, s);
1366       }
1367
1368     if (new_smtp_port)
1369       {
1370       daemon_smtp_port = string_from_gstring(new_smtp_port);
1371       DEBUG(D_any) debug_printf("daemon_smtp_port overridden by -oX:\n  %s\n",
1372         daemon_smtp_port);
1373       }
1374
1375     if (new_local_interfaces)
1376       {
1377       local_interfaces = string_from_gstring(new_local_interfaces);
1378       local_iface_source = US"-oX data";
1379       DEBUG(D_any) debug_printf("local_interfaces overridden by -oX:\n  %s\n",
1380         local_interfaces);
1381       }
1382     }
1383
1384   /* Create a list of default SMTP ports, to be used if local_interfaces
1385   contains entries without explicit ports. First count the number of ports, then
1386   build a translated list in a vector. */
1387
1388   list = daemon_smtp_port;
1389   sep = 0;
1390   while ((s = string_nextinlist(&list, &sep, NULL, 0)))
1391     pct++;
1392   default_smtp_port = store_get((pct+1) * sizeof(int), FALSE);
1393   list = daemon_smtp_port;
1394   sep = 0;
1395   for (pct = 0;
1396        (s = string_nextinlist(&list, &sep, NULL, 0));
1397        pct++)
1398     {
1399     if (isdigit(*s))
1400       {
1401       uschar *end;
1402       default_smtp_port[pct] = Ustrtol(s, &end, 0);
1403       if (end != s + Ustrlen(s))
1404         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "invalid SMTP port: %s", s);
1405       }
1406     else
1407       {
1408       struct servent *smtp_service = getservbyname(CS s, "tcp");
1409       if (!smtp_service)
1410         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "TCP port \"%s\" not found", s);
1411       default_smtp_port[pct] = ntohs(smtp_service->s_port);
1412       }
1413     }
1414   default_smtp_port[pct] = 0;
1415
1416   /* Check the list of TLS-on-connect ports and do name lookups if needed */
1417
1418   list = tls_in.on_connect_ports;
1419   sep = 0;
1420   while ((s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
1421     if (!isdigit(*s))
1422       {
1423       gstring * g = NULL;
1424
1425       list = tls_in.on_connect_ports;
1426       tls_in.on_connect_ports = NULL;
1427       sep = 0;
1428       while ((s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
1429         {
1430         if (!isdigit(*s))
1431           {
1432           struct servent * smtp_service = getservbyname(CS s, "tcp");
1433           if (!smtp_service)
1434             log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "TCP port \"%s\" not found", s);
1435           s = string_sprintf("%d", (int)ntohs(smtp_service->s_port));
1436           }
1437         g = string_append_listele(g, ':', s);
1438         }
1439       if (g)
1440         tls_in.on_connect_ports = g->s;
1441       break;
1442       }
1443
1444   /* Create the list of local interfaces, possibly with ports included. This
1445   list may contain references to 0.0.0.0 and ::0 as wildcards. These special
1446   values are converted below. */
1447
1448   addresses = host_build_ifacelist(local_interfaces, local_iface_source);
1449
1450   /* In the list of IP addresses, convert 0.0.0.0 into an empty string, and ::0
1451   into the string ":". We use these to recognize wildcards in IPv4 and IPv6. In
1452   fact, many IP stacks recognize 0.0.0.0 and ::0 and handle them as wildcards
1453   anyway, but we need to know which are the wildcard addresses, and the shorter
1454   strings are neater.
1455
1456   In the same scan, fill in missing port numbers from the default list. When
1457   there is more than one item in the list, extra items are created. */
1458
1459   for (ipa = addresses; ipa; ipa = ipa->next)
1460     {
1461     if (Ustrcmp(ipa->address, "0.0.0.0") == 0)
1462       ipa->address[0] = 0;
1463     else if (Ustrcmp(ipa->address, "::0") == 0)
1464       {
1465       ipa->address[0] = ':';
1466       ipa->address[1] = 0;
1467       }
1468
1469     if (ipa->port > 0) continue;
1470
1471     if (daemon_smtp_port[0] <= 0)
1472       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "no port specified for interface "
1473         "%s and daemon_smtp_port is unset; cannot start daemon",
1474         ipa->address[0] == 0 ? US"\"all IPv4\"" :
1475         ipa->address[1] == 0 ? US"\"all IPv6\"" : ipa->address);
1476
1477     ipa->port = default_smtp_port[0];
1478     for (int i = 1; default_smtp_port[i] > 0; i++)
1479       {
1480       ip_address_item *new = store_get(sizeof(ip_address_item), FALSE);
1481
1482       memcpy(new->address, ipa->address, Ustrlen(ipa->address) + 1);
1483       new->port = default_smtp_port[i];
1484       new->next = ipa->next;
1485       ipa->next = new;
1486       ipa = new;
1487       }
1488     }
1489
1490   /* Scan the list of addresses for wildcards. If we find an IPv4 and an IPv6
1491   wildcard for the same port, ensure that (a) they are together and (b) the
1492   IPv6 address comes first. This makes handling the messy features easier, and
1493   also simplifies the construction of the "daemon started" log line. */
1494
1495   pipa = &addresses;
1496   for (ipa = addresses; ipa; pipa = &ipa->next, ipa = ipa->next)
1497     {
1498     ip_address_item *ipa2;
1499
1500     /* Handle an IPv4 wildcard */
1501
1502     if (ipa->address[0] == 0)
1503       for (ipa2 = ipa; ipa2->next; ipa2 = ipa2->next)
1504         {
1505         ip_address_item *ipa3 = ipa2->next;
1506         if (ipa3->address[0] == ':' &&
1507             ipa3->address[1] == 0 &&
1508             ipa3->port == ipa->port)
1509           {
1510           ipa2->next = ipa3->next;
1511           ipa3->next = ipa;
1512           *pipa = ipa3;
1513           break;
1514           }
1515         }
1516
1517     /* Handle an IPv6 wildcard. */
1518
1519     else if (ipa->address[0] == ':' && ipa->address[1] == 0)
1520       for (ipa2 = ipa; ipa2->next; ipa2 = ipa2->next)
1521         {
1522         ip_address_item *ipa3 = ipa2->next;
1523         if (ipa3->address[0] == 0 && ipa3->port == ipa->port)
1524           {
1525           ipa2->next = ipa3->next;
1526           ipa3->next = ipa->next;
1527           ipa->next = ipa3;
1528           ipa = ipa3;
1529           break;
1530           }
1531         }
1532     }
1533
1534   /* Get a vector to remember all the sockets in */
1535
1536   for (ipa = addresses; ipa; ipa = ipa->next)
1537     listen_socket_count++;
1538   listen_sockets = store_get(sizeof(int) * listen_socket_count, FALSE);
1539
1540   } /* daemon_listen but not inetd_wait_mode */
1541
1542 if (f.daemon_listen)
1543   {
1544
1545   /* Do a sanity check on the max connects value just to save us from getting
1546   a huge amount of store. */
1547
1548   if (smtp_accept_max > 4095) smtp_accept_max = 4096;
1549
1550   /* There's no point setting smtp_accept_queue unless it is less than the max
1551   connects limit. The configuration reader ensures that the max is set if the
1552   queue-only option is set. */
1553
1554   if (smtp_accept_queue > smtp_accept_max) smtp_accept_queue = 0;
1555
1556   /* Get somewhere to keep the list of SMTP accepting pids if we are keeping
1557   track of them for total number and queue/host limits. */
1558
1559   if (smtp_accept_max > 0)
1560     {
1561     smtp_slots = store_get(smtp_accept_max * sizeof(smtp_slot), FALSE);
1562     for (int i = 0; i < smtp_accept_max; i++) smtp_slots[i] = empty_smtp_slot;
1563     }
1564   }
1565
1566 /* The variable background_daemon is always false when debugging, but
1567 can also be forced false in order to keep a non-debugging daemon in the
1568 foreground. If background_daemon is true, close all open file descriptors that
1569 we know about, but then re-open stdin, stdout, and stderr to /dev/null.  Also
1570 do this for inetd_wait mode.
1571
1572 This is protection against any called functions (in libraries, or in
1573 Perl, or whatever) that think they can write to stderr (or stdout). Before this
1574 was added, it was quite likely that an SMTP connection would use one of these
1575 file descriptors, in which case writing random stuff to it caused chaos.
1576
1577 Then disconnect from the controlling terminal, Most modern Unixes seem to have
1578 setsid() for getting rid of the controlling terminal. For any OS that doesn't,
1579 setsid() can be #defined as a no-op, or as something else. */
1580
1581 if (f.background_daemon || f.inetd_wait_mode)
1582   {
1583   log_close_all();    /* Just in case anything was logged earlier */
1584   search_tidyup();    /* Just in case any were used in reading the config. */
1585   (void)close(0);           /* Get rid of stdin/stdout/stderr */
1586   (void)close(1);
1587   (void)close(2);
1588   exim_nullstd();     /* Connect stdin/stdout/stderr to /dev/null */
1589   log_stderr = NULL;  /* So no attempt to copy paniclog output */
1590   }
1591
1592 if (f.background_daemon)
1593   {
1594   /* If the parent process of this one has pid == 1, we are re-initializing the
1595   daemon as the result of a SIGHUP. In this case, there is no need to do
1596   anything, because the controlling terminal has long gone. Otherwise, fork, in
1597   case current process is a process group leader (see 'man setsid' for an
1598   explanation) before calling setsid(). */
1599
1600   if (getppid() != 1)
1601     {
1602     pid_t pid = exim_fork(US"daemon");
1603     if (pid < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1604       "fork() failed when starting daemon: %s", strerror(errno));
1605     if (pid > 0) exit(EXIT_SUCCESS);      /* in parent process, just exit */
1606     (void)setsid();                       /* release controlling terminal */
1607     }
1608   }
1609
1610 /* We are now in the disconnected, daemon process (unless debugging). Set up
1611 the listening sockets if required. */
1612
1613 daemon_notifier_socket();
1614
1615 if (f.daemon_listen && !f.inetd_wait_mode)
1616   {
1617   int sk;
1618   ip_address_item *ipa;
1619
1620   /* For each IP address, create a socket, bind it to the appropriate port, and
1621   start listening. See comments above about IPv6 sockets that may or may not
1622   accept IPv4 calls when listening on all interfaces. We also have to cope with
1623   the case of a system with IPv6 libraries, but no IPv6 support in the kernel.
1624   listening, provided a wildcard IPv4 socket for the same port follows. */
1625
1626   for (ipa = addresses, sk = 0; sk < listen_socket_count; ipa = ipa->next, sk++)
1627     {
1628     BOOL wildcard;
1629     ip_address_item *ipa2;
1630     int af;
1631
1632     if (Ustrchr(ipa->address, ':') != NULL)
1633       {
1634       af = AF_INET6;
1635       wildcard = ipa->address[1] == 0;
1636       }
1637     else
1638       {
1639       af = AF_INET;
1640       wildcard = ipa->address[0] == 0;
1641       }
1642
1643     if ((listen_sockets[sk] = ip_socket(SOCK_STREAM, af)) < 0)
1644       {
1645       if (check_special_case(0, addresses, ipa, FALSE))
1646         {
1647         log_write(0, LOG_MAIN, "Failed to create IPv6 socket for wildcard "
1648           "listening (%s): will use IPv4", strerror(errno));
1649         goto SKIP_SOCKET;
1650         }
1651       log_write(0, LOG_PANIC_DIE, "IPv%c socket creation failed: %s",
1652         (af == AF_INET6)? '6' : '4', strerror(errno));
1653       }
1654
1655     /* If this is an IPv6 wildcard socket, set IPV6_V6ONLY if that option is
1656     available. Just log failure (can get protocol not available, just like
1657     socket creation can). */
1658
1659 #ifdef IPV6_V6ONLY
1660     if (af == AF_INET6 && wildcard &&
1661         setsockopt(listen_sockets[sk], IPPROTO_IPV6, IPV6_V6ONLY, CS (&on),
1662           sizeof(on)) < 0)
1663       log_write(0, LOG_MAIN, "Setting IPV6_V6ONLY on daemon's IPv6 wildcard "
1664         "socket failed (%s): carrying on without it", strerror(errno));
1665 #endif  /* IPV6_V6ONLY */
1666
1667     /* Set SO_REUSEADDR so that the daemon can be restarted while a connection
1668     is being handled.  Without this, a connection will prevent reuse of the
1669     smtp port for listening. */
1670
1671     if (setsockopt(listen_sockets[sk], SOL_SOCKET, SO_REUSEADDR,
1672                    US (&on), sizeof(on)) < 0)
1673       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "setting SO_REUSEADDR on socket "
1674         "failed when starting daemon: %s", strerror(errno));
1675
1676     /* Set TCP_NODELAY; Exim does its own buffering. There is a switch to
1677     disable this because it breaks some broken clients. */
1678
1679     if (tcp_nodelay) setsockopt(listen_sockets[sk], IPPROTO_TCP, TCP_NODELAY,
1680       US (&on), sizeof(on));
1681
1682     /* Now bind the socket to the required port; if Exim is being restarted
1683     it may not always be possible to bind immediately, even with SO_REUSEADDR
1684     set, so try 10 times, waiting between each try. After 10 failures, we give
1685     up. In an IPv6 environment, if bind () fails with the error EADDRINUSE and
1686     we are doing wildcard IPv4 listening and there was a previous IPv6 wildcard
1687     address for the same port, ignore the error on the grounds that we must be
1688     in a system where the IPv6 socket accepts both kinds of call. This is
1689     necessary for (some release of) USAGI Linux; other IP stacks fail at the
1690     listen() stage instead. */
1691
1692 #ifdef TCP_FASTOPEN
1693     f.tcp_fastopen_ok = TRUE;
1694 #endif
1695     for(;;)
1696       {
1697       uschar *msg, *addr;
1698       if (ip_bind(listen_sockets[sk], af, ipa->address, ipa->port) >= 0) break;
1699       if (check_special_case(errno, addresses, ipa, TRUE))
1700         {
1701         DEBUG(D_any) debug_printf("wildcard IPv4 bind() failed after IPv6 "
1702           "listen() success; EADDRINUSE ignored\n");
1703         (void)close(listen_sockets[sk]);
1704         goto SKIP_SOCKET;
1705         }
1706       msg = US strerror(errno);
1707       addr = wildcard
1708         ? af == AF_INET6
1709         ? US"(any IPv6)"
1710         : US"(any IPv4)"
1711         : ipa->address;
1712       if (daemon_startup_retries <= 0)
1713         log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1714           "socket bind() to port %d for address %s failed: %s: "
1715           "daemon abandoned", ipa->port, addr, msg);
1716       log_write(0, LOG_MAIN, "socket bind() to port %d for address %s "
1717         "failed: %s: waiting %s before trying again (%d more %s)",
1718         ipa->port, addr, msg, readconf_printtime(daemon_startup_sleep),
1719         daemon_startup_retries, (daemon_startup_retries > 1)? "tries" : "try");
1720       daemon_startup_retries--;
1721       sleep(daemon_startup_sleep);
1722       }
1723
1724     DEBUG(D_any)
1725       if (wildcard)
1726         debug_printf("listening on all interfaces (IPv%c) port %d\n",
1727           af == AF_INET6 ? '6' : '4', ipa->port);
1728       else
1729         debug_printf("listening on %s port %d\n", ipa->address, ipa->port);
1730
1731 #if defined(TCP_FASTOPEN) && !defined(__APPLE__)
1732     if (  f.tcp_fastopen_ok
1733        && setsockopt(listen_sockets[sk], IPPROTO_TCP, TCP_FASTOPEN,
1734                     &smtp_connect_backlog, sizeof(smtp_connect_backlog)))
1735       {
1736       DEBUG(D_any) debug_printf("setsockopt FASTOPEN: %s\n", strerror(errno));
1737       f.tcp_fastopen_ok = FALSE;
1738       }
1739 #endif
1740
1741     /* Start listening on the bound socket, establishing the maximum backlog of
1742     connections that is allowed. On success, continue to the next address. */
1743
1744     if (listen(listen_sockets[sk], smtp_connect_backlog) >= 0)
1745       {
1746 #if defined(TCP_FASTOPEN) && defined(__APPLE__)
1747       if (  f.tcp_fastopen_ok
1748          && setsockopt(listen_sockets[sk], IPPROTO_TCP, TCP_FASTOPEN,
1749                       &on, sizeof(on)))
1750         {
1751         DEBUG(D_any) debug_printf("setsockopt FASTOPEN: %s\n", strerror(errno));
1752         f.tcp_fastopen_ok = FALSE;
1753         }
1754 #endif
1755       continue;
1756       }
1757
1758     /* Listening has failed. In an IPv6 environment, as for bind(), if listen()
1759     fails with the error EADDRINUSE and we are doing IPv4 wildcard listening
1760     and there was a previous successful IPv6 wildcard listen on the same port,
1761     we want to ignore the error on the grounds that we must be in a system
1762     where the IPv6 socket accepts both kinds of call. */
1763
1764     if (!check_special_case(errno, addresses, ipa, TRUE))
1765       log_write(0, LOG_PANIC_DIE, "listen() failed on interface %s: %s",
1766         wildcard
1767         ? af == AF_INET6 ? US"(any IPv6)" : US"(any IPv4)" : ipa->address,
1768         strerror(errno));
1769
1770     DEBUG(D_any) debug_printf("wildcard IPv4 listen() failed after IPv6 "
1771       "listen() success; EADDRINUSE ignored\n");
1772     (void)close(listen_sockets[sk]);
1773
1774     /* Come here if there has been a problem with the socket which we
1775     are going to ignore. We remove the address from the chain, and back up the
1776     counts. */
1777
1778   SKIP_SOCKET:
1779     sk--;                          /* Back up the count */
1780     listen_socket_count--;         /* Reduce the total */
1781     if (ipa == addresses) addresses = ipa->next; else
1782       {
1783       for (ipa2 = addresses; ipa2->next != ipa; ipa2 = ipa2->next);
1784       ipa2->next = ipa->next;
1785       ipa = ipa2;
1786       }
1787     }          /* End of bind/listen loop for each address */
1788   }            /* End of setup for listening */
1789
1790
1791 /* If we are not listening, we want to write a pid file only if -oP was
1792 explicitly given. */
1793
1794 else if (!override_pid_file_path)
1795   write_pid = FALSE;
1796
1797 /* Write the pid to a known file for assistance in identification, if required.
1798 We do this before giving up root privilege, because on some systems it is
1799 necessary to be root in order to write into the pid file directory. There's
1800 nothing to stop multiple daemons running, as long as no more than one listens
1801 on a given TCP/IP port on the same interface(s). However, in these
1802 circumstances it gets far too complicated to mess with pid file names
1803 automatically. Consequently, Exim 4 writes a pid file only
1804
1805   (a) When running in the test harness, or
1806   (b) When -bd is used and -oX is not used, or
1807   (c) When -oP is used to supply a path.
1808
1809 The variable daemon_write_pid is used to control this. */
1810
1811 if (f.running_in_test_harness || write_pid)
1812   {
1813   FILE *f;
1814
1815   set_pid_file_path();
1816   if ((f = modefopen(pid_file_path, "wb", 0644)))
1817     {
1818     (void)fprintf(f, "%d\n", (int)getpid());
1819     (void)fclose(f);
1820     DEBUG(D_any) debug_printf("pid written to %s\n", pid_file_path);
1821     }
1822   else
1823     DEBUG(D_any)
1824       debug_printf("%s\n", string_open_failed("pid file %s", pid_file_path));
1825   }
1826
1827 /* Set up the handler for SIGHUP, which causes a restart of the daemon. */
1828
1829 sighup_seen = FALSE;
1830 signal(SIGHUP, sighup_handler);
1831
1832 /* Give up root privilege at this point (assuming that exim_uid and exim_gid
1833 are not root). The third argument controls the running of initgroups().
1834 Normally we do this, in order to set up the groups for the Exim user. However,
1835 if we are not root at this time - some odd installations run that way - we
1836 cannot do this. */
1837
1838 exim_setugid(exim_uid, exim_gid, geteuid()==root_uid, US"running as a daemon");
1839
1840 /* Update the originator_xxx fields so that received messages as listed as
1841 coming from Exim, not whoever started the daemon. */
1842
1843 originator_uid = exim_uid;
1844 originator_gid = exim_gid;
1845 originator_login = (pw = getpwuid(exim_uid))
1846   ? string_copy_perm(US pw->pw_name, FALSE) : US"exim";
1847
1848 /* Get somewhere to keep the list of queue-runner pids if we are keeping track
1849 of them (and also if we are doing queue runs). */
1850
1851 if (queue_interval > 0 && local_queue_run_max > 0)
1852   {
1853   queue_pid_slots = store_get(local_queue_run_max * sizeof(pid_t), FALSE);
1854   for (int i = 0; i < local_queue_run_max; i++) queue_pid_slots[i] = 0;
1855   }
1856
1857 /* Set up the handler for termination of child processes, and the one
1858 telling us to die. */
1859
1860 sigchld_seen = FALSE;
1861 os_non_restarting_signal(SIGCHLD, main_sigchld_handler);
1862
1863 sigterm_seen = FALSE;
1864 os_non_restarting_signal(SIGTERM, main_sigterm_handler);
1865
1866 /* If we are to run the queue periodically, pretend the alarm has just gone
1867 off. This will cause the first queue-runner to get kicked off straight away. */
1868
1869 sigalrm_seen = (queue_interval > 0);
1870
1871 /* Log the start up of a daemon - at least one of listening or queue running
1872 must be set up. */
1873
1874 if (f.inetd_wait_mode)
1875   {
1876   uschar *p = big_buffer;
1877
1878   if (inetd_wait_timeout >= 0)
1879     sprintf(CS p, "terminating after %d seconds", inetd_wait_timeout);
1880   else
1881     sprintf(CS p, "with no wait timeout");
1882
1883   log_write(0, LOG_MAIN,
1884     "exim %s daemon started: pid=%d, launched with listening socket, %s",
1885     version_string, getpid(), big_buffer);
1886   set_process_info("daemon(%s): pre-listening socket", version_string);
1887
1888   /* set up the timeout logic */
1889   sigalrm_seen = TRUE;
1890   }
1891
1892 else if (f.daemon_listen)
1893   {
1894   int smtp_ports = 0;
1895   int smtps_ports = 0;
1896   ip_address_item * ipa;
1897   uschar * p;
1898   uschar * qinfo = queue_interval > 0
1899     ? string_sprintf("-q%s%s",
1900         f.queue_2stage ? "q" : "", readconf_printtime(queue_interval))
1901     : US"no queue runs";
1902
1903   /* Build a list of listening addresses in big_buffer, but limit it to 10
1904   items. The style is for backwards compatibility.
1905
1906   It is now possible to have some ports listening for SMTPS (the old,
1907   deprecated protocol that starts TLS without using STARTTLS), and others
1908   listening for standard SMTP. Keep their listings separate. */
1909
1910   for (int j = 0, i; j < 2; j++)
1911     {
1912     for (i = 0, ipa = addresses; i < 10 && ipa; i++, ipa = ipa->next)
1913       {
1914       /* First time round, look for SMTP ports; second time round, look for
1915       SMTPS ports. Build IP+port strings. */
1916
1917       if (host_is_tls_on_connect_port(ipa->port) == (j > 0))
1918         {
1919         if (j == 0)
1920           smtp_ports++;
1921         else
1922           smtps_ports++;
1923
1924         /* Now the information about the port (and sometimes interface) */
1925
1926         if (ipa->address[0] == ':' && ipa->address[1] == 0)
1927           {                                             /* v6 wildcard */
1928           if (ipa->next && ipa->next->address[0] == 0 &&
1929               ipa->next->port == ipa->port)
1930             {
1931             ipa->log = string_sprintf(" port %d (IPv6 and IPv4)", ipa->port);
1932             (ipa = ipa->next)->log = NULL;
1933             }
1934           else if (ipa->v6_include_v4)
1935             ipa->log = string_sprintf(" port %d (IPv6 with IPv4)", ipa->port);
1936           else
1937             ipa->log = string_sprintf(" port %d (IPv6)", ipa->port);
1938           }
1939         else if (ipa->address[0] == 0)                  /* v4 wildcard */
1940           ipa->log = string_sprintf(" port %d (IPv4)", ipa->port);
1941         else                            /* check for previously-seen IP */
1942           {
1943           ip_address_item * i2;
1944           for (i2 = addresses; i2 != ipa; i2 = i2->next)
1945             if (  host_is_tls_on_connect_port(i2->port) == (j > 0)
1946                && Ustrcmp(ipa->address, i2->address) == 0
1947                )
1948               {                         /* found; append port to list */
1949               for (p = i2->log; *p; ) p++;      /* end of existing string */
1950               if (*--p == '}') *p = '\0';       /* drop EOL */
1951               while (isdigit(*--p)) ;           /* char before port */
1952
1953               i2->log = *p == ':'               /* no list yet? */
1954                 ? string_sprintf("%.*s{%s,%d}",
1955                   (int)(p - i2->log + 1), i2->log, p+1, ipa->port)
1956                 : string_sprintf("%s,%d}", i2->log, ipa->port);
1957               ipa->log = NULL;
1958               break;
1959               }
1960           if (i2 == ipa)                /* first-time IP */
1961             ipa->log = string_sprintf(" [%s]:%d", ipa->address, ipa->port);
1962           }
1963         }
1964       }
1965     }
1966
1967   p = big_buffer;
1968   for (int j = 0, i; j < 2; j++)
1969     {
1970     /* First time round, look for SMTP ports; second time round, look for
1971     SMTPS ports. For the first one of each, insert leading text. */
1972
1973     if (j == 0)
1974       {
1975       if (smtp_ports > 0)
1976         p += sprintf(CS p, "SMTP on");
1977       }
1978     else
1979       if (smtps_ports > 0)
1980         p += sprintf(CS p, "%sSMTPS on",
1981           smtp_ports == 0 ? "" : " and for ");
1982
1983     /* Now the information about the port (and sometimes interface) */
1984
1985     for (i = 0, ipa = addresses; i < 10 && ipa; i++, ipa = ipa->next)
1986       if (host_is_tls_on_connect_port(ipa->port) == (j > 0))
1987         if (ipa->log)
1988           p += sprintf(CS p, "%s",  ipa->log);
1989
1990     if (ipa)
1991       p += sprintf(CS p, " ...");
1992     }
1993
1994   log_write(0, LOG_MAIN,
1995     "exim %s daemon started: pid=%d, %s, listening for %s",
1996     version_string, getpid(), qinfo, big_buffer);
1997   set_process_info("daemon(%s): %s, listening for %s",
1998     version_string, qinfo, big_buffer);
1999   }
2000
2001 else
2002   {
2003   uschar * s = *queue_name
2004     ? string_sprintf("-qG%s/%s", queue_name, readconf_printtime(queue_interval))
2005     : string_sprintf("-q%s", readconf_printtime(queue_interval));
2006   log_write(0, LOG_MAIN,
2007     "exim %s daemon started: pid=%d, %s, not listening for SMTP",
2008     version_string, getpid(), s);
2009   set_process_info("daemon(%s): %s, not listening", version_string, s);
2010   }
2011
2012 /* Do any work it might be useful to amortize over our children
2013 (eg: compile regex) */
2014
2015 dns_pattern_init();
2016 smtp_deliver_init();    /* Used for callouts */
2017
2018 #ifndef DISABLE_DKIM
2019   {
2020 # ifdef MEASURE_TIMING
2021   struct timeval t0;
2022   gettimeofday(&t0, NULL);
2023 # endif
2024   dkim_exim_init();
2025 # ifdef MEASURE_TIMING
2026   report_time_since(&t0, US"dkim_exim_init (delta)");
2027 # endif
2028   }
2029 #endif
2030
2031 #ifdef WITH_CONTENT_SCAN
2032 malware_init();
2033 #endif
2034 #ifdef SUPPORT_SPF
2035 spf_init();
2036 #endif
2037
2038 /* Close the log so it can be renamed and moved. In the few cases below where
2039 this long-running process writes to the log (always exceptional conditions), it
2040 closes the log afterwards, for the same reason. */
2041
2042 log_close_all();
2043
2044 DEBUG(D_any) debug_print_ids(US"daemon running with");
2045
2046 /* Any messages accepted via this route are going to be SMTP. */
2047
2048 smtp_input = TRUE;
2049
2050 #ifdef MEASURE_TIMING
2051 report_time_since(&timestamp_startup, US"daemon loop start");   /* testcase 0022 */
2052 #endif
2053
2054 /* Enter the never-ending loop... */
2055
2056 for (;;)
2057   {
2058   #if HAVE_IPV6
2059   struct sockaddr_in6 accepted;
2060   #else
2061   struct sockaddr_in accepted;
2062   #endif
2063
2064   EXIM_SOCKLEN_T len;
2065   pid_t pid;
2066
2067   if (sigterm_seen)
2068     daemon_die();       /* Does not return */
2069
2070   /* This code is placed first in the loop, so that it gets obeyed at the
2071   start, before the first wait, for the queue-runner case, so that the first
2072   one can be started immediately.
2073
2074   The other option is that we have an inetd wait timeout specified to -bw. */
2075
2076   if (sigalrm_seen)
2077     {
2078     if (inetd_wait_timeout > 0)
2079       {
2080       time_t resignal_interval = inetd_wait_timeout;
2081
2082       if (last_connection_time == (time_t)0)
2083         {
2084         DEBUG(D_any)
2085           debug_printf("inetd wait timeout expired, but still not seen first message, ignoring\n");
2086         }
2087       else
2088         {
2089         time_t now = time(NULL);
2090         if (now == (time_t)-1)
2091           {
2092           DEBUG(D_any) debug_printf("failed to get time: %s\n", strerror(errno));
2093           }
2094         else
2095           {
2096           if ((now - last_connection_time) >= inetd_wait_timeout)
2097             {
2098             DEBUG(D_any)
2099               debug_printf("inetd wait timeout %d expired, ending daemon\n",
2100                   inetd_wait_timeout);
2101             log_write(0, LOG_MAIN, "exim %s daemon terminating, inetd wait timeout reached.\n",
2102                 version_string);
2103             exit(EXIT_SUCCESS);
2104             }
2105           else
2106             {
2107             resignal_interval -= (now - last_connection_time);
2108             }
2109           }
2110         }
2111
2112       sigalrm_seen = FALSE;
2113       ALARM(resignal_interval);
2114       }
2115
2116     else
2117       {
2118       DEBUG(D_any) debug_printf("%s received\n",
2119 #ifndef DISABLE_QUEUE_RAMP
2120         *queuerun_msgid ? "qrun notification" :
2121 #endif
2122         "SIGALRM");
2123
2124       /* Do a full queue run in a child process, if required, unless we already
2125       have enough queue runners on the go. If we are not running as root, a
2126       re-exec is required. */
2127
2128       if (  queue_interval > 0
2129          && (local_queue_run_max <= 0 || queue_run_count < local_queue_run_max))
2130         {
2131         if ((pid = exim_fork(US"queue-runner")) == 0)
2132           {
2133           /* Disable debugging if it's required only for the daemon process. We
2134           leave the above message, because it ties up with the "child ended"
2135           debugging messages. */
2136
2137           if (f.debug_daemon) debug_selector = 0;
2138
2139           /* Close any open listening sockets in the child */
2140
2141           close_daemon_sockets(daemon_notifier_fd,
2142             listen_sockets, listen_socket_count);
2143
2144           /* Reset SIGHUP and SIGCHLD in the child in both cases. */
2145
2146           signal(SIGHUP,  SIG_DFL);
2147           signal(SIGCHLD, SIG_DFL);
2148           signal(SIGTERM, SIG_DFL);
2149
2150           /* Re-exec if privilege has been given up, unless deliver_drop_
2151           privilege is set. Reset SIGALRM before exec(). */
2152
2153           if (geteuid() != root_uid && !deliver_drop_privilege)
2154             {
2155             uschar opt[8];
2156             uschar *p = opt;
2157             uschar *extra[7];
2158             int extracount = 1;
2159
2160             signal(SIGALRM, SIG_DFL);
2161             *p++ = '-';
2162             *p++ = 'q';
2163             if (  f.queue_2stage
2164 #ifndef DISABLE_QUEUE_RAMP
2165                && !*queuerun_msgid
2166 #endif
2167                ) *p++ = 'q';
2168             if (f.queue_run_first_delivery) *p++ = 'i';
2169             if (f.queue_run_force) *p++ = 'f';
2170             if (f.deliver_force_thaw) *p++ = 'f';
2171             if (f.queue_run_local) *p++ = 'l';
2172             *p = 0;
2173             extra[0] = *queue_name
2174               ? string_sprintf("%sG%s", opt, queue_name) : opt;
2175
2176 #ifndef DISABLE_QUEUE_RAMP
2177             if (*queuerun_msgid)
2178               {
2179               log_write(0, LOG_MAIN, "notify triggered queue run");
2180               extra[extracount++] = queuerun_msgid;     /* Trigger only the */
2181               extra[extracount++] = queuerun_msgid;     /* one message      */
2182               }
2183 #endif
2184
2185             /* If -R or -S were on the original command line, ensure they get
2186             passed on. */
2187
2188             if (deliver_selectstring)
2189               {
2190               extra[extracount++] = f.deliver_selectstring_regex ? US"-Rr" : US"-R";
2191               extra[extracount++] = deliver_selectstring;
2192               }
2193
2194             if (deliver_selectstring_sender)
2195               {
2196               extra[extracount++] = f.deliver_selectstring_sender_regex
2197                 ? US"-Sr" : US"-S";
2198               extra[extracount++] = deliver_selectstring_sender;
2199               }
2200
2201             /* Overlay this process with a new execution. */
2202
2203             (void)child_exec_exim(CEE_EXEC_PANIC, FALSE, NULL, FALSE, extracount,
2204               extra[0], extra[1], extra[2], extra[3], extra[4], extra[5], extra[6]);
2205
2206             /* Control never returns here. */
2207             }
2208
2209           /* No need to re-exec; SIGALRM remains set to the default handler */
2210
2211 #ifndef DISABLE_QUEUE_RAMP
2212           if (*queuerun_msgid)
2213             {
2214             log_write(0, LOG_MAIN, "notify triggered queue run");
2215             f.queue_2stage = FALSE;
2216             queue_run(queuerun_msgid, queuerun_msgid, FALSE);
2217             }
2218           else
2219 #endif
2220             queue_run(NULL, NULL, FALSE);
2221           exim_underbar_exit(EXIT_SUCCESS);
2222           }
2223
2224         if (pid < 0)
2225           {
2226           log_write(0, LOG_MAIN|LOG_PANIC, "daemon: fork of queue-runner "
2227             "process failed: %s", strerror(errno));
2228           log_close_all();
2229           }
2230         else
2231           {
2232           for (int i = 0; i < local_queue_run_max; ++i)
2233             if (queue_pid_slots[i] <= 0)
2234               {
2235               queue_pid_slots[i] = pid;
2236               queue_run_count++;
2237               break;
2238               }
2239           DEBUG(D_any) debug_printf("%d queue-runner process%s running\n",
2240             queue_run_count, queue_run_count == 1 ? "" : "es");
2241           }
2242         }
2243
2244       /* Reset the alarm clock */
2245
2246       sigalrm_seen = FALSE;
2247 #ifndef DISABLE_QUEUE_RAMP
2248       if (*queuerun_msgid)
2249         *queuerun_msgid = 0;
2250       else
2251 #endif
2252         ALARM(queue_interval);
2253       }
2254
2255     } /* sigalrm_seen */
2256
2257
2258   /* Sleep till a connection happens if listening, and handle the connection if
2259   that is why we woke up. The FreeBSD operating system requires the use of
2260   select() before accept() because the latter function is not interrupted by
2261   a signal, and we want to wake up for SIGCHLD and SIGALRM signals. Some other
2262   OS do notice signals in accept() but it does no harm to have the select()
2263   in for all of them - and it won't then be a lurking problem for ports to
2264   new OS. In fact, the later addition of listening on specific interfaces only
2265   requires this way of working anyway. */
2266
2267   if (f.daemon_listen)
2268     {
2269     int lcount, select_errno;
2270     int max_socket = 0;
2271     BOOL select_failed = FALSE;
2272     fd_set select_listen;
2273
2274     FD_ZERO(&select_listen);
2275     if (daemon_notifier_fd >= 0)
2276       FD_SET(daemon_notifier_fd, &select_listen);
2277     for (int sk = 0; sk < listen_socket_count; sk++)
2278       {
2279       FD_SET(listen_sockets[sk], &select_listen);
2280       if (listen_sockets[sk] > max_socket) max_socket = listen_sockets[sk];
2281       }
2282
2283     DEBUG(D_any) debug_printf("Listening...\n");
2284
2285     /* In rare cases we may have had a SIGCHLD signal in the time between
2286     setting the handler (below) and getting back here. If so, pretend that the
2287     select() was interrupted so that we reap the child. This might still leave
2288     a small window when a SIGCHLD could get lost. However, since we use SIGCHLD
2289     only to do the reaping more quickly, it shouldn't result in anything other
2290     than a delay until something else causes a wake-up. */
2291
2292     if (sigchld_seen)
2293       {
2294       lcount = -1;
2295       errno = EINTR;
2296       }
2297     else
2298       lcount = select(max_socket + 1, (SELECT_ARG2_TYPE *)&select_listen,
2299         NULL, NULL, NULL);
2300
2301     if (lcount < 0)
2302       {
2303       select_failed = TRUE;
2304       lcount = 1;
2305       }
2306
2307     /* Clean up any subprocesses that may have terminated. We need to do this
2308     here so that smtp_accept_max_per_host works when a connection to that host
2309     has completed, and we are about to accept a new one. When this code was
2310     later in the sequence, a new connection could be rejected, even though an
2311     old one had just finished. Preserve the errno from any select() failure for
2312     the use of the common select/accept error processing below. */
2313
2314     select_errno = errno;
2315     handle_ending_processes();
2316     errno = select_errno;
2317
2318 #ifndef DISABLE_TLS
2319     /* Create or rotate any required keys */
2320     tls_daemon_init();
2321 #endif
2322
2323     /* Loop for all the sockets that are currently ready to go. If select
2324     actually failed, we have set the count to 1 and select_failed=TRUE, so as
2325     to use the common error code for select/accept below. */
2326
2327     while (lcount-- > 0)
2328       {
2329       int accept_socket = -1;
2330
2331       if (!select_failed)
2332         {
2333         if (  daemon_notifier_fd >= 0
2334            && FD_ISSET(daemon_notifier_fd, &select_listen))
2335           {
2336           FD_CLR(daemon_notifier_fd, &select_listen);
2337           sigalrm_seen = daemon_notification();
2338           break;        /* to top of daemon loop */
2339           }
2340         for (int sk = 0; sk < listen_socket_count; sk++)
2341           if (FD_ISSET(listen_sockets[sk], &select_listen))
2342             {
2343             len = sizeof(accepted);
2344             accept_socket = accept(listen_sockets[sk],
2345               (struct sockaddr *)&accepted, &len);
2346             FD_CLR(listen_sockets[sk], &select_listen);
2347             break;
2348             }
2349         }
2350
2351       /* If select or accept has failed and this was not caused by an
2352       interruption, log the incident and try again. With asymmetric TCP/IP
2353       routing errors such as "No route to network" have been seen here. Also
2354       "connection reset by peer" has been seen. These cannot be classed as
2355       disastrous errors, but they could fill up a lot of log. The code in smail
2356       crashes the daemon after 10 successive failures of accept, on the grounds
2357       that some OS fail continuously. Exim originally followed suit, but this
2358       appears to have caused problems. Now it just keeps going, but instead of
2359       logging each error, it batches them up when they are continuous. */
2360
2361       if (accept_socket < 0 && errno != EINTR)
2362         {
2363         if (accept_retry_count == 0)
2364           {
2365           accept_retry_errno = errno;
2366           accept_retry_select_failed = select_failed;
2367           }
2368         else
2369           {
2370           if (errno != accept_retry_errno ||
2371               select_failed != accept_retry_select_failed ||
2372               accept_retry_count >= 50)
2373             {
2374             log_write(0, LOG_MAIN | ((accept_retry_count >= 50)? LOG_PANIC : 0),
2375               "%d %s() failure%s: %s",
2376               accept_retry_count,
2377               accept_retry_select_failed? "select" : "accept",
2378               (accept_retry_count == 1)? "" : "s",
2379               strerror(accept_retry_errno));
2380             log_close_all();
2381             accept_retry_count = 0;
2382             accept_retry_errno = errno;
2383             accept_retry_select_failed = select_failed;
2384             }
2385           }
2386         accept_retry_count++;
2387         }
2388
2389       else
2390         {
2391         if (accept_retry_count > 0)
2392           {
2393           log_write(0, LOG_MAIN, "%d %s() failure%s: %s",
2394             accept_retry_count,
2395             accept_retry_select_failed? "select" : "accept",
2396             (accept_retry_count == 1)? "" : "s",
2397             strerror(accept_retry_errno));
2398           log_close_all();
2399           accept_retry_count = 0;
2400           }
2401         }
2402
2403       /* If select/accept succeeded, deal with the connection. */
2404
2405       if (accept_socket >= 0)
2406         {
2407         if (inetd_wait_timeout)
2408           last_connection_time = time(NULL);
2409         handle_smtp_call(listen_sockets, listen_socket_count, accept_socket,
2410           (struct sockaddr *)&accepted);
2411         }
2412       }
2413     }
2414
2415   /* If not listening, then just sleep for the queue interval. If we woke
2416   up early the last time for some other signal, it won't matter because
2417   the alarm signal will wake at the right time. This code originally used
2418   sleep() but it turns out that on the FreeBSD system, sleep() is not inter-
2419   rupted by signals, so it wasn't waking up for SIGALRM or SIGCHLD. Luckily
2420   select() can be used as an interruptible sleep() on all versions of Unix. */
2421
2422   else
2423     {
2424     struct timeval tv;
2425     tv.tv_sec = queue_interval;
2426     tv.tv_usec = 0;
2427     select(0, NULL, NULL, NULL, &tv);
2428     handle_ending_processes();
2429     }
2430
2431   /* Re-enable the SIGCHLD handler if it has been run. It can't do it
2432   for itself, because it isn't doing the waiting itself. */
2433
2434   if (sigchld_seen)
2435     {
2436     sigchld_seen = FALSE;
2437     os_non_restarting_signal(SIGCHLD, main_sigchld_handler);
2438     }
2439
2440   /* Handle being woken by SIGHUP. We know at this point that the result
2441   of accept() has been dealt with, so we can re-exec exim safely, first
2442   closing the listening sockets so that they can be reused. Cancel any pending
2443   alarm in case it is just about to go off, and set SIGHUP to be ignored so
2444   that another HUP in quick succession doesn't clobber the new daemon before it
2445   gets going. All log files get closed by the close-on-exec flag; however, if
2446   the exec fails, we need to close the logs. */
2447
2448   if (sighup_seen)
2449     {
2450     log_write(0, LOG_MAIN, "pid %d: SIGHUP received: re-exec daemon",
2451       getpid());
2452     close_daemon_sockets(daemon_notifier_fd,
2453       listen_sockets, listen_socket_count);
2454     ALARM_CLR(0);
2455     signal(SIGHUP, SIG_IGN);
2456     sighup_argv[0] = exim_path;
2457     exim_nullstd();
2458     execv(CS exim_path, (char *const *)sighup_argv);
2459     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "pid %d: exec of %s failed: %s",
2460       getpid(), exim_path, strerror(errno));
2461     log_close_all();
2462     }
2463
2464   }   /* End of main loop */
2465
2466 /* Control never reaches here */
2467 }
2468
2469 /* vi: aw ai sw=2
2470 */
2471 /* End of exim_daemon.c */