593f9b688ced612076ff93185f65eb207a073b77

Build # 593f9b688ced612076ff93185f65eb207a073b77

Build Type

push

github-actions

Committed by Unrud

Commit Message

Remove unnecessary string trimming

Run Details

1180 of 1529 branches covered (77.17%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

2856 of 3409 relevant lines covered (83.78%)

12.56 hits per line

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

76.42

/radicale/server.py

# This file is part of Radicale Server - Calendar Server
# Copyright © 2008 Nicolas Kandel
# Copyright © 2008 Pascal Halter
# Copyright © 2008-2017 Guillaume Ayoub
# Copyright © 2017-2019 Unrud <unrud@outlook.com>
#
# 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 errno
import os
import select
import socket
import socketserver
import ssl
import sys
import wsgiref.simple_server
from urllib.parse import unquote

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

if hasattr(socket, "EAI_ADDRFAMILY"):
    COMPAT_EAI_ADDRFAMILY = socket.EAI_ADDRFAMILY
elif hasattr(socket, "EAI_NONAME"):
    # Windows and BSD don't have a special error code for this
    COMPAT_EAI_ADDRFAMILY = socket.EAI_NONAME
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
if hasattr(socket, "IPPROTO_IPV6"):
    COMPAT_IPPROTO_IPV6 = socket.IPPROTO_IPV6
elif os.name == "nt":
    # Workaround: https://bugs.python.org/issue29515
    COMPAT_IPPROTO_IPV6 = 41


def format_address(address):
    return "[%s]:%d" % address[:2]


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

    # We wait for child threads ourself
    block_on_close = False

    def __init__(self, configuration, family, address, RequestHandlerClass):
        self.configuration = configuration
        self.address_family = family
        super().__init__(address, RequestHandlerClass)
        self.client_sockets = set()

    def server_bind(self):
        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(self):
        # Set timeout for client
        request, client_address = super().get_request()
        timeout = self.configuration.get("server", "timeout")
        if timeout:
            request.settimeout(timeout)
        client_socket, client_socket_out = socket.socketpair()
        self.client_sockets.add(client_socket_out)
        return request, (*client_address, client_socket)

    def finish_request_locked(self, request, client_address):
        return super().finish_request(request, client_address)

    def finish_request(self, request, client_address):
        *client_address, client_socket = client_address
        client_address = tuple(client_address)
        try:
            return self.finish_request_locked(request, client_address)
        finally:
            client_socket.close()

    def handle_error(self, request, client_address):
        if issubclass(sys.exc_info()[0], 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):
        super().server_bind()
        # Wrap the TCP socket in an SSL socket
        certfile = self.configuration.get("server", "certificate")
        keyfile = self.configuration.get("server", "key")
        cafile = 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(self, request, client_address):
        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)
            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 = {}

    def log_exception(self, exc_info):
        logger.error("An exception occurred during request: %s",
                     exc_info[1], exc_info=exc_info)


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

    def log_request(self, code="-", size="-"):
        pass  # Disable request logging.

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

    def get_environ(self):
        env = super().get_environ()
        if hasattr(self.connection, "getpeercert"):
            # 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):
        """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
        handler.run(self.server.get_app())


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

    use_ssl = configuration.get("server", "ssl")
    server_class = ParallelHTTPSServer if use_ssl else ParallelHTTPServer
    application = Application(configuration)
    servers = {}
    try:
        for address in configuration.get("server", "hosts"):
            # Try to bind sockets for IPv4 and IPv6
            possible_families = (socket.AF_INET, socket.AF_INET6)
            bind_ok = False
            for i, family in enumerate(possible_families):
                is_last = i == len(possible_families) - 1
                try:
                    server = server_class(configuration, family, address,
                                          RequestHandler)
                except OSError as e:
                    # Ignore unsupported families (only one must work)
                    if ((bind_ok or not is_last) and (
                            isinstance(e, socket.gaierror) and (
                                # Hostname does not exist or doesn't have
                                # address for address family
                                # macOS: IPv6 address for INET address family
                                e.errno == socket.EAI_NONAME or
                                # Address not for address family
                                e.errno == COMPAT_EAI_ADDRFAMILY or
                                e.errno == COMPAT_EAI_NODATA) or
                            # Workaround for PyPy
                            str(e) == "address family mismatched" or
                            # Address family not available (e.g. IPv6 disabled)
                            # macOS: IPv4 address for INET6 address family with
                            #        IPV6_V6ONLY set
                            e.errno == errno.EADDRNOTAVAIL)):
                        continue
                    raise RuntimeError("Failed to start server %r: %s" % (
                                           format_address(address), e)) from e
                servers[server.socket] = server
                bind_ok = True
                server.set_app(application)
                logger.info("Listening on %r%s",
                            format_address(server.server_address),
                            " with SSL" if use_ssl else "")
        assert servers, "no servers started"

        # Mainloop
        select_timeout = None
        if os.name == "nt":
            # Fallback to busy waiting. (select(...) blocks SIGINT on Windows.)
            select_timeout = 1.0
        max_connections = configuration.get("server", "max_connections")
        logger.info("Radicale server ready")
        while True:
            rlist = xlist = []
            # Wait for finished clients
            for server in servers.values():
                rlist.extend(server.client_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
            rlist.append(shutdown_socket)
            rlist, _, xlist = select.select(rlist, [], xlist, select_timeout)
            if xlist:
                raise RuntimeError("unhandled socket error")
            rlist = set(rlist)
            if shutdown_socket in rlist:
                logger.info("Stopping Radicale")
                break
            for server in servers.values():
                finished_sockets = server.client_sockets.intersection(rlist)
                for s in finished_sockets:
                    s.close()
                    server.client_sockets.remove(s)
                    rlist.remove(s)
                if finished_sockets:
                    server.service_actions()
            if rlist:
                server = servers.get(rlist.pop())
                if server:
                    server.handle_request()
    finally:
        # Wait for clients to finish and close servers
        for server in servers.values():
            for s in server.client_sockets:
                s.recv(1)
                s.close()
            server.server_close()

1	# This file is part of Radicale Server - Calendar 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	#
7	# This library is free software: you can redistribute it and/or modify
8	# it under the terms of the GNU General Public License as published by
9	# the Free Software Foundation, either version 3 of the License, or
10	# (at your option) any later version.
11	#
12	# This library is distributed in the hope that it will be useful,
13	# but WITHOUT ANY WARRANTY; without even the implied warranty of
14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	# GNU General Public License for more details.
16	#
17	# You should have received a copy of the GNU General Public License
18	# along with Radicale. If not, see <http://www.gnu.org/licenses/>.
19
20	"""	15✔
21	Built-in WSGI server.
22
23	"""
24
25	import errno	15✔
26	import os	15✔
27	import select	15✔
28	import socket	15✔
29	import socketserver	15✔
30	import ssl	15✔
31	import sys	15✔
32	import wsgiref.simple_server	15✔
33	from urllib.parse import unquote	15✔
34
35	from radicale import Application, config	15✔
36	from radicale.log import logger	15✔
37
38	if hasattr(socket, "EAI_ADDRFAMILY"):	15!
39	COMPAT_EAI_ADDRFAMILY = socket.EAI_ADDRFAMILY	15✔
40	elif hasattr(socket, "EAI_NONAME"):	×
41	# Windows and BSD don't have a special error code for this
42	COMPAT_EAI_ADDRFAMILY = socket.EAI_NONAME	×
43	if hasattr(socket, "EAI_NODATA"):	15!
44	COMPAT_EAI_NODATA = socket.EAI_NODATA	15✔
45	elif hasattr(socket, "EAI_NONAME"):	×
46	# Windows and BSD don't have a special error code for this
47	COMPAT_EAI_NODATA = socket.EAI_NONAME	×
48	if hasattr(socket, "IPPROTO_IPV6"):	15!
49	COMPAT_IPPROTO_IPV6 = socket.IPPROTO_IPV6	15✔
50	elif os.name == "nt":	×
51	# Workaround: https://bugs.python.org/issue29515
52	COMPAT_IPPROTO_IPV6 = 41	×
53
54
55	def format_address(address):	15✔
56	return "[%s]:%d" % address[:2]	15✔
57
58
59	class ParallelHTTPServer(socketserver.ThreadingMixIn,	15✔
60	wsgiref.simple_server.WSGIServer):
61
62	# We wait for child threads ourself
63	block_on_close = False	15✔
64
65	def __init__(self, configuration, family, address, RequestHandlerClass):	15✔
66	self.configuration = configuration	15✔
67	self.address_family = family	15✔
68	super().__init__(address, RequestHandlerClass)	15✔
69	self.client_sockets = set()	15✔
70
71	def server_bind(self):	15✔
72	if self.address_family == socket.AF_INET6:	15✔
73	# Only allow IPv6 connections to the IPv6 socket
74	self.socket.setsockopt(COMPAT_IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)	15✔
75	super().server_bind()	15✔
76
77	def get_request(self):	15✔
78	# Set timeout for client
79	request, client_address = super().get_request()	15✔
80	timeout = self.configuration.get("server", "timeout")	15✔
81	if timeout:	15!
82	request.settimeout(timeout)	15✔
83	client_socket, client_socket_out = socket.socketpair()	15✔
84	self.client_sockets.add(client_socket_out)	15✔
85	return request, (*client_address, client_socket)	15✔
86
87	def finish_request_locked(self, request, client_address):	15✔
88	return super().finish_request(request, client_address)	15✔
89
90	def finish_request(self, request, client_address):	15✔
91	*client_address, client_socket = client_address	15✔
92	client_address = tuple(client_address)	15✔
93	try:	15✔
94	return self.finish_request_locked(request, client_address)	15✔
95	finally:
96	client_socket.close()	15✔
97
98	def handle_error(self, request, client_address):	15✔
99	if issubclass(sys.exc_info()[0], socket.timeout):	×
100	logger.info("client timed out", exc_info=True)	×
101	else:
102	logger.error("An exception occurred during request: %s",	×
103	sys.exc_info()[1], exc_info=True)
104
105
106	class ParallelHTTPSServer(ParallelHTTPServer):	15✔
107
108	def server_bind(self):	15✔
109	super().server_bind()	15✔
110	# Wrap the TCP socket in an SSL socket
111	certfile = self.configuration.get("server", "certificate")	15✔
112	keyfile = self.configuration.get("server", "key")	15✔
113	cafile = self.configuration.get("server", "certificate_authority")	15✔
114	# Test if the files can be read
115	for name, filename in [("certificate", certfile), ("key", keyfile),	15✔
116	("certificate_authority", cafile)]:
117	type_name = config.DEFAULT_CONFIG_SCHEMA["server"][name][	15✔
118	"type"].__name__
119	source = self.configuration.get_source("server", name)	15✔
120	if name == "certificate_authority" and not filename:	15✔
121	continue	15✔
122	try:	15✔
123	open(filename, "r").close()	15✔
124	except OSError as e:	×
125	raise RuntimeError(	×
126	"Invalid %s value for option %r in section %r in %s: %r "
127	"(%s)" % (type_name, name, "server", source, filename,
128	e)) from e
129	context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)	15✔
130	context.load_cert_chain(certfile=certfile, keyfile=keyfile)	15✔
131	if cafile:	15!
132	context.load_verify_locations(cafile=cafile)	×
133	context.verify_mode = ssl.CERT_REQUIRED	×
134	self.socket = context.wrap_socket(	15✔
135	self.socket, server_side=True, do_handshake_on_connect=False)
136
137	def finish_request_locked(self, request, client_address):	15✔
138	try:	15✔
139	try:	15✔
140	request.do_handshake()	15✔
141	except socket.timeout:	×
142	raise	×
143	except Exception as e:	×
144	raise RuntimeError("SSL handshake failed: %s" % e) from e	×
145	except Exception:	×
146	try:	×
147	self.handle_error(request, client_address)	×
148	finally:
149	self.shutdown_request(request)	×
150	return	×
151	return super().finish_request_locked(request, client_address)	15✔
152
153
154	class ServerHandler(wsgiref.simple_server.ServerHandler):	15✔
155
156	# Don't pollute WSGI environ with OS environment
157	os_environ = {}	15✔
158
159	def log_exception(self, exc_info):	15✔
160	logger.error("An exception occurred during request: %s",	×
161	exc_info[1], exc_info=exc_info)
162
163
164	class RequestHandler(wsgiref.simple_server.WSGIRequestHandler):	15✔
165	"""HTTP requests handler."""
166
167	def log_request(self, code="-", size="-"):	15✔
168	pass # Disable request logging.	15✔
169
170	def log_error(self, format_, *args):	15✔
171	logger.error("An error occurred during request: %s", format_ % args)	×
172
173	def get_environ(self):	15✔
174	env = super().get_environ()	15✔
175	if hasattr(self.connection, "getpeercert"):	15✔
176	# The certificate can be evaluated by the auth module
177	env["REMOTE_CERTIFICATE"] = self.connection.getpeercert()	15✔
178	# Parent class only tries latin1 encoding
179	env["PATH_INFO"] = unquote(self.path.split("?", 1)[0])	15✔
180	return env	15✔
181
182	def handle(self):	15✔
183	"""Copy of WSGIRequestHandler.handle with different ServerHandler"""
184
185	self.raw_requestline = self.rfile.readline(65537)	15✔
186	if len(self.raw_requestline) > 65536:	15!
187	self.requestline = ""	×
188	self.request_version = ""	×
189	self.command = ""	×
190	self.send_error(414)	×
191	return	×
192
193	if not self.parse_request():	15!
194	return	×
195
196	handler = ServerHandler(	15✔
197	self.rfile, self.wfile, self.get_stderr(), self.get_environ()
198	)
199	handler.request_handler = self	15✔
200	handler.run(self.server.get_app())	15✔
201
202
203	def serve(configuration, shutdown_socket):	15✔
204	"""Serve radicale from configuration."""
205	logger.info("Starting Radicale")	15✔
206	# Copy configuration before modifying
207	configuration = configuration.copy()	15✔
208	configuration.update({"server": {"_internal_server": "True"}}, "server",	15✔
209	privileged=True)
210
211	use_ssl = configuration.get("server", "ssl")	15✔
212	server_class = ParallelHTTPSServer if use_ssl else ParallelHTTPServer	15✔
213	application = Application(configuration)	15✔
214	servers = {}	15✔
215	try:	15✔
216	for address in configuration.get("server", "hosts"):	15✔
217	# Try to bind sockets for IPv4 and IPv6
218	possible_families = (socket.AF_INET, socket.AF_INET6)	15✔
219	bind_ok = False	15✔
220	for i, family in enumerate(possible_families):	15✔
221	is_last = i == len(possible_families) - 1	15✔
222	try:	15✔
223	server = server_class(configuration, family, address,	15✔
224	RequestHandler)
225	except OSError as e:	15✔
226	# Ignore unsupported families (only one must work)
227	if ((bind_ok or not is_last) and (	15!
228	isinstance(e, socket.gaierror) and (
229	# Hostname does not exist or doesn't have
230	# address for address family
231	# macOS: IPv6 address for INET address family
232	e.errno == socket.EAI_NONAME or
233	# Address not for address family
234	e.errno == COMPAT_EAI_ADDRFAMILY or
235	e.errno == COMPAT_EAI_NODATA) or
236	# Workaround for PyPy
237	str(e) == "address family mismatched" or
238	# Address family not available (e.g. IPv6 disabled)
239	# macOS: IPv4 address for INET6 address family with
240	# IPV6_V6ONLY set
241	e.errno == errno.EADDRNOTAVAIL)):
242	continue	15✔
243	raise RuntimeError("Failed to start server %r: %s" % (	×
244	format_address(address), e)) from e
245	servers[server.socket] = server	15✔
246	bind_ok = True	15✔
247	server.set_app(application)	15✔
248	logger.info("Listening on %r%s",	15✔
249	format_address(server.server_address),
250	" with SSL" if use_ssl else "")
251	assert servers, "no servers started"	15✔
252
253	# Mainloop
254	select_timeout = None	15✔
255	if os.name == "nt":	15!
256	# Fallback to busy waiting. (select(...) blocks SIGINT on Windows.)
257	select_timeout = 1.0	×
258	max_connections = configuration.get("server", "max_connections")	15✔
259	logger.info("Radicale server ready")	15✔
260	while True:	12✔
261	rlist = xlist = []	15✔
262	# Wait for finished clients
263	for server in servers.values():	15✔
264	rlist.extend(server.client_sockets)	15✔
265	# Accept new connections if max_connections is not reached
266	if max_connections <= 0 or len(rlist) < max_connections:	15!
267	rlist.extend(servers)	15✔
268	# Use socket to get notified of program shutdown
269	rlist.append(shutdown_socket)	15✔
270	rlist, _, xlist = select.select(rlist, [], xlist, select_timeout)	15✔
271	if xlist:	15!
272	raise RuntimeError("unhandled socket error")	×
273	rlist = set(rlist)	15✔
274	if shutdown_socket in rlist:	15✔
275	logger.info("Stopping Radicale")	15✔
276	break	15✔
277	for server in servers.values():	15✔
278	finished_sockets = server.client_sockets.intersection(rlist)	15✔
279	for s in finished_sockets:	15✔
280	s.close()	15✔
281	server.client_sockets.remove(s)	15✔
282	rlist.remove(s)	15✔
283	if finished_sockets:	15✔
284	server.service_actions()	15✔
285	if rlist:	15✔
286	server = servers.get(rlist.pop())	15✔
287	if server:	15!
288	server.handle_request()	15✔
289	finally:
290	# Wait for clients to finish and close servers
291	for server in servers.values():	15✔
292	for s in server.client_sockets:	15!
UNCOV 293	s.recv(1)	×
UNCOV 294	s.close()	×
295	server.server_close()	15✔

Kozea / Radicale / 593f9b688ced612076ff93185f65eb207a073b77

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