feat: Improve domain name decoding

Use an iterative instead of a recursive approach in the decoding of
domain names.

Author: LinkTed

src/decode/domain_name.rs

@@ -1,7 +1,7 @@
 use crate::{
     decode::Decoder, domain_name::DOMAIN_NAME_MAX_RECURSION, DecodeError, DecodeResult, DomainName,
 };
-use std::{collections::HashSet, str::from_utf8};
+use std::{collections::HashSet, str::from_utf8, usize};
 
 const COMPRESSION_BITS: u8 = 0b1100_0000;
 const COMPRESSION_BITS_REV: u8 = 0b0011_1111;
@@ -19,38 +19,56 @@ const fn get_offset(length_1: u8, length_2: u8) -> usize {
 impl<'a, 'b: 'a> Decoder<'a, 'b> {
     pub(super) fn domain_name(&mut self) -> DecodeResult<DomainName> {
         let mut domain_name = DomainName::default();
-        let mut recursions = HashSet::new();
-        self.domain_name_recursion(&mut domain_name, &mut recursions)?;
+
+        let mut length = self.u8()?;
+        while length != 0 {
+            if is_compressed(length) {
+                let mut recursions = HashSet::new();
+                self.domain_name_recursion(&mut domain_name, &mut recursions, length)?;
+                return Ok(domain_name);
+            } else {
+                length = self.domain_name_label(&mut domain_name, length)?;
+            }
+        }
         Ok(domain_name)
     }
 
+    fn domain_name_label(&mut self, domain_name: &mut DomainName, length: u8) -> DecodeResult<u8> {
+        let buffer = self.read(length as usize)?;
+        let label = from_utf8(buffer.as_ref())?;
+        let label = label.parse()?;
+        domain_name.append_label(label)?;
+        self.u8()
+    }
+
     fn domain_name_recursion(
         &mut self,
         domain_name: &mut DomainName,
         recursions: &mut HashSet<usize>,
+        mut length: u8,
     ) -> DecodeResult<()> {
-        let recursions_len = recursions.len();
-        if recursions_len > DOMAIN_NAME_MAX_RECURSION {
-            return Err(DecodeError::MaxRecursion(recursions_len));
-        }
+        let mut buffer = self.u8()?;
+        let mut offset = get_offset(length, buffer);
+        let mut decoder = self.new_main_offset(offset);
+
+        length = decoder.u8()?;
 
-        let mut length = self.u8()?;
         while length != 0 {
             if is_compressed(length) {
-                let buffer = self.u8()?;
-                let offset = get_offset(length, buffer);
+                buffer = decoder.u8()?;
+                offset = get_offset(length, buffer);
                 if recursions.insert(offset) {
-                    let mut decoder = self.new_main_offset(offset);
-                    return decoder.domain_name_recursion(domain_name, recursions);
+                    let recursions_len = recursions.len();
+                    if recursions_len > DOMAIN_NAME_MAX_RECURSION {
+                        return Err(DecodeError::MaxRecursion(recursions_len));
+                    }
                 } else {
                     return Err(DecodeError::EndlessRecursion(offset));
                 }
+                decoder.offset = offset as usize;
+                length = decoder.u8()?;
             } else {
-                let buffer = self.read(length as usize)?;
-                let label = from_utf8(buffer.as_ref())?;
-                let label = label.parse()?;
-                domain_name.append_label(label)?;
-                length = self.u8()?;
+                length = decoder.domain_name_label(domain_name, length)?;
             }
         }
 

tests/decode_error.rs

@@ -65,13 +65,13 @@ fn flags_5() {
 #[test]
 fn domain_name_1() {
     let msg = b"\xc0\x02\xc0\x00";
-    decode_domain_name_error(msg, DecodeError::EndlessRecursion(2));
+    decode_domain_name_error(msg, DecodeError::EndlessRecursion(0));
 }
 
 #[test]
 fn domain_name_2() {
     let msg =
-        b"\xc0\x02\xc0\x04\xc0\x06\xc0\x08\xc0\x0a\xc0\x0c\xc0\x0e\xc0\x10\xc0\x12\xc0\x14\xc0\x16\xc0\x18\xc0\x1a\xc0\x1c\xc0\x1e\xc0\x20\xc0\x22";
+        b"\xc0\x02\xc0\x04\xc0\x06\xc0\x08\xc0\x0a\xc0\x0c\xc0\x0e\xc0\x10\xc0\x12\xc0\x14\xc0\x16\xc0\x18\xc0\x1a\xc0\x1c\xc0\x1e\xc0\x20\xc0\x22\xc0\x24";
     decode_domain_name_error(msg, DecodeError::MaxRecursion(17));
 }