Be consistent with read_exact and logging

• Prefer using `read_exact` rather than using a growable Vec when we already know how long the buffer needs to be
• Make sure to log after every field, in hex where appropriate

dns/src/record/aaaa.rs

@@ -34,7 +34,7 @@ impl Wire for AAAA {
         c.read_exact(&mut buf)?;
 
         let address = Ipv6Addr::from(buf);
-        trace!("Parsed IPv6 address -> {:?}", address);
+        trace!("Parsed IPv6 address -> {:#x?}", address);
 
         Ok(Self { address })
     }

dns/src/record/caa.rs

@@ -30,6 +30,8 @@ impl Wire for CAA {
 
     #[cfg_attr(feature = "with_mutagen", ::mutagen::mutate)]
     fn read(stated_length: u16, c: &mut Cursor<&[u8]>) -> Result<Self, WireError> {
+
+        // flags
         let flags = c.read_u8()?;
         trace!("Parsed flags -> {:#08b}", flags);
 
@@ -37,26 +39,24 @@ impl Wire for CAA {
         let critical = has_bit(0b_1000_0000);
         trace!("Parsed critical flag -> {:?}", critical);
 
+        // tag
         let tag_length = c.read_u8()?;
         trace!("Parsed tag length -> {:?}", tag_length);
 
-        let mut tag_buf = Vec::new();
-        for _ in 0 .. tag_length {
-            tag_buf.push(c.read_u8()?);
-        }
+        let mut tag_buffer = vec![0_u8; usize::from(tag_length)];
+        c.read_exact(&mut tag_buffer)?;
 
-        let tag = String::from_utf8_lossy(&tag_buf).to_string();
+        let tag = String::from_utf8_lossy(&tag_buffer).to_string();
         trace!("Parsed tag -> {:?}", tag);
 
+        // value
         let remaining_length = stated_length.saturating_sub(u16::from(tag_length)).saturating_sub(2);
         trace!("Remaining length -> {:?}", remaining_length);
 
-        let mut value_buf = Vec::new();
-        for _ in 0 .. remaining_length {
-            value_buf.push(c.read_u8()?);
-        }
+        let mut value_buffer = vec![0_u8; usize::from(remaining_length)];
+        c.read_exact(&mut value_buffer)?;
 
-        let value = String::from_utf8_lossy(&value_buf).to_string();
+        let value = String::from_utf8_lossy(&value_buffer).to_string();
         trace!("Parsed value -> {:?}", value);
 
         Ok(Self { critical, tag, value })

dns/src/record/eui48.rs

@@ -31,6 +31,7 @@ impl Wire for EUI48 {
 
         let mut octets = [0_u8; 6];
         c.read_exact(&mut octets)?;
+        trace!("Parsed 6-byte address -> {:#x?}", octets);
 
         Ok(Self { octets })
     }

dns/src/record/eui64.rs

@@ -31,6 +31,7 @@ impl Wire for EUI64 {
 
         let mut octets = [0_u8; 8];
         c.read_exact(&mut octets)?;
+        trace!("Parsed 8-byte address -> {:#x?}", octets);
 
         Ok(Self { octets })
     }

dns/src/record/hinfo.rs

@@ -34,10 +34,8 @@ impl Wire for HINFO {
         let cpu_length = c.read_u8()?;
         trace!("Parsed CPU length -> {:?}", cpu_length);
 
-        let mut cpu_buffer = Vec::with_capacity(cpu_length.into());
-        for _ in 0 .. cpu_length {
-            cpu_buffer.push(c.read_u8()?);
-        }
+        let mut cpu_buffer = vec![0_u8; usize::from(cpu_length)];
+        c.read_exact(&mut cpu_buffer)?;
 
         let cpu = String::from_utf8_lossy(&cpu_buffer).to_string();
         trace!("Parsed CPU -> {:?}", cpu);
@@ -45,10 +43,8 @@ impl Wire for HINFO {
         let os_length = c.read_u8()?;
         trace!("Parsed OS length -> {:?}", os_length);
 
-        let mut os_buffer = Vec::with_capacity(os_length.into());
-        for _ in 0 .. os_length {
-            os_buffer.push(c.read_u8()?);
-        }
+        let mut os_buffer = vec![0_u8; usize::from(os_length)];
+        c.read_exact(&mut os_buffer)?;
 
         let os = String::from_utf8_lossy(&os_buffer).to_string();
         trace!("Parsed OS -> {:?}", cpu);

dns/src/record/naptr.rs

@@ -45,42 +45,41 @@ impl Wire for NAPTR {
         let order = c.read_u16::<BigEndian>()?;
         trace!("Parsed order -> {:?}", order);
 
+        // preference
         let preference = c.read_u16::<BigEndian>()?;
         trace!("Parsed preference -> {:?}", preference);
 
+        // flags
         let flags_length = c.read_u8()?;
         trace!("Parsed flags length -> {:?}", flags_length);
 
-        let mut flags_buffer = Vec::with_capacity(flags_length.into());
-        for _ in 0 .. flags_length {
-            flags_buffer.push(c.read_u8()?);
-        }
+        let mut flags_buffer = vec![0_u8; usize::from(flags_length)];
+        c.read_exact(&mut flags_buffer)?;
 
         let flags = String::from_utf8_lossy(&flags_buffer).to_string();
         trace!("Parsed flags -> {:?}", flags);
 
+        // service
         let service_length = c.read_u8()?;
         trace!("Parsed service length -> {:?}", service_length);
 
-        let mut service_buffer = Vec::with_capacity(service_length.into());
-        for _ in 0 .. service_length {
-            service_buffer.push(c.read_u8()?);
-        }
+        let mut service_buffer = vec![0_u8; usize::from(service_length)];
+        c.read_exact(&mut service_buffer)?;
 
         let service = String::from_utf8_lossy(&service_buffer).to_string();
         trace!("Parsed service -> {:?}", service);
 
+        // regex
         let regex_length = c.read_u8()?;
         trace!("Parsed regex length -> {:?}", regex_length);
 
-        let mut regex_buffer = Vec::with_capacity(regex_length.into());
-        for _ in 0 .. regex_length {
-            regex_buffer.push(c.read_u8()?);
-        }
+        let mut regex_buffer = vec![0_u8; usize::from(regex_length)];
+        c.read_exact(&mut regex_buffer)?;
 
         let regex = String::from_utf8_lossy(&regex_buffer).to_string();
         trace!("Parsed regex -> {:?}", regex);
 
+        // replacement
         let (replacement, replacement_length) = c.read_labels()?;
         trace!("Parsed replacement -> {:?}", replacement);
 

dns/src/record/openpgpkey.rs

@@ -1,3 +1,5 @@
+use log::*;
+
 use crate::wire::*;
 
 
@@ -27,6 +29,8 @@ impl Wire for OPENPGPKEY {
 
         let mut key = vec![0_u8; usize::from(stated_length)];
         c.read_exact(&mut key)?;
+        trace!("Parsed key -> {:#x?}", key);
+
         Ok(Self { key })
     }
 }

dns/src/record/opt.rs

@@ -79,10 +79,8 @@ impl OPT {
         let data_length = c.read_u16::<BigEndian>()?;
         trace!("Parsed data length -> {:?}", data_length);
 
-        let mut data = Vec::new();
-        for _ in 0 .. data_length {
-            data.push(c.read_u8()?);
-        }
+        let mut data = vec![0_u8; usize::from(data_length)];
+        c.read_exact(&mut data)?;
         trace!("Parsed data -> {:#x?}", data);
 
         Ok(Self { udp_payload_size, higher_bits, edns0_version, flags, data })

dns/src/record/sshfp.rs

@@ -44,10 +44,9 @@ impl Wire for SSHFP {
         }
 
         let fingerprint_length = stated_length - 1 - 1;
-        let mut fingerprint = Vec::new();
-        for _ in 0 .. fingerprint_length {
-            fingerprint.push(c.read_u8()?);
-        }
+        let mut fingerprint = vec![0_u8; usize::from(fingerprint_length)];
+        c.read_exact(&mut fingerprint)?;
+        trace!("Parsed fingerprint -> {:#x?}", fingerprint);
 
         Ok(Self { algorithm, fingerprint_type, fingerprint })
     }

dns/src/record/tlsa.rs

@@ -52,10 +52,9 @@ impl Wire for TLSA {
         }
 
         let certificate_data_length = stated_length - 1 - 1 - 1;
-        let mut certificate_data = Vec::new();
-        for _ in 0 .. certificate_data_length {
-            certificate_data.push(c.read_u8()?);
-        }
+        let mut certificate_data = vec![0_u8; usize::from(certificate_data_length)];
+        c.read_exact(&mut certificate_data)?;
+        trace!("Parsed fingerprint -> {:#x?}", certificate_data);
 
         Ok(Self { certificate_usage, selector, matching_type, certificate_data })
     }

dns/src/record/uri.rs

@@ -47,13 +47,10 @@ impl Wire for URI {
         }
 
         let remaining_length = stated_length - 4;
-        let mut buf = Vec::with_capacity(remaining_length.into());
+        let mut target_buffer = vec![0_u8; usize::from(remaining_length)];
+        c.read_exact(&mut target_buffer)?;
 
-        for _ in 0 .. remaining_length {
-            buf.push(c.read_u8()?);
-        }
-
-        let target = String::from_utf8_lossy(&buf).to_string();
+        let target = String::from_utf8_lossy(&target_buffer).to_string();
         trace!("Parsed target -> {:?}", target);
 
         Ok(Self { priority, weight, target })