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