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