mirror of https://github.com/morpheus65535/bazarr
524 lines
18 KiB
Python
524 lines
18 KiB
Python
|
##############################################################################
|
||
|
#
|
||
|
# Copyright (c) 2002 Zope Foundation and Contributors.
|
||
|
# All Rights Reserved.
|
||
|
#
|
||
|
# This software is subject to the provisions of the Zope Public License,
|
||
|
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
|
||
|
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
|
||
|
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||
|
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
|
||
|
# FOR A PARTICULAR PURPOSE.
|
||
|
#
|
||
|
##############################################################################
|
||
|
"""Adjustments are tunable parameters.
|
||
|
"""
|
||
|
import getopt
|
||
|
import socket
|
||
|
import warnings
|
||
|
|
||
|
from .compat import HAS_IPV6, WIN
|
||
|
from .proxy_headers import PROXY_HEADERS
|
||
|
|
||
|
truthy = frozenset(("t", "true", "y", "yes", "on", "1"))
|
||
|
|
||
|
KNOWN_PROXY_HEADERS = frozenset(
|
||
|
header.lower().replace("_", "-") for header in PROXY_HEADERS
|
||
|
)
|
||
|
|
||
|
|
||
|
def asbool(s):
|
||
|
"""Return the boolean value ``True`` if the case-lowered value of string
|
||
|
input ``s`` is any of ``t``, ``true``, ``y``, ``on``, or ``1``, otherwise
|
||
|
return the boolean value ``False``. If ``s`` is the value ``None``,
|
||
|
return ``False``. If ``s`` is already one of the boolean values ``True``
|
||
|
or ``False``, return it."""
|
||
|
if s is None:
|
||
|
return False
|
||
|
if isinstance(s, bool):
|
||
|
return s
|
||
|
s = str(s).strip()
|
||
|
return s.lower() in truthy
|
||
|
|
||
|
|
||
|
def asoctal(s):
|
||
|
"""Convert the given octal string to an actual number."""
|
||
|
return int(s, 8)
|
||
|
|
||
|
|
||
|
def aslist_cronly(value):
|
||
|
if isinstance(value, str):
|
||
|
value = filter(None, [x.strip() for x in value.splitlines()])
|
||
|
return list(value)
|
||
|
|
||
|
|
||
|
def aslist(value):
|
||
|
"""Return a list of strings, separating the input based on newlines
|
||
|
and, if flatten=True (the default), also split on spaces within
|
||
|
each line."""
|
||
|
values = aslist_cronly(value)
|
||
|
result = []
|
||
|
for value in values:
|
||
|
subvalues = value.split()
|
||
|
result.extend(subvalues)
|
||
|
return result
|
||
|
|
||
|
|
||
|
def asset(value):
|
||
|
return set(aslist(value))
|
||
|
|
||
|
|
||
|
def slash_fixed_str(s):
|
||
|
s = s.strip()
|
||
|
if s:
|
||
|
# always have a leading slash, replace any number of leading slashes
|
||
|
# with a single slash, and strip any trailing slashes
|
||
|
s = "/" + s.lstrip("/").rstrip("/")
|
||
|
return s
|
||
|
|
||
|
|
||
|
def str_iftruthy(s):
|
||
|
return str(s) if s else None
|
||
|
|
||
|
|
||
|
def as_socket_list(sockets):
|
||
|
"""Checks if the elements in the list are of type socket and
|
||
|
removes them if not."""
|
||
|
return [sock for sock in sockets if isinstance(sock, socket.socket)]
|
||
|
|
||
|
|
||
|
class _str_marker(str):
|
||
|
pass
|
||
|
|
||
|
|
||
|
class _int_marker(int):
|
||
|
pass
|
||
|
|
||
|
|
||
|
class _bool_marker:
|
||
|
pass
|
||
|
|
||
|
|
||
|
class Adjustments:
|
||
|
"""This class contains tunable parameters."""
|
||
|
|
||
|
_params = (
|
||
|
("host", str),
|
||
|
("port", int),
|
||
|
("ipv4", asbool),
|
||
|
("ipv6", asbool),
|
||
|
("listen", aslist),
|
||
|
("threads", int),
|
||
|
("trusted_proxy", str_iftruthy),
|
||
|
("trusted_proxy_count", int),
|
||
|
("trusted_proxy_headers", asset),
|
||
|
("log_untrusted_proxy_headers", asbool),
|
||
|
("clear_untrusted_proxy_headers", asbool),
|
||
|
("url_scheme", str),
|
||
|
("url_prefix", slash_fixed_str),
|
||
|
("backlog", int),
|
||
|
("recv_bytes", int),
|
||
|
("send_bytes", int),
|
||
|
("outbuf_overflow", int),
|
||
|
("outbuf_high_watermark", int),
|
||
|
("inbuf_overflow", int),
|
||
|
("connection_limit", int),
|
||
|
("cleanup_interval", int),
|
||
|
("channel_timeout", int),
|
||
|
("log_socket_errors", asbool),
|
||
|
("max_request_header_size", int),
|
||
|
("max_request_body_size", int),
|
||
|
("expose_tracebacks", asbool),
|
||
|
("ident", str_iftruthy),
|
||
|
("asyncore_loop_timeout", int),
|
||
|
("asyncore_use_poll", asbool),
|
||
|
("unix_socket", str),
|
||
|
("unix_socket_perms", asoctal),
|
||
|
("sockets", as_socket_list),
|
||
|
("channel_request_lookahead", int),
|
||
|
("server_name", str),
|
||
|
)
|
||
|
|
||
|
_param_map = dict(_params)
|
||
|
|
||
|
# hostname or IP address to listen on
|
||
|
host = _str_marker("0.0.0.0")
|
||
|
|
||
|
# TCP port to listen on
|
||
|
port = _int_marker(8080)
|
||
|
|
||
|
listen = ["{}:{}".format(host, port)]
|
||
|
|
||
|
# number of threads available for tasks
|
||
|
threads = 4
|
||
|
|
||
|
# Host allowed to overrid ``wsgi.url_scheme`` via header
|
||
|
trusted_proxy = None
|
||
|
|
||
|
# How many proxies we trust when chained
|
||
|
#
|
||
|
# X-Forwarded-For: 192.0.2.1, "[2001:db8::1]"
|
||
|
#
|
||
|
# or
|
||
|
#
|
||
|
# Forwarded: for=192.0.2.1, For="[2001:db8::1]"
|
||
|
#
|
||
|
# means there were (potentially), two proxies involved. If we know there is
|
||
|
# only 1 valid proxy, then that initial IP address "192.0.2.1" is not
|
||
|
# trusted and we completely ignore it. If there are two trusted proxies in
|
||
|
# the path, this value should be set to a higher number.
|
||
|
trusted_proxy_count = None
|
||
|
|
||
|
# Which of the proxy headers should we trust, this is a set where you
|
||
|
# either specify forwarded or one or more of forwarded-host, forwarded-for,
|
||
|
# forwarded-proto, forwarded-port.
|
||
|
trusted_proxy_headers = set()
|
||
|
|
||
|
# Would you like waitress to log warnings about untrusted proxy headers
|
||
|
# that were encountered while processing the proxy headers? This only makes
|
||
|
# sense to set when you have a trusted_proxy, and you expect the upstream
|
||
|
# proxy server to filter invalid headers
|
||
|
log_untrusted_proxy_headers = False
|
||
|
|
||
|
# Should waitress clear any proxy headers that are not deemed trusted from
|
||
|
# the environ? Change to True by default in 2.x
|
||
|
clear_untrusted_proxy_headers = _bool_marker
|
||
|
|
||
|
# default ``wsgi.url_scheme`` value
|
||
|
url_scheme = "http"
|
||
|
|
||
|
# default ``SCRIPT_NAME`` value, also helps reset ``PATH_INFO``
|
||
|
# when nonempty
|
||
|
url_prefix = ""
|
||
|
|
||
|
# server identity (sent in Server: header)
|
||
|
ident = "waitress"
|
||
|
|
||
|
# backlog is the value waitress passes to pass to socket.listen() This is
|
||
|
# the maximum number of incoming TCP connections that will wait in an OS
|
||
|
# queue for an available channel. From listen(1): "If a connection
|
||
|
# request arrives when the queue is full, the client may receive an error
|
||
|
# with an indication of ECONNREFUSED or, if the underlying protocol
|
||
|
# supports retransmission, the request may be ignored so that a later
|
||
|
# reattempt at connection succeeds."
|
||
|
backlog = 1024
|
||
|
|
||
|
# recv_bytes is the argument to pass to socket.recv().
|
||
|
recv_bytes = 8192
|
||
|
|
||
|
# deprecated setting controls how many bytes will be buffered before
|
||
|
# being flushed to the socket
|
||
|
send_bytes = 1
|
||
|
|
||
|
# A tempfile should be created if the pending output is larger than
|
||
|
# outbuf_overflow, which is measured in bytes. The default is 1MB. This
|
||
|
# is conservative.
|
||
|
outbuf_overflow = 1048576
|
||
|
|
||
|
# The app_iter will pause when pending output is larger than this value
|
||
|
# in bytes.
|
||
|
outbuf_high_watermark = 16777216
|
||
|
|
||
|
# A tempfile should be created if the pending input is larger than
|
||
|
# inbuf_overflow, which is measured in bytes. The default is 512K. This
|
||
|
# is conservative.
|
||
|
inbuf_overflow = 524288
|
||
|
|
||
|
# Stop creating new channels if too many are already active (integer).
|
||
|
# Each channel consumes at least one file descriptor, and, depending on
|
||
|
# the input and output body sizes, potentially up to three. The default
|
||
|
# is conservative, but you may need to increase the number of file
|
||
|
# descriptors available to the Waitress process on most platforms in
|
||
|
# order to safely change it (see ``ulimit -a`` "open files" setting).
|
||
|
# Note that this doesn't control the maximum number of TCP connections
|
||
|
# that can be waiting for processing; the ``backlog`` argument controls
|
||
|
# that.
|
||
|
connection_limit = 100
|
||
|
|
||
|
# Minimum seconds between cleaning up inactive channels.
|
||
|
cleanup_interval = 30
|
||
|
|
||
|
# Maximum seconds to leave an inactive connection open.
|
||
|
channel_timeout = 120
|
||
|
|
||
|
# Boolean: turn off to not log premature client disconnects.
|
||
|
log_socket_errors = True
|
||
|
|
||
|
# maximum number of bytes of all request headers combined (256K default)
|
||
|
max_request_header_size = 262144
|
||
|
|
||
|
# maximum number of bytes in request body (1GB default)
|
||
|
max_request_body_size = 1073741824
|
||
|
|
||
|
# expose tracebacks of uncaught exceptions
|
||
|
expose_tracebacks = False
|
||
|
|
||
|
# Path to a Unix domain socket to use.
|
||
|
unix_socket = None
|
||
|
|
||
|
# Path to a Unix domain socket to use.
|
||
|
unix_socket_perms = 0o600
|
||
|
|
||
|
# The socket options to set on receiving a connection. It is a list of
|
||
|
# (level, optname, value) tuples. TCP_NODELAY disables the Nagle
|
||
|
# algorithm for writes (Waitress already buffers its writes).
|
||
|
socket_options = [
|
||
|
(socket.SOL_TCP, socket.TCP_NODELAY, 1),
|
||
|
]
|
||
|
|
||
|
# The asyncore.loop timeout value
|
||
|
asyncore_loop_timeout = 1
|
||
|
|
||
|
# The asyncore.loop flag to use poll() instead of the default select().
|
||
|
asyncore_use_poll = False
|
||
|
|
||
|
# Enable IPv4 by default
|
||
|
ipv4 = True
|
||
|
|
||
|
# Enable IPv6 by default
|
||
|
ipv6 = True
|
||
|
|
||
|
# A list of sockets that waitress will use to accept connections. They can
|
||
|
# be used for e.g. socket activation
|
||
|
sockets = []
|
||
|
|
||
|
# By setting this to a value larger than zero, each channel stays readable
|
||
|
# and continues to read requests from the client even if a request is still
|
||
|
# running, until the number of buffered requests exceeds this value.
|
||
|
# This allows detecting if a client closed the connection while its request
|
||
|
# is being processed.
|
||
|
channel_request_lookahead = 0
|
||
|
|
||
|
# This setting controls the SERVER_NAME of the WSGI environment, this is
|
||
|
# only ever used if the remote client sent a request without a Host header
|
||
|
# (or when using the Proxy settings, without forwarding a Host header)
|
||
|
server_name = "waitress.invalid"
|
||
|
|
||
|
def __init__(self, **kw):
|
||
|
|
||
|
if "listen" in kw and ("host" in kw or "port" in kw):
|
||
|
raise ValueError("host or port may not be set if listen is set.")
|
||
|
|
||
|
if "listen" in kw and "sockets" in kw:
|
||
|
raise ValueError("socket may not be set if listen is set.")
|
||
|
|
||
|
if "sockets" in kw and ("host" in kw or "port" in kw):
|
||
|
raise ValueError("host or port may not be set if sockets is set.")
|
||
|
|
||
|
if "sockets" in kw and "unix_socket" in kw:
|
||
|
raise ValueError("unix_socket may not be set if sockets is set")
|
||
|
|
||
|
if "unix_socket" in kw and ("host" in kw or "port" in kw):
|
||
|
raise ValueError("unix_socket may not be set if host or port is set")
|
||
|
|
||
|
if "unix_socket" in kw and "listen" in kw:
|
||
|
raise ValueError("unix_socket may not be set if listen is set")
|
||
|
|
||
|
if "send_bytes" in kw:
|
||
|
warnings.warn(
|
||
|
"send_bytes will be removed in a future release", DeprecationWarning
|
||
|
)
|
||
|
|
||
|
for k, v in kw.items():
|
||
|
if k not in self._param_map:
|
||
|
raise ValueError("Unknown adjustment %r" % k)
|
||
|
setattr(self, k, self._param_map[k](v))
|
||
|
|
||
|
if not isinstance(self.host, _str_marker) or not isinstance(
|
||
|
self.port, _int_marker
|
||
|
):
|
||
|
self.listen = ["{}:{}".format(self.host, self.port)]
|
||
|
|
||
|
enabled_families = socket.AF_UNSPEC
|
||
|
|
||
|
if not self.ipv4 and not HAS_IPV6: # pragma: no cover
|
||
|
raise ValueError(
|
||
|
"IPv4 is disabled but IPv6 is not available. Cowardly refusing to start."
|
||
|
)
|
||
|
|
||
|
if self.ipv4 and not self.ipv6:
|
||
|
enabled_families = socket.AF_INET
|
||
|
|
||
|
if not self.ipv4 and self.ipv6 and HAS_IPV6:
|
||
|
enabled_families = socket.AF_INET6
|
||
|
|
||
|
wanted_sockets = []
|
||
|
hp_pairs = []
|
||
|
for i in self.listen:
|
||
|
if ":" in i:
|
||
|
(host, port) = i.rsplit(":", 1)
|
||
|
|
||
|
# IPv6 we need to make sure that we didn't split on the address
|
||
|
if "]" in port: # pragma: nocover
|
||
|
(host, port) = (i, str(self.port))
|
||
|
else:
|
||
|
(host, port) = (i, str(self.port))
|
||
|
|
||
|
if WIN: # pragma: no cover
|
||
|
try:
|
||
|
# Try turning the port into an integer
|
||
|
port = int(port)
|
||
|
|
||
|
except Exception:
|
||
|
raise ValueError(
|
||
|
"Windows does not support service names instead of port numbers"
|
||
|
)
|
||
|
|
||
|
try:
|
||
|
if "[" in host and "]" in host: # pragma: nocover
|
||
|
host = host.strip("[").rstrip("]")
|
||
|
|
||
|
if host == "*":
|
||
|
host = None
|
||
|
|
||
|
for s in socket.getaddrinfo(
|
||
|
host,
|
||
|
port,
|
||
|
enabled_families,
|
||
|
socket.SOCK_STREAM,
|
||
|
socket.IPPROTO_TCP,
|
||
|
socket.AI_PASSIVE,
|
||
|
):
|
||
|
(family, socktype, proto, _, sockaddr) = s
|
||
|
|
||
|
# It seems that getaddrinfo() may sometimes happily return
|
||
|
# the same result multiple times, this of course makes
|
||
|
# bind() very unhappy...
|
||
|
#
|
||
|
# Split on %, and drop the zone-index from the host in the
|
||
|
# sockaddr. Works around a bug in OS X whereby
|
||
|
# getaddrinfo() returns the same link-local interface with
|
||
|
# two different zone-indices (which makes no sense what so
|
||
|
# ever...) yet treats them equally when we attempt to bind().
|
||
|
if (
|
||
|
sockaddr[1] == 0
|
||
|
or (sockaddr[0].split("%", 1)[0], sockaddr[1]) not in hp_pairs
|
||
|
):
|
||
|
wanted_sockets.append((family, socktype, proto, sockaddr))
|
||
|
hp_pairs.append((sockaddr[0].split("%", 1)[0], sockaddr[1]))
|
||
|
|
||
|
except Exception:
|
||
|
raise ValueError("Invalid host/port specified.")
|
||
|
|
||
|
if self.trusted_proxy_count is not None and self.trusted_proxy is None:
|
||
|
raise ValueError(
|
||
|
"trusted_proxy_count has no meaning without setting " "trusted_proxy"
|
||
|
)
|
||
|
|
||
|
elif self.trusted_proxy_count is None:
|
||
|
self.trusted_proxy_count = 1
|
||
|
|
||
|
if self.trusted_proxy_headers and self.trusted_proxy is None:
|
||
|
raise ValueError(
|
||
|
"trusted_proxy_headers has no meaning without setting " "trusted_proxy"
|
||
|
)
|
||
|
|
||
|
if self.trusted_proxy_headers:
|
||
|
self.trusted_proxy_headers = {
|
||
|
header.lower() for header in self.trusted_proxy_headers
|
||
|
}
|
||
|
|
||
|
unknown_values = self.trusted_proxy_headers - KNOWN_PROXY_HEADERS
|
||
|
if unknown_values:
|
||
|
raise ValueError(
|
||
|
"Received unknown trusted_proxy_headers value (%s) expected one "
|
||
|
"of %s"
|
||
|
% (", ".join(unknown_values), ", ".join(KNOWN_PROXY_HEADERS))
|
||
|
)
|
||
|
|
||
|
if (
|
||
|
"forwarded" in self.trusted_proxy_headers
|
||
|
and self.trusted_proxy_headers - {"forwarded"}
|
||
|
):
|
||
|
raise ValueError(
|
||
|
"The Forwarded proxy header and the "
|
||
|
"X-Forwarded-{By,Host,Proto,Port,For} headers are mutually "
|
||
|
"exclusive. Can't trust both!"
|
||
|
)
|
||
|
|
||
|
elif self.trusted_proxy is not None:
|
||
|
warnings.warn(
|
||
|
"No proxy headers were marked as trusted, but trusted_proxy was set. "
|
||
|
"Implicitly trusting X-Forwarded-Proto for backwards compatibility. "
|
||
|
"This will be removed in future versions of waitress.",
|
||
|
DeprecationWarning,
|
||
|
)
|
||
|
self.trusted_proxy_headers = {"x-forwarded-proto"}
|
||
|
|
||
|
if self.clear_untrusted_proxy_headers is _bool_marker:
|
||
|
warnings.warn(
|
||
|
"In future versions of Waitress clear_untrusted_proxy_headers will be "
|
||
|
"set to True by default. You may opt-out by setting this value to "
|
||
|
"False, or opt-in explicitly by setting this to True.",
|
||
|
DeprecationWarning,
|
||
|
)
|
||
|
self.clear_untrusted_proxy_headers = False
|
||
|
|
||
|
self.listen = wanted_sockets
|
||
|
|
||
|
self.check_sockets(self.sockets)
|
||
|
|
||
|
@classmethod
|
||
|
def parse_args(cls, argv):
|
||
|
"""Pre-parse command line arguments for input into __init__. Note that
|
||
|
this does not cast values into adjustment types, it just creates a
|
||
|
dictionary suitable for passing into __init__, where __init__ does the
|
||
|
casting.
|
||
|
"""
|
||
|
long_opts = ["help", "call"]
|
||
|
for opt, cast in cls._params:
|
||
|
opt = opt.replace("_", "-")
|
||
|
if cast is asbool:
|
||
|
long_opts.append(opt)
|
||
|
long_opts.append("no-" + opt)
|
||
|
else:
|
||
|
long_opts.append(opt + "=")
|
||
|
|
||
|
kw = {
|
||
|
"help": False,
|
||
|
"call": False,
|
||
|
}
|
||
|
|
||
|
opts, args = getopt.getopt(argv, "", long_opts)
|
||
|
for opt, value in opts:
|
||
|
param = opt.lstrip("-").replace("-", "_")
|
||
|
|
||
|
if param == "listen":
|
||
|
kw["listen"] = "{} {}".format(kw.get("listen", ""), value)
|
||
|
continue
|
||
|
|
||
|
if param.startswith("no_"):
|
||
|
param = param[3:]
|
||
|
kw[param] = "false"
|
||
|
elif param in ("help", "call"):
|
||
|
kw[param] = True
|
||
|
elif cls._param_map[param] is asbool:
|
||
|
kw[param] = "true"
|
||
|
else:
|
||
|
kw[param] = value
|
||
|
|
||
|
return kw, args
|
||
|
|
||
|
@classmethod
|
||
|
def check_sockets(cls, sockets):
|
||
|
has_unix_socket = False
|
||
|
has_inet_socket = False
|
||
|
has_unsupported_socket = False
|
||
|
for sock in sockets:
|
||
|
if (
|
||
|
sock.family == socket.AF_INET or sock.family == socket.AF_INET6
|
||
|
) and sock.type == socket.SOCK_STREAM:
|
||
|
has_inet_socket = True
|
||
|
elif (
|
||
|
hasattr(socket, "AF_UNIX")
|
||
|
and sock.family == socket.AF_UNIX
|
||
|
and sock.type == socket.SOCK_STREAM
|
||
|
):
|
||
|
has_unix_socket = True
|
||
|
else:
|
||
|
has_unsupported_socket = True
|
||
|
if has_unix_socket and has_inet_socket:
|
||
|
raise ValueError("Internet and UNIX sockets may not be mixed.")
|
||
|
if has_unsupported_socket:
|
||
|
raise ValueError("Only Internet or UNIX stream sockets may be used.")
|