9985748381

Committed 18 Jul 2024 04:56AM UTC coverage: 80.552% (-0.007%) from 80.559%

Build # 9985748381

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1544 from pbiering/option-strip-domain-name-from-login

Option strip domain name from login

Run Details

1687 of 2314 branches covered (72.9%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 1 file covered. (100.0%)

2 existing lines in 1 file now uncovered.

3623 of 4278 relevant lines covered (84.69%)

15.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.82

/radicale/server.py

# This file is part of Radicale - CalDAV and CardDAV server
# Copyright © 2008 Nicolas Kandel
# Copyright © 2008 Pascal Halter
# Copyright © 2008-2017 Guillaume Ayoub
# Copyright © 2017-2019 Unrud <unrud@outlook.com>
# Copyright © 2024-2024 Peter Bieringer <pb@bieringer.de>
#
# This library is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Radicale.  If not, see <http://www.gnu.org/licenses/>.

"""
Built-in WSGI server.

"""

import http
import select
import socket
import socketserver
import ssl
import sys
import wsgiref.simple_server
from typing import (Any, Callable, Dict, List, MutableMapping, Optional, Set,
                    Tuple, Union)
from urllib.parse import unquote

from radicale import Application, config
from radicale.log import logger

COMPAT_EAI_ADDRFAMILY: int
if hasattr(socket, "EAI_ADDRFAMILY"):
    COMPAT_EAI_ADDRFAMILY = socket.EAI_ADDRFAMILY  # type:ignore[attr-defined]
elif hasattr(socket, "EAI_NONAME"):
    # Windows and BSD don't have a special error code for this
    COMPAT_EAI_ADDRFAMILY = socket.EAI_NONAME
COMPAT_EAI_NODATA: int
if hasattr(socket, "EAI_NODATA"):
    COMPAT_EAI_NODATA = socket.EAI_NODATA
elif hasattr(socket, "EAI_NONAME"):
    # Windows and BSD don't have a special error code for this
    COMPAT_EAI_NODATA = socket.EAI_NONAME
COMPAT_IPPROTO_IPV6: int
if hasattr(socket, "IPPROTO_IPV6"):
    COMPAT_IPPROTO_IPV6 = socket.IPPROTO_IPV6
elif sys.platform == "win32":
    # HACK: https://bugs.python.org/issue29515
    COMPAT_IPPROTO_IPV6 = 41


# IPv4 (host, port) and IPv6 (host, port, flowinfo, scopeid)
ADDRESS_TYPE = Union[Tuple[Union[str, bytes, bytearray], int],
                     Tuple[str, int, int, int]]


def format_address(address: ADDRESS_TYPE) -> str:
    host, port, *_ = address
    if not isinstance(host, str):
        raise NotImplementedError("Unsupported address format: %r" %
                                  (address,))
    if host.find(":") == -1:
        return "%s:%d" % (host, port)
    else:
        return "[%s]:%d" % (host, port)


class ParallelHTTPServer(socketserver.ThreadingMixIn,
                         wsgiref.simple_server.WSGIServer):

    configuration: config.Configuration
    worker_sockets: Set[socket.socket]
    _timeout: float

    # We wait for child threads ourself (ThreadingMixIn)
    block_on_close: bool = False
    daemon_threads: bool = True

    def __init__(self, configuration: config.Configuration, family: int,
                 address: Tuple[str, int], RequestHandlerClass:
                 Callable[..., http.server.BaseHTTPRequestHandler]) -> None:
        self.configuration = configuration
        self.address_family = family
        super().__init__(address, RequestHandlerClass)
        self.worker_sockets = set()
        self._timeout = configuration.get("server", "timeout")

    def server_bind(self) -> None:
        if self.address_family == socket.AF_INET6:
            # Only allow IPv6 connections to the IPv6 socket
            self.socket.setsockopt(COMPAT_IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
        super().server_bind()

    def get_request(  # type:ignore[override]
            self) -> Tuple[socket.socket, Tuple[ADDRESS_TYPE, socket.socket]]:
        # Set timeout for client
        request: socket.socket
        client_address: ADDRESS_TYPE
        request, client_address = super().get_request()  # type:ignore[misc]
        if self._timeout > 0:
            request.settimeout(self._timeout)
        worker_socket, worker_socket_out = socket.socketpair()
        self.worker_sockets.add(worker_socket_out)
        # HACK: Forward `worker_socket` via `client_address` return value
        # to worker thread.
        # The super class calls `verify_request`, `process_request` and
        # `handle_error` with modified `client_address` value.
        return request, (client_address, worker_socket)

    def verify_request(  # type:ignore[override]
            self, request: socket.socket, client_address_and_socket:
            Tuple[ADDRESS_TYPE, socket.socket]) -> bool:
        return True

    def process_request(  # type:ignore[override]
            self, request: socket.socket, client_address_and_socket:
            Tuple[ADDRESS_TYPE, socket.socket]) -> None:
        # HACK: Super class calls `finish_request` in new thread with
        # `client_address_and_socket`
        return super().process_request(
            request, client_address_and_socket)  # type:ignore[arg-type]

    def finish_request(  # type:ignore[override]
            self, request: socket.socket, client_address_and_socket:
            Tuple[ADDRESS_TYPE, socket.socket]) -> None:
        # HACK: Unpack `client_address_and_socket` and call super class
        # `finish_request` with original `client_address`
        client_address, worker_socket = client_address_and_socket
        try:
            return self.finish_request_locked(request, client_address)
        finally:
            worker_socket.close()

    def finish_request_locked(self, request: socket.socket,
                              client_address: ADDRESS_TYPE) -> None:
        return super().finish_request(
            request, client_address)  # type:ignore[arg-type]

    def handle_error(  # type:ignore[override]
            self, request: socket.socket,
            client_address_or_client_address_and_socket:
            Union[ADDRESS_TYPE, Tuple[ADDRESS_TYPE, socket.socket]]) -> None:
        # HACK: This method can be called with the modified
        # `client_address_and_socket` or the original `client_address` value
        e = sys.exc_info()[1]
        assert e is not None
        if isinstance(e, socket.timeout):
            logger.info("Client timed out", exc_info=True)
        else:
            logger.error("An exception occurred during request: %s",
                         sys.exc_info()[1], exc_info=True)


class ParallelHTTPSServer(ParallelHTTPServer):

    def server_bind(self) -> None:
        super().server_bind()
        # Wrap the TCP socket in an SSL socket
        certfile: str = self.configuration.get("server", "certificate")
        keyfile: str = self.configuration.get("server", "key")
        cafile: str = self.configuration.get("server", "certificate_authority")
        # Test if the files can be read
        for name, filename in [("certificate", certfile), ("key", keyfile),
                               ("certificate_authority", cafile)]:
            type_name = config.DEFAULT_CONFIG_SCHEMA["server"][name][
                "type"].__name__
            source = self.configuration.get_source("server", name)
            if name == "certificate_authority" and not filename:
                continue
            try:
                open(filename, "r").close()
            except OSError as e:
                raise RuntimeError(
                    "Invalid %s value for option %r in section %r in %s: %r "
                    "(%s)" % (type_name, name, "server", source, filename,
                              e)) from e
        context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        context.load_cert_chain(certfile=certfile, keyfile=keyfile)
        if cafile:
            context.load_verify_locations(cafile=cafile)
            context.verify_mode = ssl.CERT_REQUIRED
        self.socket = context.wrap_socket(
            self.socket, server_side=True, do_handshake_on_connect=False)

    def finish_request_locked(  # type:ignore[override]
            self, request: ssl.SSLSocket, client_address: ADDRESS_TYPE
            ) -> None:
        try:
            try:
                request.do_handshake()
            except socket.timeout:
                raise
            except Exception as e:
                raise RuntimeError("SSL handshake failed: %s" % e) from e
        except Exception:
            try:
                self.handle_error(request, client_address)
            finally:
                self.shutdown_request(request)  # type:ignore[attr-defined]
            return
        return super().finish_request_locked(request, client_address)


class ServerHandler(wsgiref.simple_server.ServerHandler):

    # Don't pollute WSGI environ with OS environment
    os_environ: MutableMapping[str, str] = {}

    def log_exception(self, exc_info) -> None:
        logger.error("An exception occurred during request: %s",
                     exc_info[1], exc_info=exc_info)  # type:ignore[arg-type]


class RequestHandler(wsgiref.simple_server.WSGIRequestHandler):
    """HTTP requests handler."""

    # HACK: Assigned in `socketserver.StreamRequestHandler`
    connection: socket.socket

    def log_request(self, code: Union[int, str] = "-",
                    size: Union[int, str] = "-") -> None:
        pass  # Disable request logging.

    def log_error(self, format_: str, *args: Any) -> None:
        logger.error("An error occurred during request: %s", format_ % args)

    def get_environ(self) -> Dict[str, Any]:
        env = super().get_environ()
        if isinstance(self.connection, ssl.SSLSocket):
            # The certificate can be evaluated by the auth module
            env["REMOTE_CERTIFICATE"] = self.connection.getpeercert()
        # Parent class only tries latin1 encoding
        env["PATH_INFO"] = unquote(self.path.split("?", 1)[0])
        return env

    def handle(self) -> None:
        """Copy of WSGIRequestHandler.handle with different ServerHandler"""

        self.raw_requestline = self.rfile.readline(65537)
        if len(self.raw_requestline) > 65536:
            self.requestline = ""
            self.request_version = ""
            self.command = ""
            self.send_error(414)
            return

        if not self.parse_request():
            return

        handler = ServerHandler(
            self.rfile, self.wfile, self.get_stderr(), self.get_environ()
        )
        handler.request_handler = self  # type:ignore[attr-defined]
        app = self.server.get_app()  # type:ignore[attr-defined]
        handler.run(app)


def serve(configuration: config.Configuration,
          shutdown_socket: Optional[socket.socket] = None) -> None:
    """Serve radicale from configuration.

    `shutdown_socket` can be used to gracefully shutdown the server.
    The socket can be created with `socket.socketpair()`, when the other socket
    gets closed the server stops accepting new requests by clients and the
    function returns after all active requests are finished.

    """

    logger.info("Starting Radicale")
    # Copy configuration before modifying
    configuration = configuration.copy()
    configuration.update({"server": {"_internal_server": "True"}}, "server",
                         privileged=True)

    use_ssl: bool = configuration.get("server", "ssl")
    server_class = ParallelHTTPSServer if use_ssl else ParallelHTTPServer
    application = Application(configuration)
    servers = {}
    try:
        hosts: List[Tuple[str, int]] = configuration.get("server", "hosts")
        for address_port in hosts:
            # retrieve IPv4/IPv6 address of address
            try:
                getaddrinfo = socket.getaddrinfo(address_port[0], address_port[1], 0, socket.SOCK_STREAM, socket.IPPROTO_TCP)
            except OSError as e:
                logger.warn("cannot retrieve IPv4 or IPv6 address of '%s': %s" % (format_address(address_port), e))
                continue
            logger.debug("getaddrinfo of '%s': %s" % (format_address(address_port), getaddrinfo))
            for (address_family, socket_kind, socket_proto, socket_flags, socket_address) in getaddrinfo:
                logger.debug("try to create server socket on '%s'" % (format_address(socket_address)))
                try:
                    server = server_class(configuration, address_family, (socket_address[0], socket_address[1]), RequestHandler)
                except OSError as e:
                    logger.warn("cannot create server socket on '%s': %s" % (format_address(socket_address), e))
                    continue
                servers[server.socket] = server
                server.set_app(application)
                logger.info("Listening on %r%s",
                            format_address(server.server_address),
                            " with SSL" if use_ssl else "")
        if not servers:
            raise RuntimeError("No servers started")

        # Mainloop
        select_timeout = None
        if sys.platform == "win32":
            # Fallback to busy waiting. (select(...) blocks SIGINT on Windows.)
            select_timeout = 1.0
        max_connections: int = configuration.get("server", "max_connections")
        logger.info("Radicale server ready")
        while True:
            rlist: List[socket.socket] = []
            # Wait for finished clients
            for server in servers.values():
                rlist.extend(server.worker_sockets)
            # Accept new connections if max_connections is not reached
            if max_connections <= 0 or len(rlist) < max_connections:
                rlist.extend(servers)
            # Use socket to get notified of program shutdown
            if shutdown_socket is not None:
                rlist.append(shutdown_socket)
            rlist, _, _ = select.select(rlist, [], [], select_timeout)
            rset = set(rlist)
            if shutdown_socket in rset:
                logger.info("Stopping Radicale")
                break
            for server in servers.values():
                finished_sockets = server.worker_sockets.intersection(rset)
                for s in finished_sockets:
                    s.close()
                    server.worker_sockets.remove(s)
                    rset.remove(s)
                if finished_sockets:
                    server.service_actions()
            if rset:
                active_server = servers.get(rset.pop())
                if active_server:
                    active_server.handle_request()
    finally:
        # Wait for clients to finish and close servers
        for server in servers.values():
            for s in server.worker_sockets:
                s.recv(1)
                s.close()
            server.server_close()

1	# This file is part of Radicale - CalDAV and CardDAV server
2	# Copyright © 2008 Nicolas Kandel
3	# Copyright © 2008 Pascal Halter
4	# Copyright © 2008-2017 Guillaume Ayoub
5	# Copyright © 2017-2019 Unrud <unrud@outlook.com>
6	# Copyright © 2024-2024 Peter Bieringer <pb@bieringer.de>
7	#
8	# This library is free software: you can redistribute it and/or modify
9	# it under the terms of the GNU General Public License as published by
10	# the Free Software Foundation, either version 3 of the License, or
11	# (at your option) any later version.
12	#
13	# This library is distributed in the hope that it will be useful,
14	# but WITHOUT ANY WARRANTY; without even the implied warranty of
15	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	# GNU General Public License for more details.
17	#
18	# You should have received a copy of the GNU General Public License
19	# along with Radicale. If not, see <http://www.gnu.org/licenses/>.
20
21	"""
22	Built-in WSGI server.
23
24	"""
25
26	import http	19✔
27	import select	19✔
28	import socket	19✔
29	import socketserver	19✔
30	import ssl	19✔
31	import sys	19✔
32	import wsgiref.simple_server	19✔
33	from typing import (Any, Callable, Dict, List, MutableMapping, Optional, Set,	19✔
34	Tuple, Union)
35	from urllib.parse import unquote	19✔
36
37	from radicale import Application, config	19✔
38	from radicale.log import logger	19✔
39
40	COMPAT_EAI_ADDRFAMILY: int	19✔
41	if hasattr(socket, "EAI_ADDRFAMILY"):	19✔
42	COMPAT_EAI_ADDRFAMILY = socket.EAI_ADDRFAMILY # type:ignore[attr-defined]	14✔
43	elif hasattr(socket, "EAI_NONAME"):	5!
44	# Windows and BSD don't have a special error code for this
45	COMPAT_EAI_ADDRFAMILY = socket.EAI_NONAME	5✔
46	COMPAT_EAI_NODATA: int	19✔
47	if hasattr(socket, "EAI_NODATA"):	19!
48	COMPAT_EAI_NODATA = socket.EAI_NODATA	19✔
49	elif hasattr(socket, "EAI_NONAME"):	×
50	# Windows and BSD don't have a special error code for this
51	COMPAT_EAI_NODATA = socket.EAI_NONAME	×
52	COMPAT_IPPROTO_IPV6: int	19✔
53	if hasattr(socket, "IPPROTO_IPV6"):	19!
54	COMPAT_IPPROTO_IPV6 = socket.IPPROTO_IPV6	19✔
55	elif sys.platform == "win32":	×
56	# HACK: https://bugs.python.org/issue29515
57	COMPAT_IPPROTO_IPV6 = 41	×
58
59
60	# IPv4 (host, port) and IPv6 (host, port, flowinfo, scopeid)
61	ADDRESS_TYPE = Union[Tuple[Union[str, bytes, bytearray], int],	19✔
62	Tuple[str, int, int, int]]
63
64
65	def format_address(address: ADDRESS_TYPE) -> str:	19✔
66	host, port, *_ = address	19✔
67	if not isinstance(host, str):	19✔
68	raise NotImplementedError("Unsupported address format: %r" %
69	(address,))
70	if host.find(":") == -1:	19!
71	return "%s:%d" % (host, port)	19✔
72	else:
73	return "[%s]:%d" % (host, port)	19✔
74
75
76	class ParallelHTTPServer(socketserver.ThreadingMixIn,	19✔
77	wsgiref.simple_server.WSGIServer):
78
79	configuration: config.Configuration	19✔
80	worker_sockets: Set[socket.socket]	19✔
81	_timeout: float	19✔
82
83	# We wait for child threads ourself (ThreadingMixIn)
84	block_on_close: bool = False	19✔
85	daemon_threads: bool = True	19✔
86
87	def __init__(self, configuration: config.Configuration, family: int,	19✔
88	address: Tuple[str, int], RequestHandlerClass:
89	Callable[..., http.server.BaseHTTPRequestHandler]) -> None:
90	self.configuration = configuration	19✔
91	self.address_family = family	19✔
92	super().__init__(address, RequestHandlerClass)	19✔
93	self.worker_sockets = set()	19✔
94	self._timeout = configuration.get("server", "timeout")	19✔
95
96	def server_bind(self) -> None:	19✔
97	if self.address_family == socket.AF_INET6:	19✔
98	# Only allow IPv6 connections to the IPv6 socket
99	self.socket.setsockopt(COMPAT_IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)	19✔
100	super().server_bind()	19✔
101
102	def get_request( # type:ignore[override]	19✔
103	self) -> Tuple[socket.socket, Tuple[ADDRESS_TYPE, socket.socket]]:
104	# Set timeout for client
105	request: socket.socket
106	client_address: ADDRESS_TYPE
107	request, client_address = super().get_request() # type:ignore[misc]	19✔
108	if self._timeout > 0:	19!
109	request.settimeout(self._timeout)	19✔
110	worker_socket, worker_socket_out = socket.socketpair()	19✔
111	self.worker_sockets.add(worker_socket_out)	19✔
112	# HACK: Forward `worker_socket` via `client_address` return value
113	# to worker thread.
114	# The super class calls `verify_request`, `process_request` and
115	# `handle_error` with modified `client_address` value.
116	return request, (client_address, worker_socket)	19✔
117
118	def verify_request( # type:ignore[override]	19✔
119	self, request: socket.socket, client_address_and_socket:
120	Tuple[ADDRESS_TYPE, socket.socket]) -> bool:
121	return True	19✔
122
123	def process_request( # type:ignore[override]	19✔
124	self, request: socket.socket, client_address_and_socket:
125	Tuple[ADDRESS_TYPE, socket.socket]) -> None:
126	# HACK: Super class calls `finish_request` in new thread with
127	# `client_address_and_socket`
128	return super().process_request(	19✔
129	request, client_address_and_socket) # type:ignore[arg-type]
130
131	def finish_request( # type:ignore[override]	19✔
132	self, request: socket.socket, client_address_and_socket:
133	Tuple[ADDRESS_TYPE, socket.socket]) -> None:
134	# HACK: Unpack `client_address_and_socket` and call super class
135	# `finish_request` with original `client_address`
136	client_address, worker_socket = client_address_and_socket	19✔
137	try:	19✔
138	return self.finish_request_locked(request, client_address)	19✔
139	finally:
140	worker_socket.close()	19✔
141
142	def finish_request_locked(self, request: socket.socket,	19✔
143	client_address: ADDRESS_TYPE) -> None:
144	return super().finish_request(	19✔
145	request, client_address) # type:ignore[arg-type]
146
147	def handle_error( # type:ignore[override]	19✔
148	self, request: socket.socket,
149	client_address_or_client_address_and_socket:
150	Union[ADDRESS_TYPE, Tuple[ADDRESS_TYPE, socket.socket]]) -> None:
151	# HACK: This method can be called with the modified
152	# `client_address_and_socket` or the original `client_address` value
153	e = sys.exc_info()[1]	×
154	assert e is not None	×
155	if isinstance(e, socket.timeout):	×
156	logger.info("Client timed out", exc_info=True)	×
157	else:
158	logger.error("An exception occurred during request: %s",	×
159	sys.exc_info()[1], exc_info=True)
160
161
162	class ParallelHTTPSServer(ParallelHTTPServer):	19✔
163
164	def server_bind(self) -> None:	19✔
165	super().server_bind()	19✔
166	# Wrap the TCP socket in an SSL socket
167	certfile: str = self.configuration.get("server", "certificate")	19✔
168	keyfile: str = self.configuration.get("server", "key")	19✔
169	cafile: str = self.configuration.get("server", "certificate_authority")	19✔
170	# Test if the files can be read
171	for name, filename in [("certificate", certfile), ("key", keyfile),	19✔
172	("certificate_authority", cafile)]:
173	type_name = config.DEFAULT_CONFIG_SCHEMA["server"][name][	19✔
174	"type"].__name__
175	source = self.configuration.get_source("server", name)	19✔
176	if name == "certificate_authority" and not filename:	19✔
177	continue	19✔
178	try:	19✔
179	open(filename, "r").close()	19✔
180	except OSError as e:	×
181	raise RuntimeError(	×
182	"Invalid %s value for option %r in section %r in %s: %r "
183	"(%s)" % (type_name, name, "server", source, filename,
184	e)) from e
185	context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)	19✔
186	context.load_cert_chain(certfile=certfile, keyfile=keyfile)	19✔
187	if cafile:	19!
188	context.load_verify_locations(cafile=cafile)	×
189	context.verify_mode = ssl.CERT_REQUIRED	×
190	self.socket = context.wrap_socket(	19✔
191	self.socket, server_side=True, do_handshake_on_connect=False)
192
193	def finish_request_locked( # type:ignore[override]	19✔
194	self, request: ssl.SSLSocket, client_address: ADDRESS_TYPE
195	) -> None:
196	try:	19✔
197	try:	19✔
198	request.do_handshake()	19✔
199	except socket.timeout:	×
200	raise	×
201	except Exception as e:	×
202	raise RuntimeError("SSL handshake failed: %s" % e) from e	×
203	except Exception:	×
204	try:	×
205	self.handle_error(request, client_address)	×
206	finally:
207	self.shutdown_request(request) # type:ignore[attr-defined]	×
208	return	×
209	return super().finish_request_locked(request, client_address)	19✔
210
211
212	class ServerHandler(wsgiref.simple_server.ServerHandler):	19✔
213
214	# Don't pollute WSGI environ with OS environment
215	os_environ: MutableMapping[str, str] = {}	19✔
216
217	def log_exception(self, exc_info) -> None:	19✔
218	logger.error("An exception occurred during request: %s",	×
219	exc_info[1], exc_info=exc_info) # type:ignore[arg-type]
220
221
222	class RequestHandler(wsgiref.simple_server.WSGIRequestHandler):	19✔
223	"""HTTP requests handler."""
224
225	# HACK: Assigned in `socketserver.StreamRequestHandler`
226	connection: socket.socket	19✔
227
228	def log_request(self, code: Union[int, str] = "-",	19✔
229	size: Union[int, str] = "-") -> None:
230	pass # Disable request logging.	17✔
231
232	def log_error(self, format_: str, *args: Any) -> None:	19✔
233	logger.error("An error occurred during request: %s", format_ % args)	×
234
235	def get_environ(self) -> Dict[str, Any]:	19✔
236	env = super().get_environ()	19✔
237	if isinstance(self.connection, ssl.SSLSocket):	19✔
238	# The certificate can be evaluated by the auth module
239	env["REMOTE_CERTIFICATE"] = self.connection.getpeercert()	19✔
240	# Parent class only tries latin1 encoding
241	env["PATH_INFO"] = unquote(self.path.split("?", 1)[0])	19✔
242	return env	19✔
243
244	def handle(self) -> None:	19✔
245	"""Copy of WSGIRequestHandler.handle with different ServerHandler"""
246
247	self.raw_requestline = self.rfile.readline(65537)	19✔
248	if len(self.raw_requestline) > 65536:	19!
249	self.requestline = ""	×
250	self.request_version = ""	×
251	self.command = ""	×
252	self.send_error(414)	×
253	return	×
254
255	if not self.parse_request():	19!
256	return	×
257
258	handler = ServerHandler(	19✔
259	self.rfile, self.wfile, self.get_stderr(), self.get_environ()
260	)
261	handler.request_handler = self # type:ignore[attr-defined]	19✔
262	app = self.server.get_app() # type:ignore[attr-defined]	19✔
263	handler.run(app)	19✔
264
265
266	def serve(configuration: config.Configuration,	19✔
267	shutdown_socket: Optional[socket.socket] = None) -> None:
268	"""Serve radicale from configuration.
269
270	`shutdown_socket` can be used to gracefully shutdown the server.
271	The socket can be created with `socket.socketpair()`, when the other socket
272	gets closed the server stops accepting new requests by clients and the
273	function returns after all active requests are finished.
274
275	"""
276
277	logger.info("Starting Radicale")	19✔
278	# Copy configuration before modifying
279	configuration = configuration.copy()	19✔
280	configuration.update({"server": {"_internal_server": "True"}}, "server",	19✔
281	privileged=True)
282
283	use_ssl: bool = configuration.get("server", "ssl")	19✔
284	server_class = ParallelHTTPSServer if use_ssl else ParallelHTTPServer	19✔
285	application = Application(configuration)	19✔
286	servers = {}	19✔
287	try:	19✔
288	hosts: List[Tuple[str, int]] = configuration.get("server", "hosts")	19✔
289	for address_port in hosts:	19✔
290	# retrieve IPv4/IPv6 address of address
291	try:	19✔
292	getaddrinfo = socket.getaddrinfo(address_port[0], address_port[1], 0, socket.SOCK_STREAM, socket.IPPROTO_TCP)	19✔
293	except OSError as e:	×
294	logger.warn("cannot retrieve IPv4 or IPv6 address of '%s': %s" % (format_address(address_port), e))	×
295	continue	×
296	logger.debug("getaddrinfo of '%s': %s" % (format_address(address_port), getaddrinfo))	19✔
297	for (address_family, socket_kind, socket_proto, socket_flags, socket_address) in getaddrinfo:	19✔
298	logger.debug("try to create server socket on '%s'" % (format_address(socket_address)))	19✔
299	try:	19✔
300	server = server_class(configuration, address_family, (socket_address[0], socket_address[1]), RequestHandler)	19✔
301	except OSError as e:	×
302	logger.warn("cannot create server socket on '%s': %s" % (format_address(socket_address), e))	×
303	continue	×
304	servers[server.socket] = server	19✔
305	server.set_app(application)	19✔
306	logger.info("Listening on %r%s",	19✔
307	format_address(server.server_address),
308	" with SSL" if use_ssl else "")
309	if not servers:	19!
310	raise RuntimeError("No servers started")	×
311
312	# Mainloop
313	select_timeout = None	19✔
314	if sys.platform == "win32":	19✔
315	# Fallback to busy waiting. (select(...) blocks SIGINT on Windows.)
316	select_timeout = 1.0	5✔
317	max_connections: int = configuration.get("server", "max_connections")	19✔
318	logger.info("Radicale server ready")	19✔
319	while True:	9✔
320	rlist: List[socket.socket] = []	19✔
321	# Wait for finished clients
322	for server in servers.values():	19✔
323	rlist.extend(server.worker_sockets)	19✔
324	# Accept new connections if max_connections is not reached
325	if max_connections <= 0 or len(rlist) < max_connections:	19!
326	rlist.extend(servers)	19✔
327	# Use socket to get notified of program shutdown
328	if shutdown_socket is not None:	19!
329	rlist.append(shutdown_socket)	19✔
330	rlist, _, _ = select.select(rlist, [], [], select_timeout)	19✔
331	rset = set(rlist)	19✔
332	if shutdown_socket in rset:	19✔
333	logger.info("Stopping Radicale")	19✔
334	break	19✔
335	for server in servers.values():	19✔
336	finished_sockets = server.worker_sockets.intersection(rset)	19✔
337	for s in finished_sockets:	19✔
338	s.close()	19✔
339	server.worker_sockets.remove(s)	19✔
340	rset.remove(s)	19✔
341	if finished_sockets:	19✔
342	server.service_actions()	19✔
343	if rset:	19✔
344	active_server = servers.get(rset.pop())	19✔
345	if active_server:	19!
346	active_server.handle_request()	19✔
347	finally:
348	# Wait for clients to finish and close servers
349	for server in servers.values():	19✔
350	for s in server.worker_sockets:	19!
UNCOV 351	s.recv(1)	×
UNCOV 352	s.close()	×
353	server.server_close()	19✔

Kozea / Radicale / 9985748381

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous