7ed51226360212d2958a142d7d193b3bdd0c0e40

Build # 7ed51226360212d2958a142d7d193b3bdd0c0e40

Build Type

push

github-actions

Committed by Unrud

Commit Message

Use 403 response for supported-report and valid-sync-token errors

Run Details

1188 of 1529 branches covered (77.7%)

Branch coverage included in aggregate %.

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

8 existing lines in 3 files now uncovered.

2868 of 3409 relevant lines covered (84.13%)

12.6 hits per line

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

74.81

/radicale/app/report.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-2018 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/>.

import contextlib
import posixpath
import socket
from http import client
from urllib.parse import unquote, urlparse
from xml.etree import ElementTree as ET

from radicale import app, httputils, pathutils, storage, xmlutils
from radicale.item import filter as radicale_filter
from radicale.log import logger


def xml_report(base_prefix, path, xml_request, collection, encoding,
               unlock_storage_fn):
    """Read and answer REPORT requests.

    Read rfc3253-3.6 for info.

    """
    multistatus = ET.Element(xmlutils.make_clark("D:multistatus"))
    if xml_request is None:
        return client.MULTI_STATUS, multistatus
    root = xml_request
    if root.tag in (
            xmlutils.make_clark("D:principal-search-property-set"),
            xmlutils.make_clark("D:principal-property-search"),
            xmlutils.make_clark("D:expand-property")):
        # We don't support searching for principals or indirect retrieving of
        # properties, just return an empty result.
        # InfCloud asks for expand-property reports (even if we don't announce
        # support for them) and stops working if an error code is returned.
        logger.warning("Unsupported REPORT method %r on %r requested",
                       xmlutils.make_human_tag(root.tag), path)
        return client.MULTI_STATUS, multistatus
    if (root.tag == xmlutils.make_clark("C:calendar-multiget") and
            collection.get_meta("tag") != "VCALENDAR" or
            root.tag == xmlutils.make_clark("CR:addressbook-multiget") and
            collection.get_meta("tag") != "VADDRESSBOOK" or
            root.tag == xmlutils.make_clark("D:sync-collection") and
            collection.get_meta("tag") not in ("VADDRESSBOOK", "VCALENDAR")):
        logger.warning("Invalid REPORT method %r on %r requested",
                       xmlutils.make_human_tag(root.tag), path)
        return (client.FORBIDDEN,
                xmlutils.webdav_error("D:supported-report"))
    prop_element = root.find(xmlutils.make_clark("D:prop"))
    props = (
        [prop.tag for prop in prop_element]
        if prop_element is not None else [])

    if root.tag in (
            xmlutils.make_clark("C:calendar-multiget"),
            xmlutils.make_clark("CR:addressbook-multiget")):
        # Read rfc4791-7.9 for info
        hreferences = set()
        for href_element in root.findall(xmlutils.make_clark("D:href")):
            href_path = pathutils.sanitize_path(
                unquote(urlparse(href_element.text).path))
            if (href_path + "/").startswith(base_prefix + "/"):
                hreferences.add(href_path[len(base_prefix):])
            else:
                logger.warning("Skipping invalid path %r in REPORT request on "
                               "%r", href_path, path)
    elif root.tag == xmlutils.make_clark("D:sync-collection"):
        old_sync_token_element = root.find(
            xmlutils.make_clark("D:sync-token"))
        old_sync_token = ""
        if old_sync_token_element is not None and old_sync_token_element.text:
            old_sync_token = old_sync_token_element.text.strip()
        logger.debug("Client provided sync token: %r", old_sync_token)
        try:
            sync_token, names = collection.sync(old_sync_token)
        except ValueError as e:
            # Invalid sync token
            logger.warning("Client provided invalid sync token %r: %s",
                           old_sync_token, e, exc_info=True)
            # client.CONFLICT doesn't work with some clients (e.g. InfCloud)
            return (client.FORBIDDEN,
                    xmlutils.webdav_error("D:valid-sync-token"))
        hreferences = (pathutils.unstrip_path(
            posixpath.join(collection.path, n)) for n in names)
        # Append current sync token to response
        sync_token_element = ET.Element(xmlutils.make_clark("D:sync-token"))
        sync_token_element.text = sync_token
        multistatus.append(sync_token_element)
    else:
        hreferences = (path,)
    filters = (
        root.findall("./%s" % xmlutils.make_clark("C:filter")) +
        root.findall("./%s" % xmlutils.make_clark("CR:filter")))

    def retrieve_items(collection, hreferences, multistatus):
        """Retrieves all items that are referenced in ``hreferences`` from
           ``collection`` and adds 404 responses for missing and invalid items
           to ``multistatus``."""
        collection_requested = False

        def get_names():
            """Extracts all names from references in ``hreferences`` and adds
               404 responses for invalid references to ``multistatus``.
               If the whole collections is referenced ``collection_requested``
               gets set to ``True``."""
            nonlocal collection_requested
            for hreference in hreferences:
                try:
                    name = pathutils.name_from_path(hreference, collection)
                except ValueError as e:
                    logger.warning("Skipping invalid path %r in REPORT request"
                                   " on %r: %s", hreference, path, e)
                    response = xml_item_response(base_prefix, hreference,
                                                 found_item=False)
                    multistatus.append(response)
                    continue
                if name:
                    # Reference is an item
                    yield name
                else:
                    # Reference is a collection
                    collection_requested = True

        for name, item in collection.get_multi(get_names()):
            if not item:
                uri = pathutils.unstrip_path(
                    posixpath.join(collection.path, name))
                response = xml_item_response(base_prefix, uri,
                                             found_item=False)
                multistatus.append(response)
            else:
                yield item, False
        if collection_requested:
            yield from collection.get_filtered(filters)

    # Retrieve everything required for finishing the request.
    retrieved_items = list(retrieve_items(collection, hreferences,
                                          multistatus))
    collection_tag = collection.get_meta("tag")
    # Don't access storage after this!
    unlock_storage_fn()

    def match(item, filter_):
        tag = collection_tag
        if (tag == "VCALENDAR" and
                filter_.tag != xmlutils.make_clark("C:%s" % filter_)):
            if len(filter_) == 0:
                return True
            if len(filter_) > 1:
                raise ValueError("Filter with %d children" % len(filter_))
            if filter_[0].tag != xmlutils.make_clark("C:comp-filter"):
                raise ValueError("Unexpected %r in filter" % filter_[0].tag)
            return radicale_filter.comp_match(item, filter_[0])
        if (tag == "VADDRESSBOOK" and
                filter_.tag != xmlutils.make_clark("CR:%s" % filter_)):
            for child in filter_:
                if child.tag != xmlutils.make_clark("CR:prop-filter"):
                    raise ValueError("Unexpected %r in filter" % child.tag)
            test = filter_.get("test", "anyof")
            if test == "anyof":
                return any(
                    radicale_filter.prop_match(item.vobject_item, f, "CR")
                    for f in filter_)
            if test == "allof":
                return all(
                    radicale_filter.prop_match(item.vobject_item, f, "CR")
                    for f in filter_)
            raise ValueError("Unsupported filter test: %r" % test)
        raise ValueError("unsupported filter %r for %r" % (filter_.tag, tag))

    while retrieved_items:
        # ``item.vobject_item`` might be accessed during filtering.
        # Don't keep reference to ``item``, because VObject requires a lot of
        # memory.
        item, filters_matched = retrieved_items.pop(0)
        if filters and not filters_matched:
            try:
                if not all(match(item, filter_) for filter_ in filters):
                    continue
            except ValueError as e:
                raise ValueError("Failed to filter item %r from %r: %s" %
                                 (item.href, collection.path, e)) from e
            except Exception as e:
                raise RuntimeError("Failed to filter item %r from %r: %s" %
                                   (item.href, collection.path, e)) from e

        found_props = []
        not_found_props = []

        for tag in props:
            element = ET.Element(tag)
            if tag == xmlutils.make_clark("D:getetag"):
                element.text = item.etag
                found_props.append(element)
            elif tag == xmlutils.make_clark("D:getcontenttype"):
                element.text = xmlutils.get_content_type(item, encoding)
                found_props.append(element)
            elif tag in (
                    xmlutils.make_clark("C:calendar-data"),
                    xmlutils.make_clark("CR:address-data")):
                element.text = item.serialize()
                found_props.append(element)
            else:
                not_found_props.append(element)

        uri = pathutils.unstrip_path(
            posixpath.join(collection.path, item.href))
        multistatus.append(xml_item_response(
            base_prefix, uri, found_props=found_props,
            not_found_props=not_found_props, found_item=True))

    return client.MULTI_STATUS, multistatus


def xml_item_response(base_prefix, href, found_props=(), not_found_props=(),
                      found_item=True):
    response = ET.Element(xmlutils.make_clark("D:response"))

    href_tag = ET.Element(xmlutils.make_clark("D:href"))
    href_tag.text = xmlutils.make_href(base_prefix, href)
    response.append(href_tag)

    if found_item:
        for code, props in ((200, found_props), (404, not_found_props)):
            if props:
                propstat = ET.Element(xmlutils.make_clark("D:propstat"))
                status = ET.Element(xmlutils.make_clark("D:status"))
                status.text = xmlutils.make_response(code)
                prop_tag = ET.Element(xmlutils.make_clark("D:prop"))
                for prop in props:
                    prop_tag.append(prop)
                propstat.append(prop_tag)
                propstat.append(status)
                response.append(propstat)
    else:
        status = ET.Element(xmlutils.make_clark("D:status"))
        status.text = xmlutils.make_response(404)
        response.append(status)

    return response


class ApplicationReportMixin:
    def do_REPORT(self, environ, base_prefix, path, user):
        """Manage REPORT request."""
        access = app.Access(self._rights, user, path)
        if not access.check("r"):
            return httputils.NOT_ALLOWED
        try:
            xml_content = self._read_xml_content(environ)
        except RuntimeError as e:
            logger.warning(
                "Bad REPORT request on %r: %s", path, e, exc_info=True)
            return httputils.BAD_REQUEST
        except socket.timeout:
            logger.debug("client timed out", exc_info=True)
            return httputils.REQUEST_TIMEOUT
        with contextlib.ExitStack() as lock_stack:
            lock_stack.enter_context(self._storage.acquire_lock("r", user))
            item = next(self._storage.discover(path), None)
            if not item:
                return httputils.NOT_FOUND
            if not access.check("r", item):
                return httputils.NOT_ALLOWED
            if isinstance(item, storage.BaseCollection):
                collection = item
            else:
                collection = item.collection
            headers = {"Content-Type": "text/xml; charset=%s" % self._encoding}
            try:
                status, xml_answer = xml_report(
                    base_prefix, path, xml_content, collection, self._encoding,
                    lock_stack.close)
            except ValueError as e:
                logger.warning(
                    "Bad REPORT request on %r: %s", path, e, exc_info=True)
                return httputils.BAD_REQUEST
            return (status, headers, self._write_xml_content(xml_answer))

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-2018 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	import contextlib	15✔
21	import posixpath	15✔
22	import socket	15✔
23	from http import client	15✔
24	from urllib.parse import unquote, urlparse	15✔
25	from xml.etree import ElementTree as ET	15✔
26
27	from radicale import app, httputils, pathutils, storage, xmlutils	15✔
28	from radicale.item import filter as radicale_filter	15✔
29	from radicale.log import logger	15✔
30
31
32	def xml_report(base_prefix, path, xml_request, collection, encoding,	15✔
33	unlock_storage_fn):
34	"""Read and answer REPORT requests.
35
36	Read rfc3253-3.6 for info.
37
38	"""
39	multistatus = ET.Element(xmlutils.make_clark("D:multistatus"))	15✔
40	if xml_request is None:	15!
41	return client.MULTI_STATUS, multistatus	×
42	root = xml_request	15✔
43	if root.tag in (	15!
44	xmlutils.make_clark("D:principal-search-property-set"),
45	xmlutils.make_clark("D:principal-property-search"),
46	xmlutils.make_clark("D:expand-property")):
47	# We don't support searching for principals or indirect retrieving of
48	# properties, just return an empty result.
49	# InfCloud asks for expand-property reports (even if we don't announce
50	# support for them) and stops working if an error code is returned.
51	logger.warning("Unsupported REPORT method %r on %r requested",	×
52	xmlutils.make_human_tag(root.tag), path)
53	return client.MULTI_STATUS, multistatus	×
54	if (root.tag == xmlutils.make_clark("C:calendar-multiget") and	15!
55	collection.get_meta("tag") != "VCALENDAR" or
56	root.tag == xmlutils.make_clark("CR:addressbook-multiget") and
57	collection.get_meta("tag") != "VADDRESSBOOK" or
58	root.tag == xmlutils.make_clark("D:sync-collection") and
59	collection.get_meta("tag") not in ("VADDRESSBOOK", "VCALENDAR")):
60	logger.warning("Invalid REPORT method %r on %r requested",	×
61	xmlutils.make_human_tag(root.tag), path)
NEW 62	return (client.FORBIDDEN,	×
63	xmlutils.webdav_error("D:supported-report"))
64	prop_element = root.find(xmlutils.make_clark("D:prop"))	15✔
65	props = (	15✔
66	[prop.tag for prop in prop_element]
67	if prop_element is not None else [])
68
69	if root.tag in (	15!
70	xmlutils.make_clark("C:calendar-multiget"),
71	xmlutils.make_clark("CR:addressbook-multiget")):
72	# Read rfc4791-7.9 for info
73	hreferences = set()	×
74	for href_element in root.findall(xmlutils.make_clark("D:href")):	×
75	href_path = pathutils.sanitize_path(	×
76	unquote(urlparse(href_element.text).path))
77	if (href_path + "/").startswith(base_prefix + "/"):	×
78	hreferences.add(href_path[len(base_prefix):])	×
79	else:
80	logger.warning("Skipping invalid path %r in REPORT request on "	×
81	"%r", href_path, path)
82	elif root.tag == xmlutils.make_clark("D:sync-collection"):	15✔
83	old_sync_token_element = root.find(	15✔
84	xmlutils.make_clark("D:sync-token"))
85	old_sync_token = ""	15✔
86	if old_sync_token_element is not None and old_sync_token_element.text:	15✔
87	old_sync_token = old_sync_token_element.text.strip()	15✔
88	logger.debug("Client provided sync token: %r", old_sync_token)	15✔
89	try:	15✔
90	sync_token, names = collection.sync(old_sync_token)	15✔
91	except ValueError as e:	15✔
92	# Invalid sync token
93	logger.warning("Client provided invalid sync token %r: %s",	15✔
94	old_sync_token, e, exc_info=True)
95	# client.CONFLICT doesn't work with some clients (e.g. InfCloud)
96	return (client.FORBIDDEN,	15✔
97	xmlutils.webdav_error("D:valid-sync-token"))
98	hreferences = (pathutils.unstrip_path(	15✔
99	posixpath.join(collection.path, n)) for n in names)
100	# Append current sync token to response
101	sync_token_element = ET.Element(xmlutils.make_clark("D:sync-token"))	15✔
102	sync_token_element.text = sync_token	15✔
103	multistatus.append(sync_token_element)	15✔
104	else:
105	hreferences = (path,)	15✔
106	filters = (	15✔
107	root.findall("./%s" % xmlutils.make_clark("C:filter")) +
108	root.findall("./%s" % xmlutils.make_clark("CR:filter")))
109
110	def retrieve_items(collection, hreferences, multistatus):	15✔
111	"""Retrieves all items that are referenced in ``hreferences`` from
112	``collection`` and adds 404 responses for missing and invalid items
113	to ``multistatus``."""
114	collection_requested = False	15✔
115
116	def get_names():	15✔
117	"""Extracts all names from references in ``hreferences`` and adds
118	404 responses for invalid references to ``multistatus``.
119	If the whole collections is referenced ``collection_requested``
120	gets set to ``True``."""
121	nonlocal collection_requested
122	for hreference in hreferences:	15✔
123	try:	15✔
124	name = pathutils.name_from_path(hreference, collection)	15✔
125	except ValueError as e:	×
126	logger.warning("Skipping invalid path %r in REPORT request"	×
127	" on %r: %s", hreference, path, e)
128	response = xml_item_response(base_prefix, hreference,	×
129	found_item=False)
130	multistatus.append(response)	×
131	continue	×
132	if name:	15✔
133	# Reference is an item
134	yield name	15✔
135	else:
136	# Reference is a collection
137	collection_requested = True	15✔
138
139	for name, item in collection.get_multi(get_names()):	15✔
140	if not item:	15✔
141	uri = pathutils.unstrip_path(	15✔
142	posixpath.join(collection.path, name))
143	response = xml_item_response(base_prefix, uri,	15✔
144	found_item=False)
145	multistatus.append(response)	15✔
146	else:
147	yield item, False	15✔
148	if collection_requested:	15✔
149	yield from collection.get_filtered(filters)	15✔
150
151	# Retrieve everything required for finishing the request.
152	retrieved_items = list(retrieve_items(collection, hreferences,	15✔
153	multistatus))
154	collection_tag = collection.get_meta("tag")	15✔
155	# Don't access storage after this!
156	unlock_storage_fn()	15✔
157
158	def match(item, filter_):	15✔
159	tag = collection_tag	15✔
160	if (tag == "VCALENDAR" and	15✔
161	filter_.tag != xmlutils.make_clark("C:%s" % filter_)):
162	if len(filter_) == 0:	15!
163	return True	×
164	if len(filter_) > 1:	15!
165	raise ValueError("Filter with %d children" % len(filter_))	×
166	if filter_[0].tag != xmlutils.make_clark("C:comp-filter"):	15!
167	raise ValueError("Unexpected %r in filter" % filter_[0].tag)	×
168	return radicale_filter.comp_match(item, filter_[0])	15✔
169	if (tag == "VADDRESSBOOK" and	15!
170	filter_.tag != xmlutils.make_clark("CR:%s" % filter_)):
171	for child in filter_:	15✔
172	if child.tag != xmlutils.make_clark("CR:prop-filter"):	15!
173	raise ValueError("Unexpected %r in filter" % child.tag)	×
174	test = filter_.get("test", "anyof")	15✔
175	if test == "anyof":	15✔
176	return any(	15✔
177	radicale_filter.prop_match(item.vobject_item, f, "CR")
178	for f in filter_)
179	if test == "allof":	15!
180	return all(	15✔
181	radicale_filter.prop_match(item.vobject_item, f, "CR")
182	for f in filter_)
183	raise ValueError("Unsupported filter test: %r" % test)	×
184	raise ValueError("unsupported filter %r for %r" % (filter_.tag, tag))	×
185
186	while retrieved_items:	15✔
187	# ``item.vobject_item`` might be accessed during filtering.
188	# Don't keep reference to ``item``, because VObject requires a lot of
189	# memory.
190	item, filters_matched = retrieved_items.pop(0)	15✔
191	if filters and not filters_matched:	15✔
192	try:	15✔
193	if not all(match(item, filter_) for filter_ in filters):	15✔
194	continue	15✔
195	except ValueError as e:	×
196	raise ValueError("Failed to filter item %r from %r: %s" %	×
197	(item.href, collection.path, e)) from e
198	except Exception as e:	×
199	raise RuntimeError("Failed to filter item %r from %r: %s" %	×
200	(item.href, collection.path, e)) from e
201
202	found_props = []	15✔
203	not_found_props = []	15✔
204
205	for tag in props:	15✔
206	element = ET.Element(tag)	15✔
207	if tag == xmlutils.make_clark("D:getetag"):	15✔
208	element.text = item.etag	15✔
209	found_props.append(element)	15✔
210	elif tag == xmlutils.make_clark("D:getcontenttype"):	15!
211	element.text = xmlutils.get_content_type(item, encoding)	15✔
212	found_props.append(element)	15✔
213	elif tag in (	×
214	xmlutils.make_clark("C:calendar-data"),
215	xmlutils.make_clark("CR:address-data")):
216	element.text = item.serialize()	×
217	found_props.append(element)	×
218	else:
219	not_found_props.append(element)	×
220
221	uri = pathutils.unstrip_path(	15✔
222	posixpath.join(collection.path, item.href))
223	multistatus.append(xml_item_response(	15✔
224	base_prefix, uri, found_props=found_props,
225	not_found_props=not_found_props, found_item=True))
226
227	return client.MULTI_STATUS, multistatus	15✔
228
229
230	def xml_item_response(base_prefix, href, found_props=(), not_found_props=(),	15✔
231	found_item=True):
232	response = ET.Element(xmlutils.make_clark("D:response"))	15✔
233
234	href_tag = ET.Element(xmlutils.make_clark("D:href"))	15✔
235	href_tag.text = xmlutils.make_href(base_prefix, href)	15✔
236	response.append(href_tag)	15✔
237
238	if found_item:	15✔
239	for code, props in ((200, found_props), (404, not_found_props)):	15✔
240	if props:	15✔
241	propstat = ET.Element(xmlutils.make_clark("D:propstat"))	15✔
242	status = ET.Element(xmlutils.make_clark("D:status"))	15✔
243	status.text = xmlutils.make_response(code)	15✔
244	prop_tag = ET.Element(xmlutils.make_clark("D:prop"))	15✔
245	for prop in props:	15✔
246	prop_tag.append(prop)	15✔
247	propstat.append(prop_tag)	15✔
248	propstat.append(status)	15✔
249	response.append(propstat)	15✔
250	else:
251	status = ET.Element(xmlutils.make_clark("D:status"))	15✔
252	status.text = xmlutils.make_response(404)	15✔
253	response.append(status)	15✔
254
255	return response	15✔
256
257
258	class ApplicationReportMixin:	15✔
259	def do_REPORT(self, environ, base_prefix, path, user):	15✔
260	"""Manage REPORT request."""
261	access = app.Access(self._rights, user, path)	15✔
262	if not access.check("r"):	15!
263	return httputils.NOT_ALLOWED	×
264	try:	15✔
265	xml_content = self._read_xml_content(environ)	15✔
266	except RuntimeError as e:	×
267	logger.warning(	×
268	"Bad REPORT request on %r: %s", path, e, exc_info=True)
269	return httputils.BAD_REQUEST	×
270	except socket.timeout:	×
271	logger.debug("client timed out", exc_info=True)	×
272	return httputils.REQUEST_TIMEOUT	×
273	with contextlib.ExitStack() as lock_stack:	15✔
274	lock_stack.enter_context(self._storage.acquire_lock("r", user))	15✔
275	item = next(self._storage.discover(path), None)	15✔
276	if not item:	15!
277	return httputils.NOT_FOUND	×
278	if not access.check("r", item):	15!
279	return httputils.NOT_ALLOWED	×
280	if isinstance(item, storage.BaseCollection):	15✔
281	collection = item	15✔
282	else:
283	collection = item.collection	15✔
284	headers = {"Content-Type": "text/xml; charset=%s" % self._encoding}	15✔
285	try:	15✔
286	status, xml_answer = xml_report(	15✔
287	base_prefix, path, xml_content, collection, self._encoding,
288	lock_stack.close)
289	except ValueError as e:	×
290	logger.warning(	×
291	"Bad REPORT request on %r: %s", path, e, exc_info=True)
292	return httputils.BAD_REQUEST	×
293	return (status, headers, self._write_xml_content(xml_answer))	15✔

Kozea / Radicale / 7ed51226360212d2958a142d7d193b3bdd0c0e40

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