Applying rust fmt & add return_buf to ip defrag pool

etherparse/src/defrag/ip_defrag_buf.rs

@@ -1,4 +1,4 @@
-use crate::{*, defrag::*};
+use crate::{defrag::*, *};
 use std::vec::Vec;
 
 /// Buffer to reconstruct a single fragmented IP packet.
@@ -18,7 +18,11 @@ pub struct IpDefragBuf {
 }
 
 impl IpDefragBuf {
-    pub fn new(ip_number: IpNumber, mut data: Vec<u8>, mut sections: Vec<IpFragRange>) -> IpDefragBuf {
+    pub fn new(
+        ip_number: IpNumber,
+        mut data: Vec<u8>,
+        mut sections: Vec<IpFragRange>,
+    ) -> IpDefragBuf {
         IpDefragBuf {
             ip_number,
             data: {
@@ -57,16 +61,16 @@ impl IpDefragBuf {
         self.end
     }
 
-    /// Add a IPv4 slice 
+    /// Add a IPv4 slice
     #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
     pub fn add(
         &mut self,
         offset: IpFragOffset,
         more_fragments: bool,
-        payload: &[u8]
+        payload: &[u8],
     ) -> Result<(), IpDefragError> {
         use IpDefragError::*;
-        
+
         // validate lengths
         let Ok(len_u16) = u16::try_from(payload.len()) else {
             return Err(SegmentTooBig {
@@ -103,7 +107,7 @@ impl IpDefragBuf {
             }
         }
 
-        // get enough memory to store the de-fragmented 
+        // get enough memory to store the de-fragmented
         let required_len = usize::from(end);
         if self.data.len() < required_len {
             if self.data.capacity() < required_len
@@ -195,7 +199,11 @@ mod test {
 
     #[test]
     fn new() {
-        let actual = IpDefragBuf::new(IpNumber::UDP, vec![1], vec![IpFragRange{start: 0, end: 1}]);
+        let actual = IpDefragBuf::new(
+            IpNumber::UDP,
+            vec![1],
+            vec![IpFragRange { start: 0, end: 1 }],
+        );
         assert_eq!(actual.ip_number(), IpNumber::UDP);
         assert!(actual.data().is_empty());
         assert!(actual.sections().is_empty());

etherparse/src/defrag/ip_defrag_error.rs

@@ -4,7 +4,10 @@ use crate::*;
 pub enum IpDefragError {
     /// Error if a payload lenght of a IP Fragment packet is not a multiple of 16
     /// and the "more fragments" flag is set.
-    UnalignedFragmentPayloadLen { offset: IpFragOffset, payload_len: usize },
+    UnalignedFragmentPayloadLen {
+        offset: IpFragOffset,
+        payload_len: usize,
+    },
 
     /// Error if a segment is bigger then the maximum allowed size.
     SegmentTooBig {
@@ -43,13 +46,16 @@ impl std::error::Error for IpDefragError {}
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use super::IpDefragError::*;
+    use super::*;
     use std::format;
 
     #[test]
     fn debug() {
-        let err = UnalignedFragmentPayloadLen { offset: IpFragOffset::try_new(0).unwrap(), payload_len: 16 };
+        let err = UnalignedFragmentPayloadLen {
+            offset: IpFragOffset::try_new(0).unwrap(),
+            payload_len: 16,
+        };
         let _ = format!("{err:?}");
     }
 
@@ -59,7 +65,10 @@ mod tests {
         use std::collections::hash_map::DefaultHasher;
         use std::hash::{Hash, Hasher};
 
-        let err = UnalignedFragmentPayloadLen { offset: IpFragOffset::try_new(0).unwrap(), payload_len: 16 };
+        let err = UnalignedFragmentPayloadLen {
+            offset: IpFragOffset::try_new(0).unwrap(),
+            payload_len: 16,
+        };
         assert_eq!(err, err.clone());
         let hash_a = {
             let mut hasher = DefaultHasher::new();
@@ -92,10 +101,11 @@ mod tests {
     #[test]
     fn source() {
         use std::error::Error;
-        assert!(
-            UnalignedFragmentPayloadLen { offset: IpFragOffset::try_new(0).unwrap(), payload_len: 16 }
-            .source()
-            .is_none()
-        );
+        assert!(UnalignedFragmentPayloadLen {
+            offset: IpFragOffset::try_new(0).unwrap(),
+            payload_len: 16
+        }
+        .source()
+        .is_none());
     }
 }

etherparse/src/defrag/ip_defrag_payload_vec.rs

@@ -30,9 +30,7 @@ mod test {
         assert_eq!(
             format!(
                 "IpDefragPayloadVec {{ ip_number: {:?}, len_source: {:?}, payload: {:?} }}",
-                s.ip_number,
-                s.len_source,
-                s.payload
+                s.ip_number, s.len_source, s.payload
             ),
             format!("{:?}", s)
         );

etherparse/src/defrag/ip_defrag_pool.rs

@@ -1,4 +1,4 @@
-use crate::{*, defrag::*};
+use crate::{defrag::*, *};
 use std::collections::HashMap;
 use std::vec::Vec;
 
@@ -35,7 +35,6 @@ where
     Timestamp: Sized + core::fmt::Debug + Clone,
     CustomChannelId: Sized + core::fmt::Debug + Clone + core::hash::Hash + Eq + PartialEq,
 {
-
     pub fn new() -> IpDefragPool {
         IpDefragPool {
             active: HashMap::new(),
@@ -45,8 +44,12 @@ where
     }
 
     /// Add data from a sliced packet.
-    pub fn process_sliced_packet(&mut self, slice: &SlicedPacket, timestamp: Timestamp, channel_id: CustomChannelId) -> Result<Option<IpDefragPayloadVec>, IpDefragError> {
-
+    pub fn process_sliced_packet(
+        &mut self,
+        slice: &SlicedPacket,
+        timestamp: Timestamp,
+        channel_id: CustomChannelId,
+    ) -> Result<Option<IpDefragPayloadVec>, IpDefragError> {
         // extract the fragment related data and skip non-fragmented packets
         let (frag_id, offset, more_fragments, payload, is_ipv4) = match &slice.net {
             Some(NetSlice::Ipv4(ipv4)) => {
@@ -58,15 +61,18 @@ where
 
                 let (outer_vlan_id, inner_vlan_id) = match &slice.vlan {
                     Some(VlanSlice::SingleVlan(s)) => (Some(s.vlan_identifier()), None),
-                    Some(VlanSlice::DoubleVlan(d)) => (Some(d.outer().vlan_identifier()), Some(d.inner().vlan_identifier())),
-                    None => (None, None)
+                    Some(VlanSlice::DoubleVlan(d)) => (
+                        Some(d.outer().vlan_identifier()),
+                        Some(d.inner().vlan_identifier()),
+                    ),
+                    None => (None, None),
                 };
 
                 (
                     IpFragId {
                         outer_vlan_id,
                         inner_vlan_id,
-                        ip: IpFragVersionSpecId::Ipv4{
+                        ip: IpFragVersionSpecId::Ipv4 {
                             source: header.source(),
                             destination: header.destination(),
                             identification: header.identification(),
@@ -77,7 +83,7 @@ where
                     header.fragments_offset(),
                     header.more_fragments(),
                     ipv4.payload(),
-                    true
+                    true,
                 )
             }
             Some(NetSlice::Ipv6(ipv6)) => {
@@ -107,16 +113,19 @@ where
 
                 let (outer_vlan_id, inner_vlan_id) = match &slice.vlan {
                     Some(VlanSlice::SingleVlan(s)) => (Some(s.vlan_identifier()), None),
-                    Some(VlanSlice::DoubleVlan(d)) => (Some(d.outer().vlan_identifier()), Some(d.inner().vlan_identifier())),
-                    None => (None, None)
+                    Some(VlanSlice::DoubleVlan(d)) => (
+                        Some(d.outer().vlan_identifier()),
+                        Some(d.inner().vlan_identifier()),
+                    ),
+                    None => (None, None),
                 };
 
                 // calculate frag id
                 (
                     IpFragId {
                         outer_vlan_id,
                         inner_vlan_id,
-                        ip: IpFragVersionSpecId::Ipv6{
+                        ip: IpFragVersionSpecId::Ipv6 {
                             source: ipv6.header().source(),
                             destination: ipv6.header().destination(),
                             identification: frag.identification,
@@ -127,7 +136,7 @@ where
                     frag.fragment_offset,
                     frag.more_fragments,
                     ipv6.payload(),
-                    false
+                    false,
                 )
             }
             None => {
@@ -146,7 +155,7 @@ where
                 if buf.0.is_complete() {
                     let (defraged_payload, sections) = entry.remove().0.take_bufs();
                     self.finished_section_bufs.push(sections);
-                    Ok(Some(IpDefragPayloadVec{
+                    Ok(Some(IpDefragPayloadVec {
                         ip_number: payload.ip_number,
                         len_source: if is_ipv4 {
                             LenSource::Ipv4HeaderTotalLen
@@ -164,7 +173,7 @@ where
                     d.clear();
                     d
                 } else {
-                    Vec::with_capacity(payload.payload.len()*2)
+                    Vec::with_capacity(payload.payload.len() * 2)
                 };
                 let sections = if let Some(mut s) = self.finished_section_bufs.pop() {
                     s.clear();
@@ -179,7 +188,7 @@ where
                         if defrag_buf.is_complete() {
                             let (defraged_payload, sections) = defrag_buf.take_bufs();
                             self.finished_section_bufs.push(sections);
-                            Ok(Some(IpDefragPayloadVec{
+                            Ok(Some(IpDefragPayloadVec {
                                 ip_number: payload.ip_number,
                                 len_source: if is_ipv4 {
                                     LenSource::Ipv4HeaderTotalLen
@@ -192,24 +201,24 @@ where
                             entry.insert((defrag_buf, timestamp));
                             Ok(None)
                         }
-                    },
+                    }
                     Err(err) => {
                         // return the buffers
                         let (data_buf, sections) = defrag_buf.take_bufs();
                         self.finished_data_bufs.push(data_buf);
                         self.finished_section_bufs.push(sections);
                         Err(err)
-                    },
+                    }
                 }
             }
         }
     }
-}
 
+    /// Returns a buffer to the pool so it can be re-used.
+    pub fn return_buf(&mut self, buf: IpDefragPayloadVec) {
+        self.finished_data_bufs.push(buf.payload);
+    }
+}
 
 #[cfg(test)]
-mod test {
-
-
-
-}
+mod test {}

etherparse/src/defrag/ip_frag_id.rs

@@ -1,4 +1,4 @@
-use crate::{*, defrag::*};
+use crate::{defrag::*, *};
 
 /// Values identifying a fragmented packet.
 #[derive(Debug, Clone, Hash, Eq, PartialEq)]

etherparse/src/defrag/ip_frag_range.rs

@@ -1,4 +1,3 @@
-
 /// Describing the range of reconstructed data.
 #[derive(Debug, Copy, Clone, Eq, Hash, PartialEq, Ord, PartialOrd)]
 pub struct IpFragRange {

etherparse/src/defrag/ip_frag_version_spec_id.rs

@@ -2,14 +2,14 @@
 #[derive(Debug, Clone, Hash, Eq, PartialEq)]
 pub enum IpFragVersionSpecId {
     /// IPv4 specific data.
-    Ipv4{
-        source: [u8; 4], 
+    Ipv4 {
+        source: [u8; 4],
         destination: [u8; 4],
         identification: u16,
     },
     /// IPv6 specific data.
-    Ipv6{
-        source: [u8; 16], 
+    Ipv6 {
+        source: [u8; 16],
         destination: [u8; 16],
         identification: u32,
     },