From 5e71a7d84804a86d049d3e0a614c35bedf7cb636 Mon Sep 17 00:00:00 2001 From: Quentin Dufour Date: Wed, 6 Mar 2024 23:24:54 +0100 Subject: [PATCH] Rewrote the whole decoder --- src/dav/caldecoder.rs | 8 +- src/dav/calencoder.rs | 4 +- src/dav/caltypes.rs | 3 +- src/dav/decoder.rs | 748 +++++++++++++++++------------------------ src/dav/encoder.rs | 2 +- src/dav/error.rs | 1 + src/dav/realization.rs | 4 +- src/dav/types.rs | 19 +- src/dav/xml.rs | 87 ++++- 9 files changed, 406 insertions(+), 470 deletions(-) diff --git a/src/dav/caldecoder.rs b/src/dav/caldecoder.rs index b45d649..5f40c4b 100644 --- a/src/dav/caldecoder.rs +++ b/src/dav/caldecoder.rs @@ -7,25 +7,25 @@ use super::error; // ---- EXTENSIONS --- impl xml::QRead for Violation { - async fn qread(xml: &mut xml::Reader) -> Result, error::ParsingError> { + async fn qread(xml: &mut xml::Reader) -> Result { unreachable!(); } } impl xml::QRead for Property { - async fn qread(xml: &mut xml::Reader) -> Result, error::ParsingError> { + async fn qread(xml: &mut xml::Reader) -> Result { unreachable!(); } } impl xml::QRead for PropertyRequest { - async fn qread(xml: &mut xml::Reader) -> Result, error::ParsingError> { + async fn qread(xml: &mut xml::Reader) -> Result { unreachable!(); } } impl xml::QRead for ResourceType { - async fn qread(xml: &mut xml::Reader) -> Result, error::ParsingError> { + async fn qread(xml: &mut xml::Reader) -> Result { unreachable!(); } } diff --git a/src/dav/calencoder.rs b/src/dav/calencoder.rs index cadfc78..58b88c7 100644 --- a/src/dav/calencoder.rs +++ b/src/dav/calencoder.rs @@ -4,8 +4,8 @@ use quick_xml::name::PrefixDeclaration; use tokio::io::AsyncWrite; use super::caltypes::*; -use super::xml::{QWrite, IWrite, Writer}; -use super::types::{Extension, Node}; +use super::xml::{Node, QWrite, IWrite, Writer}; +use super::types::Extension; const ICAL_DATETIME_FMT: &str = "%Y%m%dT%H%M%SZ"; diff --git a/src/dav/caltypes.rs b/src/dav/caltypes.rs index d9cbb12..befecef 100644 --- a/src/dav/caltypes.rs +++ b/src/dav/caltypes.rs @@ -2,6 +2,7 @@ use chrono::{DateTime,Utc}; use super::types as dav; +use super::xml; //@FIXME ACL (rfc3744) is missing, required //@FIXME Versioning (rfc3253) is missing, required @@ -44,7 +45,7 @@ pub struct MkCalendar(pub dav::Set); /// /// #[derive(Debug, PartialEq)] -pub struct MkCalendarResponse>(pub Vec>); +pub struct MkCalendarResponse>(pub Vec>); // --- (REPORT PART) --- diff --git a/src/dav/decoder.rs b/src/dav/decoder.rs index 41eca36..144cc4e 100644 --- a/src/dav/decoder.rs +++ b/src/dav/decoder.rs @@ -9,7 +9,7 @@ use tokio::io::AsyncBufRead; use super::types::*; use super::error::ParsingError; -use super::xml::{QRead, Reader, IRead, DAV_URN, CAL_URN}; +use super::xml::{Node, QRead, Reader, IRead, DAV_URN, CAL_URN}; //@TODO (1) Rewrite all objects as Href, // where we return Ok(None) instead of trying to find the object at any cost. @@ -24,21 +24,22 @@ use super::xml::{QRead, Reader, IRead, DAV_URN, CAL_URN}; /// Propfind request impl QRead> for PropFind { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { + async fn qread(xml: &mut Reader) -> Result { // Find propfind - xml.tag_start(DAV_URN, "propfind").await?; + xml.open(DAV_URN, "propfind").await?; + // Find any tag let propfind: PropFind = loop { match xml.peek() { Event::Start(_) if xml.is_tag(DAV_URN, "allprop") => { - xml.tag_start(DAV_URN, "allprop").await?; - let r = PropFind::AllProp(Include::qread(xml).await?); + xml.open(DAV_URN, "allprop").await?; + let includ = xml.maybe_find::>().await?; + let r = PropFind::AllProp(includ); xml.tag_stop(DAV_URN, "allprop").await?; break r }, Event::Start(_) if xml.is_tag(DAV_URN, "prop") => { - let propname = PropName::qread(xml).await?.ok_or(ParsingError::MissingChild)?; - break PropFind::Prop(propname); + break PropFind::Prop(xml.find::>().await?); }, Event::Empty(_) if xml.is_tag(DAV_URN, "allprop") => { xml.next().await?; @@ -55,47 +56,32 @@ impl QRead> for PropFind { // Close tag xml.tag_stop(DAV_URN, "propfind").await?; - Ok(Some(propfind)) + Ok(propfind) } } /// PROPPATCH request impl QRead> for PropertyUpdate { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "propertyupdate").await?; - let mut collected_items = Vec::new(); - loop { - // Try to collect a property item - if let Some(item) = PropertyUpdateItem::qread(xml).await? { - collected_items.push(item); - continue - } - - // Skip or stop otherwise - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } - + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "propertyupdate").await?; + let collected_items = xml.collect::>().await?; xml.tag_stop(DAV_URN, "propertyupdate").await?; - Ok(Some(PropertyUpdate(collected_items))) + Ok(PropertyUpdate(collected_items)) } } /// Generic response impl> QRead> for Multistatus { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "multistatus").await?; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "multistatus").await?; let mut responses = Vec::new(); let mut responsedescription = None; loop { - if let Some(v) = Response::qread(xml).await? { - responses.push(v); - } else if let Some(v) = ResponseDescription::qread(xml).await? { - responsedescription = Some(v); - } else { + let mut dirty = false; + xml.maybe_push(&mut responses, &mut dirty).await?; + xml.maybe_read(&mut responsedescription, &mut dirty).await?; + if !dirty { match xml.peek() { Event::End(_) => break, _ => xml.skip().await?, @@ -104,23 +90,22 @@ impl> QRead> for Multistatus { } xml.tag_stop(DAV_URN, "multistatus").await?; - Ok(Some(Multistatus { responses, responsedescription })) + Ok(Multistatus { responses, responsedescription }) } } // LOCK REQUEST impl QRead for LockInfo { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "lockinfo").await?; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "lockinfo").await?; let (mut m_scope, mut m_type, mut owner) = (None, None, None); loop { - if let Some(v) = LockScope::qread(xml).await? { - m_scope = Some(v); - } else if let Some(v) = LockType::qread(xml).await? { - m_type = Some(v); - } else if let Some(v) = Owner::qread(xml).await? { - owner = Some(v); - } else { + let mut dirty = false; + xml.maybe_read::(&mut m_scope, &mut dirty).await?; + xml.maybe_read::(&mut m_type, &mut dirty).await?; + xml.maybe_read::(&mut owner, &mut dirty).await?; + + if !dirty { match xml.peek() { Event::End(_) => break, _ => xml.skip().await?, @@ -129,7 +114,7 @@ impl QRead for LockInfo { } xml.tag_stop(DAV_URN, "lockinfo").await?; match (m_scope, m_type) { - (Some(lockscope), Some(locktype)) => Ok(Some(LockInfo { lockscope, locktype, owner })), + (Some(lockscope), Some(locktype)) => Ok(LockInfo { lockscope, locktype, owner }), _ => Err(ParsingError::MissingChild), } } @@ -137,44 +122,22 @@ impl QRead for LockInfo { // LOCK RESPONSE impl QRead> for PropValue { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "prop").await?; - let mut acc = Vec::new(); - loop { - // Found a property - if let Some(prop) = Property::qread(xml).await? { - acc.push(prop); - continue; - } - - // Otherwise skip or escape - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "prop").await?; + let mut acc = xml.collect::>().await?; xml.tag_stop(DAV_URN, "prop").await?; - Ok(Some(PropValue(acc))) + Ok(PropValue(acc)) } } /// Error response impl QRead> for Error { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "error").await?; - let mut violations = Vec::new(); - loop { - match xml.peek() { - Event::Start(_) | Event::Empty(_) => { - Violation::qread(xml).await?.map(|v| violations.push(v)); - }, - Event::End(_) if xml.is_tag(DAV_URN, "error") => break, - _ => { xml.skip().await?; }, - } - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "error").await?; + let violations = xml.collect::>().await?; xml.tag_stop(DAV_URN, "error").await?; - Ok(Some(Error(violations))) + Ok(Error(violations)) } } @@ -182,28 +145,22 @@ impl QRead> for Error { // ---- INNER XML impl> QRead> for Response { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "response").await?.is_none() { - return Ok(None) - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "response").await?; let (mut status, mut error, mut responsedescription, mut location) = (None, None, None, None); let mut href = Vec::new(); let mut propstat = Vec::new(); loop { - if let Some(v) = Status::qread(xml).await? { - status = Some(v); - } else if let Some(v) = Href::qread(xml).await? { - href.push(v); - } else if let Some(v) = PropStat::qread(xml).await? { - propstat.push(v); - } else if let Some(v) = Error::qread(xml).await? { - error = Some(v); - } else if let Some(v) = ResponseDescription::qread(xml).await? { - responsedescription = Some(v); - } else if let Some(v) = Location::qread(xml).await? { - location = Some(v); - } else { + let mut dirty = false; + xml.maybe_read::(&mut status, &mut dirty).await?; + xml.maybe_push::(&mut href, &mut dirty).await?; + xml.maybe_push::>(&mut propstat, &mut dirty).await?; + xml.maybe_read::>(&mut error, &mut dirty).await?; + xml.maybe_read::(&mut responsedescription, &mut dirty).await?; + xml.maybe_read::(&mut location, &mut dirty).await?; + + if !dirty { match xml.peek() { Event::End(_) => break, _ => { xml.skip().await? }, @@ -213,14 +170,14 @@ impl> QRead> for Response { xml.tag_stop(DAV_URN, "response").await?; match (status, &propstat[..], &href[..]) { - (Some(status), &[], &[_, ..]) => Ok(Some(Response { + (Some(status), &[], &[_, ..]) => Ok(Response { status_or_propstat: StatusOrPropstat::Status(href, status), error, responsedescription, location, - })), - (None, &[_, ..], &[_, ..]) => Ok(Some(Response { + }), + (None, &[_, ..], &[_, ..]) => Ok(Response { status_or_propstat: StatusOrPropstat::PropStat(href.into_iter().next().unwrap(), propstat), error, responsedescription, location, - })), + }), (Some(_), &[_, ..], _) => Err(ParsingError::InvalidValue), _ => Err(ParsingError::MissingChild), } @@ -228,255 +185,173 @@ impl> QRead> for Response { } impl> QRead> for PropStat { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "propstat").await?.is_none() { - return Ok(None) + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "propstat").await?; + + let (mut m_prop, mut m_status, mut error, mut responsedescription) = (None, None, None, None); + + loop { + let mut dirty = false; + xml.maybe_read::(&mut m_prop, &mut dirty).await?; + xml.maybe_read::(&mut m_status, &mut dirty).await?; + xml.maybe_read::>(&mut error, &mut dirty).await?; + xml.maybe_read::(&mut responsedescription, &mut dirty).await?; + + if !dirty { + match xml.peek() { + Event::End(_) => break, + _ => xml.skip().await?, + }; + } + } + + xml.tag_stop(DAV_URN, "propstat").await?; + match (m_prop, m_status) { + (Some(prop), Some(status)) => Ok(PropStat { prop, status, error, responsedescription }), + _ => Err(ParsingError::MissingChild), } - unimplemented!(); } } impl QRead for Status { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "status").await?.is_none() { - return Ok(None) - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "status").await?; let fullcode = xml.tag_string().await?; let txtcode = fullcode.splitn(3, ' ').nth(1).ok_or(ParsingError::InvalidValue)?; let code = http::status::StatusCode::from_bytes(txtcode.as_bytes()).or(Err(ParsingError::InvalidValue))?; xml.tag_stop(DAV_URN, "status").await?; - Ok(Some(Status(code))) + Ok(Status(code)) } } impl QRead for ResponseDescription { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "responsedescription").await?.is_none() { - return Ok(None) - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "responsedescription").await?; let cnt = xml.tag_string().await?; xml.tag_stop(DAV_URN, "responsedescription").await?; - Ok(Some(ResponseDescription(cnt))) + Ok(ResponseDescription(cnt)) } } impl QRead for Location { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "location").await?.is_none() { - return Ok(None) - } - let href = loop { - if let Some(v) = Href::qread(xml).await? { - break v - } - - match xml.peek() { - Event::End(_) => return Err(ParsingError::MissingChild), - _ => xml.skip().await?, - }; - }; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "location").await?; + let href = xml.find::().await?; xml.tag_stop(DAV_URN, "location").await?; - Ok(Some(Location(href))) + Ok(Location(href)) } } impl QRead> for PropertyUpdateItem { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if let Some(rm) = Remove::qread(xml).await? { - return Ok(Some(PropertyUpdateItem::Remove(rm))) + async fn qread(xml: &mut Reader) -> Result { + match Remove::qread(xml).await { + Err(ParsingError::Recoverable) => (), + otherwise => return otherwise.map(PropertyUpdateItem::Remove), } - Ok(Set::qread(xml).await?.map(PropertyUpdateItem::Set)) + Set::qread(xml).await.map(PropertyUpdateItem::Set) } } impl QRead> for Remove { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - match xml.peek() { - Event::Start(b) if xml.is_tag(DAV_URN, "remove") => xml.next().await?, - _ => return Ok(None), - }; - - let propname = loop { - match xml.peek() { - Event::Start(b) | Event::Empty(b) if xml.is_tag(DAV_URN, "prop") => break PropName::qread(xml).await?, - _ => xml.skip().await?, - }; - }; - + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "remove").await?; + let propname = xml.find::>().await?; xml.tag_stop(DAV_URN, "remove").await?; - Ok(propname.map(Remove)) + Ok(Remove(propname)) } } impl QRead> for Set { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - match xml.peek() { - Event::Start(b) if xml.is_tag(DAV_URN, "set") => xml.next().await?, - _ => return Ok(None), - }; - let propvalue = loop { - match xml.peek() { - Event::Start(b) | Event::Empty(b) if xml.is_tag(DAV_URN, "prop") => break PropValue::qread(xml).await?, - _ => xml.skip().await?, - }; - }; - - + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "set").await?; + let propvalue = xml.find::>().await?; xml.tag_stop(DAV_URN, "set").await?; - Ok(propvalue.map(Set)) + Ok(Set(propvalue)) } } impl QRead> for Violation { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - loop { - let bs = match xml.peek() { - Event::Start(b) | Event::Empty(b) => b, - _ => { - xml.skip().await?; - continue + async fn qread(xml: &mut Reader) -> Result { + let bs = match xml.peek() { + Event::Start(b) | Event::Empty(b) => b, + _ => return Err(ParsingError::Recoverable), + }; + + // Option 1: a pure DAV property + let (ns, loc) = xml.rdr.resolve_element(bs.name()); + if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) { + match loc.into_inner() { + b"lock-token-matches-request-uri" => { + xml.next().await?; + return Ok(Violation::LockTokenMatchesRequestUri) }, + b"lock-token-submitted" => { + xml.next().await?; + let links = xml.collect::().await?; + xml.tag_stop(DAV_URN, "lock-token-submitted").await?; + return Ok(Violation::LockTokenSubmitted(links)) + }, + b"no-conflicting-lock" => { + // start tag + xml.next().await?; + let links = xml.collect::().await?; + xml.tag_stop(DAV_URN, "no-conflicting-lock").await?; + return Ok(Violation::NoConflictingLock(links)) + }, + b"no-external-entities" => { + xml.next().await?; + return Ok(Violation::NoExternalEntities) + }, + b"preserved-live-properties" => { + xml.next().await?; + return Ok(Violation::PreservedLiveProperties) + }, + b"propfind-finite-depth" => { + xml.next().await?; + return Ok(Violation::PropfindFiniteDepth) + }, + b"cannot-modify-protected-property" => { + xml.next().await?; + return Ok(Violation::CannotModifyProtectedProperty) + }, + _ => (), }; - - let mut maybe_res = None; - - // Option 1: a pure DAV property - let (ns, loc) = xml.rdr.resolve_element(bs.name()); - if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) { - maybe_res = match loc.into_inner() { - b"lock-token-matches-request-uri" => { - xml.next().await?; - Some(Violation::LockTokenMatchesRequestUri) - }, - b"lock-token-submitted" => { - // start tag - xml.next().await?; - - let mut links = Vec::new(); - loop { - // If we find a Href - if let Some(href) = Href::qread(xml).await? { - links.push(href); - continue - } - - // Otherwise - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } - xml.tag_stop(DAV_URN, "lock-token-submitted").await?; - Some(Violation::LockTokenSubmitted(links)) - }, - b"no-conflicting-lock" => { - // start tag - xml.next().await?; - - let mut links = Vec::new(); - loop { - // If we find a Href - if let Some(href) = Href::qread(xml).await? { - links.push(href); - continue - } - - // Otherwise - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } - xml.tag_stop(DAV_URN, "no-conflicting-lock").await?; - Some(Violation::NoConflictingLock(links)) - }, - b"no-external-entities" => { - xml.next().await?; - Some(Violation::NoExternalEntities) - }, - b"preserved-live-properties" => { - xml.next().await?; - Some(Violation::PreservedLiveProperties) - }, - b"propfind-finite-depth" => { - xml.next().await?; - Some(Violation::PropfindFiniteDepth) - }, - b"cannot-modify-protected-property" => { - xml.next().await?; - Some(Violation::CannotModifyProtectedProperty) - }, - _ => None, - }; - } - - // Option 2: an extension property, delegating - if maybe_res.is_none() { - maybe_res = E::Error::qread(xml).await?.map(Violation::Extension); - } - - return Ok(maybe_res) } + + // Option 2: an extension property, delegating + E::Error::qread(xml).await.map(Violation::Extension) } } impl QRead> for Include { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "include").await?; - let mut acc = Vec::new(); - loop { - // Found a property - if let Some(prop) = PropertyRequest::qread(xml).await? { - acc.push(prop); - continue; - } - - // Otherwise skip or escape - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "include").await?; + let acc = xml.collect::>().await?; xml.tag_stop(DAV_URN, "include").await?; - Ok(Some(Include(acc))) + Ok(Include(acc)) } } impl QRead> for PropName { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "prop").await?; - let mut acc = Vec::new(); - loop { - // Found a property - if let Some(prop) = PropertyRequest::qread(xml).await? { - acc.push(prop); - continue; - } - - // Otherwise skip or escape - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "prop").await?; + let acc = xml.collect::>().await?; xml.tag_stop(DAV_URN, "prop").await?; - Ok(Some(PropName(acc))) + Ok(PropName(acc)) } } impl QRead> for PropertyRequest { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { + async fn qread(xml: &mut Reader) -> Result { let bs = match xml.peek() { Event::Start(b) | Event::Empty(b) => b, - _ => return Ok(None), + _ => return Err(ParsingError::Recoverable), }; - let mut maybe_res = None; - // Option 1: a pure core DAV property let (ns, loc) = xml.rdr.resolve_element(bs.name()); if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) { - maybe_res = match loc.into_inner() { + let maybe_res = match loc.into_inner() { b"creationdate" => Some(PropertyRequest::CreationDate), b"displayname" => Some(PropertyRequest::DisplayName), b"getcontentlanguage" => Some(PropertyRequest::GetContentLanguage), @@ -490,163 +365,105 @@ impl QRead> for PropertyRequest { _ => None, }; // Close the current tag if we read something - if maybe_res.is_some() { + if let Some(res) = maybe_res { xml.skip().await?; + return Ok(res) } } // Option 2: an extension property, delegating - if maybe_res.is_none() { - maybe_res = E::PropertyRequest::qread(xml).await?.map(PropertyRequest::Extension); - } - - Ok(maybe_res) + E::PropertyRequest::qread(xml).await.map(PropertyRequest::Extension) } } impl QRead> for Property { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { + async fn qread(xml: &mut Reader) -> Result { use chrono::{DateTime, FixedOffset, TimeZone}; let bs = match xml.peek() { Event::Start(b) | Event::Empty(b) => b, - _ => return Ok(None), + _ => return Err(ParsingError::Recoverable), }; - let mut maybe_res = None; - // Option 1: a pure core DAV property let (ns, loc) = xml.rdr.resolve_element(bs.name()); if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) { - maybe_res = match loc.into_inner() { + match loc.into_inner() { b"creationdate" => { xml.next().await?; let datestr = xml.tag_string().await?; - Some(Property::CreationDate(DateTime::parse_from_rfc3339(datestr.as_str())?)) + return Ok(Property::CreationDate(DateTime::parse_from_rfc3339(datestr.as_str())?)) }, b"displayname" => { xml.next().await?; - Some(Property::DisplayName(xml.tag_string().await?)) + return Ok(Property::DisplayName(xml.tag_string().await?)) }, b"getcontentlanguage" => { xml.next().await?; - Some(Property::GetContentLanguage(xml.tag_string().await?)) + return Ok(Property::GetContentLanguage(xml.tag_string().await?)) }, b"getcontentlength" => { xml.next().await?; let cl = xml.tag_string().await?.parse::()?; - Some(Property::GetContentLength(cl)) + return Ok(Property::GetContentLength(cl)) }, b"getcontenttype" => { xml.next().await?; - Some(Property::GetContentType(xml.tag_string().await?)) + return Ok(Property::GetContentType(xml.tag_string().await?)) }, b"getetag" => { xml.next().await?; - Some(Property::GetEtag(xml.tag_string().await?)) + return Ok(Property::GetEtag(xml.tag_string().await?)) }, b"getlastmodified" => { - xml.next().await?; xml.next().await?; let datestr = xml.tag_string().await?; - Some(Property::CreationDate(DateTime::parse_from_rfc2822(datestr.as_str())?)) + return Ok(Property::CreationDate(DateTime::parse_from_rfc2822(datestr.as_str())?)) }, b"lockdiscovery" => { - // start tag xml.next().await?; - - let mut acc = Vec::new(); - loop { - // If we find a lock - if let Some(lock) = ActiveLock::qread(xml).await? { - acc.push(lock); - continue - } - - // Otherwise - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } + let acc = xml.collect::().await?; xml.tag_stop(DAV_URN, "lockdiscovery").await?; - Some(Property::LockDiscovery(acc)) + return Ok(Property::LockDiscovery(acc)) }, b"resourcetype" => { xml.next().await?; - - let mut acc = Vec::new(); - loop { - // If we find a resource type... - if let Some(restype) = ResourceType::qread(xml).await? { - acc.push(restype); - continue - } - - // Otherwise - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } + let acc = xml.collect::>().await?; xml.tag_stop(DAV_URN, "resourcetype").await?; - Some(Property::ResourceType(acc)) + return Ok(Property::ResourceType(acc)) }, b"supportedlock" => { xml.next().await?; - - let mut acc = Vec::new(); - loop { - // If we find a resource type... - if let Some(restype) = LockEntry::qread(xml).await? { - acc.push(restype); - continue - } - - // Otherwise - match xml.peek() { - Event::End(_) => break, - _ => { xml.skip().await?; }, - } - } + let acc = xml.collect::().await?; xml.tag_stop(DAV_URN, "supportedlock").await?; - Some(Property::SupportedLock(acc)) + return Ok(Property::SupportedLock(acc)) }, - _ => None, + _ => (), }; } // Option 2: an extension property, delegating - if maybe_res.is_none() { - maybe_res = E::Property::qread(xml).await?.map(Property::Extension); - } - - Ok(maybe_res) + E::Property::qread(xml).await.map(Property::Extension) } } impl QRead for ActiveLock { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "activelock").await?; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "activelock").await?; let (mut m_scope, mut m_type, mut m_depth, mut owner, mut timeout, mut locktoken, mut m_root) = (None, None, None, None, None, None, None); loop { - if let Some(v) = LockScope::qread(xml).await? { - m_scope = Some(v); - } else if let Some(v) = LockType::qread(xml).await? { - m_type = Some(v); - } else if let Some(v) = Depth::qread(xml).await? { - m_depth = Some(v); - } else if let Some(v) = Owner::qread(xml).await? { - owner = Some(v); - } else if let Some(v) = Timeout::qread(xml).await? { - timeout = Some(v); - } else if let Some(v) = LockToken::qread(xml).await? { - locktoken = Some(v); - } else if let Some(v) = LockRoot::qread(xml).await? { - m_root = Some(v); - } else { + let mut dirty = false; + xml.maybe_read::(&mut m_scope, &mut dirty).await?; + xml.maybe_read::(&mut m_type, &mut dirty).await?; + xml.maybe_read::(&mut m_depth, &mut dirty).await?; + xml.maybe_read::(&mut owner, &mut dirty).await?; + xml.maybe_read::(&mut timeout, &mut dirty).await?; + xml.maybe_read::(&mut locktoken, &mut dirty).await?; + xml.maybe_read::(&mut m_root, &mut dirty).await?; + + if !dirty { match xml.peek() { Event::End(_) => break, _ => { xml.skip().await?; }, @@ -657,31 +474,29 @@ impl QRead for ActiveLock { xml.tag_stop(DAV_URN, "activelock").await?; match (m_scope, m_type, m_depth, m_root) { (Some(lockscope), Some(locktype), Some(depth), Some(lockroot)) => - Ok(Some(ActiveLock { lockscope, locktype, depth, owner, timeout, locktoken, lockroot })), + Ok(ActiveLock { lockscope, locktype, depth, owner, timeout, locktoken, lockroot }), _ => Err(ParsingError::MissingChild), } } } impl QRead for Depth { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "depth").await?; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "depth").await?; let depth_str = xml.tag_string().await?; xml.tag_stop(DAV_URN, "depth").await?; match depth_str.as_str() { - "0" => Ok(Some(Depth::Zero)), - "1" => Ok(Some(Depth::One)), - "infinity" => Ok(Some(Depth::Infinity)), + "0" => Ok(Depth::Zero), + "1" => Ok(Depth::One), + "infinity" => Ok(Depth::Infinity), _ => Err(ParsingError::WrongToken), } } } impl QRead for Owner { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "owner").await?.is_none() { - return Ok(None) - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "owner").await?; let mut owner = Owner::Unknown; loop { @@ -693,28 +508,25 @@ impl QRead for Owner { } } Event::Start(_) | Event::Empty(_) => { - if let Some(href) = Href::qread(xml).await? { - owner = Owner::Href(href) + match Href::qread(xml).await { + Ok(href) => { owner = Owner::Href(href); }, + Err(ParsingError::Recoverable) => { xml.skip().await?; }, + Err(e) => return Err(e), } - xml.skip().await?; } Event::End(_) => break, _ => { xml.skip().await?; }, } }; xml.tag_stop(DAV_URN, "owner").await?; - Ok(Some(owner)) + Ok(owner) } } impl QRead for Timeout { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { + async fn qread(xml: &mut Reader) -> Result { const SEC_PFX: &str = "SEC_PFX"; - - match xml.peek() { - Event::Start(b) if xml.is_tag(DAV_URN, "timeout") => xml.next().await?, - _ => return Ok(None), - }; + xml.open(DAV_URN, "timeout").await?; let timeout = match xml.tag_string().await?.as_str() { "Infinite" => Timeout::Infinite, @@ -725,79 +537,70 @@ impl QRead for Timeout { }; xml.tag_stop(DAV_URN, "timeout").await?; - Ok(Some(timeout)) + Ok(timeout) } } impl QRead for LockToken { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - match xml.peek() { - Event::Start(b) if xml.is_tag(DAV_URN, "locktoken") => xml.next().await?, - _ => return Ok(None), - }; - let href = Href::qread(xml).await?.ok_or(ParsingError::MissingChild)?; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "locktoken").await?; + let href = Href::qread(xml).await?; xml.tag_stop(DAV_URN, "locktoken").await?; - Ok(Some(LockToken(href))) + Ok(LockToken(href)) } } impl QRead for LockRoot { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "lockroot").await?; - let href = Href::qread(xml).await?.ok_or(ParsingError::MissingChild)?; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "lockroot").await?; + let href = Href::qread(xml).await?; xml.tag_stop(DAV_URN, "lockroot").await?; - Ok(Some(LockRoot(href))) + Ok(LockRoot(href)) } } impl QRead> for ResourceType { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { + async fn qread(xml: &mut Reader) -> Result { match xml.peek() { Event::Empty(b) if xml.is_tag(DAV_URN, "collection") => { xml.next().await?; - Ok(Some(ResourceType::Collection)) + Ok(ResourceType::Collection) }, - _ => Ok(E::ResourceType::qread(xml).await?.map(ResourceType::Extension)), + _ => E::ResourceType::qread(xml).await.map(ResourceType::Extension), } } } impl QRead for LockEntry { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - xml.tag_start(DAV_URN, "lockentry").await?; + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "lockentry").await?; let (mut maybe_scope, mut maybe_type) = (None, None); loop { - match xml.peek() { - Event::Start(_) if xml.is_tag(DAV_URN, "lockscope") => { - maybe_scope = LockScope::qread(xml).await?; - }, - Event::Start(_) if xml.is_tag(DAV_URN, "lockentry") => { - maybe_type = LockType::qread(xml).await?; - } - Event::End(_) => break, - _ => { xml.skip().await?; }, + let mut dirty = false; + xml.maybe_read::(&mut maybe_scope, &mut dirty).await?; + xml.maybe_read::(&mut maybe_type, &mut dirty).await?; + if !dirty { + match xml.peek() { + Event::End(_) => break, + _ => xml.skip().await?, + }; } } - let lockentry = match (maybe_scope, maybe_type) { - (Some(lockscope), Some(locktype)) => LockEntry { lockscope, locktype }, - _ => return Err(ParsingError::MissingChild), - }; - xml.tag_stop(DAV_URN, "lockentry").await?; - Ok(Some(lockentry)) + match (maybe_scope, maybe_type) { + (Some(lockscope), Some(locktype)) => Ok(LockEntry { lockscope, locktype }), + _ => Err(ParsingError::MissingChild), + } } } impl QRead for LockScope { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "lockscope").await?.is_none() { - return Ok(None) - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "lockscope").await?; let lockscope = loop { - println!("lockscope tag: {:?}", xml.peek()); match xml.peek() { Event::Empty(_) if xml.is_tag(DAV_URN, "exclusive") => { xml.next().await?; @@ -812,15 +615,13 @@ impl QRead for LockScope { }; xml.tag_stop(DAV_URN, "lockscope").await?; - Ok(Some(lockscope)) + Ok(lockscope) } } impl QRead for LockType { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - if xml.maybe_tag_start(DAV_URN, "locktype").await?.is_none() { - return Ok(None) - } + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "locktype").await?; let locktype = loop { match xml.peek() { @@ -832,20 +633,16 @@ impl QRead for LockType { }; }; xml.tag_stop(DAV_URN, "locktype").await?; - Ok(Some(locktype)) + Ok(locktype) } } impl QRead for Href { - async fn qread(xml: &mut Reader) -> Result, ParsingError> { - match xml.peek() { - Event::Start(b) if xml.is_tag(DAV_URN, "href") => xml.next().await?, - _ => return Ok(None), - }; - + async fn qread(xml: &mut Reader) -> Result { + xml.open(DAV_URN, "href").await?; let mut url = xml.tag_string().await?; xml.tag_stop(DAV_URN, "href").await?; - Ok(Some(Href(url))) + Ok(Href(url)) } } @@ -865,7 +662,7 @@ mod tests { "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap(); - let got = PropFind::::qread(&mut rdr).await.unwrap().unwrap(); + let got = rdr.find::>().await.unwrap(); assert_eq!(got, PropFind::::PropName); } @@ -889,7 +686,7 @@ mod tests { "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap(); - let got = PropFind::::qread(&mut rdr).await.unwrap().unwrap(); + let got = rdr.find::>().await.unwrap(); assert_eq!(got, PropFind::Prop(PropName(vec![ PropertyRequest::DisplayName, @@ -912,7 +709,7 @@ mod tests { "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap(); - let got = Error::::qread(&mut rdr).await.unwrap().unwrap(); + let got = rdr.find::>().await.unwrap(); assert_eq!(got, Error(vec![ Violation::LockTokenSubmitted(vec![ @@ -941,7 +738,7 @@ mod tests { "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap(); - let got = PropertyUpdate::::qread(&mut rdr).await.unwrap().unwrap(); + let got = rdr.find::>().await.unwrap(); assert_eq!(got, PropertyUpdate(vec![ PropertyUpdateItem::Set(Set(PropValue(vec![]))), @@ -950,7 +747,7 @@ mod tests { } #[tokio::test] - async fn rfc_lockinfo1() { + async fn rfc_lockinfo() { let src = r#" @@ -963,7 +760,8 @@ mod tests { "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap(); - let got = LockInfo::qread(&mut rdr).await.unwrap().unwrap(); + let got = rdr.find::().await.unwrap(); + assert_eq!(got, LockInfo { lockscope: LockScope::Exclusive, locktype: LockType::Write, @@ -971,4 +769,58 @@ mod tests { }); } + #[tokio::test] + async fn rfc_multistatus_name() { + let src = r#" + + + + http://www.example.com/container/ + + + + + + + + + + HTTP/1.1 200 OK + + + + http://www.example.com/container/front.html + + + + + + + + + + + + + HTTP/1.1 200 OK + + + +"#; + + let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap(); + let got = rdr.find::>>().await.unwrap(); + + /*assert_eq!(got, Multistatus { + responses: vec![ + Response { + status_or_propstat: + }, + Response {}, + ], + responsedescription: None, + });*/ + + } + } diff --git a/src/dav/encoder.rs b/src/dav/encoder.rs index 9e60f29..4de5440 100644 --- a/src/dav/encoder.rs +++ b/src/dav/encoder.rs @@ -6,7 +6,7 @@ use quick_xml::writer::ElementWriter; use quick_xml::name::PrefixDeclaration; use tokio::io::AsyncWrite; use super::types::*; -use super::xml::{Writer,QWrite,IWrite}; +use super::xml::{Node, Writer,QWrite,IWrite}; // --- XML ROOTS diff --git a/src/dav/error.rs b/src/dav/error.rs index 88a5e60..78c6d6b 100644 --- a/src/dav/error.rs +++ b/src/dav/error.rs @@ -2,6 +2,7 @@ use quick_xml::events::attributes::AttrError; #[derive(Debug)] pub enum ParsingError { + Recoverable, MissingChild, NamespacePrefixAlreadyUsed, WrongToken, diff --git a/src/dav/realization.rs b/src/dav/realization.rs index 1898173..33a556e 100644 --- a/src/dav/realization.rs +++ b/src/dav/realization.rs @@ -6,8 +6,8 @@ use super::error; #[derive(Debug, PartialEq)] pub struct Disabled(()); impl xml::QRead for Disabled { - async fn qread(xml: &mut xml::Reader) -> Result, error::ParsingError> { - Ok(None) + async fn qread(xml: &mut xml::Reader) -> Result { + Err(error::ParsingError::Recoverable) } } impl xml::QWrite for Disabled { diff --git a/src/dav/types.rs b/src/dav/types.rs index 246a4bd..5ea38d1 100644 --- a/src/dav/types.rs +++ b/src/dav/types.rs @@ -7,12 +7,11 @@ use super::error; /// It's how we implement a DAV extension /// (That's the dark magic part...) -pub trait Node = xml::QRead + xml::QWrite + Debug + PartialEq; -pub trait Extension { - type Error: Node; - type Property: Node; - type PropertyRequest: Node; - type ResourceType: Node; +pub trait Extension: std::fmt::Debug + PartialEq { + type Error: xml::Node; + type Property: xml::Node; + type PropertyRequest: xml::Node; + type ResourceType: xml::Node; } /// 14.1. activelock XML Element @@ -333,7 +332,7 @@ pub enum LockType { /// /// #[derive(Debug, PartialEq)] -pub struct Multistatus> { +pub struct Multistatus> { pub responses: Vec>, pub responsedescription: Option, } @@ -465,7 +464,7 @@ pub enum PropFind { /// /// #[derive(Debug, PartialEq)] -pub struct PropStat> { +pub struct PropStat> { pub prop: N, pub status: Status, pub error: Option>, @@ -514,7 +513,7 @@ pub struct Remove(pub PropName); /// --- rewritten as --- /// #[derive(Debug, PartialEq)] -pub enum StatusOrPropstat> { +pub enum StatusOrPropstat> { // One status, multiple hrefs... Status(Vec, Status), // A single href, multiple properties... @@ -522,7 +521,7 @@ pub enum StatusOrPropstat> { } #[derive(Debug, PartialEq)] -pub struct Response> { +pub struct Response> { pub status_or_propstat: StatusOrPropstat, pub error: Option>, pub responsedescription: Option, diff --git a/src/dav/xml.rs b/src/dav/xml.rs index ff121f4..d465d60 100644 --- a/src/dav/xml.rs +++ b/src/dav/xml.rs @@ -19,9 +19,14 @@ pub trait QWrite { async fn qwrite(&self, xml: &mut Writer) -> Result<(), quick_xml::Error>; } pub trait QRead { - async fn qread(xml: &mut Reader) -> Result, ParsingError>; + async fn qread(xml: &mut Reader) -> Result; } +// The representation of an XML node in Rust +pub trait Node = QRead + QWrite + std::fmt::Debug + PartialEq; + +// --------------- + /// Transform a Rust object into an XML stream of characters pub struct Writer { pub q: quick_xml::writer::Writer, @@ -106,6 +111,8 @@ impl Reader { } } + /* + * Disabled /// maybe find start tag pub async fn maybe_tag_start(&mut self, ns: &[u8], key: &str) -> Result>, ParsingError> { println!("maybe start tag {}", key); @@ -118,7 +125,6 @@ impl Reader { /// find start tag pub async fn tag_start(&mut self, ns: &[u8], key: &str) -> Result, ParsingError> { - println!("search start tag {}", key); loop { match self.peek() { Event::Start(b) if self.is_tag(ns, key) => break, @@ -127,6 +133,7 @@ impl Reader { } self.next().await } + */ // find stop tag pub async fn tag_stop(&mut self, ns: &[u8], key: &str) -> Result, ParsingError> { @@ -157,5 +164,81 @@ impl Reader { }; } } + + // NEW API + pub async fn maybe_read>(&mut self, t: &mut Option, dirty: &mut bool) -> Result<(), ParsingError> { + match N::qread(self).await { + Ok(v) => { + *t = Some(v); + *dirty = true; + Ok(()) + }, + Err(ParsingError::Recoverable) => Ok(()), + Err(e) => Err(e), + } + } + + pub async fn maybe_push>(&mut self, t: &mut Vec, dirty: &mut bool) -> Result<(), ParsingError> { + match N::qread(self).await { + Ok(v) => { + t.push(v); + *dirty = true; + Ok(()) + }, + Err(ParsingError::Recoverable) => Ok(()), + Err(e) => Err(e), + } + } + + pub async fn find>(&mut self) -> Result { + loop { + // Try parse + match N::qread(self).await { + Err(ParsingError::Recoverable) => (), + otherwise => return otherwise, + } + + // If recovered, skip the element + self.skip().await?; + } + } + + pub async fn maybe_find>(&mut self) -> Result, ParsingError> { + loop { + // Try parse + match N::qread(self).await { + Err(ParsingError::Recoverable) => (), + otherwise => return otherwise.map(Some), + } + + match self.peek() { + Event::End(_) => return Ok(None), + _ => self.skip().await?, + }; + } + } + + pub async fn collect>(&mut self) -> Result, ParsingError> { + let mut acc = Vec::new(); + loop { + match N::qread(self).await { + Err(ParsingError::Recoverable) => match self.peek() { + Event::End(_) => return Ok(acc), + _ => { + self.skip().await?; + }, + }, + Ok(v) => acc.push(v), + Err(e) => return Err(e), + } + } + } + + pub async fn open(&mut self, ns: &[u8], key: &str) -> Result, ParsingError> { + if self.is_tag(ns, key) { + return self.next().await + } + return Err(ParsingError::Recoverable); + } }