60275c02d9a958889988a0f3ad2ab779621473c0
[exim.git] / src / src / daemon.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* 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 assigments 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 != NULL)
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 != NULL)
389     {
390     uschar *nah = expand_string(raw_active_hostname);
391     if (nah == NULL)
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[0] != 0) 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       int i;
522       uschar * buf[128];
523       mac_smtp_fflush();
524       /* drain socket, for clean TCP FINs */
525       for(i = 16; read(fileno(smtp_in), buf, sizeof(buf)) > 0 && i > 0; ) i--;
526       search_tidyup();
527       smtp_log_no_mail();                 /* Log no mail if configured */
528
529       /*XXX should we pause briefly, hoping that the client will be the
530       active TCP closer hence get the TCP_WAIT endpoint? */
531       DEBUG(D_receive) debug_printf("SMTP>>(close on process exit)\n");
532       _exit(rc ? EXIT_FAILURE : EXIT_SUCCESS);
533       }
534
535     /* Show the recipients when debugging */
536
537     DEBUG(D_receive)
538       {
539       int i;
540       if (sender_address != NULL)
541         debug_printf("Sender: %s\n", sender_address);
542       if (recipients_list != NULL)
543         {
544         debug_printf("Recipients:\n");
545         for (i = 0; i < recipients_count; i++)
546           debug_printf("  %s\n", recipients_list[i].address);
547         }
548       }
549
550     /* A message has been accepted. Clean up any previous delivery processes
551     that have completed and are defunct, on systems where they don't go away
552     by themselves (see comments when setting SIG_IGN above). On such systems
553     (if any) these delivery processes hang around after termination until
554     the next message is received. */
555
556     #ifndef SIG_IGN_WORKS
557     while (waitpid(-1, NULL, WNOHANG) > 0);
558     #endif
559
560     /* Reclaim up the store used in accepting this message */
561
562     store_reset(reset_point);
563
564     /* If queue_only is set or if there are too many incoming connections in
565     existence, session_local_queue_only will be TRUE. If it is not, check
566     whether we have received too many messages in this session for immediate
567     delivery. */
568
569     if (!session_local_queue_only &&
570         smtp_accept_queue_per_connection > 0 &&
571         receive_messagecount > smtp_accept_queue_per_connection)
572       {
573       session_local_queue_only = TRUE;
574       queue_only_reason = 2;
575       }
576
577     /* Initialize local_queue_only from session_local_queue_only. If it is not
578     true, and queue_only_load is set, check that the load average is below it.
579     If local_queue_only is set by this means, we also set if for the session if
580     queue_only_load_latch is true (the default). This means that, once set,
581     local_queue_only remains set for any subsequent messages on the same SMTP
582     connection. This is a deliberate choice; even though the load average may
583     fall, it doesn't seem right to deliver later messages on the same call when
584     not delivering earlier ones. However, the are special circumstances such as
585     very long-lived connections from scanning appliances where this is not the
586     best strategy. In such cases, queue_only_load_latch should be set false. */
587
588     if (  !(local_queue_only = session_local_queue_only)
589        && queue_only_load >= 0
590        && (local_queue_only = (load_average = OS_GETLOADAVG()) > queue_only_load)
591        )
592       {
593       queue_only_reason = 3;
594       if (queue_only_load_latch) session_local_queue_only = TRUE;
595       }
596
597     /* Log the queueing here, when it will get a message id attached, but
598     not if queue_only is set (case 0). */
599
600     if (local_queue_only) switch(queue_only_reason)
601       {
602       case 1: log_write(L_delay_delivery,
603                 LOG_MAIN, "no immediate delivery: too many connections "
604                 "(%d, max %d)", smtp_accept_count, smtp_accept_queue);
605               break;
606
607       case 2: log_write(L_delay_delivery,
608                 LOG_MAIN, "no immediate delivery: more than %d messages "
609                 "received in one connection", smtp_accept_queue_per_connection);
610               break;
611
612       case 3: log_write(L_delay_delivery,
613                 LOG_MAIN, "no immediate delivery: load average %.2f",
614                 (double)load_average/1000.0);
615               break;
616       }
617
618     /* If a delivery attempt is required, spin off a new process to handle it.
619     If we are not root, we have to re-exec exim unless deliveries are being
620     done unprivileged. */
621
622     else if (!queue_only_policy && !deliver_freeze)
623       {
624       pid_t dpid;
625
626       /* Before forking, ensure that the C output buffer is flushed. Otherwise
627       anything that it in it will get duplicated, leading to duplicate copies
628       of the pending output. */
629
630       mac_smtp_fflush();
631
632       if ((dpid = fork()) == 0)
633         {
634         (void)fclose(smtp_in);
635         (void)fclose(smtp_out);
636
637         /* Don't ever molest the parent's SSL connection, but do clean up
638         the data structures if necessary. */
639
640         #ifdef SUPPORT_TLS
641         tls_close(TRUE, FALSE);
642         #endif
643
644         /* Reset SIGHUP and SIGCHLD in the child in both cases. */
645
646         signal(SIGHUP,  SIG_DFL);
647         signal(SIGCHLD, SIG_DFL);
648
649         if (geteuid() != root_uid && !deliver_drop_privilege)
650           {
651           signal(SIGALRM, SIG_DFL);
652           (void)child_exec_exim(CEE_EXEC_PANIC, FALSE, NULL, FALSE,
653             2, US"-Mc", message_id);
654           /* Control does not return here. */
655           }
656
657         /* No need to re-exec; SIGALRM remains set to the default handler */
658
659         (void)deliver_message(message_id, FALSE, FALSE);
660         search_tidyup();
661         _exit(EXIT_SUCCESS);
662         }
663
664       if (dpid > 0)
665         {
666         DEBUG(D_any) debug_printf("forked delivery process %d\n", (int)dpid);
667         }
668       else
669         log_write(0, LOG_MAIN|LOG_PANIC, "daemon: delivery process fork "
670           "failed: %s", strerror(errno));
671       }
672     }
673   }
674
675
676 /* Carrying on in the parent daemon process... Can't do much if the fork
677 failed. Otherwise, keep count of the number of accepting processes and
678 remember the pid for ticking off when the child completes. */
679
680 if (pid < 0)
681   never_error(US"daemon: accept process fork failed", US"Fork failed", errno);
682 else
683   {
684   int i;
685   for (i = 0; i < smtp_accept_max; ++i)
686     if (smtp_slots[i].pid <= 0)
687       {
688       smtp_slots[i].pid = pid;
689       if (smtp_accept_max_per_host != NULL)
690         smtp_slots[i].host_address = string_copy_malloc(sender_host_address);
691       smtp_accept_count++;
692       break;
693       }
694   DEBUG(D_any) debug_printf("%d SMTP accept process%s running\n",
695     smtp_accept_count, (smtp_accept_count == 1)? "" : "es");
696   }
697
698 /* Get here via goto in error cases */
699
700 ERROR_RETURN:
701
702 /* Close the streams associated with the socket which will also close the
703 socket fds in this process. We can't do anything if fclose() fails, but
704 logging brings it to someone's attention. However, "connection reset by peer"
705 isn't really a problem, so skip that one. On Solaris, a dropped connection can
706 manifest itself as a broken pipe, so drop that one too. If the streams don't
707 exist, something went wrong while setting things up. Make sure the socket
708 descriptors are closed, in order to drop the connection. */
709
710 if (smtp_out)
711   {
712   if (fclose(smtp_out) != 0 && errno != ECONNRESET && errno != EPIPE)
713     log_write(0, LOG_MAIN|LOG_PANIC, "daemon: fclose(smtp_out) failed: %s",
714       strerror(errno));
715   smtp_out = NULL;
716   }
717 else (void)close(accept_socket);
718
719 if (smtp_in)
720   {
721   if (fclose(smtp_in) != 0 && errno != ECONNRESET && errno != EPIPE)
722     log_write(0, LOG_MAIN|LOG_PANIC, "daemon: fclose(smtp_in) failed: %s",
723       strerror(errno));
724   smtp_in = NULL;
725   }
726 else (void)close(dup_accept_socket);
727
728 /* Release any store used in this process, including the store used for holding
729 the incoming host address and an expanded active_hostname. */
730
731 log_close_all();
732 store_reset(reset_point);
733 sender_host_address = NULL;
734 }
735
736
737
738
739 /*************************************************
740 *       Check wildcard listen special cases      *
741 *************************************************/
742
743 /* This function is used when binding and listening on lists of addresses and
744 ports. It tests for special cases of wildcard listening, when IPv4 and IPv6
745 sockets may interact in different ways in different operating systems. It is
746 passed an error number, the list of listening addresses, and the current
747 address. Two checks are available: for a previous wildcard IPv6 address, or for
748 a following wildcard IPv4 address, in both cases on the same port.
749
750 In practice, pairs of wildcard addresses should be adjacent in the address list
751 because they are sorted that way below.
752
753 Arguments:
754   eno            the error number
755   addresses      the list of addresses
756   ipa            the current IP address
757   back           if TRUE, check for previous wildcard IPv6 address
758                  if FALSE, check for a following wildcard IPv4 address
759
760 Returns:         TRUE or FALSE
761 */
762
763 static BOOL
764 check_special_case(int eno, ip_address_item *addresses, ip_address_item *ipa,
765   BOOL back)
766 {
767 ip_address_item *ipa2;
768
769 /* For the "back" case, if the failure was "address in use" for a wildcard IPv4
770 address, seek a previous IPv6 wildcard address on the same port. As it is
771 previous, it must have been successfully bound and be listening. Flag it as a
772 "6 including 4" listener. */
773
774 if (back)
775   {
776   if (eno != EADDRINUSE || ipa->address[0] != 0) return FALSE;
777   for (ipa2 = addresses; ipa2 != ipa; ipa2 = ipa2->next)
778     {
779     if (ipa2->address[1] == 0 && ipa2->port == ipa->port)
780       {
781       ipa2->v6_include_v4 = TRUE;
782       return TRUE;
783       }
784     }
785   }
786
787 /* For the "forward" case, if the current address is a wildcard IPv6 address,
788 we seek a following wildcard IPv4 address on the same port. */
789
790 else
791   {
792   if (ipa->address[0] != ':' || ipa->address[1] != 0) return FALSE;
793   for (ipa2 = ipa->next; ipa2 != NULL; ipa2 = ipa2->next)
794     if (ipa2->address[0] == 0 && ipa->port == ipa2->port) return TRUE;
795   }
796
797 return FALSE;
798 }
799
800
801
802
803 /*************************************************
804 *         Handle terminating subprocesses        *
805 *************************************************/
806
807 /* Handle the termination of child processes. Theoretically, this need be done
808 only when sigchld_seen is TRUE, but rumour has it that some systems lose
809 SIGCHLD signals at busy times, so to be on the safe side, this function is
810 called each time round. It shouldn't be too expensive.
811
812 Arguments:  none
813 Returns:    nothing
814 */
815
816 static void
817 handle_ending_processes(void)
818 {
819 int status;
820 pid_t pid;
821
822 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
823   {
824   int i;
825   DEBUG(D_any)
826     {
827     debug_printf("child %d ended: status=0x%x\n", (int)pid, status);
828 #ifdef WCOREDUMP
829     if (WIFEXITED(status))
830       debug_printf("  normal exit, %d\n", WEXITSTATUS(status));
831     else if (WIFSIGNALED(status))
832       debug_printf("  signal exit, signal %d%s\n", WTERMSIG(status),
833           WCOREDUMP(status) ? " (core dumped)" : "");
834 #endif
835     }
836
837   /* If it's a listening daemon for which we are keeping track of individual
838   subprocesses, deal with an accepting process that has terminated. */
839
840   if (smtp_slots != NULL)
841     {
842     for (i = 0; i < smtp_accept_max; i++)
843       {
844       if (smtp_slots[i].pid == pid)
845         {
846         if (smtp_slots[i].host_address != NULL)
847           store_free(smtp_slots[i].host_address);
848         smtp_slots[i] = empty_smtp_slot;
849         if (--smtp_accept_count < 0) smtp_accept_count = 0;
850         DEBUG(D_any) debug_printf("%d SMTP accept process%s now running\n",
851           smtp_accept_count, (smtp_accept_count == 1)? "" : "es");
852         break;
853         }
854       }
855     if (i < smtp_accept_max) continue;  /* Found an accepting process */
856     }
857
858   /* If it wasn't an accepting process, see if it was a queue-runner
859   process that we are tracking. */
860
861   if (queue_pid_slots)
862     {
863     int max = atoi(CS expand_string(queue_run_max));
864     for (i = 0; i < max; i++)
865       if (queue_pid_slots[i] == pid)
866         {
867         queue_pid_slots[i] = 0;
868         if (--queue_run_count < 0) queue_run_count = 0;
869         DEBUG(D_any) debug_printf("%d queue-runner process%s now running\n",
870           queue_run_count, (queue_run_count == 1)? "" : "es");
871         break;
872         }
873     }
874   }
875 }
876
877
878
879 /*************************************************
880 *              Exim Daemon Mainline              *
881 *************************************************/
882
883 /* The daemon can do two jobs, either of which is optional:
884
885 (1) Listens for incoming SMTP calls and spawns off a sub-process to handle
886 each one. This is requested by the -bd option, with -oX specifying the SMTP
887 port on which to listen (for testing).
888
889 (2) Spawns a queue-running process every so often. This is controlled by the
890 -q option with a an interval time. (If no time is given, a single queue run
891 is done from the main function, and control doesn't get here.)
892
893 Root privilege is required in order to attach to port 25. Some systems require
894 it when calling socket() rather than bind(). To cope with all cases, we run as
895 root for both socket() and bind(). Some systems also require root in order to
896 write to the pid file directory. This function must therefore be called as root
897 if it is to work properly in all circumstances. Once the socket is bound and
898 the pid file written, root privilege is given up if there is an exim uid.
899
900 There are no arguments to this function, and it never returns. */
901
902 void
903 daemon_go(void)
904 {
905 struct passwd *pw;
906 int *listen_sockets = NULL;
907 int listen_socket_count = 0;
908 ip_address_item *addresses = NULL;
909 time_t last_connection_time = (time_t)0;
910 int local_queue_run_max = atoi(CS expand_string(queue_run_max));
911
912 /* If any debugging options are set, turn on the D_pid bit so that all
913 debugging lines get the pid added. */
914
915 DEBUG(D_any|D_v) debug_selector |= D_pid;
916
917 if (inetd_wait_mode)
918   {
919   listen_socket_count = 1;
920   listen_sockets = store_get(sizeof(int));
921   (void) close(3);
922   if (dup2(0, 3) == -1)
923     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
924         "failed to dup inetd socket safely away: %s", strerror(errno));
925
926   listen_sockets[0] = 3;
927   (void) close(0);
928   (void) close(1);
929   (void) close(2);
930   exim_nullstd();
931
932   if (debug_file == stderr)
933     {
934     /* need a call to log_write before call to open debug_file, so that
935     log.c:file_path has been initialised.  This is unfortunate. */
936     log_write(0, LOG_MAIN, "debugging Exim in inetd wait mode starting");
937
938     fclose(debug_file);
939     debug_file = NULL;
940     exim_nullstd(); /* re-open fd2 after we just closed it again */
941     debug_logging_activate(US"-wait", NULL);
942     }
943
944   DEBUG(D_any) debug_printf("running in inetd wait mode\n");
945
946   /* As per below, when creating sockets ourselves, we handle tcp_nodelay for
947   our own buffering; we assume though that inetd set the socket REUSEADDR. */
948
949   if (tcp_nodelay)
950     if (setsockopt(3, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
951       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to set socket NODELAY: %s",
952         strerror(errno));
953   }
954
955
956 if (inetd_wait_mode || daemon_listen)
957   {
958   /* If any option requiring a load average to be available during the
959   reception of a message is set, call os_getloadavg() while we are root
960   for those OS for which this is necessary the first time it is called (in
961   order to perform an "open" on the kernel memory file). */
962
963   #ifdef LOAD_AVG_NEEDS_ROOT
964   if (queue_only_load >= 0 || smtp_load_reserve >= 0 ||
965        (deliver_queue_load_max >= 0 && deliver_drop_privilege))
966     (void)os_getloadavg();
967   #endif
968   }
969
970
971 /* Do the preparation for setting up a listener on one or more interfaces, and
972 possible on various ports. This is controlled by the combination of
973 local_interfaces (which can set IP addresses and ports) and daemon_smtp_port
974 (which is a list of default ports to use for those items in local_interfaces
975 that do not specify a port). The -oX command line option can be used to
976 override one or both of these options.
977
978 If local_interfaces is not set, the default is to listen on all interfaces.
979 When it is set, it can include "all IPvx interfaces" as an item. This is useful
980 when different ports are in use.
981
982 It turns out that listening on all interfaces is messy in an IPv6 world,
983 because several different implementation approaches have been taken. This code
984 is now supposed to work with all of them. The point of difference is whether an
985 IPv6 socket that is listening on all interfaces will receive incoming IPv4
986 calls or not. We also have to cope with the case when IPv6 libraries exist, but
987 there is no IPv6 support in the kernel.
988
989 . On Solaris, an IPv6 socket will accept IPv4 calls, and give them as mapped
990   addresses. However, if an IPv4 socket is also listening on all interfaces,
991   calls are directed to the appropriate socket.
992
993 . On (some versions of) Linux, an IPv6 socket will accept IPv4 calls, and
994   give them as mapped addresses, but an attempt also to listen on an IPv4
995   socket on all interfaces causes an error.
996
997 . On OpenBSD, an IPv6 socket will not accept IPv4 calls. You have to set up
998   two sockets if you want to accept both kinds of call.
999
1000 . FreeBSD is like OpenBSD, but it has the IPV6_V6ONLY socket option, which
1001   can be turned off, to make it behave like the versions of Linux described
1002   above.
1003
1004 . I heard a report that the USAGI IPv6 stack for Linux has implemented
1005   IPV6_V6ONLY.
1006
1007 So, what we do when IPv6 is supported is as follows:
1008
1009  (1) After it is set up, the list of interfaces is scanned for wildcard
1010      addresses. If an IPv6 and an IPv4 wildcard are both found for the same
1011      port, the list is re-arranged so that they are together, with the IPv6
1012      wildcard first.
1013
1014  (2) If the creation of a wildcard IPv6 socket fails, we just log the error and
1015      carry on if an IPv4 wildcard socket for the same port follows later in the
1016      list. This allows Exim to carry on in the case when the kernel has no IPv6
1017      support.
1018
1019  (3) Having created an IPv6 wildcard socket, we try to set IPV6_V6ONLY if that
1020      option is defined. However, if setting fails, carry on regardless (but log
1021      the incident).
1022
1023  (4) If binding or listening on an IPv6 wildcard socket fails, it is a serious
1024      error.
1025
1026  (5) If binding or listening on an IPv4 wildcard socket fails with the error
1027      EADDRINUSE, and a previous interface was an IPv6 wildcard for the same
1028      port (which must have succeeded or we wouldn't have got this far), we
1029      assume we are in the situation where just a single socket is permitted,
1030      and ignore the error.
1031
1032 Phew!
1033
1034 The preparation code decodes options and sets up the relevant data. We do this
1035 first, so that we can return non-zero if there are any syntax errors, and also
1036 write to stderr. */
1037
1038 if (daemon_listen && !inetd_wait_mode)
1039   {
1040   int *default_smtp_port;
1041   int sep;
1042   int pct = 0;
1043   uschar *s;
1044   const uschar * list;
1045   uschar *local_iface_source = US"local_interfaces";
1046   ip_address_item *ipa;
1047   ip_address_item **pipa;
1048
1049   /* If -oX was used, disable the writing of a pid file unless -oP was
1050   explicitly used to force it. Then scan the string given to -oX. Any items
1051   that contain neither a dot nor a colon are used to override daemon_smtp_port.
1052   Any other items are used to override local_interfaces. */
1053
1054   if (override_local_interfaces != NULL)
1055     {
1056     uschar *new_smtp_port = NULL;
1057     uschar *new_local_interfaces = NULL;
1058     int portsize = 0;
1059     int portptr = 0;
1060     int ifacesize = 0;
1061     int ifaceptr = 0;
1062
1063     if (override_pid_file_path == NULL) write_pid = FALSE;
1064
1065     list = override_local_interfaces;
1066     sep = 0;
1067     while ((s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
1068       {
1069       uschar joinstr[4];
1070       uschar **ptr;
1071       int *sizeptr;
1072       int *ptrptr;
1073
1074       if (Ustrpbrk(s, ".:") == NULL)
1075         {
1076         ptr = &new_smtp_port;
1077         sizeptr = &portsize;
1078         ptrptr = &portptr;
1079         }
1080       else
1081         {
1082         ptr = &new_local_interfaces;
1083         sizeptr = &ifacesize;
1084         ptrptr = &ifaceptr;
1085         }
1086
1087       if (*ptr == NULL)
1088         {
1089         joinstr[0] = sep;
1090         joinstr[1] = ' ';
1091         *ptr = string_catn(*ptr, sizeptr, ptrptr, US"<", 1);
1092         }
1093
1094       *ptr = string_catn(*ptr, sizeptr, ptrptr, joinstr, 2);
1095       *ptr = string_cat (*ptr, sizeptr, ptrptr, s);
1096       }
1097
1098     if (new_smtp_port != NULL)
1099       {
1100       new_smtp_port[portptr] = 0;
1101       daemon_smtp_port = new_smtp_port;
1102       DEBUG(D_any) debug_printf("daemon_smtp_port overridden by -oX:\n  %s\n",
1103         daemon_smtp_port);
1104       }
1105
1106     if (new_local_interfaces != NULL)
1107       {
1108       new_local_interfaces[ifaceptr] = 0;
1109       local_interfaces = new_local_interfaces;
1110       local_iface_source = US"-oX data";
1111       DEBUG(D_any) debug_printf("local_interfaces overridden by -oX:\n  %s\n",
1112         local_interfaces);
1113       }
1114     }
1115
1116   /* Create a list of default SMTP ports, to be used if local_interfaces
1117   contains entries without explict ports. First count the number of ports, then
1118   build a translated list in a vector. */
1119
1120   list = daemon_smtp_port;
1121   sep = 0;
1122   while ((s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
1123     pct++;
1124   default_smtp_port = store_get((pct+1) * sizeof(int));
1125   list = daemon_smtp_port;
1126   sep = 0;
1127   for (pct = 0;
1128        (s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size));
1129        pct++)
1130     {
1131     if (isdigit(*s))
1132       {
1133       uschar *end;
1134       default_smtp_port[pct] = Ustrtol(s, &end, 0);
1135       if (end != s + Ustrlen(s))
1136         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "invalid SMTP port: %s", s);
1137       }
1138     else
1139       {
1140       struct servent *smtp_service = getservbyname(CS s, "tcp");
1141       if (!smtp_service)
1142         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "TCP port \"%s\" not found", s);
1143       default_smtp_port[pct] = ntohs(smtp_service->s_port);
1144       }
1145     }
1146   default_smtp_port[pct] = 0;
1147
1148   /* Check the list of TLS-on-connect ports and do name lookups if needed */
1149
1150   list = tls_in.on_connect_ports;
1151   sep = 0;
1152   while ((s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
1153     if (!isdigit(*s))
1154       {
1155       list = tls_in.on_connect_ports;
1156       tls_in.on_connect_ports = NULL;
1157       sep = 0;
1158       while ((s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
1159         {
1160         if (!isdigit(*s))
1161           {
1162           struct servent *smtp_service = getservbyname(CS s, "tcp");
1163           if (!smtp_service)
1164             log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "TCP port \"%s\" not found", s);
1165           s= string_sprintf("%d", (int)ntohs(smtp_service->s_port));
1166           }
1167         tls_in.on_connect_ports = string_append_listele(tls_in.on_connect_ports,
1168             ':', s);
1169         }
1170       break;
1171       }
1172
1173   /* Create the list of local interfaces, possibly with ports included. This
1174   list may contain references to 0.0.0.0 and ::0 as wildcards. These special
1175   values are converted below. */
1176
1177   addresses = host_build_ifacelist(local_interfaces, local_iface_source);
1178
1179   /* In the list of IP addresses, convert 0.0.0.0 into an empty string, and ::0
1180   into the string ":". We use these to recognize wildcards in IPv4 and IPv6. In
1181   fact, many IP stacks recognize 0.0.0.0 and ::0 and handle them as wildcards
1182   anyway, but we need to know which are the wildcard addresses, and the shorter
1183   strings are neater.
1184
1185   In the same scan, fill in missing port numbers from the default list. When
1186   there is more than one item in the list, extra items are created. */
1187
1188   for (ipa = addresses; ipa != NULL; ipa = ipa->next)
1189     {
1190     int i;
1191
1192     if (Ustrcmp(ipa->address, "0.0.0.0") == 0) ipa->address[0] = 0;
1193     else if (Ustrcmp(ipa->address, "::0") == 0)
1194       {
1195       ipa->address[0] = ':';
1196       ipa->address[1] = 0;
1197       }
1198
1199     if (ipa->port > 0) continue;
1200
1201     if (daemon_smtp_port[0] <= 0)
1202       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "no port specified for interface "
1203         "%s and daemon_smtp_port is unset; cannot start daemon",
1204         (ipa->address[0] == 0)? US"\"all IPv4\"" :
1205         (ipa->address[1] == 0)? US"\"all IPv6\"" : ipa->address);
1206     ipa->port = default_smtp_port[0];
1207     for (i = 1; default_smtp_port[i] > 0; i++)
1208       {
1209       ip_address_item *new = store_get(sizeof(ip_address_item));
1210       memcpy(new->address, ipa->address, Ustrlen(ipa->address) + 1);
1211       new->port = default_smtp_port[i];
1212       new->next = ipa->next;
1213       ipa->next = new;
1214       ipa = new;
1215       }
1216     }
1217
1218   /* Scan the list of addresses for wildcards. If we find an IPv4 and an IPv6
1219   wildcard for the same port, ensure that (a) they are together and (b) the
1220   IPv6 address comes first. This makes handling the messy features easier, and
1221   also simplifies the construction of the "daemon started" log line. */
1222
1223   pipa = &addresses;
1224   for (ipa = addresses; ipa != NULL; pipa = &(ipa->next), ipa = ipa->next)
1225     {
1226     ip_address_item *ipa2;
1227
1228     /* Handle an IPv4 wildcard */
1229
1230     if (ipa->address[0] == 0)
1231       {
1232       for (ipa2 = ipa; ipa2->next != NULL; ipa2 = ipa2->next)
1233         {
1234         ip_address_item *ipa3 = ipa2->next;
1235         if (ipa3->address[0] == ':' &&
1236             ipa3->address[1] == 0 &&
1237             ipa3->port == ipa->port)
1238           {
1239           ipa2->next = ipa3->next;
1240           ipa3->next = ipa;
1241           *pipa = ipa3;
1242           break;
1243           }
1244         }
1245       }
1246
1247     /* Handle an IPv6 wildcard. */
1248
1249     else if (ipa->address[0] == ':' && ipa->address[1] == 0)
1250       {
1251       for (ipa2 = ipa; ipa2->next != NULL; ipa2 = ipa2->next)
1252         {
1253         ip_address_item *ipa3 = ipa2->next;
1254         if (ipa3->address[0] == 0 && ipa3->port == ipa->port)
1255           {
1256           ipa2->next = ipa3->next;
1257           ipa3->next = ipa->next;
1258           ipa->next = ipa3;
1259           ipa = ipa3;
1260           break;
1261           }
1262         }
1263       }
1264     }
1265
1266   /* Get a vector to remember all the sockets in */
1267
1268   for (ipa = addresses; ipa != NULL; ipa = ipa->next)
1269     listen_socket_count++;
1270   listen_sockets = store_get(sizeof(int) * listen_socket_count);
1271
1272   } /* daemon_listen but not inetd_wait_mode */
1273
1274 if (daemon_listen)
1275   {
1276
1277   /* Do a sanity check on the max connects value just to save us from getting
1278   a huge amount of store. */
1279
1280   if (smtp_accept_max > 4095) smtp_accept_max = 4096;
1281
1282   /* There's no point setting smtp_accept_queue unless it is less than the max
1283   connects limit. The configuration reader ensures that the max is set if the
1284   queue-only option is set. */
1285
1286   if (smtp_accept_queue > smtp_accept_max) smtp_accept_queue = 0;
1287
1288   /* Get somewhere to keep the list of SMTP accepting pids if we are keeping
1289   track of them for total number and queue/host limits. */
1290
1291   if (smtp_accept_max > 0)
1292     {
1293     int i;
1294     smtp_slots = store_get(smtp_accept_max * sizeof(smtp_slot));
1295     for (i = 0; i < smtp_accept_max; i++) smtp_slots[i] = empty_smtp_slot;
1296     }
1297   }
1298
1299 /* The variable background_daemon is always false when debugging, but
1300 can also be forced false in order to keep a non-debugging daemon in the
1301 foreground. If background_daemon is true, close all open file descriptors that
1302 we know about, but then re-open stdin, stdout, and stderr to /dev/null.  Also
1303 do this for inetd_wait mode.
1304
1305 This is protection against any called functions (in libraries, or in
1306 Perl, or whatever) that think they can write to stderr (or stdout). Before this
1307 was added, it was quite likely that an SMTP connection would use one of these
1308 file descriptors, in which case writing random stuff to it caused chaos.
1309
1310 Then disconnect from the controlling terminal, Most modern Unixes seem to have
1311 setsid() for getting rid of the controlling terminal. For any OS that doesn't,
1312 setsid() can be #defined as a no-op, or as something else. */
1313
1314 if (background_daemon || inetd_wait_mode)
1315   {
1316   log_close_all();    /* Just in case anything was logged earlier */
1317   search_tidyup();    /* Just in case any were used in reading the config. */
1318   (void)close(0);           /* Get rid of stdin/stdout/stderr */
1319   (void)close(1);
1320   (void)close(2);
1321   exim_nullstd();     /* Connect stdin/stdout/stderr to /dev/null */
1322   log_stderr = NULL;  /* So no attempt to copy paniclog output */
1323   }
1324
1325 if (background_daemon)
1326   {
1327   /* If the parent process of this one has pid == 1, we are re-initializing the
1328   daemon as the result of a SIGHUP. In this case, there is no need to do
1329   anything, because the controlling terminal has long gone. Otherwise, fork, in
1330   case current process is a process group leader (see 'man setsid' for an
1331   explanation) before calling setsid(). */
1332
1333   if (getppid() != 1)
1334     {
1335     pid_t pid = fork();
1336     if (pid < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1337       "fork() failed when starting daemon: %s", strerror(errno));
1338     if (pid > 0) exit(EXIT_SUCCESS);      /* in parent process, just exit */
1339     (void)setsid();                       /* release controlling terminal */
1340     }
1341   }
1342
1343 /* We are now in the disconnected, daemon process (unless debugging). Set up
1344 the listening sockets if required. */
1345
1346 if (daemon_listen && !inetd_wait_mode)
1347   {
1348   int sk;
1349   ip_address_item *ipa;
1350
1351   /* For each IP address, create a socket, bind it to the appropriate port, and
1352   start listening. See comments above about IPv6 sockets that may or may not
1353   accept IPv4 calls when listening on all interfaces. We also have to cope with
1354   the case of a system with IPv6 libraries, but no IPv6 support in the kernel.
1355   listening, provided a wildcard IPv4 socket for the same port follows. */
1356
1357   for (ipa = addresses, sk = 0; sk < listen_socket_count; ipa = ipa->next, sk++)
1358     {
1359     BOOL wildcard;
1360     ip_address_item *ipa2;
1361     int af;
1362
1363     if (Ustrchr(ipa->address, ':') != NULL)
1364       {
1365       af = AF_INET6;
1366       wildcard = ipa->address[1] == 0;
1367       }
1368     else
1369       {
1370       af = AF_INET;
1371       wildcard = ipa->address[0] == 0;
1372       }
1373
1374     if ((listen_sockets[sk] = ip_socket(SOCK_STREAM, af)) < 0)
1375       {
1376       if (check_special_case(0, addresses, ipa, FALSE))
1377         {
1378         log_write(0, LOG_MAIN, "Failed to create IPv6 socket for wildcard "
1379           "listening (%s): will use IPv4", strerror(errno));
1380         goto SKIP_SOCKET;
1381         }
1382       log_write(0, LOG_PANIC_DIE, "IPv%c socket creation failed: %s",
1383         (af == AF_INET6)? '6' : '4', strerror(errno));
1384       }
1385
1386     /* If this is an IPv6 wildcard socket, set IPV6_V6ONLY if that option is
1387     available. Just log failure (can get protocol not available, just like
1388     socket creation can). */
1389
1390     #ifdef IPV6_V6ONLY
1391     if (af == AF_INET6 && wildcard &&
1392         setsockopt(listen_sockets[sk], IPPROTO_IPV6, IPV6_V6ONLY, (char *)(&on),
1393           sizeof(on)) < 0)
1394       log_write(0, LOG_MAIN, "Setting IPV6_V6ONLY on daemon's IPv6 wildcard "
1395         "socket failed (%s): carrying on without it", strerror(errno));
1396     #endif  /* IPV6_V6ONLY */
1397
1398     /* Set SO_REUSEADDR so that the daemon can be restarted while a connection
1399     is being handled.  Without this, a connection will prevent reuse of the
1400     smtp port for listening. */
1401
1402     if (setsockopt(listen_sockets[sk], SOL_SOCKET, SO_REUSEADDR,
1403                    (uschar *)(&on), sizeof(on)) < 0)
1404       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "setting SO_REUSEADDR on socket "
1405         "failed when starting daemon: %s", strerror(errno));
1406
1407     /* Set TCP_NODELAY; Exim does its own buffering. There is a switch to
1408     disable this because it breaks some broken clients. */
1409
1410     if (tcp_nodelay) setsockopt(listen_sockets[sk], IPPROTO_TCP, TCP_NODELAY,
1411       (uschar *)(&on), sizeof(on));
1412
1413     /* Now bind the socket to the required port; if Exim is being restarted
1414     it may not always be possible to bind immediately, even with SO_REUSEADDR
1415     set, so try 10 times, waiting between each try. After 10 failures, we give
1416     up. In an IPv6 environment, if bind () fails with the error EADDRINUSE and
1417     we are doing wildcard IPv4 listening and there was a previous IPv6 wildcard
1418     address for the same port, ignore the error on the grounds that we must be
1419     in a system where the IPv6 socket accepts both kinds of call. This is
1420     necessary for (some release of) USAGI Linux; other IP stacks fail at the
1421     listen() stage instead. */
1422
1423     for(;;)
1424       {
1425       uschar *msg, *addr;
1426       if (ip_bind(listen_sockets[sk], af, ipa->address, ipa->port) >= 0) break;
1427       if (check_special_case(errno, addresses, ipa, TRUE))
1428         {
1429         DEBUG(D_any) debug_printf("wildcard IPv4 bind() failed after IPv6 "
1430           "listen() success; EADDRINUSE ignored\n");
1431         (void)close(listen_sockets[sk]);
1432         goto SKIP_SOCKET;
1433         }
1434       msg = US strerror(errno);
1435       addr = wildcard? ((af == AF_INET6)? US"(any IPv6)" : US"(any IPv4)") :
1436         ipa->address;
1437       if (daemon_startup_retries <= 0)
1438         log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1439           "socket bind() to port %d for address %s failed: %s: "
1440           "daemon abandoned", ipa->port, addr, msg);
1441       log_write(0, LOG_MAIN, "socket bind() to port %d for address %s "
1442         "failed: %s: waiting %s before trying again (%d more %s)",
1443         ipa->port, addr, msg, readconf_printtime(daemon_startup_sleep),
1444         daemon_startup_retries, (daemon_startup_retries > 1)? "tries" : "try");
1445       daemon_startup_retries--;
1446       sleep(daemon_startup_sleep);
1447       }
1448
1449     DEBUG(D_any)
1450       if (wildcard)
1451         debug_printf("listening on all interfaces (IPv%c) port %d\n",
1452           af == AF_INET6 ? '6' : '4', ipa->port);
1453       else
1454         debug_printf("listening on %s port %d\n", ipa->address, ipa->port);
1455
1456 #ifdef TCP_FASTOPEN
1457     if (setsockopt(listen_sockets[sk], SOL_TCP, TCP_FASTOPEN, &smtp_connect_backlog,
1458                     sizeof(smtp_connect_backlog)))
1459       log_write(0, LOG_MAIN|LOG_PANIC, "failed to set socket FASTOPEN: %s",
1460         strerror(errno));
1461 #endif
1462
1463     /* Start listening on the bound socket, establishing the maximum backlog of
1464     connections that is allowed. On success, continue to the next address. */
1465
1466     if (listen(listen_sockets[sk], smtp_connect_backlog) >= 0) continue;
1467
1468     /* Listening has failed. In an IPv6 environment, as for bind(), if listen()
1469     fails with the error EADDRINUSE and we are doing IPv4 wildcard listening
1470     and there was a previous successful IPv6 wildcard listen on the same port,
1471     we want to ignore the error on the grounds that we must be in a system
1472     where the IPv6 socket accepts both kinds of call. */
1473
1474     if (!check_special_case(errno, addresses, ipa, TRUE))
1475       log_write(0, LOG_PANIC_DIE, "listen() failed on interface %s: %s",
1476         wildcard
1477         ? af == AF_INET6 ? US"(any IPv6)" : US"(any IPv4)" : ipa->address,
1478         strerror(errno));
1479
1480     DEBUG(D_any) debug_printf("wildcard IPv4 listen() failed after IPv6 "
1481       "listen() success; EADDRINUSE ignored\n");
1482     (void)close(listen_sockets[sk]);
1483
1484     /* Come here if there has been a problem with the socket which we
1485     are going to ignore. We remove the address from the chain, and back up the
1486     counts. */
1487
1488     SKIP_SOCKET:
1489     sk--;                          /* Back up the count */
1490     listen_socket_count--;         /* Reduce the total */
1491     if (ipa == addresses) addresses = ipa->next; else
1492       {
1493       for (ipa2 = addresses; ipa2->next != ipa; ipa2 = ipa2->next);
1494       ipa2->next = ipa->next;
1495       ipa = ipa2;
1496       }
1497     }          /* End of bind/listen loop for each address */
1498   }            /* End of setup for listening */
1499
1500
1501 /* If we are not listening, we want to write a pid file only if -oP was
1502 explicitly given. */
1503
1504 else if (override_pid_file_path == NULL) write_pid = FALSE;
1505
1506 /* Write the pid to a known file for assistance in identification, if required.
1507 We do this before giving up root privilege, because on some systems it is
1508 necessary to be root in order to write into the pid file directory. There's
1509 nothing to stop multiple daemons running, as long as no more than one listens
1510 on a given TCP/IP port on the same interface(s). However, in these
1511 circumstances it gets far too complicated to mess with pid file names
1512 automatically. Consequently, Exim 4 writes a pid file only
1513
1514   (a) When running in the test harness, or
1515   (b) When -bd is used and -oX is not used, or
1516   (c) When -oP is used to supply a path.
1517
1518 The variable daemon_write_pid is used to control this. */
1519
1520 if (running_in_test_harness || write_pid)
1521   {
1522   FILE *f;
1523
1524   if (override_pid_file_path != NULL)
1525     pid_file_path = override_pid_file_path;
1526
1527   if (pid_file_path[0] == 0)
1528     pid_file_path = string_sprintf("%s/exim-daemon.pid", spool_directory);
1529
1530   f = modefopen(pid_file_path, "wb", 0644);
1531   if (f != NULL)
1532     {
1533     (void)fprintf(f, "%d\n", (int)getpid());
1534     (void)fclose(f);
1535     DEBUG(D_any) debug_printf("pid written to %s\n", pid_file_path);
1536     }
1537   else
1538     {
1539     DEBUG(D_any)
1540       debug_printf("%s\n", string_open_failed(errno, "pid file %s",
1541         pid_file_path));
1542     }
1543   }
1544
1545 /* Set up the handler for SIGHUP, which causes a restart of the daemon. */
1546
1547 sighup_seen = FALSE;
1548 signal(SIGHUP, sighup_handler);
1549
1550 /* Give up root privilege at this point (assuming that exim_uid and exim_gid
1551 are not root). The third argument controls the running of initgroups().
1552 Normally we do this, in order to set up the groups for the Exim user. However,
1553 if we are not root at this time - some odd installations run that way - we
1554 cannot do this. */
1555
1556 exim_setugid(exim_uid, exim_gid, geteuid()==root_uid, US"running as a daemon");
1557
1558 /* Update the originator_xxx fields so that received messages as listed as
1559 coming from Exim, not whoever started the daemon. */
1560
1561 originator_uid = exim_uid;
1562 originator_gid = exim_gid;
1563 originator_login = ((pw = getpwuid(exim_uid)) != NULL)?
1564   string_copy_malloc(US pw->pw_name) : US"exim";
1565
1566 /* Get somewhere to keep the list of queue-runner pids if we are keeping track
1567 of them (and also if we are doing queue runs). */
1568
1569 if (queue_interval > 0 && local_queue_run_max > 0)
1570   {
1571   int i;
1572   queue_pid_slots = store_get(local_queue_run_max * sizeof(pid_t));
1573   for (i = 0; i < local_queue_run_max; i++) queue_pid_slots[i] = 0;
1574   }
1575
1576 /* Set up the handler for termination of child processes. */
1577
1578 sigchld_seen = FALSE;
1579 os_non_restarting_signal(SIGCHLD, main_sigchld_handler);
1580
1581 /* If we are to run the queue periodically, pretend the alarm has just gone
1582 off. This will cause the first queue-runner to get kicked off straight away. */
1583
1584 sigalrm_seen = (queue_interval > 0);
1585
1586 /* Log the start up of a daemon - at least one of listening or queue running
1587 must be set up. */
1588
1589 if (inetd_wait_mode)
1590   {
1591   uschar *p = big_buffer;
1592
1593   if (inetd_wait_timeout >= 0)
1594     sprintf(CS p, "terminating after %d seconds", inetd_wait_timeout);
1595   else
1596     sprintf(CS p, "with no wait timeout");
1597
1598   log_write(0, LOG_MAIN,
1599     "exim %s daemon started: pid=%d, launched with listening socket, %s",
1600     version_string, getpid(), big_buffer);
1601   set_process_info("daemon(%s): pre-listening socket", version_string);
1602
1603   /* set up the timeout logic */
1604   sigalrm_seen = 1;
1605   }
1606
1607 else if (daemon_listen)
1608   {
1609   int i, j;
1610   int smtp_ports = 0;
1611   int smtps_ports = 0;
1612   ip_address_item * ipa;
1613   uschar * p = big_buffer;
1614   uschar * qinfo = queue_interval > 0
1615     ? string_sprintf("-q%s", readconf_printtime(queue_interval))
1616     : US"no queue runs";
1617
1618   /* Build a list of listening addresses in big_buffer, but limit it to 10
1619   items. The style is for backwards compatibility.
1620
1621   It is now possible to have some ports listening for SMTPS (the old,
1622   deprecated protocol that starts TLS without using STARTTLS), and others
1623   listening for standard SMTP. Keep their listings separate. */
1624
1625   for (j = 0; j < 2; j++)
1626     {
1627     for (i = 0, ipa = addresses; i < 10 && ipa; i++, ipa = ipa->next)
1628        {
1629        /* First time round, look for SMTP ports; second time round, look for
1630        SMTPS ports. For the first one of each, insert leading text. */
1631
1632        if (host_is_tls_on_connect_port(ipa->port) == (j > 0))
1633          {
1634          if (j == 0)
1635            {
1636            if (smtp_ports++ == 0)
1637              {
1638              memcpy(p, "SMTP on", 8);
1639              p += 7;
1640              }
1641            }
1642          else
1643            {
1644            if (smtps_ports++ == 0)
1645              {
1646              (void)sprintf(CS p, "%sSMTPS on",
1647                smtp_ports == 0 ? "" : " and for ");
1648              while (*p) p++;
1649              }
1650            }
1651
1652          /* Now the information about the port (and sometimes interface) */
1653
1654          if (ipa->address[0] == ':' && ipa->address[1] == 0)
1655            {
1656            if (ipa->next != NULL && ipa->next->address[0] == 0 &&
1657                ipa->next->port == ipa->port)
1658              {
1659              (void)sprintf(CS p, " port %d (IPv6 and IPv4)", ipa->port);
1660              ipa = ipa->next;
1661              }
1662            else if (ipa->v6_include_v4)
1663              (void)sprintf(CS p, " port %d (IPv6 with IPv4)", ipa->port);
1664            else
1665              (void)sprintf(CS p, " port %d (IPv6)", ipa->port);
1666            }
1667          else if (ipa->address[0] == 0)
1668            (void)sprintf(CS p, " port %d (IPv4)", ipa->port);
1669          else
1670            (void)sprintf(CS p, " [%s]:%d", ipa->address, ipa->port);
1671          while (*p != 0) p++;
1672          }
1673        }
1674
1675     if (ipa)
1676       {
1677       memcpy(p, " ...", 5);
1678       p += 4;
1679       }
1680     }
1681
1682   log_write(0, LOG_MAIN,
1683     "exim %s daemon started: pid=%d, %s, listening for %s",
1684     version_string, getpid(), qinfo, big_buffer);
1685   set_process_info("daemon(%s): %s, listening for %s",
1686     version_string, qinfo, big_buffer);
1687   }
1688
1689 else
1690   {
1691   uschar * s = *queue_name
1692     ? string_sprintf("-qG%s/%s", queue_name, readconf_printtime(queue_interval))
1693     : string_sprintf("-q%s", readconf_printtime(queue_interval));
1694   log_write(0, LOG_MAIN,
1695     "exim %s daemon started: pid=%d, %s, not listening for SMTP",
1696     version_string, getpid(), s);
1697   set_process_info("daemon(%s): %s, not listening", version_string, s);
1698   }
1699
1700 /* Do any work it might be useful to amortize over our children
1701 (eg: compile regex) */
1702
1703 dns_pattern_init();
1704
1705 #ifdef WITH_CONTENT_SCAN
1706 malware_init();
1707 #endif
1708
1709 /* Close the log so it can be renamed and moved. In the few cases below where
1710 this long-running process writes to the log (always exceptional conditions), it
1711 closes the log afterwards, for the same reason. */
1712
1713 log_close_all();
1714
1715 DEBUG(D_any) debug_print_ids(US"daemon running with");
1716
1717 /* Any messages accepted via this route are going to be SMTP. */
1718
1719 smtp_input = TRUE;
1720
1721 /* Enter the never-ending loop... */
1722
1723 for (;;)
1724   {
1725   #if HAVE_IPV6
1726   struct sockaddr_in6 accepted;
1727   #else
1728   struct sockaddr_in accepted;
1729   #endif
1730
1731   EXIM_SOCKLEN_T len;
1732   pid_t pid;
1733
1734   /* This code is placed first in the loop, so that it gets obeyed at the
1735   start, before the first wait, for the queue-runner case, so that the first
1736   one can be started immediately.
1737
1738   The other option is that we have an inetd wait timeout specified to -bw. */
1739
1740   if (sigalrm_seen)
1741     {
1742     if (inetd_wait_timeout > 0)
1743       {
1744       time_t resignal_interval = inetd_wait_timeout;
1745
1746       if (last_connection_time == (time_t)0)
1747         {
1748         DEBUG(D_any)
1749           debug_printf("inetd wait timeout expired, but still not seen first message, ignoring\n");
1750         }
1751       else
1752         {
1753         time_t now = time(NULL);
1754         if (now == (time_t)-1)
1755           {
1756           DEBUG(D_any) debug_printf("failed to get time: %s\n", strerror(errno));
1757           }
1758         else
1759           {
1760           if ((now - last_connection_time) >= inetd_wait_timeout)
1761             {
1762             DEBUG(D_any)
1763               debug_printf("inetd wait timeout %d expired, ending daemon\n",
1764                   inetd_wait_timeout);
1765             log_write(0, LOG_MAIN, "exim %s daemon terminating, inetd wait timeout reached.\n",
1766                 version_string);
1767             exit(EXIT_SUCCESS);
1768             }
1769           else
1770             {
1771             resignal_interval -= (now - last_connection_time);
1772             }
1773           }
1774         }
1775
1776       sigalrm_seen = FALSE;
1777       alarm(resignal_interval);
1778       }
1779
1780     else
1781       {
1782       DEBUG(D_any) debug_printf("SIGALRM received\n");
1783
1784       /* Do a full queue run in a child process, if required, unless we already
1785       have enough queue runners on the go. If we are not running as root, a
1786       re-exec is required. */
1787
1788       if (queue_interval > 0 &&
1789          (local_queue_run_max <= 0 || queue_run_count < local_queue_run_max))
1790         {
1791         if ((pid = fork()) == 0)
1792           {
1793           int sk;
1794
1795           DEBUG(D_any) debug_printf("Starting queue-runner: pid %d\n",
1796             (int)getpid());
1797
1798           /* Disable debugging if it's required only for the daemon process. We
1799           leave the above message, because it ties up with the "child ended"
1800           debugging messages. */
1801
1802           if (debug_daemon) debug_selector = 0;
1803
1804           /* Close any open listening sockets in the child */
1805
1806           for (sk = 0; sk < listen_socket_count; sk++)
1807             (void)close(listen_sockets[sk]);
1808
1809           /* Reset SIGHUP and SIGCHLD in the child in both cases. */
1810
1811           signal(SIGHUP,  SIG_DFL);
1812           signal(SIGCHLD, SIG_DFL);
1813
1814           /* Re-exec if privilege has been given up, unless deliver_drop_
1815           privilege is set. Reset SIGALRM before exec(). */
1816
1817           if (geteuid() != root_uid && !deliver_drop_privilege)
1818             {
1819             uschar opt[8];
1820             uschar *p = opt;
1821             uschar *extra[5];
1822             int extracount = 1;
1823
1824             signal(SIGALRM, SIG_DFL);
1825             *p++ = '-';
1826             *p++ = 'q';
1827             if (queue_2stage) *p++ = 'q';
1828             if (queue_run_first_delivery) *p++ = 'i';
1829             if (queue_run_force) *p++ = 'f';
1830             if (deliver_force_thaw) *p++ = 'f';
1831             if (queue_run_local) *p++ = 'l';
1832             *p = 0;
1833             extra[0] = queue_name
1834               ? string_sprintf("%sG%s", opt, queue_name) : opt;
1835
1836             /* If -R or -S were on the original command line, ensure they get
1837             passed on. */
1838
1839             if (deliver_selectstring)
1840               {
1841               extra[extracount++] = deliver_selectstring_regex ? US"-Rr" : US"-R";
1842               extra[extracount++] = deliver_selectstring;
1843               }
1844
1845             if (deliver_selectstring_sender)
1846               {
1847               extra[extracount++] = deliver_selectstring_sender_regex
1848                 ? US"-Sr" : US"-S";
1849               extra[extracount++] = deliver_selectstring_sender;
1850               }
1851
1852             /* Overlay this process with a new execution. */
1853
1854             (void)child_exec_exim(CEE_EXEC_PANIC, FALSE, NULL, TRUE, extracount,
1855               extra[0], extra[1], extra[2], extra[3], extra[4]);
1856
1857             /* Control never returns here. */
1858             }
1859
1860           /* No need to re-exec; SIGALRM remains set to the default handler */
1861
1862           queue_run(NULL, NULL, FALSE);
1863           _exit(EXIT_SUCCESS);
1864           }
1865
1866         if (pid < 0)
1867           {
1868           log_write(0, LOG_MAIN|LOG_PANIC, "daemon: fork of queue-runner "
1869             "process failed: %s", strerror(errno));
1870           log_close_all();
1871           }
1872         else
1873           {
1874           int i;
1875           for (i = 0; i < local_queue_run_max; ++i)
1876             if (queue_pid_slots[i] <= 0)
1877               {
1878               queue_pid_slots[i] = pid;
1879               queue_run_count++;
1880               break;
1881               }
1882           DEBUG(D_any) debug_printf("%d queue-runner process%s running\n",
1883             queue_run_count, (queue_run_count == 1)? "" : "es");
1884           }
1885         }
1886
1887       /* Reset the alarm clock */
1888
1889       sigalrm_seen = FALSE;
1890       alarm(queue_interval);
1891       }
1892
1893     } /* sigalrm_seen */
1894
1895
1896   /* Sleep till a connection happens if listening, and handle the connection if
1897   that is why we woke up. The FreeBSD operating system requires the use of
1898   select() before accept() because the latter function is not interrupted by
1899   a signal, and we want to wake up for SIGCHLD and SIGALRM signals. Some other
1900   OS do notice signals in accept() but it does no harm to have the select()
1901   in for all of them - and it won't then be a lurking problem for ports to
1902   new OS. In fact, the later addition of listening on specific interfaces only
1903   requires this way of working anyway. */
1904
1905   if (daemon_listen)
1906     {
1907     int sk, lcount, select_errno;
1908     int max_socket = 0;
1909     BOOL select_failed = FALSE;
1910     fd_set select_listen;
1911
1912     FD_ZERO(&select_listen);
1913     for (sk = 0; sk < listen_socket_count; sk++)
1914       {
1915       FD_SET(listen_sockets[sk], &select_listen);
1916       if (listen_sockets[sk] > max_socket) max_socket = listen_sockets[sk];
1917       }
1918
1919     DEBUG(D_any) debug_printf("Listening...\n");
1920
1921     /* In rare cases we may have had a SIGCHLD signal in the time between
1922     setting the handler (below) and getting back here. If so, pretend that the
1923     select() was interrupted so that we reap the child. This might still leave
1924     a small window when a SIGCHLD could get lost. However, since we use SIGCHLD
1925     only to do the reaping more quickly, it shouldn't result in anything other
1926     than a delay until something else causes a wake-up. */
1927
1928     if (sigchld_seen)
1929       {
1930       lcount = -1;
1931       errno = EINTR;
1932       }
1933     else
1934       {
1935       lcount = select(max_socket + 1, (SELECT_ARG2_TYPE *)&select_listen,
1936         NULL, NULL, NULL);
1937       }
1938
1939     if (lcount < 0)
1940       {
1941       select_failed = TRUE;
1942       lcount = 1;
1943       }
1944
1945     /* Clean up any subprocesses that may have terminated. We need to do this
1946     here so that smtp_accept_max_per_host works when a connection to that host
1947     has completed, and we are about to accept a new one. When this code was
1948     later in the sequence, a new connection could be rejected, even though an
1949     old one had just finished. Preserve the errno from any select() failure for
1950     the use of the common select/accept error processing below. */
1951
1952     select_errno = errno;
1953     handle_ending_processes();
1954     errno = select_errno;
1955
1956     /* Loop for all the sockets that are currently ready to go. If select
1957     actually failed, we have set the count to 1 and select_failed=TRUE, so as
1958     to use the common error code for select/accept below. */
1959
1960     while (lcount-- > 0)
1961       {
1962       int accept_socket = -1;
1963       if (!select_failed)
1964         {
1965         for (sk = 0; sk < listen_socket_count; sk++)
1966           {
1967           if (FD_ISSET(listen_sockets[sk], &select_listen))
1968             {
1969             len = sizeof(accepted);
1970             accept_socket = accept(listen_sockets[sk],
1971               (struct sockaddr *)&accepted, &len);
1972             FD_CLR(listen_sockets[sk], &select_listen);
1973             break;
1974             }
1975           }
1976         }
1977
1978       /* If select or accept has failed and this was not caused by an
1979       interruption, log the incident and try again. With asymmetric TCP/IP
1980       routing errors such as "No route to network" have been seen here. Also
1981       "connection reset by peer" has been seen. These cannot be classed as
1982       disastrous errors, but they could fill up a lot of log. The code in smail
1983       crashes the daemon after 10 successive failures of accept, on the grounds
1984       that some OS fail continuously. Exim originally followed suit, but this
1985       appears to have caused problems. Now it just keeps going, but instead of
1986       logging each error, it batches them up when they are continuous. */
1987
1988       if (accept_socket < 0 && errno != EINTR)
1989         {
1990         if (accept_retry_count == 0)
1991           {
1992           accept_retry_errno = errno;
1993           accept_retry_select_failed = select_failed;
1994           }
1995         else
1996           {
1997           if (errno != accept_retry_errno ||
1998               select_failed != accept_retry_select_failed ||
1999               accept_retry_count >= 50)
2000             {
2001             log_write(0, LOG_MAIN | ((accept_retry_count >= 50)? LOG_PANIC : 0),
2002               "%d %s() failure%s: %s",
2003               accept_retry_count,
2004               accept_retry_select_failed? "select" : "accept",
2005               (accept_retry_count == 1)? "" : "s",
2006               strerror(accept_retry_errno));
2007             log_close_all();
2008             accept_retry_count = 0;
2009             accept_retry_errno = errno;
2010             accept_retry_select_failed = select_failed;
2011             }
2012           }
2013         accept_retry_count++;
2014         }
2015
2016       else
2017         {
2018         if (accept_retry_count > 0)
2019           {
2020           log_write(0, LOG_MAIN, "%d %s() failure%s: %s",
2021             accept_retry_count,
2022             accept_retry_select_failed? "select" : "accept",
2023             (accept_retry_count == 1)? "" : "s",
2024             strerror(accept_retry_errno));
2025           log_close_all();
2026           accept_retry_count = 0;
2027           }
2028         }
2029
2030       /* If select/accept succeeded, deal with the connection. */
2031
2032       if (accept_socket >= 0)
2033         {
2034         if (inetd_wait_timeout)
2035           last_connection_time = time(NULL);
2036         handle_smtp_call(listen_sockets, listen_socket_count, accept_socket,
2037           (struct sockaddr *)&accepted);
2038         }
2039       }
2040     }
2041
2042   /* If not listening, then just sleep for the queue interval. If we woke
2043   up early the last time for some other signal, it won't matter because
2044   the alarm signal will wake at the right time. This code originally used
2045   sleep() but it turns out that on the FreeBSD system, sleep() is not inter-
2046   rupted by signals, so it wasn't waking up for SIGALRM or SIGCHLD. Luckily
2047   select() can be used as an interruptible sleep() on all versions of Unix. */
2048
2049   else
2050     {
2051     struct timeval tv;
2052     tv.tv_sec = queue_interval;
2053     tv.tv_usec = 0;
2054     select(0, NULL, NULL, NULL, &tv);
2055     handle_ending_processes();
2056     }
2057
2058   /* Re-enable the SIGCHLD handler if it has been run. It can't do it
2059   for itself, because it isn't doing the waiting itself. */
2060
2061   if (sigchld_seen)
2062     {
2063     sigchld_seen = FALSE;
2064     os_non_restarting_signal(SIGCHLD, main_sigchld_handler);
2065     }
2066
2067   /* Handle being woken by SIGHUP. We know at this point that the result
2068   of accept() has been dealt with, so we can re-exec exim safely, first
2069   closing the listening sockets so that they can be reused. Cancel any pending
2070   alarm in case it is just about to go off, and set SIGHUP to be ignored so
2071   that another HUP in quick succession doesn't clobber the new daemon before it
2072   gets going. All log files get closed by the close-on-exec flag; however, if
2073   the exec fails, we need to close the logs. */
2074
2075   if (sighup_seen)
2076     {
2077     int sk;
2078     log_write(0, LOG_MAIN, "pid %d: SIGHUP received: re-exec daemon",
2079       getpid());
2080     for (sk = 0; sk < listen_socket_count; sk++)
2081       (void)close(listen_sockets[sk]);
2082     alarm(0);
2083     signal(SIGHUP, SIG_IGN);
2084     sighup_argv[0] = exim_path;
2085     exim_nullstd();
2086     execv(CS exim_path, (char *const *)sighup_argv);
2087     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "pid %d: exec of %s failed: %s",
2088       getpid(), exim_path, strerror(errno));
2089     log_close_all();
2090     }
2091
2092   }   /* End of main loop */
2093
2094 /* Control never reaches here */
2095 }
2096
2097 /* vi: aw ai sw=2
2098 */
2099 /* End of exim_daemon.c */