Fix mariadb/mysql macro confusion
[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 23
f2ed27cf 24static smtp_slot empty_smtp_slot = { .pid = 0, .host_address = NULL };
059ec3d9
PH
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);
925ac8e4 112if (smtp_out != NULL) smtp_printf("421 %s\r\n", FALSE, smtp_msg);
059ec3d9
PH
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));
925ac8e4 192 smtp_printf("421 Local problem: getsockname() failed; please try again later\r\n", FALSE);
059ec3d9
PH
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; "
925ac8e4 225 "please try again later.\r\n", FALSE);
059ec3d9
PH
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);
925ac8e4 244 smtp_printf("421 Too much load; please try again later.\r\n", FALSE);
059ec3d9
PH
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 "
925ac8e4 315 "from this IP address; please try again later.\r\n", FALSE);
059ec3d9
PH
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; "
925ac8e4 399 "please try again later.\r\n", FALSE);
059ec3d9
PH
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 {
4226691b
JH
1176 int size = 0, len = 0;
1177
071c51f7
JH
1178 list = tls_in.on_connect_ports;
1179 tls_in.on_connect_ports = NULL;
1180 sep = 0;
1181 while ((s = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
1182 {
1183 if (!isdigit(*s))
1184 {
4226691b 1185 struct servent * smtp_service = getservbyname(CS s, "tcp");
071c51f7
JH
1186 if (!smtp_service)
1187 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "TCP port \"%s\" not found", s);
4226691b 1188 s = string_sprintf("%d", (int)ntohs(smtp_service->s_port));
071c51f7
JH
1189 }
1190 tls_in.on_connect_ports = string_append_listele(tls_in.on_connect_ports,
4226691b 1191 &size, &len, ':', s);
071c51f7
JH
1192 }
1193 break;
1194 }
1195
059ec3d9
PH
1196 /* Create the list of local interfaces, possibly with ports included. This
1197 list may contain references to 0.0.0.0 and ::0 as wildcards. These special
1198 values are converted below. */
1199
1200 addresses = host_build_ifacelist(local_interfaces, local_iface_source);
1201
1202 /* In the list of IP addresses, convert 0.0.0.0 into an empty string, and ::0
1203 into the string ":". We use these to recognize wildcards in IPv4 and IPv6. In
1204 fact, many IP stacks recognize 0.0.0.0 and ::0 and handle them as wildcards
1205 anyway, but we need to know which are the wildcard addresses, and the shorter
1206 strings are neater.
1207
1208 In the same scan, fill in missing port numbers from the default list. When
1209 there is more than one item in the list, extra items are created. */
1210
b891534f 1211 for (ipa = addresses; ipa; ipa = ipa->next)
059ec3d9
PH
1212 {
1213 int i;
1214
b891534f
JH
1215 if (Ustrcmp(ipa->address, "0.0.0.0") == 0)
1216 ipa->address[0] = 0;
059ec3d9
PH
1217 else if (Ustrcmp(ipa->address, "::0") == 0)
1218 {
1219 ipa->address[0] = ':';
1220 ipa->address[1] = 0;
1221 }
1222
1223 if (ipa->port > 0) continue;
1224
1225 if (daemon_smtp_port[0] <= 0)
1226 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "no port specified for interface "
1227 "%s and daemon_smtp_port is unset; cannot start daemon",
b891534f
JH
1228 ipa->address[0] == 0 ? US"\"all IPv4\"" :
1229 ipa->address[1] == 0 ? US"\"all IPv6\"" : ipa->address);
1230
059ec3d9
PH
1231 ipa->port = default_smtp_port[0];
1232 for (i = 1; default_smtp_port[i] > 0; i++)
1233 {
1234 ip_address_item *new = store_get(sizeof(ip_address_item));
b891534f 1235
059ec3d9
PH
1236 memcpy(new->address, ipa->address, Ustrlen(ipa->address) + 1);
1237 new->port = default_smtp_port[i];
1238 new->next = ipa->next;
1239 ipa->next = new;
1240 ipa = new;
1241 }
1242 }
1243
1244 /* Scan the list of addresses for wildcards. If we find an IPv4 and an IPv6
1245 wildcard for the same port, ensure that (a) they are together and (b) the
1246 IPv6 address comes first. This makes handling the messy features easier, and
1247 also simplifies the construction of the "daemon started" log line. */
1248
1249 pipa = &addresses;
b891534f 1250 for (ipa = addresses; ipa; pipa = &ipa->next, ipa = ipa->next)
059ec3d9
PH
1251 {
1252 ip_address_item *ipa2;
1253
1254 /* Handle an IPv4 wildcard */
1255
1256 if (ipa->address[0] == 0)
b891534f 1257 for (ipa2 = ipa; ipa2->next; ipa2 = ipa2->next)
059ec3d9
PH
1258 {
1259 ip_address_item *ipa3 = ipa2->next;
1260 if (ipa3->address[0] == ':' &&
1261 ipa3->address[1] == 0 &&
1262 ipa3->port == ipa->port)
1263 {
1264 ipa2->next = ipa3->next;
1265 ipa3->next = ipa;
1266 *pipa = ipa3;
1267 break;
1268 }
1269 }
059ec3d9
PH
1270
1271 /* Handle an IPv6 wildcard. */
1272
1273 else if (ipa->address[0] == ':' && ipa->address[1] == 0)
b891534f 1274 for (ipa2 = ipa; ipa2->next; ipa2 = ipa2->next)
059ec3d9
PH
1275 {
1276 ip_address_item *ipa3 = ipa2->next;
1277 if (ipa3->address[0] == 0 && ipa3->port == ipa->port)
1278 {
1279 ipa2->next = ipa3->next;
1280 ipa3->next = ipa->next;
1281 ipa->next = ipa3;
1282 ipa = ipa3;
1283 break;
1284 }
1285 }
059ec3d9
PH
1286 }
1287
1288 /* Get a vector to remember all the sockets in */
1289
b891534f 1290 for (ipa = addresses; ipa; ipa = ipa->next)
059ec3d9 1291 listen_socket_count++;
96f5fe4c 1292 listen_sockets = store_get(sizeof(int) * listen_socket_count);
059ec3d9 1293
9ee44efb
PP
1294 } /* daemon_listen but not inetd_wait_mode */
1295
1296if (daemon_listen)
1297 {
1298
059ec3d9
PH
1299 /* Do a sanity check on the max connects value just to save us from getting
1300 a huge amount of store. */
1301
1302 if (smtp_accept_max > 4095) smtp_accept_max = 4096;
1303
1304 /* There's no point setting smtp_accept_queue unless it is less than the max
1305 connects limit. The configuration reader ensures that the max is set if the
1306 queue-only option is set. */
1307
1308 if (smtp_accept_queue > smtp_accept_max) smtp_accept_queue = 0;
1309
1310 /* Get somewhere to keep the list of SMTP accepting pids if we are keeping
1311 track of them for total number and queue/host limits. */
1312
1313 if (smtp_accept_max > 0)
1314 {
1315 int i;
1316 smtp_slots = store_get(smtp_accept_max * sizeof(smtp_slot));
1317 for (i = 0; i < smtp_accept_max; i++) smtp_slots[i] = empty_smtp_slot;
1318 }
1319 }
1320
76a2d7ba
PH
1321/* The variable background_daemon is always false when debugging, but
1322can also be forced false in order to keep a non-debugging daemon in the
1323foreground. If background_daemon is true, close all open file descriptors that
9ee44efb
PP
1324we know about, but then re-open stdin, stdout, and stderr to /dev/null. Also
1325do this for inetd_wait mode.
76a2d7ba
PH
1326
1327This is protection against any called functions (in libraries, or in
1328Perl, or whatever) that think they can write to stderr (or stdout). Before this
1329was added, it was quite likely that an SMTP connection would use one of these
1330file descriptors, in which case writing random stuff to it caused chaos.
1331
1332Then disconnect from the controlling terminal, Most modern Unixes seem to have
1333setsid() for getting rid of the controlling terminal. For any OS that doesn't,
1334setsid() can be #defined as a no-op, or as something else. */
059ec3d9 1335
9ee44efb 1336if (background_daemon || inetd_wait_mode)
059ec3d9 1337 {
76a2d7ba
PH
1338 log_close_all(); /* Just in case anything was logged earlier */
1339 search_tidyup(); /* Just in case any were used in reading the config. */
f1e894f3
PH
1340 (void)close(0); /* Get rid of stdin/stdout/stderr */
1341 (void)close(1);
1342 (void)close(2);
8e669ac1 1343 exim_nullstd(); /* Connect stdin/stdout/stderr to /dev/null */
059ec3d9 1344 log_stderr = NULL; /* So no attempt to copy paniclog output */
9ee44efb 1345 }
059ec3d9 1346
9ee44efb
PP
1347if (background_daemon)
1348 {
059ec3d9 1349 /* If the parent process of this one has pid == 1, we are re-initializing the
8e669ac1 1350 daemon as the result of a SIGHUP. In this case, there is no need to do
76a2d7ba
PH
1351 anything, because the controlling terminal has long gone. Otherwise, fork, in
1352 case current process is a process group leader (see 'man setsid' for an
1353 explanation) before calling setsid(). */
059ec3d9
PH
1354
1355 if (getppid() != 1)
1356 {
1357 pid_t pid = fork();
1358 if (pid < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1359 "fork() failed when starting daemon: %s", strerror(errno));
1360 if (pid > 0) exit(EXIT_SUCCESS); /* in parent process, just exit */
1361 (void)setsid(); /* release controlling terminal */
1362 }
1363 }
1364
1365/* We are now in the disconnected, daemon process (unless debugging). Set up
1366the listening sockets if required. */
1367
9ee44efb 1368if (daemon_listen && !inetd_wait_mode)
059ec3d9
PH
1369 {
1370 int sk;
059ec3d9
PH
1371 ip_address_item *ipa;
1372
1373 /* For each IP address, create a socket, bind it to the appropriate port, and
1374 start listening. See comments above about IPv6 sockets that may or may not
1375 accept IPv4 calls when listening on all interfaces. We also have to cope with
1376 the case of a system with IPv6 libraries, but no IPv6 support in the kernel.
1377 listening, provided a wildcard IPv4 socket for the same port follows. */
1378
1379 for (ipa = addresses, sk = 0; sk < listen_socket_count; ipa = ipa->next, sk++)
1380 {
1381 BOOL wildcard;
1382 ip_address_item *ipa2;
059ec3d9
PH
1383 int af;
1384
1385 if (Ustrchr(ipa->address, ':') != NULL)
1386 {
1387 af = AF_INET6;
1388 wildcard = ipa->address[1] == 0;
1389 }
1390 else
1391 {
1392 af = AF_INET;
1393 wildcard = ipa->address[0] == 0;
1394 }
1395
96f5fe4c 1396 if ((listen_sockets[sk] = ip_socket(SOCK_STREAM, af)) < 0)
059ec3d9
PH
1397 {
1398 if (check_special_case(0, addresses, ipa, FALSE))
1399 {
1400 log_write(0, LOG_MAIN, "Failed to create IPv6 socket for wildcard "
1401 "listening (%s): will use IPv4", strerror(errno));
1402 goto SKIP_SOCKET;
1403 }
1404 log_write(0, LOG_PANIC_DIE, "IPv%c socket creation failed: %s",
1405 (af == AF_INET6)? '6' : '4', strerror(errno));
1406 }
1407
1408 /* If this is an IPv6 wildcard socket, set IPV6_V6ONLY if that option is
1409 available. Just log failure (can get protocol not available, just like
1410 socket creation can). */
1411
b891534f 1412#ifdef IPV6_V6ONLY
059ec3d9 1413 if (af == AF_INET6 && wildcard &&
5903c6ff 1414 setsockopt(listen_sockets[sk], IPPROTO_IPV6, IPV6_V6ONLY, CS (&on),
059ec3d9
PH
1415 sizeof(on)) < 0)
1416 log_write(0, LOG_MAIN, "Setting IPV6_V6ONLY on daemon's IPv6 wildcard "
1417 "socket failed (%s): carrying on without it", strerror(errno));
b891534f 1418#endif /* IPV6_V6ONLY */
059ec3d9
PH
1419
1420 /* Set SO_REUSEADDR so that the daemon can be restarted while a connection
1421 is being handled. Without this, a connection will prevent reuse of the
1422 smtp port for listening. */
1423
1424 if (setsockopt(listen_sockets[sk], SOL_SOCKET, SO_REUSEADDR,
5903c6ff 1425 US (&on), sizeof(on)) < 0)
059ec3d9
PH
1426 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "setting SO_REUSEADDR on socket "
1427 "failed when starting daemon: %s", strerror(errno));
1428
1429 /* Set TCP_NODELAY; Exim does its own buffering. There is a switch to
1430 disable this because it breaks some broken clients. */
1431
1432 if (tcp_nodelay) setsockopt(listen_sockets[sk], IPPROTO_TCP, TCP_NODELAY,
5903c6ff 1433 US (&on), sizeof(on));
059ec3d9
PH
1434
1435 /* Now bind the socket to the required port; if Exim is being restarted
1436 it may not always be possible to bind immediately, even with SO_REUSEADDR
1437 set, so try 10 times, waiting between each try. After 10 failures, we give
1438 up. In an IPv6 environment, if bind () fails with the error EADDRINUSE and
1439 we are doing wildcard IPv4 listening and there was a previous IPv6 wildcard
1440 address for the same port, ignore the error on the grounds that we must be
1441 in a system where the IPv6 socket accepts both kinds of call. This is
1442 necessary for (some release of) USAGI Linux; other IP stacks fail at the
1443 listen() stage instead. */
1444
6af7e591
JH
1445#ifdef TCP_FASTOPEN
1446 tcp_fastopen_ok = TRUE;
1447#endif
059ec3d9
PH
1448 for(;;)
1449 {
1450 uschar *msg, *addr;
1451 if (ip_bind(listen_sockets[sk], af, ipa->address, ipa->port) >= 0) break;
1452 if (check_special_case(errno, addresses, ipa, TRUE))
1453 {
1454 DEBUG(D_any) debug_printf("wildcard IPv4 bind() failed after IPv6 "
1455 "listen() success; EADDRINUSE ignored\n");
f1e894f3 1456 (void)close(listen_sockets[sk]);
059ec3d9
PH
1457 goto SKIP_SOCKET;
1458 }
1459 msg = US strerror(errno);
b891534f
JH
1460 addr = wildcard
1461 ? af == AF_INET6
1462 ? US"(any IPv6)"
1463 : US"(any IPv4)"
1464 : ipa->address;
4aee0225 1465 if (daemon_startup_retries <= 0)
059ec3d9
PH
1466 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1467 "socket bind() to port %d for address %s failed: %s: "
1468 "daemon abandoned", ipa->port, addr, msg);
1469 log_write(0, LOG_MAIN, "socket bind() to port %d for address %s "
4aee0225
PH
1470 "failed: %s: waiting %s before trying again (%d more %s)",
1471 ipa->port, addr, msg, readconf_printtime(daemon_startup_sleep),
1472 daemon_startup_retries, (daemon_startup_retries > 1)? "tries" : "try");
1473 daemon_startup_retries--;
1474 sleep(daemon_startup_sleep);
059ec3d9
PH
1475 }
1476
1477 DEBUG(D_any)
059ec3d9
PH
1478 if (wildcard)
1479 debug_printf("listening on all interfaces (IPv%c) port %d\n",
fb05276a 1480 af == AF_INET6 ? '6' : '4', ipa->port);
059ec3d9
PH
1481 else
1482 debug_printf("listening on %s port %d\n", ipa->address, ipa->port);
fb05276a
JH
1483
1484#ifdef TCP_FASTOPEN
4670e9d3
JH
1485 if (setsockopt(listen_sockets[sk], IPPROTO_TCP, TCP_FASTOPEN,
1486 &smtp_connect_backlog, sizeof(smtp_connect_backlog)))
6af7e591 1487 {
a23ff3b4 1488 DEBUG(D_any) debug_printf("setsockopt FASTOPEN: %s\n", strerror(errno));
6af7e591
JH
1489 tcp_fastopen_ok = FALSE;
1490 }
fb05276a 1491#endif
059ec3d9
PH
1492
1493 /* Start listening on the bound socket, establishing the maximum backlog of
1494 connections that is allowed. On success, continue to the next address. */
1495
1496 if (listen(listen_sockets[sk], smtp_connect_backlog) >= 0) continue;
1497
1498 /* Listening has failed. In an IPv6 environment, as for bind(), if listen()
1499 fails with the error EADDRINUSE and we are doing IPv4 wildcard listening
1500 and there was a previous successful IPv6 wildcard listen on the same port,
1501 we want to ignore the error on the grounds that we must be in a system
1502 where the IPv6 socket accepts both kinds of call. */
1503
1504 if (!check_special_case(errno, addresses, ipa, TRUE))
1505 log_write(0, LOG_PANIC_DIE, "listen() failed on interface %s: %s",
fb05276a
JH
1506 wildcard
1507 ? af == AF_INET6 ? US"(any IPv6)" : US"(any IPv4)" : ipa->address,
059ec3d9
PH
1508 strerror(errno));
1509
1510 DEBUG(D_any) debug_printf("wildcard IPv4 listen() failed after IPv6 "
1511 "listen() success; EADDRINUSE ignored\n");
f1e894f3 1512 (void)close(listen_sockets[sk]);
059ec3d9
PH
1513
1514 /* Come here if there has been a problem with the socket which we
1515 are going to ignore. We remove the address from the chain, and back up the
1516 counts. */
1517
b891534f 1518 SKIP_SOCKET:
059ec3d9
PH
1519 sk--; /* Back up the count */
1520 listen_socket_count--; /* Reduce the total */
1521 if (ipa == addresses) addresses = ipa->next; else
1522 {
1523 for (ipa2 = addresses; ipa2->next != ipa; ipa2 = ipa2->next);
1524 ipa2->next = ipa->next;
1525 ipa = ipa2;
1526 }
1527 } /* End of bind/listen loop for each address */
1528 } /* End of setup for listening */
1529
1530
1531/* If we are not listening, we want to write a pid file only if -oP was
1532explicitly given. */
1533
b891534f
JH
1534else if (!override_pid_file_path)
1535 write_pid = FALSE;
059ec3d9
PH
1536
1537/* Write the pid to a known file for assistance in identification, if required.
1538We do this before giving up root privilege, because on some systems it is
1539necessary to be root in order to write into the pid file directory. There's
1540nothing to stop multiple daemons running, as long as no more than one listens
1541on a given TCP/IP port on the same interface(s). However, in these
1542circumstances it gets far too complicated to mess with pid file names
1543automatically. Consequently, Exim 4 writes a pid file only
1544
1545 (a) When running in the test harness, or
1546 (b) When -bd is used and -oX is not used, or
1547 (c) When -oP is used to supply a path.
1548
1549The variable daemon_write_pid is used to control this. */
1550
1551if (running_in_test_harness || write_pid)
1552 {
1553 FILE *f;
1554
b891534f 1555 if (override_pid_file_path)
059ec3d9
PH
1556 pid_file_path = override_pid_file_path;
1557
1558 if (pid_file_path[0] == 0)
1559 pid_file_path = string_sprintf("%s/exim-daemon.pid", spool_directory);
1560
b891534f 1561 if ((f = modefopen(pid_file_path, "wb", 0644)))
059ec3d9 1562 {
ff790e47 1563 (void)fprintf(f, "%d\n", (int)getpid());
ff790e47 1564 (void)fclose(f);
059ec3d9
PH
1565 DEBUG(D_any) debug_printf("pid written to %s\n", pid_file_path);
1566 }
1567 else
059ec3d9
PH
1568 DEBUG(D_any)
1569 debug_printf("%s\n", string_open_failed(errno, "pid file %s",
1570 pid_file_path));
059ec3d9
PH
1571 }
1572
1573/* Set up the handler for SIGHUP, which causes a restart of the daemon. */
1574
1575sighup_seen = FALSE;
1576signal(SIGHUP, sighup_handler);
1577
1578/* Give up root privilege at this point (assuming that exim_uid and exim_gid
1579are not root). The third argument controls the running of initgroups().
1580Normally we do this, in order to set up the groups for the Exim user. However,
1581if we are not root at this time - some odd installations run that way - we
1582cannot do this. */
1583
1584exim_setugid(exim_uid, exim_gid, geteuid()==root_uid, US"running as a daemon");
1585
ebeaf996
PH
1586/* Update the originator_xxx fields so that received messages as listed as
1587coming from Exim, not whoever started the daemon. */
1588
1589originator_uid = exim_uid;
1590originator_gid = exim_gid;
1591originator_login = ((pw = getpwuid(exim_uid)) != NULL)?
1592 string_copy_malloc(US pw->pw_name) : US"exim";
1593
059ec3d9
PH
1594/* Get somewhere to keep the list of queue-runner pids if we are keeping track
1595of them (and also if we are doing queue runs). */
1596
0cd5fd23 1597if (queue_interval > 0 && local_queue_run_max > 0)
059ec3d9
PH
1598 {
1599 int i;
0cd5fd23
JH
1600 queue_pid_slots = store_get(local_queue_run_max * sizeof(pid_t));
1601 for (i = 0; i < local_queue_run_max; i++) queue_pid_slots[i] = 0;
059ec3d9
PH
1602 }
1603
1604/* Set up the handler for termination of child processes. */
1605
1606sigchld_seen = FALSE;
7d468ab8 1607os_non_restarting_signal(SIGCHLD, main_sigchld_handler);
059ec3d9
PH
1608
1609/* If we are to run the queue periodically, pretend the alarm has just gone
1610off. This will cause the first queue-runner to get kicked off straight away. */
1611
1612sigalrm_seen = (queue_interval > 0);
1613
1614/* Log the start up of a daemon - at least one of listening or queue running
1615must be set up. */
1616
9ee44efb
PP
1617if (inetd_wait_mode)
1618 {
1619 uschar *p = big_buffer;
1620
1621 if (inetd_wait_timeout >= 0)
1622 sprintf(CS p, "terminating after %d seconds", inetd_wait_timeout);
1623 else
1624 sprintf(CS p, "with no wait timeout");
1625
1626 log_write(0, LOG_MAIN,
1627 "exim %s daemon started: pid=%d, launched with listening socket, %s",
1628 version_string, getpid(), big_buffer);
2f21487f 1629 set_process_info("daemon(%s): pre-listening socket", version_string);
9ee44efb
PP
1630
1631 /* set up the timeout logic */
1632 sigalrm_seen = 1;
1633 }
1634
1635else if (daemon_listen)
059ec3d9
PH
1636 {
1637 int i, j;
1638 int smtp_ports = 0;
1639 int smtps_ports = 0;
e4d0fc93 1640 ip_address_item * ipa, * i2;
e37f8a84
JH
1641 uschar * p = big_buffer;
1642 uschar * qinfo = queue_interval > 0
1643 ? string_sprintf("-q%s", readconf_printtime(queue_interval))
1644 : US"no queue runs";
059ec3d9
PH
1645
1646 /* Build a list of listening addresses in big_buffer, but limit it to 10
1647 items. The style is for backwards compatibility.
1648
1649 It is now possible to have some ports listening for SMTPS (the old,
1650 deprecated protocol that starts TLS without using STARTTLS), and others
1651 listening for standard SMTP. Keep their listings separate. */
1652
1653 for (j = 0; j < 2; j++)
1654 {
e37f8a84 1655 for (i = 0, ipa = addresses; i < 10 && ipa; i++, ipa = ipa->next)
b891534f
JH
1656 {
1657 /* First time round, look for SMTP ports; second time round, look for
1658 SMTPS ports. For the first one of each, insert leading text. */
1659
1660 if (host_is_tls_on_connect_port(ipa->port) == (j > 0))
1661 {
1662 if (j == 0)
1663 {
1664 if (smtp_ports++ == 0)
fc3f96af 1665 {
b891534f
JH
1666 memcpy(p, "SMTP on", 8);
1667 p += 7;
fc3f96af 1668 }
b891534f
JH
1669 }
1670 else
1671 if (smtps_ports++ == 0)
1672 p += sprintf(CS p, "%sSMTPS on",
1673 smtp_ports == 0 ? "" : " and for ");
1674
1675 /* Now the information about the port (and sometimes interface) */
1676
1677 if (ipa->address[0] == ':' && ipa->address[1] == 0)
e4d0fc93 1678 { /* v6 wildcard */
b891534f
JH
1679 if (ipa->next && ipa->next->address[0] == 0 &&
1680 ipa->next->port == ipa->port)
1681 {
1682 p += sprintf(CS p, " port %d (IPv6 and IPv4)", ipa->port);
1683 ipa = ipa->next;
1684 }
1685 else if (ipa->v6_include_v4)
1686 p += sprintf(CS p, " port %d (IPv6 with IPv4)", ipa->port);
1687 else
1688 p += sprintf(CS p, " port %d (IPv6)", ipa->port);
1689 }
e4d0fc93 1690 else if (ipa->address[0] == 0) /* v4 wildcard */
b891534f 1691 p += sprintf(CS p, " port %d (IPv4)", ipa->port);
e4d0fc93 1692 else /* check for previously-seen IP */
b891534f 1693 {
e4d0fc93
JH
1694 for (i2 = addresses; i2 != ipa; i2 = i2->next)
1695 if ( host_is_tls_on_connect_port(i2->port) == (j > 0)
1696 && Ustrcmp(ipa->address, i2->address) == 0
1697 )
1698 { /* found; append port to list */
1699 if (p[-1] == '}') p--;
1700 while (isdigit(*--p)) ;
1701 p += 1 + sprintf(CS p+1, "%s%d,%d}", *p == ',' ? "" : "{",
1702 i2->port, ipa->port);
1703 break;
1704 }
1705 if (i2 == ipa) /* first-time IP */
1706 p += sprintf(CS p, " [%s]:%d", ipa->address, ipa->port);
b891534f 1707 }
b891534f
JH
1708 }
1709 }
059ec3d9 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 */