adding Linus SLL link type (WIP)

src/networking/parse_packets.rs

@@ -25,9 +25,7 @@
 use crate::utils::types::timestamp::Timestamp;
 use async_channel::Sender;
 use dns_lookup::lookup_addr;
-use etherparse::err::ip::{HeaderError, LaxHeaderSliceError};
-use etherparse::err::{Layer, LenError};
-use etherparse::{LaxPacketHeaders, LenSource};
+use etherparse::LaxPacketHeaders;
 use pcap::{Address, Device, Packet};
 use std::collections::HashMap;
 use std::net::IpAddr;
@@ -95,7 +93,7 @@ pub fn parse_packets(
                 }
             }
             Ok(packet) => {
-                if let Ok(headers) = get_sniffable_headers(&packet, my_link_type) {
+                if let Some(headers) = get_sniffable_headers(&packet, my_link_type) {
                     #[allow(clippy::useless_conversion)]
                     let secs = i64::from(packet.header.ts.tv_sec);
                     #[allow(clippy::useless_conversion)]
@@ -281,27 +279,22 @@ pub fn parse_packets(
 fn get_sniffable_headers<'a>(
     packet: &'a Packet,
     my_link_type: MyLinkType,
-) -> Result<LaxPacketHeaders<'a>, LaxHeaderSliceError> {
+) -> Option<LaxPacketHeaders<'a>> {
     match my_link_type {
         MyLinkType::Ethernet(_) | MyLinkType::Unsupported(_) | MyLinkType::NotYetAssigned => {
-            LaxPacketHeaders::from_ethernet(packet).map_err(LaxHeaderSliceError::Len)
+            LaxPacketHeaders::from_ethernet(packet).ok()
         }
         MyLinkType::RawIp(_) | MyLinkType::IPv4(_) | MyLinkType::IPv6(_) => {
-            LaxPacketHeaders::from_ip(packet)
+            LaxPacketHeaders::from_ip(packet).ok()
         }
+        MyLinkType::LinuxSll(_) => LaxPacketHeaders::from_linux_sll(packet).ok(),
         MyLinkType::Null(_) | MyLinkType::Loop(_) => from_null(packet),
     }
 }
 
-fn from_null(packet: &[u8]) -> Result<LaxPacketHeaders<'_>, LaxHeaderSliceError> {
+fn from_null(packet: &[u8]) -> Option<LaxPacketHeaders<'_>> {
     if packet.len() <= 4 {
-        return Err(LaxHeaderSliceError::Len(LenError {
-            required_len: 4,
-            len: packet.len(),
-            len_source: LenSource::Slice,
-            layer: Layer::Ethernet2Header,
-            layer_start_offset: 0,
-        }));
+        return None;
     }
 
     let is_valid_af_inet = {
@@ -322,11 +315,9 @@ fn matches(value: u32) -> bool {
     };
 
     if is_valid_af_inet {
-        LaxPacketHeaders::from_ip(&packet[4..])
+        LaxPacketHeaders::from_ip(&packet[4..]).ok()
     } else {
-        Err(LaxHeaderSliceError::Content(
-            HeaderError::UnsupportedIpVersion { version_number: 0 },
-        ))
+        None
     }
 }
 

src/networking/types/my_link_type.rs

@@ -12,6 +12,7 @@ pub enum MyLinkType {
     Loop(Linktype),
     IPv4(Linktype),
     IPv6(Linktype),
+    LinuxSll(Linktype),
     Unsupported(Linktype),
     #[default]
     NotYetAssigned,
@@ -30,6 +31,8 @@ pub fn from_pcap_link_type(link_type: Linktype) -> Self {
             Linktype::LOOP => Self::Loop(link_type),
             Linktype::IPV4 => Self::IPv4(link_type),
             Linktype::IPV6 => Self::IPv6(link_type),
+            Linktype::LINUX_SLL => Self::LinuxSll(link_type),
+            // TODO: also add Linktype::LINUX_SLL2 (???)
             _ => Self::Unsupported(link_type),
         }
     }
@@ -42,6 +45,7 @@ pub fn full_print_on_one_line(self, language: Language) -> String {
             | Self::Loop(l)
             | Self::IPv4(l)
             | Self::IPv6(l)
+            | Self::LinuxSll(l)
             | Self::Unsupported(l) => {
                 format!(
                     "{}: {} ({})",