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