listen.c revision 9591ec71b8911ecefbf6571333ff78fcb6efffa5
/* 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_config.h"
#include "http_core.h"
#include "ap_listen.h"
#include "http_log.h"
#include "mpm_common.h"
#ifdef HAVE_SYSTEMD
#include <systemd/sd-daemon.h>
#endif
/* we know core's module_index is 0 */
static ap_listen_rec *old_listeners;
static int ap_listenbacklog;
static int send_buffer_size;
static int receive_buffer_size;
#ifdef HAVE_SYSTEMD
static int use_systemd;
#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 (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 fd,
{
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;
}
} else {
}
}
{
void *data;
const char *userdata_key = "ap_systemd_listeners";
int sdc = sd_listen_fds(0);
if (sdc < 0) {
"open_systemd_listeners: Error parsing enviroment, sd_listen_fds returned %d",
sdc);
return 1;
}
if (sdc == 0) {
"open_systemd_listeners: At least one socket must be set.");
return 1;
}
last = ap_listeners;
}
if (rv != APR_SUCCESS) {
"open_systemd_listeners: failed to setup socket %d.", fd);
return 1;
}
}
else {
}
}
/* clear the enviroment on our second run
* so that none of our future children get confused.
*/
if (!data) {
}
else {
sd_listen_fds(1);
}
return 0;
}
#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) {
if (open_systemd_listeners(s->process) != 0) {
return 0;
}
}
else
#endif
{
return 0;
}
}
found = 0;
found = 1;
}
}
}
if (!found) {
}
}
return num_listeners;
}
AP_DECLARE_NONSTD(void) ap_close_listeners(void)
{
}
}
{
int n = 0;
}
else {
++n;
}
}
return n;
}
AP_DECLARE(void) ap_listen_pre_config(void)
{
ap_listeners = NULL;
}
{
return err;
}
return "Listen requires 1 or 2 arguments.";
}
#ifdef HAVE_SYSTEMD
use_systemd = 1;
if (ap_listeners != NULL) {
return "systemd socket activation support must be used exclusive of normal listeners.";
}
return NULL;
#else
return "systemd support was not compiled in.";
#endif
}
#ifdef HAVE_SYSTEMD
if (use_systemd) {
return "systemd socket activation support must be used exclusive of normal listeners.";
}
#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 {
}
}
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)
{
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;
}