Bump quick-xml dependency

Author: mdecimus

Cargo.toml

@@ -19,7 +19,7 @@ doctest = false
 default = ["ring", "rustls-pemfile", "report"]
 rust-crypto = ["ed25519-dalek", "rsa", "sha1", "sha2"]
 generate = ["rsa", "rand"]
-report = ["quick-xml", "zip"]
+report = ["quick-xml", "zip", "hashify"]
 test = []
 rkyv = ["dep:rkyv", "mail-parser/rkyv"]
 
@@ -29,7 +29,8 @@ ed25519-dalek = { version = "2.0", optional = true }
 flate2 = "1.0.25"
 mail-parser = { version = "0.11", features = ["full_encoding"] }
 mail-builder = { version = "0.4" }
-quick-xml = { version = "0.37", optional = true }
+quick-xml = { version = "0.38", optional = true }
+hashify =  { version = "0.2.6", optional = true }
 ring = { version = "0.17", optional = true }
 rsa = { version = "0.9.8", optional = true }
 rustls-pemfile = { version = "2", optional = true }

src/dkim/canonicalize.rs

@@ -245,30 +245,30 @@ mod test {
                 ),
                 (
                     concat!("from:John doe <[email protected]>\r\n", "subject:test\r\n"),
-                    concat!(" body\r\n"),
+                    " body\r\n",
                 ),
                 (
                     concat!(
                         "  From : John\tdoe <[email protected]>\t\r\n",
                         "SUB JECT:\ttest  \t  \r\n"
                     ),
-                    concat!(" body \t   \r\n"),
+                    " body \t   \r\n",
                 ),
             ),
             (
-                concat!("H: value\t\r\n\r\n",),
-                (concat!("h:value\r\n"), concat!("")),
-                (concat!("H: value\t\r\n"), concat!("\r\n")),
+                "H: value\t\r\n\r\n",
+                ("h:value\r\n", ""),
+                ("H: value\t\r\n", "\r\n"),
             ),
             (
-                concat!("\tx\t: \t\t\tz\r\n\r\nabc",),
-                (concat!("x:z\r\n"), concat!("abc\r\n")),
-                ("\tx\t: \t\t\tz\r\n", concat!("abc\r\n")),
+                "\tx\t: \t\t\tz\r\n\r\nabc",
+                ("x:z\r\n", "abc\r\n"),
+                ("\tx\t: \t\t\tz\r\n", "abc\r\n"),
             ),
             (
-                concat!("Subject: hello\r\n\r\n\r\n",),
-                (concat!("subject:hello\r\n"), ""),
-                ("Subject: hello\r\n", concat!("\r\n")),
+                "Subject: hello\r\n\r\n\r\n",
+                ("subject:hello\r\n", ""),
+                ("Subject: hello\r\n", "\r\n"),
             ),
         ] {
             let mut header_iterator = HeaderIterator::new(message.as_bytes());

src/dkim/mod.rs

@@ -241,7 +241,7 @@ impl ArcOutput<'_> {
         &self.result
     }
 
-    pub fn sets(&self) -> &[Set] {
+    pub fn sets(&'_ self) -> &'_ [Set<'_>] {
         &self.set
     }
 }

src/lib.rs

@@ -69,7 +69,7 @@ pub trait ResolverCache<K, V>: Sized {
     fn insert(&self, key: K, value: V, valid_until: Instant);
 }
 
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, Hash, PartialEq, Eq)]
 pub enum IpLookupStrategy {
     /// Only query for A (Ipv4) records
     Ipv4Only,

src/report/dmarc/parse.rs

@@ -4,21 +4,20 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  */
 
-use std::io::{BufRead, Cursor, Read};
-use std::net::IpAddr;
-use std::str::FromStr;
-
-use flate2::read::GzDecoder;
-use mail_parser::{MessageParser, MimeHeaders, PartType};
-use quick_xml::events::{BytesStart, Event};
-use quick_xml::reader::Reader;
-
 use crate::report::{
     ActionDisposition, Alignment, AuthResult, DKIMAuthResult, DateRange, Disposition, DkimResult,
     DmarcResult, Error, Extension, Identifier, PolicyEvaluated, PolicyOverride,
     PolicyOverrideReason, PolicyPublished, Record, Report, ReportMetadata, Row, SPFAuthResult,
     SPFDomainScope, SpfResult,
 };
+use flate2::read::GzDecoder;
+use mail_parser::{MessageParser, MimeHeaders, PartType};
+use quick_xml::events::{BytesStart, Event};
+use quick_xml::reader::Reader;
+use std::borrow::Cow;
+use std::io::{BufRead, Cursor, Read};
+use std::net::IpAddr;
+use std::str::FromStr;
 
 impl Report {
     pub fn parse_rfc5322(report: &[u8]) -> Result<Self, Error> {
@@ -707,11 +706,46 @@ impl<R: BufRead> ReaderHelper for Reader<R> {
     }
 
     fn next_value<T: FromStr>(&mut self, buf: &mut Vec<u8>) -> Result<Option<T>, String> {
-        let mut value = None;
+        let mut value: Option<String> = None;
+
         loop {
             match self.read_event_into(buf) {
                 Ok(Event::Text(e)) => {
-                    value = e.unescape().ok().and_then(|v| T::from_str(v.as_ref()).ok());
+                    let v = e.xml_content().map_err(|e| {
+                        format!(
+                            "Failed to decode text value at position {}: {}",
+                            self.buffer_position(),
+                            e
+                        )
+                    })?;
+                    if let Some(value) = &mut value {
+                        value.push_str(&v);
+                    } else {
+                        value = Some(v.into_owned());
+                    }
+                }
+                Ok(Event::GeneralRef(e)) => {
+                    let v = hashify::tiny_map!(e.as_ref(),
+                        b"lt" => "<",
+                        b"gt" => ">",
+                        b"amp" => "&",
+                        b"apos" => "'",
+                        b"quot" => "\"",
+                    )
+                    .map(Cow::Borrowed)
+                    .or_else(|| {
+                        e.resolve_char_ref()
+                            .ok()
+                            .flatten()
+                            .map(|v| Cow::Owned(v.to_string()))
+                    })
+                    .unwrap_or_else(|| e.xml_content().unwrap_or_default());
+
+                    if let Some(value) = &mut value {
+                        value.push_str(&v);
+                    } else {
+                        value = Some(v.into_owned());
+                    }
                 }
                 Ok(Event::End(_)) => {
                     break;
@@ -733,7 +767,7 @@ impl<R: BufRead> ReaderHelper for Reader<R> {
             }
         }
 
-        Ok(value)
+        Ok(value.and_then(|v| T::from_str(&v).ok()))
     }
 
     fn skip_tag(&mut self, buf: &mut Vec<u8>) -> Result<(), String> {

src/spf/parse.rs

@@ -1423,7 +1423,7 @@ mod test {
                 },
             ),
             (
-                concat!("v=spf1 mx:example.org -all ra=postmaster rp=15 rr=e:f:s:n"),
+                "v=spf1 mx:example.org -all ra=postmaster rp=15 rr=e:f:s:n",
                 Spf {
                     version: Version::V1,
                     ra: b"postmaster".to_vec().into(),
@@ -1445,7 +1445,7 @@ mod test {
                 },
             ),
             (
-                concat!("v=spf1 ip6:fe80:0000:0000::0000:0000:0000:1 -all"),
+                "v=spf1 ip6:fe80:0000:0000::0000:0000:0000:1 -all",
                 Spf {
                     version: Version::V1,
                     ra: None,