granicus.if.org Git - apache/blob - server/listen.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "apr_network_io.h"
  18 #include "apr_strings.h"
  19
  20 #define APR_WANT_STRFUNC
  21 #include "apr_want.h"
  22
  23 #include "ap_config.h"
  24 #include "httpd.h"
  25 #include "http_config.h"
  26 #include "http_core.h"
  27 #include "ap_listen.h"
  28 #include "http_log.h"
  29 #include "mpm_common.h"
  30
  31 #ifdef HAVE_SYSTEMD
  32 #include <systemd/sd-daemon.h>
  33 #endif
  34
  35 /* we know core's module_index is 0 */
  36 #undef APLOG_MODULE_INDEX
  37 #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX
  38
  39 AP_DECLARE_DATA ap_listen_rec *ap_listeners = NULL;
  40
  41 AP_DECLARE_DATA ap_listen_rec **mpm_listen = NULL;
  42 AP_DECLARE_DATA int enable_default_listener = 1;
  43 AP_DECLARE_DATA int num_buckets = 1;
  44 AP_DECLARE_DATA int have_so_reuseport = 0;
  45
  46 static ap_listen_rec *old_listeners;
  47 static int ap_listenbacklog;
  48 static int send_buffer_size;
  49 static int receive_buffer_size;
  50 #ifdef HAVE_SYSTEMD
  51 static int use_systemd;
  52 #endif
  53
  54 /* TODO: make_sock is just begging and screaming for APR abstraction */
  55 static apr_status_t make_sock(apr_pool_t *p, ap_listen_rec *server, int do_bind_listen)
  56 {
  57     apr_socket_t *s = server->sd;
  58     int one = 1;
  59 #if APR_HAVE_IPV6
  60 #ifdef AP_ENABLE_V4_MAPPED
  61     int v6only_setting = 0;
  62 #else
  63     int v6only_setting = 1;
  64 #endif
  65 #endif
  66     apr_status_t stat;
  67
  68 #ifndef WIN32
  69     stat = apr_socket_opt_set(s, APR_SO_REUSEADDR, one);
  70     if (stat != APR_SUCCESS && stat != APR_ENOTIMPL) {
  71         ap_log_perror(APLOG_MARK, APLOG_CRIT, stat, p, APLOGNO(00067)
  72                       "make_sock: for address %pI, apr_socket_opt_set: (SO_REUSEADDR)",
  73                       server->bind_addr);
  74         apr_socket_close(s);
  75         return stat;
  76     }
  77 #endif
  78
  79     stat = apr_socket_opt_set(s, APR_SO_KEEPALIVE, one);
  80     if (stat != APR_SUCCESS && stat != APR_ENOTIMPL) {
  81         ap_log_perror(APLOG_MARK, APLOG_CRIT, stat, p, APLOGNO(00068)
  82                       "make_sock: for address %pI, apr_socket_opt_set: (SO_KEEPALIVE)",
  83                       server->bind_addr);
  84         apr_socket_close(s);
  85         return stat;
  86     }
  87
  88     /*
  89      * To send data over high bandwidth-delay connections at full
  90      * speed we must force the TCP window to open wide enough to keep the
  91      * pipe full.  The default window size on many systems
  92      * is only 4kB.  Cross-country WAN connections of 100ms
  93      * at 1Mb/s are not impossible for well connected sites.
  94      * If we assume 100ms cross-country latency,
  95      * a 4kB buffer limits throughput to 40kB/s.
  96      *
  97      * To avoid this problem I've added the SendBufferSize directive
  98      * to allow the web master to configure send buffer size.
  99      *
 100      * The trade-off of larger buffers is that more kernel memory
 101      * is consumed.  YMMV, know your customers and your network!
 102      *
 103      * -John Heidemann <johnh@isi.edu> 25-Oct-96
 104      *
 105      * If no size is specified, use the kernel default.
 106      */
 107     if (send_buffer_size) {
 108         stat = apr_socket_opt_set(s, APR_SO_SNDBUF,  send_buffer_size);
 109         if (stat != APR_SUCCESS && stat != APR_ENOTIMPL) {
 110             ap_log_perror(APLOG_MARK, APLOG_WARNING, stat, p, APLOGNO(00070)
 111                           "make_sock: failed to set SendBufferSize for "
 112                           "address %pI, using default",
 113                           server->bind_addr);
 114             /* not a fatal error */
 115         }
 116     }
 117     if (receive_buffer_size) {
 118         stat = apr_socket_opt_set(s, APR_SO_RCVBUF, receive_buffer_size);
 119         if (stat != APR_SUCCESS && stat != APR_ENOTIMPL) {
 120             ap_log_perror(APLOG_MARK, APLOG_WARNING, stat, p, APLOGNO(00071)
 121                           "make_sock: failed to set ReceiveBufferSize for "
 122                           "address %pI, using default",
 123                           server->bind_addr);
 124             /* not a fatal error */
 125         }
 126     }
 127
 128 #if APR_TCP_NODELAY_INHERITED
 129     ap_sock_disable_nagle(s);
 130 #endif
 131
 132 #ifdef SO_REUSEPORT
 133     {
 134       int thesock;
 135       apr_os_sock_get(&thesock, s);
 136       if (setsockopt(thesock, SOL_SOCKET, SO_REUSEPORT, (void *)&one, sizeof(int)) < 0) {
 137           /* defined by not valid? */
 138           if (errno == ENOPROTOOPT) {
 139               have_so_reuseport = 0;
 140           } /* Check if SO_REUSEPORT is supported by the running Linux Kernel.*/
 141           else {
 142               ap_log_perror(APLOG_MARK, APLOG_CRIT, stat, p, APLOGNO(02638)
 143                       "make_sock: for address %pI, apr_socket_opt_set: (SO_REUSEPORT)",
 144                        server->bind_addr);
 145               apr_socket_close(s);
 146               return errno;
 147           }
 148       }
 149       else {
 150           have_so_reuseport = 1;
 151       }
 152     }
 153 #endif
 154
 155     if (do_bind_listen) {
 156 #if APR_HAVE_IPV6
 157         if (server->bind_addr->family == APR_INET6) {
 158             stat = apr_socket_opt_set(s, APR_IPV6_V6ONLY, v6only_setting);
 159             if (stat != APR_SUCCESS && stat != APR_ENOTIMPL) {
 160                 ap_log_perror(APLOG_MARK, APLOG_CRIT, stat, p, APLOGNO(00069)
 161                               "make_sock: for address %pI, apr_socket_opt_set: "
 162                               "(IPV6_V6ONLY)",
 163                               server->bind_addr);
 164                 apr_socket_close(s);
 165                 return stat;
 166             }
 167         }
 168 #endif
 169
 170         if ((stat = apr_socket_bind(s, server->bind_addr)) != APR_SUCCESS) {
 171             ap_log_perror(APLOG_MARK, APLOG_STARTUP|APLOG_CRIT, stat, p, APLOGNO(00072)
 172                           "make_sock: could not bind to address %pI",
 173                           server->bind_addr);
 174             apr_socket_close(s);
 175             return stat;
 176         }
 177
 178         if ((stat = apr_socket_listen(s, ap_listenbacklog)) != APR_SUCCESS) {
 179             ap_log_perror(APLOG_MARK, APLOG_STARTUP|APLOG_ERR, stat, p, APLOGNO(00073)
 180                           "make_sock: unable to listen for connections "
 181                           "on address %pI",
 182                           server->bind_addr);
 183             apr_socket_close(s);
 184             return stat;
 185         }
 186     }
 187
 188 #ifdef WIN32
 189     /* I seriously doubt that this would work on Unix; I have doubts that
 190      * it entirely solves the problem on Win32.  However, since setting
 191      * reuseaddr on the listener -prior- to binding the socket has allowed
 192      * us to attach to the same port as an already running instance of
 193      * Apache, or even another web server, we cannot identify that this
 194      * port was exclusively granted to this instance of Apache.
 195      *
 196      * So set reuseaddr, but do not attempt to do so until we have the
 197      * parent listeners successfully bound.
 198      */
 199     stat = apr_socket_opt_set(s, APR_SO_REUSEADDR, one);
 200     if (stat != APR_SUCCESS && stat != APR_ENOTIMPL) {
 201         ap_log_perror(APLOG_MARK, APLOG_CRIT, stat, p, APLOGNO(00074)
 202                     "make_sock: for address %pI, apr_socket_opt_set: (SO_REUSEADDR)",
 203                      server->bind_addr);
 204         apr_socket_close(s);
 205         return stat;
 206     }
 207 #endif
 208
 209     server->sd = s;
 210     server->active = enable_default_listener;
 211
 212     server->accept_func = NULL;
 213
 214     return APR_SUCCESS;
 215 }
 216
 217 static const char* find_accf_name(server_rec *s, const char *proto)
 218 {
 219     const char* accf;
 220     core_server_config *conf = ap_get_core_module_config(s->module_config);
 221     if (!proto) {
 222         return NULL;
 223     }
 224
 225     accf = apr_table_get(conf->accf_map, proto);
 226
 227     if (accf && !strcmp("none", accf)) {
 228         return NULL;
 229     }
 230
 231     return accf;
 232 }
 233
 234 static void ap_apply_accept_filter(apr_pool_t *p, ap_listen_rec *lis,
 235                                            server_rec *server)
 236 {
 237     apr_socket_t *s = lis->sd;
 238     const char *accf;
 239     apr_status_t rv;
 240     const char *proto;
 241
 242     proto = lis->protocol;
 243
 244     if (!proto) {
 245         proto = ap_get_server_protocol(server);
 246     }
 247
 248
 249     accf = find_accf_name(server, proto);
 250
 251     if (accf) {
 252 #if APR_HAS_SO_ACCEPTFILTER
 253         /* In APR 1.x, the 2nd and 3rd parameters are char * instead of
 254          * const char *, so make a copy of those args here.
 255          */
 256         rv = apr_socket_accept_filter(s, apr_pstrdup(p, accf),
 257                                       apr_pstrdup(p, ""));
 258         if (rv != APR_SUCCESS && !APR_STATUS_IS_ENOTIMPL(rv)) {
 259             ap_log_perror(APLOG_MARK, APLOG_WARNING, rv, p, APLOGNO(00075)
 260                           "Failed to enable the '%s' Accept Filter",
 261                           accf);
 262         }
 263 #else
 264         rv = apr_socket_opt_set(s, APR_TCP_DEFER_ACCEPT, 30);
 265         if (rv != APR_SUCCESS && !APR_STATUS_IS_ENOTIMPL(rv)) {
 266             ap_log_perror(APLOG_MARK, APLOG_WARNING, rv, p, APLOGNO(00076)
 267                               "Failed to enable APR_TCP_DEFER_ACCEPT");
 268         }
 269 #endif
 270     }
 271 }
 272
 273 static apr_status_t close_listeners_on_exec(void *v)
 274 {
 275     ap_close_listeners();
 276     return APR_SUCCESS;
 277 }
 278
 279
 280 #ifdef HAVE_SYSTEMD
 281
 282 static apr_status_t alloc_systemd_listener(process_rec * process,
 283                                            int fd,
 284                                            ap_listen_rec **out_rec)
 285 {
 286     apr_status_t rv;
 287     struct sockaddr sa;
 288     socklen_t len;
 289     apr_os_sock_info_t si;
 290     ap_listen_rec *rec;
 291     *out_rec = NULL;
 292
 293     memset(&si, 0, sizeof(si));
 294
 295     rv = getsockname(fd, &sa, &len);
 296
 297     if (rv != 0) {
 298         rv = apr_get_netos_error();
 299         ap_log_perror(APLOG_MARK, APLOG_CRIT, rv, process->pool, APLOGNO(02489)
 300                       "getsockname on %d failed.", fd);
 301         return rv;
 302     }
 303
 304     si.os_sock = &fd;
 305     si.family = sa.sa_family;
 306     si.type = SOCK_STREAM;
 307     si.protocol = APR_PROTO_TCP;
 308
 309     rec = apr_palloc(process->pool, sizeof(ap_listen_rec));
 310     rec->active = 0;
 311     rec->next = 0;
 312
 313
 314     rv = apr_os_sock_make(&rec->sd, &si, process->pool);
 315     if (rv != APR_SUCCESS) {
 316         ap_log_perror(APLOG_MARK, APLOG_CRIT, rv, process->pool, APLOGNO(02490)
 317                       "apr_os_sock_make on %d failed.", fd);
 318         return rv;
 319     }
 320
 321     rv = apr_socket_addr_get(&rec->bind_addr, APR_LOCAL, rec->sd);
 322     if (rv != APR_SUCCESS) {
 323         ap_log_perror(APLOG_MARK, APLOG_CRIT, rv, process->pool, APLOGNO(02491)
 324                       "apr_socket_addr_get on %d failed.", fd);
 325         return rv;
 326     }
 327
 328     if (rec->bind_addr->port == 443) {
 329         rec->protocol = apr_pstrdup(process->pool, "https");
 330     } else {
 331         rec->protocol = apr_pstrdup(process->pool, "http");
 332     }
 333
 334     *out_rec = rec;
 335
 336     return make_sock(process->pool, rec, 0);
 337 }
 338
 339 static int open_systemd_listeners(process_rec *process)
 340 {
 341     ap_listen_rec *last, *new;
 342     int fdcount, fd;
 343     apr_status_t rv;
 344     void *data;
 345     const char *userdata_key = "ap_systemd_listeners";
 346     int sdc = sd_listen_fds(0);
 347
 348     if (sdc < 0) {
 349         ap_log_perror(APLOG_MARK, APLOG_CRIT, sdc, process->pool, APLOGNO(02486)
 350                       "open_systemd_listeners: Error parsing enviroment, sd_listen_fds returned %d",
 351                       sdc);
 352         return 1;
 353     }
 354
 355     if (sdc == 0) {
 356         ap_log_perror(APLOG_MARK, APLOG_CRIT, sdc, process->pool, APLOGNO(02487)
 357                       "open_systemd_listeners: At least one socket must be set.");
 358         return 1;
 359     }
 360
 361     last = ap_listeners;
 362     while (last && last->next) {
 363         last = last->next;
 364     }
 365
 366     fdcount = atoi(getenv("LISTEN_FDS"));
 367
 368     for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + fdcount; fd++) {
 369         rv = alloc_systemd_listener(process, fd, &new);
 370
 371         if (rv != APR_SUCCESS) {
 372             ap_log_perror(APLOG_MARK, APLOG_CRIT, rv, process->pool, APLOGNO(02488)
 373                           "open_systemd_listeners: failed to setup socket %d.", fd);
 374             return 1;
 375         }
 376
 377         if (last == NULL) {
 378             ap_listeners = last = new;
 379         }
 380         else {
 381             last->next = new;
 382             last = new;
 383         }
 384     }
 385
 386     /* clear the enviroment on our second run
 387      * so that none of our future children get confused.
 388      */
 389      apr_pool_userdata_get(&data, userdata_key, process->pool);
 390      if (!data) {
 391          apr_pool_userdata_set((const void *)1, userdata_key,
 392                                apr_pool_cleanup_null, process->pool);
 393      }
 394      else {
 395          sd_listen_fds(1);
 396      }
 397
 398
 399     return 0;
 400 }
 401
 402 #endif /* HAVE_SYSTEMD */
 403
 404 static const char *alloc_listener(process_rec *process, char *addr,
 405                                   apr_port_t port, const char* proto,
 406                                   void *slave)
 407 {
 408     ap_listen_rec **walk, *last;
 409     apr_status_t status;
 410     apr_sockaddr_t *sa;
 411     int found_listener = 0;
 412
 413     /* see if we've got an old listener for this address:port */
 414     for (walk = &old_listeners; *walk;) {
 415         sa = (*walk)->bind_addr;
 416         /* Some listeners are not real so they will not have a bind_addr. */
 417         if (sa) {
 418             ap_listen_rec *new;
 419             apr_port_t oldport;
 420
 421             oldport = sa->port;
 422             /* If both ports are equivalent, then if their names are equivalent,
 423              * then we will re-use the existing record.
 424              */
 425             if (port == oldport &&
 426                 ((!addr && !sa->hostname) ||
 427                  ((addr && sa->hostname) && !strcmp(sa->hostname, addr)))) {
 428                 new = *walk;
 429                 *walk = new->next;
 430                 new->next = ap_listeners;
 431                 ap_listeners = new;
 432                 found_listener = 1;
 433                 continue;
 434             }
 435         }
 436
 437         walk = &(*walk)->next;
 438     }
 439
 440     if (found_listener) {
 441         if (ap_listeners->slave != slave) {
 442             return "Cannot define a slave on the same IP:port as a Listener";
 443         }
 444         return NULL;
 445     }
 446
 447     if ((status = apr_sockaddr_info_get(&sa, addr, APR_UNSPEC, port, 0,
 448                                         process->pool))
 449         != APR_SUCCESS) {
 450         ap_log_perror(APLOG_MARK, APLOG_CRIT, status, process->pool, APLOGNO(00077)
 451                       "alloc_listener: failed to set up sockaddr for %s",
 452                       addr);
 453         return "Listen setup failed";
 454     }
 455
 456     /* Initialize to our last configured ap_listener. */
 457     last = ap_listeners;
 458     while (last && last->next) {
 459         last = last->next;
 460     }
 461
 462     while (sa) {
 463         ap_listen_rec *new;
 464
 465         /* this has to survive restarts */
 466         new = apr_palloc(process->pool, sizeof(ap_listen_rec));
 467         new->active = 0;
 468         new->next = 0;
 469         new->bind_addr = sa;
 470         new->protocol = apr_pstrdup(process->pool, proto);
 471
 472         /* Go to the next sockaddr. */
 473         sa = sa->next;
 474
 475         status = apr_socket_create(&new->sd, new->bind_addr->family,
 476                                     SOCK_STREAM, 0, process->pool);
 477
 478 #if APR_HAVE_IPV6
 479         /* What could happen is that we got an IPv6 address, but this system
 480          * doesn't actually support IPv6.  Try the next address.
 481          */
 482         if (status != APR_SUCCESS && !addr &&
 483             new->bind_addr->family == APR_INET6) {
 484             continue;
 485         }
 486 #endif
 487         if (status != APR_SUCCESS) {
 488             ap_log_perror(APLOG_MARK, APLOG_CRIT, status, process->pool, APLOGNO(00078)
 489                           "alloc_listener: failed to get a socket for %s",
 490                           addr);
 491             return "Listen setup failed";
 492         }
 493
 494         /* We need to preserve the order returned by getaddrinfo() */
 495         if (last == NULL) {
 496             ap_listeners = last = new;
 497         } else {
 498             last->next = new;
 499             last = new;
 500         }
 501         new->slave = slave;
 502     }
 503
 504     return NULL;
 505 }
 506 /* Evaluates to true if the (apr_sockaddr_t *) addr argument is the
 507  * IPv4 match-any-address, 0.0.0.0. */
 508 #define IS_INADDR_ANY(addr) ((addr)->family == APR_INET \
 509                              && (addr)->sa.sin.sin_addr.s_addr == INADDR_ANY)
 510
 511 /* Evaluates to true if the (apr_sockaddr_t *) addr argument is the
 512  * IPv6 match-any-address, [::]. */
 513 #define IS_IN6ADDR_ANY(addr) ((addr)->family == APR_INET6 \
 514                               && IN6_IS_ADDR_UNSPECIFIED(&(addr)->sa.sin6.sin6_addr))
 515
 516 /**
 517  * Create, open, listen, and bind all sockets.
 518  * @param process The process record for the currently running server
 519  * @return The number of open sockets
 520  */
 521 static int open_listeners(apr_pool_t *pool)
 522 {
 523     ap_listen_rec *lr;
 524     ap_listen_rec *next;
 525     ap_listen_rec *previous;
 526     int num_open;
 527     const char *userdata_key = "ap_open_listeners";
 528     void *data;
 529 #if AP_NONBLOCK_WHEN_MULTI_LISTEN
 530     int use_nonblock;
 531 #endif
 532
 533     /* Don't allocate a default listener.  If we need to listen to a
 534      * port, then the user needs to have a Listen directive in their
 535      * config file.
 536      */
 537     num_open = 0;
 538     previous = NULL;
 539     for (lr = ap_listeners; lr; previous = lr, lr = lr->next) {
 540         if (lr->active) {
 541             ++num_open;
 542         }
 543         else {
 544 #if APR_HAVE_IPV6
 545             ap_listen_rec *cur;
 546             int v6only_setting;
 547             int skip = 0;
 548
 549             /* If we have the unspecified IPv4 address (0.0.0.0) and
 550              * the unspecified IPv6 address (::) is next, we need to
 551              * swap the order of these in the list. We always try to
 552              * bind to IPv6 first, then IPv4, since an IPv6 socket
 553              * might be able to receive IPv4 packets if V6ONLY is not
 554              * enabled, but never the other way around.
 555              * Note: In some configurations, the unspecified IPv6 address
 556              * could be even later in the list.  This logic only corrects
 557              * the situation where it is next in the list, such as when
 558              * apr_sockaddr_info_get() returns an IPv4 and an IPv6 address,
 559              * in that order.
 560              */
 561             if (lr->next != NULL
 562                 && IS_INADDR_ANY(lr->bind_addr)
 563                 && lr->bind_addr->port == lr->next->bind_addr->port
 564                 && IS_IN6ADDR_ANY(lr->next->bind_addr)) {
 565                 /* Exchange lr and lr->next */
 566                 next = lr->next;
 567                 lr->next = next->next;
 568                 next->next = lr;
 569                 if (previous) {
 570                     previous->next = next;
 571                 }
 572                 else {
 573                     ap_listeners = next;
 574                 }
 575                 lr = next;
 576             }
 577
 578             /* If we are trying to bind to 0.0.0.0 and a previous listener
 579              * was :: on the same port and in turn that socket does not have
 580              * the IPV6_V6ONLY flag set; we must skip the current attempt to
 581              * listen (which would generate an error). IPv4 will be handled
 582              * on the established IPv6 socket.
 583              */
 584             if (IS_INADDR_ANY(lr->bind_addr) && previous) {
 585                 for (cur = ap_listeners; cur != lr; cur = cur->next) {
 586                     if (lr->bind_addr->port == cur->bind_addr->port
 587                         && IS_IN6ADDR_ANY(cur->bind_addr)
 588                         && apr_socket_opt_get(cur->sd, APR_IPV6_V6ONLY,
 589                                               &v6only_setting) == APR_SUCCESS
 590                         && v6only_setting == 0) {
 591
 592                         /* Remove the current listener from the list */
 593                         previous->next = lr->next;
 594                         lr = previous; /* maintain current value of previous after
 595                                         * post-loop expression is evaluated
 596                                         */
 597                         skip = 1;
 598                         break;
 599                     }
 600                 }
 601                 if (skip) {
 602                     continue;
 603                 }
 604             }
 605 #endif
 606             if (make_sock(pool, lr, enable_default_listener) == APR_SUCCESS) {
 607                 ++num_open;
 608             }
 609             else {
 610 #if APR_HAVE_IPV6
 611                 /* If we tried to bind to ::, and the next listener is
 612                  * on 0.0.0.0 with the same port, don't give a fatal
 613                  * error. The user will still get a warning from make_sock
 614                  * though.
 615                  */
 616                 if (lr->next != NULL
 617                     && IS_IN6ADDR_ANY(lr->bind_addr)
 618                     && lr->bind_addr->port == lr->next->bind_addr->port
 619                     && IS_INADDR_ANY(lr->next->bind_addr)) {
 620
 621                     /* Remove the current listener from the list */
 622                     if (previous) {
 623                         previous->next = lr->next;
 624                     }
 625                     else {
 626                         ap_listeners = lr->next;
 627                     }
 628
 629                     /* Although we've removed ourselves from the list,
 630                      * we need to make sure that the next iteration won't
 631                      * consider "previous" a working IPv6 '::' socket.
 632                      * Changing the family is enough to make sure the
 633                      * conditions before make_sock() fail.
 634                      */
 635                     lr->bind_addr->family = AF_INET;
 636
 637                     continue;
 638                 }
 639 #endif
 640                 /* fatal error */
 641                 return -1;
 642             }
 643         }
 644     }
 645
 646     /* close the old listeners */
 647     for (lr = old_listeners; lr; lr = next) {
 648         apr_socket_close(lr->sd);
 649         lr->active = 0;
 650         next = lr->next;
 651     }
 652     old_listeners = NULL;
 653
 654 #if AP_NONBLOCK_WHEN_MULTI_LISTEN
 655     /* if multiple listening sockets, make them non-blocking so that
 656      * if select()/poll() reports readability for a reset connection that
 657      * is already forgotten about by the time we call accept, we won't
 658      * be hung until another connection arrives on that port
 659      */
 660     use_nonblock = (ap_listeners && ap_listeners->next);
 661     for (lr = ap_listeners; lr; lr = lr->next) {
 662         apr_status_t status;
 663
 664         status = apr_socket_opt_set(lr->sd, APR_SO_NONBLOCK, use_nonblock);
 665         if (status != APR_SUCCESS) {
 666             ap_log_perror(APLOG_MARK, APLOG_STARTUP|APLOG_ERR, status, pool, APLOGNO(00079)
 667                           "unable to control socket non-blocking status");
 668             return -1;
 669         }
 670     }
 671 #endif /* AP_NONBLOCK_WHEN_MULTI_LISTEN */
 672
 673     /* we come through here on both passes of the open logs phase
 674      * only register the cleanup once... otherwise we try to close
 675      * listening sockets twice when cleaning up prior to exec
 676      */
 677     apr_pool_userdata_get(&data, userdata_key, pool);
 678     if (!data) {
 679         apr_pool_userdata_set((const void *)1, userdata_key,
 680                               apr_pool_cleanup_null, pool);
 681         apr_pool_cleanup_register(pool, NULL, apr_pool_cleanup_null,
 682                                   close_listeners_on_exec);
 683     }
 684
 685     return num_open ? 0 : -1;
 686 }
 687
 688 AP_DECLARE(int) ap_setup_listeners(server_rec *s)
 689 {
 690     server_rec *ls;
 691     server_addr_rec *addr;
 692     ap_listen_rec *lr;
 693     int num_listeners = 0;
 694     const char* proto;
 695     int found;
 696
 697     for (ls = s; ls; ls = ls->next) {
 698         proto = ap_get_server_protocol(ls);
 699         if (!proto) {
 700             found = 0;
 701             /* No protocol was set for this vhost,
 702              * use the default for this listener.
 703              */
 704             for (addr = ls->addrs; addr && !found; addr = addr->next) {
 705                 for (lr = ap_listeners; lr; lr = lr->next) {
 706                     if (apr_sockaddr_equal(lr->bind_addr, addr->host_addr) &&
 707                         lr->bind_addr->port == addr->host_port) {
 708                         ap_set_server_protocol(ls, lr->protocol);
 709                         found = 1;
 710                         break;
 711                     }
 712                 }
 713             }
 714
 715             if (!found) {
 716                 /* TODO: set protocol defaults per-Port, eg 25=smtp */
 717                 ap_set_server_protocol(ls, "http");
 718             }
 719         }
 720     }
 721
 722
 723 #ifdef HAVE_SYSTEMD
 724     if (use_systemd) {
 725         if (open_systemd_listeners(s->process) != 0) {
 726             return 0;
 727         }
 728     }
 729     else
 730 #endif
 731     {
 732         if (open_listeners(s->process->pool)) {
 733             return 0;
 734         }
 735     }
 736
 737     for (lr = ap_listeners; lr; lr = lr->next) {
 738         num_listeners++;
 739         found = 0;
 740         for (ls = s; ls && !found; ls = ls->next) {
 741             for (addr = ls->addrs; addr && !found; addr = addr->next) {
 742                 if (apr_sockaddr_equal(lr->bind_addr, addr->host_addr) &&
 743                     lr->bind_addr->port == addr->host_port) {
 744                     found = 1;
 745                     ap_apply_accept_filter(s->process->pool, lr, ls);
 746                 }
 747             }
 748         }
 749
 750         if (!found) {
 751             ap_apply_accept_filter(s->process->pool, lr, s);
 752         }
 753     }
 754
 755     return num_listeners;
 756 }
 757
 758 AP_DECLARE(apr_status_t) ap_duplicate_listeners(server_rec *s, apr_pool_t *p,
 759                                                   int num_buckets) {
 760     int i;
 761     apr_status_t stat;
 762     int use_nonblock = 0;
 763     ap_listen_rec *lr;
 764
 765     mpm_listen = apr_palloc(p, sizeof(ap_listen_rec*) * num_buckets);
 766     for (i = 0; i < num_buckets; i++) {
 767         ap_listen_rec *last = NULL;
 768         lr = ap_listeners;
 769         while (lr) {
 770             ap_listen_rec *duplr;
 771             char *hostname;
 772             apr_port_t port;
 773             apr_sockaddr_t *sa;
 774             duplr  = apr_palloc(p, sizeof(ap_listen_rec));
 775             duplr->slave = NULL;
 776             duplr->protocol = apr_pstrdup(p, lr->protocol);
 777             hostname = apr_pstrdup(p, lr->bind_addr->hostname);
 778             port = lr->bind_addr->port;
 779             apr_sockaddr_info_get(&sa, hostname, APR_UNSPEC, port, 0, p);
 780             duplr->bind_addr = sa;
 781             duplr->next = NULL;
 782             if ((stat = apr_socket_create(&duplr->sd, duplr->bind_addr->family,
 783                                           SOCK_STREAM, 0, p)) != APR_SUCCESS) {
 784                 ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, p, APLOGNO(02640)
 785                               "ap_duplicate_socket: for address %pI, "
 786                               "cannot duplicate a new socket!",
 787                               duplr->bind_addr);
 788                 return stat;
 789             }
 790             make_sock(p, duplr, 1);
 791 #if AP_NONBLOCK_WHEN_MULTI_LISTEN
 792             use_nonblock = (ap_listeners && ap_listeners->next);
 793             if ((stat = apr_socket_opt_set(duplr->sd, APR_SO_NONBLOCK, use_nonblock))
 794                 != APR_SUCCESS) {
 795                 ap_log_perror(APLOG_MARK, APLOG_CRIT, stat, p, APLOGNO(02641)
 796                               "unable to control socket non-blocking status");
 797                 return stat;
 798             }
 799 #endif
 800             ap_apply_accept_filter(p, duplr, s);
 801
 802             if (last == NULL) {
 803                 mpm_listen[i] = last = duplr;
 804             }
 805             else {
 806                 last->next = duplr;
 807                 last = duplr;
 808             }
 809             lr = lr->next;
 810         }
 811     }
 812     return APR_SUCCESS;
 813 }
 814
 815 AP_DECLARE_NONSTD(void) ap_close_listeners(void)
 816 {
 817     ap_listen_rec *lr;
 818     int i;
 819     for (i = 0; i < num_buckets; i++) {
 820         for (lr = mpm_listen[i]; lr; lr = lr->next) {
 821             apr_socket_close(lr->sd);
 822             lr->active = 0;
 823         }
 824     }
 825 }
 826
 827 AP_DECLARE_NONSTD(int) ap_close_selected_listeners(ap_slave_t *slave)
 828 {
 829     ap_listen_rec *lr;
 830     int n = 0;
 831
 832     for (lr = ap_listeners; lr; lr = lr->next) {
 833         if (lr->slave != slave) {
 834             apr_socket_close(lr->sd);
 835             lr->active = 0;
 836         }
 837         else {
 838             ++n;
 839         }
 840     }
 841     return n;
 842 }
 843
 844 AP_DECLARE(void) ap_listen_pre_config(void)
 845 {
 846     old_listeners = ap_listeners;
 847     ap_listeners = NULL;
 848     ap_listenbacklog = DEFAULT_LISTENBACKLOG;
 849 }
 850
 851 AP_DECLARE_NONSTD(const char *) ap_set_listener(cmd_parms *cmd, void *dummy,
 852                                                 int argc, char *const argv[])
 853 {
 854     char *host, *scope_id, *proto;
 855     apr_port_t port;
 856     apr_status_t rv;
 857     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 858
 859     if (err != NULL) {
 860         return err;
 861     }
 862
 863     if (argc < 1 || argc > 2) {
 864         return "Listen requires 1 or 2 arguments.";
 865     }
 866
 867     if (strcmp("systemd", argv[0]) == 0) {
 868 #ifdef HAVE_SYSTEMD
 869       use_systemd = 1;
 870       if (ap_listeners != NULL) {
 871         return "systemd socket activation support must be used exclusive of normal listeners.";
 872       }
 873       return NULL;
 874 #else
 875       return "systemd support was not compiled in.";
 876 #endif
 877     }
 878
 879 #ifdef HAVE_SYSTEMD
 880     if (use_systemd) {
 881       return "systemd socket activation support must be used exclusive of normal listeners.";
 882     }
 883 #endif
 884
 885     rv = apr_parse_addr_port(&host, &scope_id, &port, argv[0], cmd->pool);
 886     if (rv != APR_SUCCESS) {
 887         return "Invalid address or port";
 888     }
 889
 890     if (host && !strcmp(host, "*")) {
 891         host = NULL;
 892     }
 893
 894     if (scope_id) {
 895         /* XXX scope id support is useful with link-local IPv6 addresses */
 896         return "Scope id is not supported";
 897     }
 898
 899     if (!port) {
 900         return "Port must be specified";
 901     }
 902
 903     if (argc != 2) {
 904         if (port == 443) {
 905             proto = "https";
 906         } else {
 907             proto = "http";
 908         }
 909     }
 910     else {
 911         proto = apr_pstrdup(cmd->pool, argv[1]);
 912         ap_str_tolower(proto);
 913     }
 914
 915     return alloc_listener(cmd->server->process, host, port, proto, NULL);
 916 }
 917
 918 AP_DECLARE_NONSTD(const char *) ap_set_listenbacklog(cmd_parms *cmd,
 919                                                      void *dummy,
 920                                                      const char *arg)
 921 {
 922     int b;
 923     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 924
 925     if (err != NULL) {
 926         return err;
 927     }
 928
 929     b = atoi(arg);
 930     if (b < 1) {
 931         return "ListenBacklog must be > 0";
 932     }
 933
 934     ap_listenbacklog = b;
 935     return NULL;
 936 }
 937
 938 AP_DECLARE_NONSTD(const char *) ap_set_send_buffer_size(cmd_parms *cmd,
 939                                                         void *dummy,
 940                                                         const char *arg)
 941 {
 942     int s = atoi(arg);
 943     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 944
 945     if (err != NULL) {
 946         return err;
 947     }
 948
 949     if (s < 512 && s != 0) {
 950         return "SendBufferSize must be >= 512 bytes, or 0 for system default.";
 951     }
 952
 953     send_buffer_size = s;
 954     return NULL;
 955 }
 956
 957 AP_DECLARE_NONSTD(const char *) ap_set_receive_buffer_size(cmd_parms *cmd,
 958                                                            void *dummy,
 959                                                            const char *arg)
 960 {
 961     int s = atoi(arg);
 962     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 963
 964     if (err != NULL) {
 965         return err;
 966     }
 967
 968     if (s < 512 && s != 0) {
 969         return "ReceiveBufferSize must be >= 512 bytes, or 0 for system default.";
 970     }
 971
 972     receive_buffer_size = s;
 973     return NULL;
 974 }