Merge pull request #449 from GyulyVGC/dependabot/cargo/main/etherparse-0.14.2

build(deps): bump etherparse from 0.13.0 to 0.14.2

Cargo.toml

@@ -38,7 +38,7 @@ strip = true
 
 [dependencies]
 pcap = "1.2.0"
-etherparse = "0.13.0"
+etherparse = "0.14.2"
 chrono = { version = "0.4.33", default_features = false, features = ["clock"] }
 plotters = { version = "0.3.5", default_features = false, features = ["area_series"] }
 iced = { version = "0.10.0", features = ["tokio", "svg", "advanced", "lazy"] }

src/networking/manage_packets.rs

@@ -5,7 +5,7 @@ use std::sync::{Arc, Mutex};
 
 use chrono::Local;
 use dns_lookup::lookup_addr;
-use etherparse::{Ethernet2Header, IpHeader, PacketHeaders, TransportHeader};
+use etherparse::{Ethernet2Header, NetHeaders, PacketHeaders, TransportHeader};
 use pcap::{Active, Address, Capture, Device};
 
 use crate::mmdb::asn::get_asn;
@@ -37,10 +37,15 @@ pub fn analyze_headers(
     icmp_type: &mut IcmpType,
     packet_filters_fields: &mut PacketFiltersFields,
 ) -> Option<AddressPortPair> {
-    analyze_link_header(headers.link, &mut mac_addresses.0, &mut mac_addresses.1);
+    analyze_link_header(
+        headers.link,
+        &mut mac_addresses.0,
+        &mut mac_addresses.1,
+        exchanged_bytes,
+    );
 
     if !analyze_network_header(
-        headers.ip,
+        headers.net,
         exchanged_bytes,
         &mut packet_filters_fields.ip_version,
         &mut packet_filters_fields.source,
@@ -75,8 +80,10 @@ fn analyze_link_header(
     link_header: Option<Ethernet2Header>,
     mac_address1: &mut Option<String>,
     mac_address2: &mut Option<String>,
+    exchanged_bytes: &mut u128,
 ) {
     if let Some(header) = link_header {
+        *exchanged_bytes += 14;
         *mac_address1 = Some(mac_from_dec_to_hex(header.source));
         *mac_address2 = Some(mac_from_dec_to_hex(header.destination));
     } else {
@@ -89,25 +96,25 @@ fn analyze_link_header(
 /// passed by reference on the basis of the packet header content.
 /// Returns false if packet has to be skipped.
 fn analyze_network_header(
-    network_header: Option<IpHeader>,
+    network_header: Option<NetHeaders>,
     exchanged_bytes: &mut u128,
     network_protocol: &mut IpVersion,
     address1: &mut IpAddr,
     address2: &mut IpAddr,
 ) -> bool {
     match network_header {
-        Some(IpHeader::Version4(ipv4header, _)) => {
+        Some(NetHeaders::Ipv4(ipv4header, _)) => {
             *network_protocol = IpVersion::IPv4;
             *address1 = IpAddr::from(ipv4header.source);
             *address2 = IpAddr::from(ipv4header.destination);
-            *exchanged_bytes = u128::from(ipv4header.payload_len);
+            *exchanged_bytes += u128::from(ipv4header.total_len);
             true
         }
-        Some(IpHeader::Version6(ipv6header, _)) => {
+        Some(NetHeaders::Ipv6(ipv6header, _)) => {
             *network_protocol = IpVersion::IPv6;
             *address1 = IpAddr::from(ipv6header.source);
             *address2 = IpAddr::from(ipv6header.destination);
-            *exchanged_bytes = u128::from(ipv6header.payload_length);
+            *exchanged_bytes += u128::from(40 + ipv6header.payload_length);
             true
         }
         _ => false,

src/secondary_threads/parse_packets.rs

@@ -1,11 +1,13 @@
 //! Module containing functions executed by the thread in charge of parsing sniffed packets and
 //! inserting them in the shared map.
 
-use std::io::ErrorKind;
 use std::sync::{Arc, Mutex};
 use std::thread;
 
-use etherparse::{PacketHeaders, ReadError};
+use etherparse::err::ip::HeaderError;
+use etherparse::err::packet::SliceError;
+use etherparse::err::{Layer, LenError};
+use etherparse::{LenSource, PacketHeaders};
 use pcap::{Active, Capture, Packet};
 
 use crate::mmdb::types::mmdb_reader::MmdbReader;
@@ -171,7 +173,7 @@ pub fn parse_packets(
                             }
                         }
 
-                        //increment the packet count for the sniffed app protocol
+                        //increment the packet count for the sniffed service
                         info_traffic
                             .services
                             .entry(new_info.service)
@@ -194,7 +196,7 @@ pub fn parse_packets(
 fn get_sniffable_headers<'a>(
     packet: &'a Packet,
     my_link_type: MyLinkType,
-) -> Result<PacketHeaders<'a>, ReadError> {
+) -> Result<PacketHeaders<'a>, SliceError> {
     match my_link_type {
         MyLinkType::Ethernet(_) => PacketHeaders::from_ethernet_slice(packet),
         MyLinkType::RawIp(_) | MyLinkType::IPv4(_) | MyLinkType::IPv6(_) => {
@@ -207,9 +209,15 @@ fn get_sniffable_headers<'a>(
     }
 }
 
-fn from_null_slice(packet: &[u8]) -> Result<PacketHeaders, ReadError> {
+fn from_null_slice(packet: &[u8]) -> Result<PacketHeaders, SliceError> {
     if packet.len() <= 4 {
-        return Err(ReadError::UnexpectedEndOfSlice(packet.len()));
+        return Err(SliceError::Len(LenError {
+            required_len: 4,
+            len: packet.len(),
+            len_source: LenSource::Slice,
+            layer: Layer::Ethernet2Header,
+            layer_start_offset: 0,
+        }));
     }
 
     let is_valid_af_inet = {
@@ -232,9 +240,8 @@ fn from_null_slice(packet: &[u8]) -> Result<PacketHeaders, ReadError> {
     if is_valid_af_inet {
         PacketHeaders::from_ip_slice(&packet[4..])
     } else {
-        Err(ReadError::IoError(std::io::Error::new(
-            ErrorKind::InvalidData,
-            "Invalid AF_INET / AF_INET6 value",
-        )))
+        Err(SliceError::Ip(HeaderError::UnsupportedIpVersion {
+            version_number: 0,
+        }))
     }
 }