Introduce a new 'zonefile' module

This is a manual squash of #491 for internal testing.

Author: bal-e

Cargo.toml

@@ -78,7 +78,7 @@ net         = ["bytes", "futures-util", "rand", "std", "tokio"]
 resolv      = ["net", "smallvec", "unstable-client-transport"]
 resolv-sync = ["resolv", "tokio/rt"]
 tsig        = ["bytes", "ring", "smallvec"]
-zonefile    = ["bytes", "serde", "std"]
+zonefile    = ["bytes", "serde", "std", "bumpalo"] # new: ["std", "bumpalo", "dep:time"]
 
 # Unstable features
 unstable-new = []
@@ -152,7 +152,7 @@ required-features = ["net", "tokio-stream", "tracing-subscriber", "unstable-clie
 
 [[example]]
 name = "read-zone"
-required-features = ["zonefile"]
+required-features = ["zonefile", "unstable-new"]
 
 [[example]]
 name = "query-zone"

examples/read-zone.rs

@@ -1,12 +1,11 @@
 //! Reads a zone file.
 
-use std::env;
 use std::fs::File;
 use std::process::exit;
 use std::time::SystemTime;
+use std::{env, io::BufReader};
 
-use domain::zonefile::inplace::Entry;
-use domain::zonefile::inplace::Zonefile;
+use domain::new::zonefile::simple::ZonefileScanner;
 
 fn main() {
     let mut args = env::args();
@@ -21,40 +20,17 @@ fn main() {
     for zone_file in zone_files {
         print!("Processing {zone_file}: ");
         let start = SystemTime::now();
-        let mut reader =
-            Zonefile::load(&mut File::open(&zone_file).unwrap()).unwrap();
-        println!(
-            "Data loaded ({:.03}s).",
-            start.elapsed().unwrap().as_secs_f32()
-        );
+        let file = BufReader::new(File::open(&zone_file).unwrap());
+        let mut scanner = ZonefileScanner::new(file, None);
 
         let mut i = 0;
-        let mut last_entry = None;
-        loop {
-            match reader.next_entry() {
-                Ok(entry) if entry.is_some() => {
-                    last_entry = entry;
-                }
-                Ok(_) => break, // EOF
-                Err(err) => {
-                    eprintln!(
-                        "\nAn error occurred while reading {zone_file}:"
-                    );
-                    eprintln!("  Error: {err}");
-                    if let Some(entry) = &last_entry {
-                        if let Entry::Record(record) = &entry {
-                            eprintln!(
-                                "\nThe last record read was:\n{record}."
-                            );
-                        } else {
-                            eprintln!("\nThe last record read was:\n{last_entry:#?}.");
-                        }
-                        eprintln!("\nTry commenting out the line after that record with a leading ; (semi-colon) character.")
-                    }
-                    exit(1);
-                }
-            }
+        while let Some(entry) = scanner.scan().transpose() {
             i += 1;
+            if let Err(err) = entry {
+                eprintln!("Could not parse {zone_file}: {err}");
+                exit(1);
+            }
+
             if i % 100_000_000 == 0 {
                 println!(
                     "Processed {}M records ({:.03}s)",

src/new/base/charstr.rs

@@ -7,6 +7,9 @@ use core::str::FromStr;
 
 use crate::utils::dst::{UnsizedCopy, UnsizedCopyFrom};
 
+#[cfg(feature = "zonefile")]
+use crate::new::zonefile::scanner::{Scan, ScanError, Scanner};
+
 use super::{
     build::{BuildInMessage, NameCompressor},
     parse::{ParseMessageBytes, SplitMessageBytes},
@@ -437,6 +440,42 @@ impl fmt::Display for CharStrParseError {
     }
 }
 
+//--- Parsing from the zonefile format
+
+#[cfg(feature = "zonefile")]
+impl<'a> Scan<'a> for &'a CharStr {
+    /// Scan a character string.
+    ///
+    /// This parses the `d-word` syntax from [the specification].
+    ///
+    /// [the specification]: crate::new::zonefile#specification
+    fn scan(
+        scanner: &mut Scanner<'_>,
+        alloc: &'a bumpalo::Bump,
+        buffer: &mut std::vec::Vec<u8>,
+    ) -> Result<Self, ScanError> {
+        let start = buffer.len();
+        match scanner.scan_token(buffer)? {
+            Some(token) if token.len() > 255 => {
+                buffer.truncate(start);
+                Err(ScanError::Custom("overlong character string"))
+            }
+
+            Some(token) => {
+                let bytes = alloc.alloc_slice_copy(token);
+                buffer.truncate(start);
+                // SAFETY: 'token' consists of up to 255 bytes.
+                Ok(unsafe { core::mem::transmute::<&[u8], Self>(bytes) })
+            }
+
+            None => {
+                buffer.truncate(start);
+                Err(ScanError::Incomplete)
+            }
+        }
+    }
+}
+
 //============ Tests =========================================================
 
 #[cfg(test)]
@@ -464,4 +503,28 @@ mod test {
         );
         assert_eq!(buffer, &bytes[..6]);
     }
+
+    #[cfg(feature = "zonefile")]
+    #[test]
+    fn scan() {
+        use crate::new::zonefile::scanner::{Scan, ScanError, Scanner};
+
+        let cases = [
+            (b"hello" as &[u8], Ok(b"hello" as &[u8])),
+            (b"\"hi\"and\"bye\"" as &[u8], Ok(b"hiandbye")),
+            (b"\"\"" as &[u8], Ok(b"")),
+            (b"" as &[u8], Err(ScanError::Incomplete)),
+        ];
+
+        let alloc = bumpalo::Bump::new();
+        let mut buffer = std::vec::Vec::new();
+        for (input, expected) in cases {
+            let mut scanner = Scanner::new(input, None);
+            assert_eq!(
+                <&CharStr>::scan(&mut scanner, &alloc, &mut buffer)
+                    .map(|c| &c.octets),
+                expected
+            );
+        }
+    }
 }

src/new/base/name/absolute.rs

@@ -21,6 +21,9 @@ use crate::{
     utils::dst::{UnsizedCopy, UnsizedCopyFrom},
 };
 
+#[cfg(feature = "zonefile")]
+use crate::new::zonefile::scanner::{Scan, ScanError, Scanner};
+
 use super::{
     CanonicalName, Label, LabelBuf, LabelIter, LabelParseError,
     NameCompressor,
@@ -190,6 +193,35 @@ impl BuildInMessage for Name {
     }
 }
 
+//--- Parsing from the zonefile format
+
+#[cfg(feature = "zonefile")]
+impl<'a> Scan<'a> for &'a Name {
+    /// Scan a domain name token.
+    ///
+    /// This parses a domain name, following the [specification].
+    ///
+    /// [specification]: crate::new::zonefile#specification
+    fn scan(
+        scanner: &mut Scanner<'_>,
+        alloc: &'a bumpalo::Bump,
+        buffer: &mut std::vec::Vec<u8>,
+    ) -> Result<Self, ScanError> {
+        let name = NameBuf::scan(scanner, alloc, buffer)?;
+        let bytes = alloc.alloc_slice_copy(name.as_bytes());
+        Ok(unsafe { Name::from_bytes_unchecked(bytes) })
+    }
+}
+
+//--- Cloning
+
+#[cfg(feature = "alloc")]
+impl Clone for alloc::boxed::Box<Name> {
+    fn clone(&self) -> Self {
+        (*self).unsized_copy_into()
+    }
+}
+
 //--- Equality
 
 impl PartialEq for Name {
@@ -575,6 +607,102 @@ impl FromStr for NameBuf {
     }
 }
 
+//--- Parsing from the zonefile format
+
+#[cfg(feature = "zonefile")]
+impl Scan<'_> for NameBuf {
+    /// Scan a domain name token.
+    ///
+    /// This parses a domain name, following the [specification].
+    ///
+    /// [specification]: crate::new::zonefile#specification
+    fn scan(
+        scanner: &mut Scanner<'_>,
+        alloc: &'_ bumpalo::Bump,
+        buffer: &mut std::vec::Vec<u8>,
+    ) -> Result<Self, ScanError> {
+        // Build up a 'Name'.
+        let mut this = Self::empty();
+
+        // Try parsing '@', indicating the origin name.
+        if let [b'@', b' ' | b'\t' | b'\r' | b'\n', ..] | [b'@'] =
+            scanner.remaining()
+        {
+            scanner.consume(1);
+            let origin = scanner
+                .origin()
+                .ok_or(ScanError::Custom("unknown origin name"))?;
+
+            origin
+                .build_bytes(&mut this.buffer)
+                .expect("Valid 'RevName's are at most 255 bytes");
+            this.size = origin.len() as u8;
+            return Ok(this);
+        }
+
+        while let Some(&c) = scanner.remaining().first() {
+            if c.is_ascii_whitespace() {
+                break;
+            }
+
+            if !c.is_ascii_alphanumeric() && !b"\\-_".contains(&c) {
+                return Err(ScanError::Custom(
+                    "irregular character in domain name",
+                ));
+            }
+
+            // Parse a label and prepend it to the buffer.
+            let label = LabelBuf::scan(scanner, alloc, buffer)?;
+            if 255 - this.size < 1 + label.as_bytes().len() as u8 {
+                return Err(ScanError::Custom(
+                    "domain name exceeds 255 bytes",
+                ));
+            }
+            this.append_label(&label);
+
+            // Check if this is the end of the domain name.
+            match scanner.remaining() {
+                &[b' ' | b'\t' | b'\r' | b'\n', ..] | &[] => {
+                    // This is a relative domain name.
+                    let origin = scanner
+                        .origin()
+                        .ok_or(ScanError::Custom("unknown origin name"))?;
+
+                    // Append the origin to this name.
+                    origin
+                        .build_bytes(&mut this.buffer[this.size as usize..])
+                        .map_err(|_| {
+                            ScanError::Custom(
+                                "relative domain name exceeds 255 bytes",
+                            )
+                        })?;
+                    // We exclude the root label, which gets added manually.
+                    this.size += origin.len() as u8 - 1;
+                    break;
+                }
+
+                &[b'.', ..] => {
+                    scanner.consume(1);
+                }
+
+                _ => {
+                    return Err(ScanError::Custom(
+                        "irregular character in domain name",
+                    ));
+                }
+            }
+        }
+
+        if this.size == 0 {
+            return Err(ScanError::Incomplete);
+        }
+
+        // Add a root label and stop.
+        this.append_label(Label::ROOT);
+        Ok(this)
+    }
+}
+
 //--- Access to the underlying 'Name'
 
 impl Deref for NameBuf {
@@ -692,3 +820,61 @@ impl fmt::Display for NameParseError {
         })
     }
 }
+
+//============ Unit tests ====================================================
+
+#[cfg(test)]
+mod test {
+    #[cfg(feature = "zonefile")]
+    #[test]
+    fn scan() {
+        use std::vec::Vec;
+
+        use crate::{
+            new::base::name::RevNameBuf,
+            new::zonefile::scanner::{Scan, ScanError, Scanner},
+        };
+
+        use super::NameBuf;
+
+        let cases = [
+            (b"".as_slice(), Err(ScanError::Incomplete)),
+            (b" ".as_slice(), Err(ScanError::Incomplete)),
+            (b"a", Ok(&[b"a" as &[u8], b"org", b""] as &[&[u8]])),
+            (b"xn--hello.", Ok(&[b"xn--hello", b""])),
+            (
+                b"hello\\.world.sld",
+                Ok(&[b"hello.world", b"sld", b"org", b""]),
+            ),
+            (b"a\\046b.c.", Ok(&[b"a.b", b"c", b""])),
+            (b"a.b\\ c.d", Ok(&[b"a", b"b c", b"d", b"org", b""])),
+        ];
+
+        let alloc = bumpalo::Bump::new();
+        let mut buffer = Vec::new();
+        for (input, expected) in cases {
+            let origin = "org".parse::<RevNameBuf>().unwrap();
+            let mut scanner = Scanner::new(input, Some(&origin));
+            let mut name_buf = None;
+            let actual = NameBuf::scan(&mut scanner, &alloc, &mut buffer)
+                .map(|name| name_buf.insert(name).labels());
+            match expected {
+                Ok(labels) => {
+                    assert!(
+                        actual.clone().is_ok_and(|actual| actual
+                            .map(|l| &l.as_bytes()[1..])
+                            .eq(labels.iter().copied())),
+                        "{actual:?} == Ok({labels:?})"
+                    );
+                }
+
+                Err(err) => {
+                    assert!(
+                        actual.clone().is_err_and(|e| e == err),
+                        "{actual:?} == Err({err:?})"
+                    );
+                }
+            }
+        }
+    }
+}