src/src/daemon.c

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