Import upstream v0.16.22, stripped

Upstream commit: 474dd0229cb20cf513036619781ed97bd8073c3f Enterprise-only files removed or emptied: 63 Enterprise-only snippets removed: 117 in 50 files Dangling module declarations removed: 5 Cargo edits turning enterprise off: 14 Verification: clean Enterprise feature gates left for rebuilt features: 19 in 18 files Produced by tools/fork/strip.py. The full report is in docs/fork/strip-reports/ on main.
2026-09-18 10:21:56 -07:00
commit 7dae9b29fd
1650 changed files with 485521 additions and 0 deletions
@@ -0,0 +1,110 @@
+/*
+ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
+ */
+
+use crate::{
+    parser::{DavParser, Token, tokenizer::Tokenizer},
+    schema::{
+        Element, NamedElement, Namespace,
+        property::{LockScope, LockType},
+        request::LockInfo,
+    },
+};
+use types::dead_property::DeadProperty;
+
+impl DavParser for LockInfo {
+    fn parse(stream: &mut Tokenizer<'_>) -> crate::parser::Result<Self> {
+        let mut lockinfo = LockInfo {
+            lock_scope: LockScope::Exclusive,
+            lock_type: LockType::Write,
+            owner: None,
+        };
+
+        if stream.expect_named_element_or_eof(NamedElement::dav(Element::Lockinfo))? {
+            loop {
+                match stream.token()? {
+                    Token::ElementStart {
+                        name:
+                            NamedElement {
+                                ns: Namespace::Dav,
+                                element: Element::Lockscope,
+                            },
+                        ..
+                    } => {
+                        lockinfo.lock_scope = LockScope::parse(stream)?;
+                    }
+                    Token::ElementStart {
+                        name:
+                            NamedElement {
+                                ns: Namespace::Dav,
+                                element: Element::Locktype,
+                            },
+                        ..
+                    } => {
+                        lockinfo.lock_type = LockType::parse(stream)?;
+                    }
+                    Token::ElementStart {
+                        name:
+                            NamedElement {
+                                ns: Namespace::Dav,
+                                element: Element::Owner,
+                            },
+                        ..
+                    } => {
+                        lockinfo.owner = Some(DeadProperty::parse(stream)?);
+                    }
+                    Token::ElementEnd | Token::Eof => {
+                        break;
+                    }
+                    other => {
+                        return Err(other.into_unexpected());
+                    }
+                }
+            }
+        }
+
+        Ok(lockinfo)
+    }
+}
+
+impl DavParser for LockScope {
+    fn parse(stream: &mut Tokenizer<'_>) -> crate::parser::Result<Self> {
+        match stream.unwrap_named_element()? {
+            NamedElement {
+                ns: Namespace::Dav,
+                element: Element::Exclusive,
+            } => {
+                stream.expect_element_end()?;
+                stream.expect_element_end()?;
+                Ok(LockScope::Exclusive)
+            }
+            NamedElement {
+                ns: Namespace::Dav,
+                element: Element::Shared,
+            } => {
+                stream.expect_element_end()?;
+                stream.expect_element_end()?;
+                Ok(LockScope::Shared)
+            }
+            other => Err(other.into_unexpected()),
+        }
+    }
+}
+
+impl DavParser for LockType {
+    fn parse(stream: &mut Tokenizer<'_>) -> crate::parser::Result<Self> {
+        match stream.unwrap_named_element()? {
+            NamedElement {
+                ns: Namespace::Dav,
+                element: Element::Write,
+            } => {
+                stream.expect_element_end()?;
+                stream.expect_element_end()?;
+                Ok(LockType::Write)
+            }
+            other => Err(other.into_unexpected()),
+        }
+    }
+}