migrate to etherparse 0.14

src/networking/manage_packets.rs

@@ -5,7 +5,7 @@
 
 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;
@@ -40,7 +40,7 @@ pub fn analyze_headers(
     analyze_link_header(headers.link, &mut mac_addresses.0, &mut mac_addresses.1);
 
     if !analyze_network_header(
-        headers.ip,
+        headers.net,
         exchanged_bytes,
         &mut packet_filters_fields.ip_version,
         &mut packet_filters_fields.source,
@@ -89,25 +89,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;
@@ -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 matches(value: u32) -> bool {
     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,
+        }))
     }
 }