Radicale 3.7.2__tar.gz → 3.7.3__tar.gz

{radicale-3.7.2 → radicale-3.7.3}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 3.7.3
+* Extension: expose RADICALE:version for authenticated users via PROPFIND
+* Fix: sharing: GET request on single item with bday conversion
+* Fix: sharing: PROPFIND response on single item with bday conversion
+* Fix: sharing: PROPFIND response related to C:supported-calendar-component-set
+* Feature: conditional log of request/response header/content by new options *_on_notice_condition
+* Fix: user/path validation related to 'unicode-letter'
+
 ## 3.7.2
 * Fix: broken storage/mtime granularity detection on vfat
 * Improve: `path_to_filesystem()` by pre-detection of collision-free file system

{radicale-3.7.2 → radicale-3.7.3}/DOCUMENTATION.md

@@ -927,6 +927,35 @@ Strip script name from URI if called by reverse proxy
 
 Default: (taken from HTTP_X_SCRIPT_NAME or SCRIPT_NAME)
 
+##### validate_user_value
+
+_(>= 3.7.2)_
+
+Validate user value content
+
+Available types are:
+* `none`
+* `minimal` (control and some special chars)
+* `unicode-letter` (unicode letters)
+* `no-unicode` (no unicode)
+* `strict` (reduced ASCII set)
+
+Default: `minimal`
+
+##### validate_path_value
+
+_(>= 3.7.2)_
+
+Validate path value content
+
+* `none`
+* `minimal` (control and some special chars)
+* `unicode-letter` (unicode letters)
+* `no-unicode` (no unicode)
+* `strict` (reduced ASCII set)
+
+Default: `minimal`
+
 #### [encoding]
 
 ##### request
@@ -1617,35 +1646,6 @@ Strict preconditions check on PUT in case item already exists [RFC6352#9.2](http
 
 Default: `False`
 
-##### validate_user_value
-
-_(>= 3.7.2)_
-
-Validate user value content
-
-Available types are:
-* `none`
-* `minimal` (control and some special chars)
-* `unicode-letter` (unicode letters)
-* `no-unicode` (no unicode)
-* `strict` (reduced ASCII set)
-
-Default: `minimum`
-
-##### validate_path_type
-
-_(>= 3.7.2)_
-
-Validate path value content
-
-* `none`
-* `minimal` (control and some special chars)
-* `unicode-letter` (unicode letters)
-* `no-unicode` (no unicode)
-* `strict` (reduced ASCII set)
-
-Default: `minimum`
-
 ##### hook
 
 Command that is run after changes to storage. See the
@@ -1803,6 +1803,65 @@ Log response content (body) on `level = debug`
 
 Default: `False`
 
+##### request_header_on_notice_condition
+
+_(>= 3.7.3)_
+
+Log request header on `level = notice` if condition is fulfilled
+
+Default: `{}`
+
+Format: JSON structure as text
+
+Supported tokens:
+  * `method`
+  * `path`
+  * `useragent`
+  * `host` (IPv4/IPv6 address/network)
+  * `login`
+  * `status` (only supported on responses)
+
+Supported matches:
+  * str: `startswith`, `endswith`, `equal`, `re`
+  * int: `==`, `<`, `<=`, `>=`, `>`, `!=`
+  * IP address: `equal`, `==`, `!=`
+  * IP network: `included`, `excluded`
+
+Examples:
+  * `{"method": {"match": "equal", "value": "GET"}, "login": {"match": "equal", "value": "owner"}}`
+  * `{"method": {"match": "equal", "value": "PUT"}, "status": {"match": ">=", "value": "201"}, "host": {"match": "included", "value": "127.0.0.0/8"}}`
+  * `{"method": {"match": "equal", "value": "PUT"}, "path": {"match": "re", "value": "ev?nt[01]"}}`
+
+##### request_content_on_notice_condition
+
+_(>= 3.7.3)_
+
+Log request content (body) on `level = notice` if condition is fulfilled
+
+Default: `{}`
+
+Format: see `request_header_on_notice_condition`
+
+##### response_header_on_notice_condition
+
+_(>= 3.7.3)_
+
+Log response header on `level = notice` if condition is fulfilled
+
+Default: `{}`
+
+Format: see `request_header_on_notice_condition`
+
+##### response_content_on_notice_condition
+
+_(>= 3.7.3)_
+
+Log response content (body) on `level = notice` if condition is fulfilled
+
+Default: `{}`
+
+Format: see `request_header_on_notice_condition`
+
 ##### rights_rule_doesnt_match_on_debug
 
 _(>= 3.2.3)_

{radicale-3.7.2 → radicale-3.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Radicale
-Version: 3.7.2
+Version: 3.7.3
 Summary: CalDAV and CardDAV Server
 Author-email: Guillaume Ayoub <guillaume.ayoub@kozea.fr>, Unrud <unrud@outlook.com>, Peter Bieringer <pb@bieringer.de>
 License: GNU GPL v3

{radicale-3.7.2 → radicale-3.7.3}/Radicale.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Radicale
-Version: 3.7.2
+Version: 3.7.3
 Summary: CalDAV and CardDAV Server
 Author-email: Guillaume Ayoub <guillaume.ayoub@kozea.fr>, Unrud <unrud@outlook.com>, Peter Bieringer <pb@bieringer.de>
 License: GNU GPL v3

{radicale-3.7.2 → radicale-3.7.3}/config

@@ -397,6 +397,18 @@
 # Log response content on level=debug
 #response_content_on_debug = False
 
+# Log request header on level=notice with condition
+#request_header_on_notice_condition = {}
+
+# Log request content on level=notice with condition
+#request_content_on_notice_condition = {}
+
+# Log response header on level=notice with condition
+#response_header_on_notice_condition = {}
+
+# Log response content on level=notice with condition
+#response_content_on_notice_condition = {}
+
 # Log rights rule which doesn't match on level=debug
 #rights_rule_doesnt_match_on_debug = False
 

{radicale-3.7.2 → radicale-3.7.3}/pyproject.toml

@@ -3,7 +3,7 @@ name = "Radicale"
 # When the version is updated, a new section in the CHANGELOG.md file must be
 # added too.
 readme = "README.md"
-version = "3.7.2"
+version = "3.7.3"
 authors = [{name = "Guillaume Ayoub", email = "guillaume.ayoub@kozea.fr"}, {name = "Unrud", email = "unrud@outlook.com"}, {name = "Peter Bieringer", email = "pb@bieringer.de"}]
 license = {text = "GNU GPL v3"}
 description = "CalDAV and CardDAV Server"

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/__init__.py

@@ -130,6 +130,14 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
         logger.debug("log request  content on debug: %s", self._request_content_on_debug)
         logger.debug("log response header  on debug: %s", self._response_header_on_debug)
         logger.debug("log response content on debug: %s", self._response_content_on_debug)
+        self._request_header_on_notice_condition = configuration.get("logging", "request_header_on_notice_condition")
+        self._request_content_on_notice_condition = configuration.get("logging", "request_content_on_notice_condition")
+        self._response_header_on_notice_condition = configuration.get("logging", "response_header_on_notice_condition")
+        self._response_content_on_notice_condition = configuration.get("logging", "response_content_on_notice_condition")
+        logger.notice("log request  header  on notice condition: %s", self._request_header_on_notice_condition)
+        logger.notice("log request  content on notice condition: %s", self._request_content_on_notice_condition)
+        logger.notice("log response header  on notice condition: %s", self._response_header_on_notice_condition)
+        logger.notice("log response content on notice condition: %s", self._response_content_on_notice_condition)
         self._limit_content = configuration.get("logging", "limit_content")
         logger.debug("log limit for content: %d", self._limit_content)
         self._auth_delay = configuration.get("auth", "delay")
@@ -274,7 +282,7 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
         """Manage a request."""
         def response(status: int, headers: types.WSGIResponseHeaders,
                      answer: Union[None, str, bytes],
-                     xml_request: Union[None, str] = None) -> _IntermediateResponse:
+                     xml_request: Union[None, str] = None, request_info: dict = {}) -> _IntermediateResponse:
             """Helper to create response from internal types.WSGIResponse"""
             headers = dict(headers)
             content_encoding = "plain"
@@ -286,8 +294,16 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
                         if logger.isEnabledFor(logging.DEBUG):
                             logger.debug("Response content (nonXML):\n%s", utils.textwrap_str(answer, self._limit_content))
                     else:
-                        if logger.isEnabledFor(logging.DEBUG):
-                            logger.debug("Response content: suppressed by config/option [logging] response_content_on_debug")
+                        if self._response_content_on_notice_condition != {}:
+                            if log.log_conditional(
+                                    "response-content",
+                                    condition=self._response_content_on_notice_condition,
+                                    value=request_info,
+                                    ):
+                                logger.notice("Response content (nonXML, log condition passed):\n%s", utils.textwrap_str(answer, self._limit_content))
+                        else:
+                            if logger.isEnabledFor(logging.DEBUG):
+                                logger.debug("Response content: suppressed by config/option [logging] response_content_on_debug")
                     headers["Content-Type"] += "; charset=%s" % self._encoding
                     answer = answer.encode(self._encoding)
                 accept_encoding = [
@@ -307,12 +323,22 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
             # Add extra headers set in configuration
             headers.update(self._extra_headers)
 
+            request_info["status"] = status
+
             if self._response_header_on_debug:
                 if logger.isEnabledFor(logging.DEBUG):
                     logger.debug("Response header:\n%s", utils.textwrap_str(pprint.pformat(headers), self._limit_content))
             else:
-                if logger.isEnabledFor(logging.DEBUG):
-                    logger.debug("Response header: suppressed by config/option [logging] response_header_on_debug")
+                if self._response_header_on_notice_condition != {}:
+                    if log.log_conditional(
+                            "response-header",
+                            condition=self._response_header_on_notice_condition,
+                            value=request_info,
+                            ):
+                        logger.notice("Response header (log condition passed):\n%s", utils.textwrap_str(pprint.pformat(headers), self._limit_content))
+                else:
+                    if logger.isEnabledFor(logging.DEBUG):
+                        logger.debug("Response header: suppressed by config/option [logging] response_header_on_debug")
 
             # Start response
             # delay on error
@@ -428,8 +454,10 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
         if environ.get("HTTP_X_FORWARDED_HOST") or environ.get("HTTP_X_FORWARDED_PROTO") or environ.get("HTTP_X_FORWARDED_SERVER"):
             reverse_proxy = True
         remote_useragent = ""
+        remote_useragent_txt = ""
         if environ.get("HTTP_USER_AGENT"):
-            remote_useragent = " using %r" % environ["HTTP_USER_AGENT"]
+            remote_useragent = environ["HTTP_USER_AGENT"]
+            remote_useragent_txt = " using %r" % environ["HTTP_USER_AGENT"]
         depthinfo = ""
         if environ.get("HTTP_DEPTH"):
             depthinfo = " with depth %r" % environ["HTTP_DEPTH"]
@@ -439,12 +467,14 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
             https_info = ""
         logger.info("%s request for %r%s received from %s%s%s",
                     request_method, unsafe_path, depthinfo,
-                    remote_host, remote_useragent, https_info)
+                    remote_host, remote_useragent_txt, https_info)
         if self._request_header_on_debug:
             logger.debug("Request header:\n%s",
                          utils.textwrap_str(pprint.pformat(self._scrub_headers(environ)), self._limit_content))
         else:
-            logger.debug("Request header: suppressed by config/option [logging] request_header_on_debug")
+            if not self._request_header_on_notice_condition != {}:
+                # conditional request header logging is later
+                logger.debug("Request header: suppressed by config/option [logging] request_header_on_debug")
 
         # SCRIPT_NAME is already removed from PATH_INFO, according to the
         # WSGI specification.
@@ -527,6 +557,23 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
                 self._rights._user_groups = self._auth._ldap_groups
             except AttributeError:
                 pass
+
+        request_info: dict = {
+                              "method": request_method,
+                              "login": login, # not 'user' in this step
+                              "path": path,
+                              "useragent": remote_useragent,
+                              "host": remote_host,
+                              }
+
+        if not self._request_header_on_debug and self._request_header_on_notice_condition != {}:
+            if log.log_conditional(
+                    "request-header",
+                    condition=self._request_header_on_notice_condition,
+                    value=request_info,
+                    ):
+                logger.notice("Request header (log condition passed):\n%s", utils.textwrap_str(pprint.pformat(self._scrub_headers(environ)), self._limit_content))
+
         if user and login == user:
             logger.info("Successful login: %r (%s)", user, info)
         elif user:
@@ -611,7 +658,7 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
 
             try:
                 status, headers, answer, xml_request = function(
-                    environ, base_prefix, path, user, remote_host, remote_useragent)
+                    environ, base_prefix, path, user, request_info)
             except PermissionError as e:
                 logger.error("PermissionError: %s", e)
                 status, headers, answer, xml_request = httputils.INTERNAL_SERVER_ERROR
@@ -648,4 +695,4 @@ class Application(ApplicationPartDelete, ApplicationPartHead,
                 "WWW-Authenticate":
                 "Basic realm=\"%s\"" % self._auth_realm})
 
-        return response(status, headers, answer, xml_request)
+        return response(status, headers, answer, xml_request, request_info)

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/base.py

@@ -23,7 +23,7 @@ import unicodedata
 import xml.etree.ElementTree as ET
 from typing import Optional, Union
 
-from radicale import (auth, config, hook, httputils, pathutils, rights,
+from radicale import (auth, config, hook, httputils, log, pathutils, rights,
                       sharing, storage, types, utils, web, xmlutils)
 from radicale.log import logger
 from radicale.rights import intersect
@@ -41,8 +41,10 @@ PATH_PATTERN_STRICT_RE: str = "^[" + PATH_PATTERN_STRICT + "]+$"
 USER_BLACKLIST_MINIMAL: list = [":", "'", '"', '*', '?']
 PATH_BLACKLIST_MINIMAL: list = USER_BLACKLIST_MINIMAL
 
-USER_WHITELIST_UNICODE: list = ["-", ".", "@", "_"]  # from USER_PATTERN_STRICT
-PATH_WHITELIST_UNICODE: list = ["-", ".", "@", "_", "/", "~"]  # from PATH_PATTERN_STRICT
+BASE_WHITELIST_UNICODE: list = ["-", ".", "@", "_", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
+
+USER_WHITELIST_UNICODE: list = BASE_WHITELIST_UNICODE   # from USER_PATTERN_STRICT
+PATH_WHITELIST_UNICODE: list = BASE_WHITELIST_UNICODE + ["/", "~"]  # from PATH_PATTERN_STRICT
 
 
 def _check_format(self: storage.BaseStorage,
@@ -72,6 +74,7 @@ def _check_format(self: storage.BaseStorage,
         if check_unicode_letter:
             if c not in whitelist_unicode:
                 if unicodedata.category(c)[0] != "L":
+                    logger.trace("_check_format found %r (%r)", c, unicodedata.category(c)[0])
                     return False
         if check_no_unicode:
             if ord(c) > 255:
@@ -137,12 +140,16 @@ class ApplicationBase:
         self._log_bad_put_request_content = configuration.get("logging", "bad_put_request_content")
         self._response_content_on_debug = configuration.get("logging", "response_content_on_debug")
         self._request_content_on_debug = configuration.get("logging", "request_content_on_debug")
+        self._response_content_on_notice_condition = configuration.get("logging", "response_content_on_notice_condition")
+        self._request_content_on_notice_condition = configuration.get("logging", "request_content_on_notice_condition")
         self._limit_content = configuration.get("logging", "limit_content")
         self._validate_user_value = configuration.get("server", "validate_user_value")
         self._validate_path_value = configuration.get("server", "validate_path_value")
         self._hook = hook.load(configuration)
 
-    def _read_xml_request_body(self, environ: types.WSGIEnviron
+    def _read_xml_request_body(self,
+                               environ: types.WSGIEnviron,
+                               request_info: dict,
                                ) -> Optional[ET.Element]:
         content = httputils.decode_request(
             self.configuration, environ,
@@ -154,19 +161,41 @@ class ApplicationBase:
         except ET.ParseError as e:
             logger.debug("Request content (Invalid XML):\n%s", content)
             raise RuntimeError("Failed to parse XML: %s" % e) from e
-        if logger.isEnabledFor(logging.DEBUG):
-            if self._request_content_on_debug:
-                logger.debug("Request content (XML):\n%s",
-                             utils.textwrap_str(xmlutils.pretty_xml(xml_content)))
+        if self._request_content_on_debug:
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug("Request content (XML):\n%s", utils.textwrap_str(xmlutils.pretty_xml(xml_content)))
+        else:
+            if self._request_content_on_notice_condition != {}:
+                if log.log_conditional(
+                        "request-content",
+                        condition=self._request_content_on_notice_condition,
+                        value=request_info,
+                        ):
+                    logger.notice("Request content (XML, log condition passed):\n%s", utils.textwrap_str(xmlutils.pretty_xml(xml_content)))
+                else:
+                    if logger.isEnabledFor(logging.DEBUG):
+                        logger.debug("Request content (XML, log condition skipped): suppressed")
             else:
-                logger.debug("Request content (XML): suppressed by config/option [logging] request_content_on_debug")
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug("Request content (XML): suppressed by config/option [logging] request_content_on_debug")
         return xml_content
 
-    def _xml_response(self, xml_content: ET.Element) -> bytes:
-        if logger.isEnabledFor(logging.DEBUG):
-            if self._response_content_on_debug:
+    def _xml_response(self, xml_content: ET.Element, request_info: dict) -> bytes:
+        if self._response_content_on_debug:
+            if logger.isEnabledFor(logging.DEBUG):
                 logger.debug("Response content (XML):\n%s",
                              utils.textwrap_str(xmlutils.pretty_xml(xml_content), self._limit_content))
+        else:
+            if self._response_content_on_notice_condition != {}:
+                if log.log_conditional(
+                        "response-content",
+                        condition=self._response_content_on_notice_condition,
+                        value=request_info,
+                        ):
+                    logger.notice("Response content (XML, log condition passed):\n%s", utils.textwrap_str(xmlutils.pretty_xml(xml_content)))
+                else:
+                    if logger.isEnabledFor(logging.DEBUG):
+                        logger.debug("Response content (XML, log condition skipped): suppressed")
             else:
                 logger.debug("Response content (XML): suppressed by config/option [logging] response_content_on_debug")
         f = io.BytesIO()
@@ -174,11 +203,11 @@ class ApplicationBase:
                                           xml_declaration=True)
         return f.getvalue()
 
-    def _webdav_error_response(self, status: int, human_tag: str
+    def _webdav_error_response(self, status: int, human_tag: str, request_info: dict
                                ) -> types.WSGIResponse:
         """Generate XML error response."""
         headers = {"Content-Type": "text/xml; charset=%s" % self._encoding}
-        content = self._xml_response(xmlutils.webdav_error(human_tag))
+        content = self._xml_response(xmlutils.webdav_error(human_tag), request_info)
         return status, headers, content, None
 
 

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/delete.py

@@ -55,7 +55,7 @@ def xml_delete(base_prefix: str, path: str, collection: storage.BaseCollection,
 class ApplicationPartDelete(ApplicationBase):
 
     def do_DELETE(self, environ: types.WSGIEnviron, base_prefix: str,
-                  path: str, user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+                  path: str, user: str, request_info: dict) -> types.WSGIResponse:
         """Manage DELETE request."""
         actor = user
         permissions_filter = None
@@ -126,4 +126,4 @@ class ApplicationPartDelete(ApplicationBase):
             for notification_item in hook_notification_item_list:  # Will be empty if hook not enabled
                 self._hook.notify(notification_item)
             headers = {"Content-Type": "text/xml; charset=%s" % self._encoding}
-            return client.OK, headers, self._xml_response(xml_answer), None
+            return client.OK, headers, self._xml_response(xml_answer, request_info), None

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/get.py

@@ -68,7 +68,7 @@ class ApplicationPartGet(ApplicationBase):
         return value
 
     def do_GET(self, environ: types.WSGIEnviron, base_prefix: str, path: str,
-               user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+               user: str, request_info: dict) -> types.WSGIResponse:
         """Manage GET request."""
         # Redirect to /.web if the root path is requested
         if not pathutils.strip_path(path):
@@ -84,7 +84,7 @@ class ApplicationPartGet(ApplicationBase):
                             base_prefix + unsafe_path, location)
                 return httputils.redirect(location, client.MOVED_PERMANENTLY)
             # Dispatch /.web path to web module
-            return self._web.get(environ, base_prefix, path, user)
+            return self._web.get(environ, base_prefix, path, user, request_info)
         permissions_filter = None
         share = None
         if self._sharing._enabled:
@@ -121,7 +121,10 @@ class ApplicationPartGet(ApplicationBase):
             elif limited_access:
                 return httputils.NOT_ALLOWED
             else:
-                content_type = xmlutils.OBJECT_MIMETYPES[item.name]
+                if share and share['Conversion'] == "bday":
+                    content_type = xmlutils.MIMETYPES["VCALENDAR"]
+                else:
+                    content_type = xmlutils.OBJECT_MIMETYPES[item.name]
                 content_disposition = ""
             assert item.last_modified
             headers = {
@@ -130,9 +133,16 @@ class ApplicationPartGet(ApplicationBase):
                 "ETag": item.etag}
             if content_disposition:
                 headers["Content-Disposition"] = content_disposition
-            if isinstance(item, storage.BaseCollection) and share and share['Conversion'] == "bday":
-                # convert VCF to ICS
-                answer = item.serialize(vcf_to_ics=True)
+            if share and share['Conversion'] == "bday":
+                if isinstance(item, storage.BaseCollection):
+                    # convert VCF to ICS
+                    answer = item.serialize(vcf_to_ics=True)
+                else:
+                    item_converted = item.convert_vcf_to_ics()
+                    if item_converted is not None:
+                        answer = item_converted.serialize()
+                    else:
+                        return httputils.NOT_FOUND
             else:
                 answer = item.serialize()
             return client.OK, headers, answer, None

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/head.py

@@ -26,7 +26,7 @@ from radicale.app.get import ApplicationPartGet
 class ApplicationPartHead(ApplicationPartGet, ApplicationBase):
 
     def do_HEAD(self, environ: types.WSGIEnviron, base_prefix: str, path: str,
-                user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+                user: str, request_info: dict) -> types.WSGIResponse:
         """Manage HEAD request."""
         # Body is dropped in `Application.__call__` for HEAD requests
-        return self.do_GET(environ, base_prefix, path, user, remote_host, remote_useragent)
+        return self.do_GET(environ, base_prefix, path, user, request_info)

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/mkcalendar.py

@@ -32,12 +32,12 @@ from radicale.log import logger
 class ApplicationPartMkcalendar(ApplicationBase):
 
     def do_MKCALENDAR(self, environ: types.WSGIEnviron, base_prefix: str,
-                      path: str, user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+                      path: str, user: str, request_info: dict) -> types.WSGIResponse:
         """Manage MKCALENDAR request."""
         if "w" not in self._rights.authorization(user, path):
             return httputils.NOT_ALLOWED
         try:
-            xml_content = self._read_xml_request_body(environ)
+            xml_content = self._read_xml_request_body(environ, request_info)
         except RuntimeError as e:
             logger.warning(
                 "Bad MKCALENDAR request on %r: %s", path, e, exc_info=True)
@@ -67,7 +67,7 @@ class ApplicationPartMkcalendar(ApplicationBase):
             item = next(iter(self._storage.discover(path)), None)
             if item:
                 return self._webdav_error_response(
-                    client.CONFLICT, "D:resource-must-be-null")
+                    client.CONFLICT, "D:resource-must-be-null", request_info)
             parent_path = pathutils.parent_path(path)
             parent_item = next(iter(self._storage.discover(parent_path)), None)
             if not parent_item:

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/mkcol.py

@@ -32,13 +32,13 @@ from radicale.log import logger
 class ApplicationPartMkcol(ApplicationBase):
 
     def do_MKCOL(self, environ: types.WSGIEnviron, base_prefix: str,
-                 path: str, user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+                 path: str, user: str, request_info: dict) -> types.WSGIResponse:
         """Manage MKCOL request."""
         permissions = self._rights.authorization(user, path)
         if not rights.intersect(permissions, "Ww"):
             return httputils.NOT_ALLOWED
         try:
-            xml_content = self._read_xml_request_body(environ)
+            xml_content = self._read_xml_request_body(environ, request_info)
         except RuntimeError as e:
             logger.warning(
                 "Bad MKCOL request on %r: %s", path, e, exc_info=True)

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/move.py

@@ -49,7 +49,7 @@ def get_server_netloc(environ: types.WSGIEnviron, force_port: bool = False):
 class ApplicationPartMove(ApplicationBase):
 
     def do_MOVE(self, environ: types.WSGIEnviron, base_prefix: str,
-                path: str, user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+                path: str, user: str, request_info: dict) -> types.WSGIResponse:
         """Manage MOVE request."""
         raw_dest = environ.get("HTTP_DESTINATION", "")
 
@@ -136,7 +136,7 @@ class ApplicationPartMove(ApplicationBase):
                     to_collection.has_uid(item.uid)):
                 return self._webdav_error_response(
                     client.CONFLICT, "%s:no-uid-conflict" % (
-                        "C" if collection_tag == "VCALENDAR" else "CR"))
+                        "C" if collection_tag == "VCALENDAR" else "CR"), request_info)
             to_href = posixpath.basename(pathutils.strip_path(to_path))
             try:
                 self._storage.move(item, to_collection, to_href)

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/options.py

@@ -28,7 +28,7 @@ from radicale.app.base import ApplicationBase
 class ApplicationPartOptions(ApplicationBase):
 
     def do_OPTIONS(self, environ: types.WSGIEnviron, base_prefix: str,
-                   path: str, user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+                   path: str, user: str, request_info: dict) -> types.WSGIResponse:
         """Manage OPTIONS request."""
         headers = {
             "Allow": ", ".join(

{radicale-3.7.2 → radicale-3.7.3}/radicale/app/post.py

@@ -26,10 +26,10 @@ from radicale.app.base import ApplicationBase
 class ApplicationPartPost(ApplicationBase):
 
     def do_POST(self, environ: types.WSGIEnviron, base_prefix: str,
-                path: str, user: str, remote_host: str, remote_useragent: str) -> types.WSGIResponse:
+                path: str, user: str, request_info: dict) -> types.WSGIResponse:
         """Manage POST request."""
         if path == "/.web" or path.startswith("/.web/"):
-            return self._web.post(environ, base_prefix, path, user)
+            return self._web.post(environ, base_prefix, path, user, request_info)
         elif path == "/.sharing" or path.startswith("/.sharing/"):
-            return self._sharing.post(environ, base_prefix, path, user)
+            return self._sharing.post(environ, base_prefix, path, user, request_info)
         return httputils.METHOD_NOT_ALLOWED