Bump to mail-parser 0.10.0

mdecimus · mdecimus · commit 14cb20cc949b · 2025-01-25T18:12:30.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,7 @@
+mail-auth 0.6.1
+================================
+- Bump to `mail-parser` 0.10.0.
+
 mail-auth 0.6.0
 ================================
 - `Resolver` is now `MessageAuthenticator`.
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,7 +26,8 @@ test = []
 ahash = "0.8.0"
 ed25519-dalek = { version = "2.0", optional = true }
 flate2 = "1.0.25"
-mail-parser = { version = "0.9", features = ["ludicrous_mode", "full_encoding"] }
+mail-parser = { path = "../mail-parser", features = ["full_encoding"] }
+#mail-parser = { version = "0.10", features = ["full_encoding"] }
 mail-builder = { version = "0.3", features = ["ludicrous_mode"] }
 quick-xml = { version = "0.37", optional = true }
 ring = { version = "0.17", optional = true }
diff --git a/resources/arf/002.json b/resources/arf/002.json
@@ -1,6 +1,6 @@
 {
   "feedback_type": "Abuse",
-  "arrival_date": 1110290400,
+  "arrival_date": 1110304800,
   "authentication_results": [
     "mail.example.com;\n                spf=fail smtp.mail=somespammer@example.com"
   ],
diff --git a/src/common/message.rs b/src/common/message.rs
@@ -45,25 +45,17 @@ impl<'x> AuthenticatedMessage<'x> {
                 HeaderName::MessageId => {
                     message.message_id_header_present = true;
                 }
-                HeaderName::Other(text) => {
-                    let name = text.as_bytes();
-                    match name.first() {
-                        Some(b'D' | b'd') => {
-                            if name.eq_ignore_ascii_case(b"DKIM-Signature") {
-                                message.parse_dkim(name, value, strict);
-                            }
-                        }
-                        Some(b'A' | b'a') => {
-                            if name.eq_ignore_ascii_case(b"ARC-Authentication-Results") {
-                                message.parse_aar(name, value);
-                            } else if name.eq_ignore_ascii_case(b"ARC-Seal") {
-                                message.parse_as(name, value);
-                            } else if name.eq_ignore_ascii_case(b"ARC-Message-Signature") {
-                                message.parse_ams(name, value, strict);
-                            }
-                        }
-                        _ => (),
-                    }
+                HeaderName::DkimSignature => {
+                    message.parse_dkim(name, value, strict);
+                }
+                HeaderName::ArcAuthenticationResults => {
+                    message.parse_aar(name, value);
+                }
+                HeaderName::ArcSeal => {
+                    message.parse_as(name, value);
+                }
+                HeaderName::ArcMessageSignature => {
+                    message.parse_ams(name, value, strict);
                 }
                 _ => (),
             }
diff --git a/src/common/resolver.rs b/src/common/resolver.rs
@@ -211,13 +211,10 @@ impl MessageAuthenticator {
         Ok(ipv4_lookup.entry)
     }
 
-    pub async fn ipv4_lookup_raw<'x>(
-        &self,
-        key: &str,
-    ) -> crate::Result<DnsEntry<Arc<Vec<Ipv4Addr>>>> {
+    pub async fn ipv4_lookup_raw(&self, key: &str) -> crate::Result<DnsEntry<Arc<Vec<Ipv4Addr>>>> {
         #[cfg(any(test, feature = "test"))]
         if true {
-            return mock_resolve(key.as_ref());
+            return mock_resolve(key);
         }
 
         let ipv4_lookup = self.0.ipv4_lookup(Name::from_str_relaxed(key)?).await?;
@@ -257,13 +254,10 @@ impl MessageAuthenticator {
         Ok(ipv6_lookup.entry)
     }
 
-    pub async fn ipv6_lookup_raw<'x>(
-        &self,
-        key: &str,
-    ) -> crate::Result<DnsEntry<Arc<Vec<Ipv6Addr>>>> {
+    pub async fn ipv6_lookup_raw(&self, key: &str) -> crate::Result<DnsEntry<Arc<Vec<Ipv6Addr>>>> {
         #[cfg(any(test, feature = "test"))]
         if true {
-            return mock_resolve(key.as_ref());
+            return mock_resolve(key);
         }
 
         let ipv6_lookup = self.0.ipv6_lookup(Name::from_str_relaxed(key)?).await?;
@@ -326,7 +320,7 @@ impl MessageAuthenticator {
         }
     }
 
-    pub async fn ptr_lookup<'x>(
+    pub async fn ptr_lookup(
         &self,
         addr: IpAddr,
         cache: Option<&impl ResolverCache<IpAddr, Arc<Vec<String>>>>,
@@ -392,8 +386,8 @@ impl MessageAuthenticator {
     ) -> crate::Result<bool> {
         let key = key.into_fqdn();
 
-        if cache_ipv4.map_or(false, |c| c.get(key.as_ref()).is_some())
-            || cache_ipv6.map_or(false, |c| c.get(key.as_ref()).is_some())
+        if cache_ipv4.is_some_and(|c| c.get(key.as_ref()).is_some())
+            || cache_ipv6.is_some_and(|c| c.get(key.as_ref()).is_some())
         {
             return Ok(true);
         }
@@ -404,7 +398,7 @@ impl MessageAuthenticator {
             .await
         {
             Ok(result) => Ok(result.as_lookup().record_iter().any(|r| {
-                r.data().map_or(false, |d| {
+                r.data().is_some_and(|d| {
                     matches!(
                         d.record_type(),
                         hickory_resolver::proto::rr::RecordType::A
diff --git a/src/dmarc/mod.rs b/src/dmarc/mod.rs
@@ -183,7 +183,7 @@ impl DmarcOutput {
     pub fn requested_reports(&self) -> bool {
         self.record
             .as_ref()
-            .map_or(false, |r| !r.rua.is_empty() || !r.ruf.is_empty())
+            .is_some_and(|r| !r.rua.is_empty() || !r.ruf.is_empty())
     }
 
     /// Returns the failure reporting options
diff --git a/src/report/dmarc/parse.rs b/src/report/dmarc/parse.rs
@@ -37,11 +37,11 @@ impl Report {
                     if part
                         .content_type()
                         .and_then(|ct| ct.subtype())
-                        .map_or(false, |t| t.eq_ignore_ascii_case("xml"))
+                        .is_some_and( |t| t.eq_ignore_ascii_case("xml"))
                         || part
                             .attachment_name()
                             .and_then(|n| n.rsplit_once('.'))
-                            .map_or(false, |(_, e)| e.eq_ignore_ascii_case("xml")) =>
+                            .is_some_and( |(_, e)| e.eq_ignore_ascii_case("xml")) =>
                 {
                     match Report::parse_xml(report.as_bytes()) {
                         Ok(feedback) => return Ok(feedback),
@@ -286,7 +286,7 @@ impl PolicyPublished {
                 b"testing" => {
                     p.testing = reader
                         .next_value::<String>(buf)?
-                        .map_or(false, |s| s.eq_ignore_ascii_case("y"));
+                        .is_some_and( |s| s.eq_ignore_ascii_case("y"));
                 }
                 b"fo" => {
                     p.fo = reader.next_value::<String>(buf)?;
diff --git a/src/report/tlsrpt/parse.rs b/src/report/tlsrpt/parse.rs
@@ -132,7 +132,7 @@ mod tests {
 
         for file in fs::read_dir(&path).unwrap() {
             let file = file.as_ref().unwrap().path();
-            if !file.extension().map_or(false, |e| e == "json") {
+            if file.extension().is_none_or(|e| e != "json") {
                 continue;
             }
             let rpt = TlsReport::parse_json(&fs::read(&file).unwrap())
@@ -144,7 +144,7 @@ mod tests {
 
         for file in fs::read_dir(&path).unwrap() {
             let mut file = file.as_ref().unwrap().path();
-            if !file.extension().map_or(false, |e| e == "eml") {
+            if file.extension().is_none_or(|e| e != "eml") {
                 continue;
             }
             let rpt = TlsReport::parse_rfc5322(&fs::read(&file).unwrap())
diff --git a/src/spf/parse.rs b/src/spf/parse.rs
@@ -28,7 +28,7 @@ impl TxtRecordParser for Spf {
         let mut record = bytes.iter();
         if !matches!(record.key(), Some(k) if k == V)
             || !record.match_bytes(b"spf1")
-            || record.next().map_or(false, |v| !v.is_ascii_whitespace())
+            || record.next().is_some_and( |v| !v.is_ascii_whitespace())
         {
             return Err(Error::InvalidRecordType);
         }

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"feedback_type": "Abuse",`
`3`		`- "arrival_date": 1110290400,`
	`3`	`+ "arrival_date": 1110304800,`
`4`	`4`	`"authentication_results": [`
`5`	`5`	`"mail.example.com;\n spf=fail [email protected]"`
`6`	`6`	`],`
Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ impl DmarcOutput {`
`183`	`183`	`pub fn requested_reports(&self) -> bool {`
`184`	`184`	`self.record`
`185`	`185`	`.as_ref()`
`186`		`- .map_or(false, \|r\| !r.rua.is_empty() \|\| !r.ruf.is_empty())`
	`186`	`+ .is_some_and(\|r\| !r.rua.is_empty() \|\| !r.ruf.is_empty())`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`/// Returns the failure reporting options`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ impl TxtRecordParser for Spf {`
`28`	`28`	`let mut record = bytes.iter();`
`29`	`29`	`if !matches!(record.key(), Some(k) if k == V)`
`30`	`30`	`\|\| !record.match_bytes(b"spf1")`
`31`		`- \|\| record.next().map_or(false, \|v\| !v.is_ascii_whitespace())`
	`31`	`+ \|\| record.next().is_some_and( \|v\| !v.is_ascii_whitespace())`
`32`	`32`	`{`
`33`	`33`	`return Err(Error::InvalidRecordType);`
`34`	`34`	`}`