Accept mnemonics in zonefile scanner for int_enum_str_decimal types

src/base/iana/macros.rs

@@ -188,7 +188,7 @@ macro_rules! int_enum_str_mnemonics_only {
 /// If the `serde` feature is enabled, also adds implementation for
 /// `Serialize` and `Deserialize`, serializing values as their decimal values.
 macro_rules! int_enum_str_decimal {
-    ($ianatype:ident, $inttype:ident) => {
+    ($ianatype:ident, $inttype:ident $(, $scan_mode:ident)?) => {
         impl $ianatype {
             #[must_use]
             pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
@@ -206,7 +206,7 @@ macro_rules! int_enum_str_decimal {
             }
         }
 
-        scan_impl!($ianatype);
+        scan_impl!($ianatype $(, $scan_mode)?);
 
         impl core::fmt::Display for $ianatype {
             fn fmt(
@@ -513,6 +513,25 @@ macro_rules! scan_impl {
             }
         }
     };
+
+    ($ianatype:ident, mnemonics) => {
+        impl $ianatype {
+            pub fn scan<S: $crate::base::scan::Scanner>(
+                scanner: &mut S,
+            ) -> Result<Self, S::Error> {
+                scanner.scan_ascii_str(|s| {
+                    $ianatype::from_mnemonic(s.as_bytes())
+                        .or_else(|| core::str::FromStr::from_str(s).ok())
+                        .ok_or_else(|| {
+                            $crate::base::scan::ScannerError::custom(concat!(
+                                "expected ",
+                                stringify!($ianatype)
+                            ))
+                        })
+                })
+            }
+        }
+    };
 }
 
 macro_rules! from_str_error {

src/base/iana/mod.rs

@@ -85,7 +85,8 @@ mod test {
     use crate::base::iana::tlsa::TlsaSelector;
     use crate::base::iana::zonemd::ZonemdAlgorithm;
     use crate::base::iana::zonemd::ZonemdScheme;
-
+    use crate::base::scan::IterScanner;
+    use alloc::vec::Vec;
     use core::fmt::Debug;
     use core::fmt::Display;
     use core::str::FromStr;
@@ -559,4 +560,48 @@ mod test {
             r#"42"#,
         );
     }
+
+    #[test]
+    fn security_algorithm_scanner_accepts_decimal_and_mnemonic() {
+        let scanned = ["8", "RSASHA256"].map(|token| {
+            let mut scanner = IterScanner::<_, Vec<u8>>::new([token]);
+            SecurityAlgorithm::scan(&mut scanner).unwrap()
+        });
+
+        assert_eq!(scanned, [SecurityAlgorithm::RSASHA256; 2]);
+    }
+
+    #[test]
+    fn decimal_scanners_reject_all_mnemonics() {
+        macro_rules! assert_rejects_mnemonics {
+            ($ianatype:path) => {
+                for value in 0..=u8::MAX {
+                    let value = <$ianatype>::from_int(value);
+                    let Some(mnemonic) = value.to_mnemonic_str() else {
+                        continue;
+                    };
+                    let mut scanner = IterScanner::<_, Vec<u8>>::new(
+                        [mnemonic].into_iter(),
+                    );
+                    assert!(
+                        <$ianatype>::scan(&mut scanner).is_err(),
+                        "{} accepted mnemonic {mnemonic}",
+                        stringify!($ianatype)
+                    );
+                }
+            };
+        }
+
+        assert_rejects_mnemonics!(DigestAlgorithm);
+        assert_rejects_mnemonics!(IpseckeyAlgorithm);
+        assert_rejects_mnemonics!(IpseckeyGatewayType);
+        assert_rejects_mnemonics!(Nsec3HashAlgorithm);
+        assert_rejects_mnemonics!(SshfpAlgorithm);
+        assert_rejects_mnemonics!(SshfpType);
+        assert_rejects_mnemonics!(TlsaCertificateUsage);
+        assert_rejects_mnemonics!(TlsaMatchingType);
+        assert_rejects_mnemonics!(TlsaSelector);
+        assert_rejects_mnemonics!(ZonemdAlgorithm);
+        assert_rejects_mnemonics!(ZonemdScheme);
+    }
 }

src/base/iana/secalg.rs

@@ -116,5 +116,5 @@ int_enum! {
     (PRIVATEOID => 254, "PRIVATEOID")
 }
 
-int_enum_str_decimal!(SecurityAlgorithm, u8);
+int_enum_str_decimal!(SecurityAlgorithm, u8, mnemonics);
 int_enum_zonefile_fmt_decimal!(SecurityAlgorithm, "algorithm");

src/rdata/dnssec.rs

@@ -2778,7 +2778,7 @@ mod test {
         test_scan(
             &[
                 "A",
-                "5",
+                "RSASHA1",
                 "3",
                 "12",
                 "13",