fix: Lib Cleanup added ParsedNetflow enum. (#159)

Co-authored-by: mikemiles-dev <[email protected]>

Author: mikemiles-dev

RELEASES.md

@@ -1,7 +1,7 @@
 # 0.6.4
 * Removed uneeded DataNumber Parsing for Durations.
 * Explicity rename methods DurationMicros and DurationNanos into DurationMicrosNTP and DurationNanosNTP.
-* Performance optimizations
+* Minor Performance optimizations
 
 # 0.6.3
 * Ipfix dateTimeNanoseconds and dateTimeMicroseconds use the NTP 64 bit time format #15

src/lib.rs

@@ -266,19 +266,15 @@ pub struct NetflowParser {
 }
 
 #[derive(Debug, Clone)]
-pub struct ParsedNetflow {
-    pub remaining: Vec<u8>,
-    /// Parsed Netflow Packet
-    pub result: NetflowPacket,
-}
-
-impl ParsedNetflow {
-    fn new(remaining: &[u8], result: NetflowPacket) -> Self {
-        Self {
-            remaining: remaining.to_vec(),
-            result,
-        }
-    }
+pub enum ParsedNetflow {
+    Success {
+        packet: NetflowPacket,
+        remaining: Vec<u8>,
+    },
+    Error {
+        error: NetflowParseError,
+    },
+    UnallowedVersion,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -291,7 +287,6 @@ pub struct NetflowPacketError {
 pub enum NetflowParseError {
     Incomplete(String),
     Partial(PartialParse),
-    UnallowedVersion(u16),
     UnknownVersion(Vec<u8>),
 }
 
@@ -343,16 +338,19 @@ impl NetflowParser {
 
         while !remaining.is_empty() {
             match self.parse_packet_by_version(&remaining) {
-                Ok(parsed) => {
-                    packets.push(parsed.result);
-                    remaining = parsed.remaining;
+                ParsedNetflow::Success {
+                    packet,
+                    remaining: new_remaining,
+                } => {
+                    packets.push(packet);
+                    remaining = new_remaining;
                 }
-                Err(NetflowParseError::UnallowedVersion(_)) => {
+                ParsedNetflow::UnallowedVersion => {
                     break;
                 }
-                Err(e) => {
+                ParsedNetflow::Error { error } => {
                     packets.push(NetflowPacket::Error(NetflowPacketError {
-                        error: e,
+                        error,
                         remaining: remaining.to_vec(),
                     }));
                     break;
@@ -376,27 +374,28 @@ impl NetflowParser {
             .collect()
     }
 
-    /// Checks the first u16 of the packet to determine the version.  Parses the packet based on the version.
-    /// If the version is unknown it returns an error.  If the packet is incomplete it returns an error.
-    /// If the packet is parsed successfully it returns the parsed Netflow packet and the remaining bytes.
-    fn parse_packet_by_version(
-        &mut self,
-        packet: &[u8],
-    ) -> Result<ParsedNetflow, NetflowParseError> {
-        let (packet, version) = GenericNetflowHeader::parse(packet)
-            .map(|(remaining, header)| (remaining, header.version))
-            .map_err(|e| NetflowParseError::Incomplete(e.to_string()))?;
+    fn parse_packet_by_version(&mut self, packet: &[u8]) -> ParsedNetflow {
+        let (packet, version) = match GenericNetflowHeader::parse(packet) {
+            Ok((remaining, header)) => (remaining, header.version),
+            Err(e) => {
+                return ParsedNetflow::Error {
+                    error: NetflowParseError::Incomplete(e.to_string()),
+                };
+            }
+        };
 
         if !self.allowed_versions.contains(&version) {
-            return Err(NetflowParseError::UnallowedVersion(version));
+            return ParsedNetflow::UnallowedVersion;
         }
 
         match version {
             5 => V5Parser::parse(packet),
             7 => V7Parser::parse(packet),
             9 => self.v9_parser.parse(packet),
             10 => self.ipfix_parser.parse(packet),
-            _ => Err(NetflowParseError::UnknownVersion(packet.to_vec())),
+            _ => ParsedNetflow::Error {
+                error: NetflowParseError::UnknownVersion(packet.to_vec()),
+            },
         }
     }
 }

src/static_versions/v5.rs

@@ -15,16 +15,20 @@ use std::net::Ipv4Addr;
 pub struct V5Parser;
 
 impl V5Parser {
-    pub fn parse(packet: &[u8]) -> Result<ParsedNetflow, NetflowParseError> {
-        V5::parse(packet)
-            .map(|(remaining, v5)| ParsedNetflow::new(remaining, NetflowPacket::V5(v5)))
-            .map_err(|e| {
-                NetflowParseError::Partial(PartialParse {
+    pub fn parse(packet: &[u8]) -> ParsedNetflow {
+        match V5::parse(packet) {
+            Ok((remaining, v5)) => ParsedNetflow::Success {
+                packet: NetflowPacket::V5(v5),
+                remaining: remaining.to_vec(),
+            },
+            Err(e) => ParsedNetflow::Error {
+                error: NetflowParseError::Partial(PartialParse {
                     version: 5,
                     error: e.to_string(),
                     remaining: packet.to_vec(),
-                })
-            })
+                }),
+            },
+        }
     }
 }
 

src/static_versions/v7.rs

@@ -16,16 +16,20 @@ use std::net::Ipv4Addr;
 pub struct V7Parser;
 
 impl V7Parser {
-    pub fn parse(packet: &[u8]) -> Result<ParsedNetflow, NetflowParseError> {
-        V7::parse(packet)
-            .map(|(remaining, v7)| ParsedNetflow::new(remaining, NetflowPacket::V7(v7)))
-            .map_err(|e| {
-                NetflowParseError::Partial(PartialParse {
+    pub fn parse(packet: &[u8]) -> ParsedNetflow {
+        match V7::parse(packet) {
+            Ok((remaining, v7)) => ParsedNetflow::Success {
+                packet: NetflowPacket::V7(v7),
+                remaining: remaining.to_vec(),
+            },
+            Err(e) => ParsedNetflow::Error {
+                error: NetflowParseError::Partial(PartialParse {
                     version: 7,
                     error: e.to_string(),
                     remaining: packet.to_vec(),
-                })
-            })
+                }),
+            },
+        }
     }
 }
 

src/variable_versions/ipfix.rs

@@ -43,18 +43,20 @@ pub struct IPFixParser {
 }
 
 impl IPFixParser {
-    pub fn parse(&mut self, packet: &[u8]) -> Result<ParsedNetflow, NetflowParseError> {
-        IPFix::parse(packet, self)
-            .map(|(remaining, ipfix)| {
-                ParsedNetflow::new(remaining, NetflowPacket::IPFix(ipfix))
-            })
-            .map_err(|e| {
-                NetflowParseError::Partial(PartialParse {
+    pub fn parse(&mut self, packet: &[u8]) -> ParsedNetflow {
+        match IPFix::parse(packet, self) {
+            Ok((remaining, ipfix)) => ParsedNetflow::Success {
+                packet: NetflowPacket::IPFix(ipfix),
+                remaining: remaining.to_vec(),
+            },
+            Err(e) => ParsedNetflow::Error {
+                error: NetflowParseError::Partial(PartialParse {
                     version: 10,
                     error: e.to_string(),
                     remaining: packet.to_vec(),
-                })
-            })
+                }),
+            },
+        }
     }
 
     /// Add a template (Template, OptionsTemplate, V9Template, or V9OptionsTemplate) to the parser generically.

src/variable_versions/v9.rs

@@ -27,16 +27,20 @@ pub type V9FieldPair = (V9Field, FieldValue);
 pub type V9FlowRecord = Vec<V9FieldPair>;
 
 impl V9Parser {
-    pub fn parse(&mut self, packet: &[u8]) -> Result<ParsedNetflow, NetflowParseError> {
-        V9::parse(packet, self)
-            .map(|(remaining, v9)| ParsedNetflow::new(remaining, NetflowPacket::V9(v9)))
-            .map_err(|e| {
-                NetflowParseError::Partial(PartialParse {
+    pub fn parse(&mut self, packet: &[u8]) -> ParsedNetflow {
+        match V9::parse(packet, self) {
+            Ok((remaining, v9)) => ParsedNetflow::Success {
+                packet: NetflowPacket::V9(v9),
+                remaining: remaining.to_vec(),
+            },
+            Err(e) => ParsedNetflow::Error {
+                error: NetflowParseError::Partial(PartialParse {
                     version: 9,
                     error: e.to_string(),
                     remaining: packet.to_vec(),
-                })
-            })
+                }),
+            },
+        }
     }
 }