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