listen.c revision e5c43448cda8c78e3d0cd8683aab2c907cc38362
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "apr_network_io.h"
#include "apr_strings.h"
#define APR_WANT_STRFUNC
#include "apr_want.h"
#include "ap_config.h"
#include "httpd.h"
#include "http_main.h"
#include "http_config.h"
#include "http_core.h"
#include "ap_listen.h"
#include "http_log.h"
#include "mpm_common.h"
#include <stdlib.h>
#include <unistd.h>
#endif
#ifdef HAVE_SYSTEMD
#include <systemd/sd-daemon.h>
#endif
/* we know core's module_index is 0 */
/* Let ap_num_listen_buckets be global so that it can
* be printed by ap_log_common(), but keep the listeners
* buckets static since it is used only here to close them
* all (including duplicated) with ap_close_listeners().
*/
static ap_listen_rec **ap_listen_buckets;
/* Determine once, at runtime, whether or not SO_REUSEPORT
* is usable on this platform, and hence whether or not
* listeners can be duplicated (if configured).
*/
static ap_listen_rec *old_listeners;
static int ap_listenbacklog;
static int ap_listencbratio;
static int send_buffer_size;
static int receive_buffer_size;
#ifdef HAVE_SYSTEMD
static int use_systemd = -1;
#endif
/* TODO: make_sock is just begging and screaming for APR abstraction */
{
int one = 1;
#if APR_HAVE_IPV6
#ifdef AP_ENABLE_V4_MAPPED
int v6only_setting = 0;
#else
int v6only_setting = 1;
#endif
#endif
#ifndef WIN32
"make_sock: for address %pI, apr_socket_opt_set: (SO_REUSEADDR)",
apr_socket_close(s);
return stat;
}
#endif
"make_sock: for address %pI, apr_socket_opt_set: (SO_KEEPALIVE)",
apr_socket_close(s);
return stat;
}
/*
* To send data over high bandwidth-delay connections at full
* speed we must force the TCP window to open wide enough to keep the
* pipe full. The default window size on many systems
* is only 4kB. Cross-country WAN connections of 100ms
* at 1Mb/s are not impossible for well connected sites.
* If we assume 100ms cross-country latency,
* a 4kB buffer limits throughput to 40kB/s.
*
* To avoid this problem I've added the SendBufferSize directive
* to allow the web master to configure send buffer size.
*
* The trade-off of larger buffers is that more kernel memory
* is consumed. YMMV, know your customers and your network!
*
* -John Heidemann <johnh@isi.edu> 25-Oct-96
*
* If no size is specified, use the kernel default.
*/
if (send_buffer_size) {
"make_sock: failed to set SendBufferSize for "
"address %pI, using default",
/* not a fatal error */
}
}
if (receive_buffer_size) {
"make_sock: failed to set ReceiveBufferSize for "
"address %pI, using default",
/* not a fatal error */
}
}
#endif
#if defined(SO_REUSEPORT)
if (ap_have_so_reuseport) {
int thesock;
apr_os_sock_get(&thesock, s);
(void *)&one, sizeof(int)) < 0) {
stat = apr_get_netos_error();
"make_sock: for address %pI, apr_socket_opt_set: "
"(SO_REUSEPORT)",
apr_socket_close(s);
return stat;
}
}
#endif
if (do_bind_listen) {
#if APR_HAVE_IPV6
"make_sock: for address %pI, apr_socket_opt_set: "
"(IPV6_V6ONLY)",
apr_socket_close(s);
return stat;
}
}
#endif
"make_sock: could not bind to address %pI",
apr_socket_close(s);
return stat;
}
"make_sock: unable to listen for connections "
"on address %pI",
apr_socket_close(s);
return stat;
}
}
#ifdef WIN32
/* I seriously doubt that this would work on Unix; I have doubts that
* it entirely solves the problem on Win32. However, since setting
* reuseaddr on the listener -prior- to binding the socket has allowed
* us to attach to the same port as an already running instance of
* Apache, or even another web server, we cannot identify that this
* port was exclusively granted to this instance of Apache.
*
* So set reuseaddr, but do not attempt to do so until we have the
* parent listeners successfully bound.
*/
"make_sock: for address %pI, apr_socket_opt_set: (SO_REUSEADDR)",
apr_socket_close(s);
return stat;
}
#endif
return APR_SUCCESS;
}
{
const char* accf;
if (!proto) {
return NULL;
}
return NULL;
}
return accf;
}
{
const char *accf;
const char *proto;
if (!proto) {
}
if (accf) {
/* In APR 1.x, the 2nd and 3rd parameters are char * instead of
* const char *, so make a copy of those args here.
*/
apr_pstrdup(p, ""));
"Failed to enable the '%s' Accept Filter",
accf);
}
#else
"Failed to enable APR_TCP_DEFER_ACCEPT");
}
#endif
}
}
static apr_status_t close_listeners_on_exec(void *v)
{
return APR_SUCCESS;
}
#ifdef HAVE_SYSTEMD
{
int sdc = sd_listen_fds(0);
if (sdc < 0) {
"find_systemd_socket: Error parsing enviroment, sd_listen_fds returned %d",
sdc);
return -1;
}
if (sdc == 0) {
"find_systemd_socket: At least one socket must be set.");
return -1;
}
return fd;
}
}
return -1;
}
{
if (rv != 0) {
rv = apr_get_netos_error();
"getsockname on %d failed.", fd);
return rv;
}
if (rv != APR_SUCCESS) {
"apr_os_sock_make on %d failed.", fd);
return rv;
}
if (rv != APR_SUCCESS) {
"apr_socket_addr_get on %d failed.", fd);
return rv;
}
}
const char *proto)
{
if (fd < 0) {
return "Systemd socket activation is used, but this port is not "
"configured in systemd";
}
last = ap_listeners;
}
if (rv != APR_SUCCESS) {
return "Failed to setup socket passed by systemd using socket activation";
}
}
else {
}
return NULL;
}
#endif /* HAVE_SYSTEMD */
void *slave)
{
int found_listener = 0;
/* see if we've got an old listener for this address:port */
/* Some listeners are not real so they will not have a bind_addr. */
if (sa) {
/* If both ports are equivalent, then if their names are equivalent,
* then we will re-use the existing record.
*/
ap_listeners = new;
found_listener = 1;
continue;
}
}
}
if (found_listener) {
return "Cannot define a slave on the same IP:port as a Listener";
}
return NULL;
}
!= APR_SUCCESS) {
"alloc_listener: failed to set up sockaddr for %s",
addr);
return "Listen setup failed";
}
/* Initialize to our last configured ap_listener. */
last = ap_listeners;
}
while (sa) {
/* this has to survive restarts */
/* Go to the next sockaddr. */
#if APR_HAVE_IPV6
/* What could happen is that we got an IPv6 address, but this system
* doesn't actually support IPv6. Try the next address.
*/
continue;
}
#endif
if (status != APR_SUCCESS) {
"alloc_listener: failed to get a socket for %s",
addr);
return "Listen setup failed";
}
/* We need to preserve the order returned by getaddrinfo() */
} else {
}
}
return NULL;
}
/* Evaluates to true if the (apr_sockaddr_t *) addr argument is the
* IPv4 match-any-address, 0.0.0.0. */
/* Evaluates to true if the (apr_sockaddr_t *) addr argument is the
* IPv6 match-any-address, [::]. */
/**
* Create, open, listen, and bind all sockets.
* @param process The process record for the currently running server
* @return The number of open sockets
*/
{
int num_open;
const char *userdata_key = "ap_open_listeners";
void *data;
int use_nonblock;
#endif
/* Don't allocate a default listener. If we need to listen to a
* port, then the user needs to have a Listen directive in their
* config file.
*/
num_open = 0;
++num_open;
}
else {
#if APR_HAVE_IPV6
int v6only_setting;
int skip = 0;
/* If we have the unspecified IPv4 address (0.0.0.0) and
* the unspecified IPv6 address (::) is next, we need to
* swap the order of these in the list. We always try to
* bind to IPv6 first, then IPv4, since an IPv6 socket
* might be able to receive IPv4 packets if V6ONLY is not
* enabled, but never the other way around.
* Note: In some configurations, the unspecified IPv6 address
* could be even later in the list. This logic only corrects
* the situation where it is next in the list, such as when
* apr_sockaddr_info_get() returns an IPv4 and an IPv6 address,
* in that order.
*/
/* Exchange lr and lr->next */
if (previous) {
}
else {
ap_listeners = next;
}
}
/* If we are trying to bind to 0.0.0.0 and a previous listener
* was :: on the same port and in turn that socket does not have
* the IPV6_V6ONLY flag set; we must skip the current attempt to
* listen (which would generate an error). IPv4 will be handled
* on the established IPv6 socket.
*/
&& v6only_setting == 0) {
/* Remove the current listener from the list */
* post-loop expression is evaluated
*/
skip = 1;
break;
}
}
if (skip) {
continue;
}
}
#endif
++num_open;
}
else {
#if APR_HAVE_IPV6
/* If we tried to bind to ::, and the next listener is
* on 0.0.0.0 with the same port, don't give a fatal
* error. The user will still get a warning from make_sock
* though.
*/
/* Remove the current listener from the list */
if (previous) {
}
else {
}
/* Although we've removed ourselves from the list,
* we need to make sure that the next iteration won't
* consider "previous" a working IPv6 '::' socket.
* Changing the family is enough to make sure the
* conditions before make_sock() fail.
*/
continue;
}
#endif
/* fatal error */
return -1;
}
}
}
/* close the old listeners */
/* if multiple listening sockets, make them non-blocking so that
* if select()/poll() reports readability for a reset connection that
* is already forgotten about by the time we call accept, we won't
* be hung until another connection arrives on that port
*/
if (status != APR_SUCCESS) {
"unable to control socket non-blocking status");
return -1;
}
}
#endif /* AP_NONBLOCK_WHEN_MULTI_LISTEN */
/* we come through here on both passes of the open logs phase
* only register the cleanup once... otherwise we try to close
* listening sockets twice when cleaning up prior to exec
*/
if (!data) {
}
return num_open ? 0 : -1;
}
{
server_rec *ls;
int num_listeners = 0;
const char* proto;
int found;
if (!proto) {
found = 0;
/* No protocol was set for this vhost,
* use the default for this listener.
*/
found = 1;
break;
}
}
}
if (!found) {
/* TODO: set protocol defaults per-Port, eg 25=smtp */
}
}
}
#ifdef HAVE_SYSTEMD
if (use_systemd) {
const char *userdata_key = "ap_open_systemd_listeners";
void *data;
/* clear the enviroment on our second run
* so that none of our future children get confused.
*/
if (!data) {
}
else {
sd_listen_fds(1);
}
}
else
#endif
{
return 0;
}
}
found = 0;
found = 1;
}
}
}
if (!found) {
}
}
return num_listeners;
}
ap_listen_rec ***buckets,
int *num_buckets)
{
static int warn_once;
int i;
int use_nonblock = 0;
if (*num_buckets < 1) {
*num_buckets = 1;
if (ap_listencbratio > 0) {
#ifdef _SC_NPROCESSORS_ONLN
if (ap_have_so_reuseport) {
if (val > 1) {
*num_buckets = val;
}
"Using %i listeners bucket(s) based on %i "
"online CPU cores and a ratio of %i",
}
else
#endif
if (!warn_once) {
"ListenCoresBucketsRatio ignored without "
"SO_REUSEPORT and _SC_NPROCESSORS_ONLN "
"support: using a single listeners bucket");
warn_once = 1;
}
}
}
(*buckets)[0] = ap_listeners;
for (i = 1; i < *num_buckets; i++) {
lr = ap_listeners;
while (lr) {
char *hostname;
#ifdef HAVE_SYSTEMD
if (use_systemd) {
int thesock;
return stat;
}
}
else
#endif
{
SOCK_STREAM, 0, p);
if (stat != APR_SUCCESS) {
"ap_duplicate_listeners: for address %pI, "
"cannot duplicate a new socket!",
return stat;
}
}
if (stat != APR_SUCCESS) {
"unable to control socket non-blocking status");
return stat;
}
#endif
ap_apply_accept_filter(p, duplr, s);
}
else {
}
}
}
return APR_SUCCESS;
}
AP_DECLARE_NONSTD(void) ap_close_listeners(void)
{
int i;
/* Start from index 1 since either ap_duplicate_listeners()
* was called and ap_listen_buckets[0] == ap_listeners, or
* it wasn't and ap_num_listen_buckets == 0.
*/
for (i = 1; i < ap_num_listen_buckets; i++) {
}
}
{
}
}
{
int n = 0;
}
else {
++n;
}
}
return n;
}
AP_DECLARE(void) ap_listen_pre_config(void)
{
ap_listeners = NULL;
ap_listencbratio = 0;
/* Check once whether or not SO_REUSEPORT is supported. */
if (ap_have_so_reuseport < 0) {
/* This is limited to Linux with defined SO_REUSEPORT (ie. 3.9+) for
* now since the implementation evenly distributes connections accross
*
* *BSDs have SO_REUSEPORT too but with a different semantic: the first
* wildcard address bound socket or the last non-wildcard address bound
* socket will receive connections (no evenness garantee); the rest of
* the sockets bound to the same port will not.
* This can't (always) work for httpd.
*
* TODO: latests DragonFlyBSD's SO_REUSEPORT (seems to?) have the same
* semantic as Linux, so we may need HAVE_SO_REUSEPORT available from
* configure.in some day.
*/
#if defined(SO_REUSEPORT) && defined(__linux__)
ap_pglobal) == APR_SUCCESS) {
SO_REUSEPORT, (void *)&on,
sizeof(int)) == 0);
}
else
#endif
ap_have_so_reuseport = 0;
}
}
{
return err;
}
return "Listen requires 1 or 2 arguments.";
}
#ifdef HAVE_SYSTEMD
if (use_systemd == -1) {
use_systemd = sd_listen_fds(0) > 0;
}
#endif
if (rv != APR_SUCCESS) {
return "Invalid address or port";
}
}
if (scope_id) {
/* XXX scope id support is useful with link-local IPv6 addresses */
return "Scope id is not supported";
}
if (!port) {
return "Port must be specified";
}
if (argc != 2) {
if (port == 443) {
proto = "https";
} else {
proto = "http";
}
}
else {
}
#ifdef HAVE_SYSTEMD
if (use_systemd) {
}
#endif
}
void *dummy,
const char *arg)
{
int b;
return err;
}
if (b < 1) {
return "ListenBacklog must be > 0";
}
ap_listenbacklog = b;
return NULL;
}
void *dummy,
const char *arg)
{
int b;
return err;
}
if (b < 1) {
return "ListenCoresBucketsRatio must be > 0";
}
ap_listencbratio = b;
return NULL;
}
void *dummy,
const char *arg)
{
return err;
}
if (s < 512 && s != 0) {
return "SendBufferSize must be >= 512 bytes, or 0 for system default.";
}
send_buffer_size = s;
return NULL;
}
void *dummy,
const char *arg)
{
return err;
}
if (s < 512 && s != 0) {
return "ReceiveBufferSize must be >= 512 bytes, or 0 for system default.";
}
receive_buffer_size = s;
return NULL;
}