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