use crate::network::dpi::DpiResult;
use crate::network::link_layer;
#[cfg(target_os = "macos")]
use crate::network::link_layer::ethernet;
#[cfg(target_os = "macos")]
use crate::network::link_layer::pktap;
use crate::network::local_addresses::{LocalAddresses, collect_local_addresses};
use crate::network::oui::OuiLookup;
use crate::network::protocol;
use crate::network::protocol::TransportParams;
use crate::network::types::*;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::time::{Duration, Instant};
const AMBIGUOUS_ENDPOINT_REFRESH_INTERVAL: Duration = Duration::from_secs(1);
const AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL: Duration = Duration::from_secs(60);
pub use crate::network::protocol::tcp::{SynWindowScale, TcpFlags, TcpHeaderInfo};
#[derive(Debug)]
pub struct ParsedPacket {
pub protocol: Protocol,
pub local_addr: SocketAddr,
pub remote_addr: SocketAddr,
pub local_addr_kind: AddrKind,
pub remote_addr_kind: AddrKind,
pub remote_is_gateway: bool,
pub vlan_id: Option<u16>,
pub tcp_header: Option<TcpHeaderInfo>, pub protocol_state: ProtocolState,
pub is_outgoing: bool,
pub packet_len: usize,
pub dpi_result: Option<DpiResult>, pub process_name: Option<String>, pub process_id: Option<u32>, }
impl ParsedPacket {
#[allow(clippy::too_many_arguments)]
pub fn new(
protocol: Protocol,
local_addr: SocketAddr,
remote_addr: SocketAddr,
protocol_state: ProtocolState,
is_outgoing: bool,
packet_len: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Self {
Self {
protocol,
local_addr,
remote_addr,
local_addr_kind: AddrKind::Unicast,
remote_addr_kind: AddrKind::Unicast,
remote_is_gateway: false,
vlan_id: None,
tcp_header: None,
protocol_state,
is_outgoing,
packet_len,
dpi_result: None,
process_name,
process_id,
}
}
#[inline]
pub fn connection_key(&self) -> ConnectionKey {
ConnectionKey::new(self.protocol, self.local_addr, self.remote_addr)
}
}
#[cfg(test)]
impl ParsedPacket {
pub(crate) fn test_base(
protocol: Protocol,
local_addr: SocketAddr,
remote_addr: SocketAddr,
protocol_state: ProtocolState,
) -> Self {
Self::new(
protocol,
local_addr,
remote_addr,
protocol_state,
false,
0,
None,
None,
)
}
pub(crate) fn test_tcp(
local_addr: SocketAddr,
remote_addr: SocketAddr,
tcp_header: TcpHeaderInfo,
) -> Self {
let mut packet = Self::test_base(
Protocol::Tcp,
local_addr,
remote_addr,
ProtocolState::Tcp(TcpState::Unknown),
);
packet.tcp_header = Some(tcp_header);
packet
}
pub(crate) fn test_udp(
local_addr: SocketAddr,
remote_addr: SocketAddr,
application: ApplicationProtocol,
) -> Self {
let mut packet =
Self::test_base(Protocol::Udp, local_addr, remote_addr, ProtocolState::Udp);
packet.dpi_result = Some(DpiResult { application });
packet
}
}
#[derive(Clone)]
pub struct ParserConfig {
pub enable_dpi: bool,
}
impl Default for ParserConfig {
fn default() -> Self {
Self { enable_dpi: true }
}
}
pub struct PacketParser {
local_ips: std::collections::HashSet<IpAddr>,
v4_broadcasts: std::collections::HashSet<Ipv4Addr>,
gateways: std::collections::HashSet<IpAddr>,
last_local_ip_refresh: Instant,
last_ambiguous_endpoint_refresh: Option<Instant>,
unchanged_ambiguous_refreshes: u32,
config: ParserConfig,
linktype: Option<i32>, oui_lookup: Option<std::sync::Arc<OuiLookup>>,
}
impl Default for PacketParser {
fn default() -> Self {
Self::new()
}
}
impl PacketParser {
pub fn new() -> Self {
Self::with_config(ParserConfig::default())
}
pub fn with_config(config: ParserConfig) -> Self {
let local = collect_local_addresses();
Self {
local_ips: local.ips,
v4_broadcasts: local.v4_broadcasts,
gateways: local.gateways,
last_local_ip_refresh: Instant::now(),
last_ambiguous_endpoint_refresh: None,
unchanged_ambiguous_refreshes: 0,
config,
linktype: None,
oui_lookup: None,
}
}
pub fn with_oui_lookup(mut self, oui_lookup: impl Into<std::sync::Arc<OuiLookup>>) -> Self {
self.oui_lookup = Some(oui_lookup.into());
self
}
pub fn with_linktype(mut self, linktype: i32) -> Self {
self.linktype = Some(linktype);
let link_type = link_layer::LinkLayerType::from_dlt(linktype);
if link_type.is_tunnel() {
log::debug!(
"Parser configured for tunnel interface: linktype {} ({:?})",
linktype,
link_type
);
log::trace!("TUN/TAP parsing available via link_layer::tun_tap module");
log::trace!(" - TUN interfaces (Layer 3): tun*, utun*");
log::trace!(" - TAP interfaces (Layer 2): tap*");
} else {
log::trace!(
"Parser configured with linktype {} ({:?})",
linktype,
link_type
);
}
self
}
pub fn refresh_local_ips(&mut self) -> bool {
self.refresh_local_ips_with(collect_local_addresses)
}
pub fn refresh_local_ips_if_due(&mut self, interval: Duration) -> bool {
if self.last_local_ip_refresh.elapsed() < interval {
return false;
}
self.refresh_local_ips()
}
pub fn parse_packet_with_refresh(&mut self, data: &[u8]) -> Option<ParsedPacket> {
self.parse_packet_with_local_ip_collector(data, collect_local_addresses)
}
fn classify_addr(&self, ip: IpAddr) -> AddrKind {
match ip {
IpAddr::V4(v4) if v4.is_multicast() => AddrKind::Multicast,
IpAddr::V4(v4) if v4 == Ipv4Addr::BROADCAST || self.v4_broadcasts.contains(&v4) => {
AddrKind::Broadcast
}
IpAddr::V6(v6) if v6.is_multicast() => AddrKind::Multicast,
_ => AddrKind::Unicast,
}
}
fn is_unicast_endpoint(&self, ip: IpAddr) -> bool {
!ip.is_unspecified() && self.classify_addr(ip) == AddrKind::Unicast
}
pub fn parse_packet(&self, data: &[u8]) -> Option<ParsedPacket> {
let mut parsed = self.parse_packet_link_layer(data)?;
parsed.local_addr_kind = self.classify_addr(parsed.local_addr.ip());
parsed.remote_addr_kind = self.classify_addr(parsed.remote_addr.ip());
parsed.remote_is_gateway = parsed.remote_addr_kind == AddrKind::Unicast
&& self.gateways.contains(&parsed.remote_addr.ip());
Some(parsed)
}
fn parse_packet_link_layer(&self, data: &[u8]) -> Option<ParsedPacket> {
if let Some(linktype) = self.linktype {
let link_type = link_layer::LinkLayerType::from_dlt(linktype);
log::trace!(
"Parsing packet with linktype {} ({:?})",
linktype,
link_type
);
match linktype {
#[cfg(target_os = "macos")]
149 | 258 if pktap::is_pktap_linktype(linktype) => {
log::debug!("Parsing as PKTAP (linktype {})", linktype);
return self.parse_pktap_packet(data);
}
113 => {
log::debug!("Parsing as Linux SLL (linktype 113)");
return link_layer::linux_sll::parse_sll(data, self, None, None);
}
276 => {
log::debug!("Parsing as Linux SLL2 (linktype 276)");
return link_layer::linux_sll::parse_sll2(data, self, None, None);
}
0
| 1
| 12
| 101
| link_layer::dlt::LINKTYPE_IPV4
| link_layer::dlt::LINKTYPE_IPV6 => {
log::debug!("Parsing TUN/TAP packet (linktype {})", linktype);
return link_layer::tun_tap::parse_by_dlt(data, linktype, self, None, None);
}
_ => {
log::debug!("Unknown linktype {}, trying Ethernet", linktype);
}
}
}
log::debug!("Using fallback Ethernet parsing");
link_layer::ethernet::parse(data, self, None, None)
}
fn parse_packet_with_local_ip_collector<F>(
&mut self,
data: &[u8],
collector: F,
) -> Option<ParsedPacket>
where
F: FnOnce() -> LocalAddresses,
{
let parsed = self.parse_packet(data)?;
let local_ip = parsed.local_addr.ip();
let remote_ip = parsed.remote_addr.ip();
if self.local_ips.contains(&local_ip)
|| self.local_ips.contains(&remote_ip)
|| !self.is_unicast_endpoint(local_ip)
|| !self.is_unicast_endpoint(remote_ip)
{
return Some(parsed);
}
let now = Instant::now();
if self
.last_ambiguous_endpoint_refresh
.is_some_and(|last| now.duration_since(last) < self.ambiguous_refresh_interval())
{
return Some(parsed);
}
self.last_ambiguous_endpoint_refresh = Some(now);
if self.refresh_local_ips_with(collector) {
self.parse_packet(data)
} else {
self.unchanged_ambiguous_refreshes =
self.unchanged_ambiguous_refreshes.saturating_add(1);
Some(parsed)
}
}
fn ambiguous_refresh_interval(&self) -> Duration {
let factor = 1u32 << self.unchanged_ambiguous_refreshes.min(6);
AMBIGUOUS_ENDPOINT_REFRESH_INTERVAL
.saturating_mul(factor)
.min(AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL)
}
fn refresh_local_ips_with<F>(&mut self, collector: F) -> bool
where
F: FnOnce() -> LocalAddresses,
{
let refreshed = collector();
self.last_local_ip_refresh = Instant::now();
if refreshed.ips == self.local_ips
&& refreshed.v4_broadcasts == self.v4_broadcasts
&& refreshed.gateways == self.gateways
{
return false;
}
log::debug!(
"Local address set changed: {} -> {} address(es)",
self.local_ips.len(),
refreshed.ips.len()
);
self.local_ips = refreshed.ips;
self.v4_broadcasts = refreshed.v4_broadcasts;
self.gateways = refreshed.gateways;
self.unchanged_ambiguous_refreshes = 0;
true
}
#[cfg(target_os = "macos")]
fn parse_pktap_packet(&self, data: &[u8]) -> Option<ParsedPacket> {
let (pktap_header, payload) = pktap::parse_pktap_packet(data)?;
let (process_name, process_id) = pktap_header.get_process_info();
log::debug!(
"PKTAP packet: interface={}, process={:?}, pid={:?}, payload_len={}",
pktap_header.get_interface(),
process_name,
process_id,
payload.len()
);
match pktap_header.inner_dlt() {
1 => {
ethernet::parse(payload, self, process_name, process_id)
}
12 => {
link_layer::raw_ip::parse(payload, self, process_name, process_id)
}
_ => {
log::debug!("Unsupported PKTAP inner DLT: {}", pktap_header.inner_dlt());
None
}
}
}
pub fn parse_ipv4_packet_inner(
&self,
data: &[u8],
offset: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
let ip_data = &data[offset..];
if ip_data.len() < 20 {
return None;
}
let version = ip_data[0] >> 4;
if version != 4 {
return None;
}
let ip_total_length = u16::from_be_bytes([ip_data[2], ip_data[3]]) as usize;
let actual_packet_len = offset + ip_total_length;
let fragment_offset = u16::from_be_bytes([ip_data[6], ip_data[7]]) & 0x1FFF;
if fragment_offset != 0 {
return None;
}
let protocol_num = ip_data[9];
let src_ip = IpAddr::V4(Ipv4Addr::new(
ip_data[12],
ip_data[13],
ip_data[14],
ip_data[15],
));
let dst_ip = IpAddr::V4(Ipv4Addr::new(
ip_data[16],
ip_data[17],
ip_data[18],
ip_data[19],
));
let ihl = ip_data[0] & 0x0F;
if ihl < 5 {
return None;
}
let ip_header_len = (ihl as usize) * 4;
if ip_data.len() < ip_header_len {
return None;
}
let transport_data = &ip_data[ip_header_len..];
let transport_data = match ip_total_length.checked_sub(ip_header_len) {
Some(payload_len) => &transport_data[..payload_len.min(transport_data.len())],
None => transport_data,
};
let params =
TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
match protocol_num {
1 => protocol::icmp::parse(transport_data, params, &self.local_ips),
2 => protocol::igmp::parse(transport_data, params, &self.local_ips),
6 => protocol::tcp::parse(transport_data, params, &self.config, &self.local_ips),
17 => protocol::udp::parse(transport_data, params, &self.config, &self.local_ips),
_ => None,
}
}
pub fn parse_ipv6_packet_inner(
&self,
data: &[u8],
offset: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
let ip_data = &data[offset..];
if ip_data.len() < 40 {
return None;
}
let version = ip_data[0] >> 4;
if version != 6 {
return None;
}
let ipv6_payload_length = u16::from_be_bytes([ip_data[4], ip_data[5]]) as usize;
let actual_packet_len = offset + 40 + ipv6_payload_length;
let next_header = ip_data[6];
let src_ip = IpAddr::V6(Ipv6Addr::new(
u16::from_be_bytes([ip_data[8], ip_data[9]]),
u16::from_be_bytes([ip_data[10], ip_data[11]]),
u16::from_be_bytes([ip_data[12], ip_data[13]]),
u16::from_be_bytes([ip_data[14], ip_data[15]]),
u16::from_be_bytes([ip_data[16], ip_data[17]]),
u16::from_be_bytes([ip_data[18], ip_data[19]]),
u16::from_be_bytes([ip_data[20], ip_data[21]]),
u16::from_be_bytes([ip_data[22], ip_data[23]]),
));
let dst_ip = IpAddr::V6(Ipv6Addr::new(
u16::from_be_bytes([ip_data[24], ip_data[25]]),
u16::from_be_bytes([ip_data[26], ip_data[27]]),
u16::from_be_bytes([ip_data[28], ip_data[29]]),
u16::from_be_bytes([ip_data[30], ip_data[31]]),
u16::from_be_bytes([ip_data[32], ip_data[33]]),
u16::from_be_bytes([ip_data[34], ip_data[35]]),
u16::from_be_bytes([ip_data[36], ip_data[37]]),
u16::from_be_bytes([ip_data[38], ip_data[39]]),
));
let transport_data = &ip_data[40..];
let transport_data = if ipv6_payload_length == 0 {
transport_data
} else {
&transport_data[..ipv6_payload_length.min(transport_data.len())]
};
let (final_next_header, transport_offset, saw_fragment) =
self.parse_ipv6_extension_headers(next_header, transport_data)?;
let final_transport_data = &transport_data[transport_offset.min(transport_data.len())..];
let params =
TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
match final_next_header {
58 => self.parse_icmpv6(final_transport_data, params, ip_data[7], saw_fragment),
6 => protocol::tcp::parse(final_transport_data, params, &self.config, &self.local_ips),
17 => protocol::udp::parse(final_transport_data, params, &self.config, &self.local_ips),
_ => None,
}
}
fn parse_icmpv6(
&self,
transport_data: &[u8],
params: TransportParams,
hop_limit: u8,
saw_fragment: bool,
) -> Option<ParsedPacket> {
let src_ip = params.src_ip;
let mut packet = protocol::icmp::parse_v6(transport_data, params, &self.local_ips)?;
if hop_limit == 255
&& !saw_fragment
&& let ProtocolState::Icmp { ndp_neighbor, .. } = &mut packet.protocol_state
{
*ndp_neighbor =
protocol::ndp::extract_neighbor(transport_data, src_ip, self.oui_lookup.as_deref());
}
Some(packet)
}
pub fn parse_arp_packet_with_offset(
&self,
data: &[u8],
header_len: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
let arp_data = &data[header_len..];
if arp_data.len() < 28 {
return None;
}
let hardware_type = u16::from_be_bytes([arp_data[0], arp_data[1]]);
let protocol_type = u16::from_be_bytes([arp_data[2], arp_data[3]]);
let opcode = u16::from_be_bytes([arp_data[6], arp_data[7]]);
if hardware_type != 1 || protocol_type != 0x0800 {
return None;
}
let sender_mac = crate::network::oui::format_mac(&arp_data[8..14]);
let target_mac = crate::network::oui::format_mac(&arp_data[18..24]);
let sender_ip = IpAddr::from([arp_data[14], arp_data[15], arp_data[16], arp_data[17]]);
let target_ip = IpAddr::from([arp_data[24], arp_data[25], arp_data[26], arp_data[27]]);
let operation = match opcode {
1 => ArpOperation::Request,
2 => ArpOperation::Reply,
_ => return None,
};
let sender_vendor = self
.oui_lookup
.as_ref()
.and_then(|oui| oui.lookup(&sender_mac).map(String::from));
let target_vendor = self
.oui_lookup
.as_ref()
.and_then(|oui| oui.lookup(&target_mac).map(String::from));
let arp_info = ArpInfo {
operation,
sender_mac,
sender_ip,
target_mac,
target_ip,
sender_vendor,
target_vendor,
};
let is_outgoing = self.local_ips.contains(&sender_ip);
let (local_addr, remote_addr) = if is_outgoing {
(SocketAddr::new(sender_ip, 0), SocketAddr::new(target_ip, 0))
} else {
(SocketAddr::new(target_ip, 0), SocketAddr::new(sender_ip, 0))
};
Some(ParsedPacket::new(
Protocol::Arp,
local_addr,
remote_addr,
ProtocolState::Arp(arp_info),
is_outgoing,
data.len(),
process_name,
process_id,
))
}
pub fn parse_raw_ipv4_packet(
&self,
data: &[u8],
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
self.parse_ipv4_packet_inner(data, 0, process_name, process_id)
}
pub fn parse_raw_ipv6_packet(
&self,
data: &[u8],
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
self.parse_ipv6_packet_inner(data, 0, process_name, process_id)
}
fn parse_ipv6_extension_headers(
&self,
mut next_header: u8,
data: &[u8],
) -> Option<(u8, usize, bool)> {
let mut offset = 0;
let mut saw_fragment = false;
const HOP_BY_HOP: u8 = 0;
const ROUTING: u8 = 43;
const FRAGMENT: u8 = 44;
const ENCAPSULATING_SECURITY: u8 = 50;
const AUTHENTICATION: u8 = 51;
const DESTINATION_OPTIONS: u8 = 60;
loop {
match next_header {
HOP_BY_HOP | ROUTING | DESTINATION_OPTIONS => {
if data.len() < offset + 2 {
return Some((next_header, offset, saw_fragment));
}
next_header = data[offset];
let header_len = ((data[offset + 1] as usize) + 1) * 8;
offset += header_len;
}
FRAGMENT => {
saw_fragment = true;
if data.len() < offset + 8 {
return Some((next_header, offset, saw_fragment));
}
let fragment_offset =
u16::from_be_bytes([data[offset + 2], data[offset + 3]]) >> 3;
if fragment_offset != 0 {
return None;
}
next_header = data[offset];
offset += 8;
}
AUTHENTICATION => {
if data.len() < offset + 2 {
return Some((next_header, offset, saw_fragment));
}
next_header = data[offset];
let header_len = ((data[offset + 1] as usize) + 2) * 4;
offset += header_len;
}
ENCAPSULATING_SECURITY => {
return Some((next_header, offset, saw_fragment));
}
_ => {
return Some((next_header, offset, saw_fragment));
}
}
if offset >= data.len() {
return Some((next_header, offset, saw_fragment));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::IpAddr;
fn local_addresses(ips: impl IntoIterator<Item = IpAddr>) -> LocalAddresses {
LocalAddresses {
ips: ips.into_iter().collect(),
..LocalAddresses::default()
}
}
fn local_addresses_with_gateways(
ips: impl IntoIterator<Item = IpAddr>,
gateways: impl IntoIterator<Item = IpAddr>,
) -> LocalAddresses {
LocalAddresses {
gateways: gateways.into_iter().collect(),
..local_addresses(ips)
}
}
fn create_parser_with_linktype(linktype: i32) -> PacketParser {
let mut parser = PacketParser::with_config(ParserConfig::default()).with_linktype(linktype);
parser
.local_ips
.insert(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 100)));
parser
}
fn ethernet_ipv4_tcp_syn() -> Vec<u8> {
vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
0x45, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1,
100, 93, 184, 216, 34, 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]
}
fn ethernet_ipv4_udp_dns() -> Vec<u8> {
vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
0x45, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, 192, 168, 1,
100, 8, 8, 8, 8, 0x04, 0xd2, 0x00, 0x35, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
]
}
fn ethernet_ipv4_udp(src: [u8; 4], dst: [u8; 4]) -> Vec<u8> {
vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
0x45, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, src[0], src[1],
src[2], src[3], dst[0], dst[1], dst[2], dst[3], 0xeb, 0x4c, 0xc8, 0x22, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
]
}
fn ethernet_ipv6_tcp() -> Vec<u8> {
vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x86, 0xdd,
0x60, 0x00, 0x00, 0x00, 0x00, 0x14, 0x06, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]
}
fn ethernet_ipv6_ndp_solicitation(fragmented: bool) -> Vec<u8> {
let mut icmpv6 = vec![135, 0, 0, 0, 0, 0, 0, 0]; icmpv6.extend_from_slice(&[
0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, ]);
icmpv6.extend_from_slice(&[1, 1, 0x68, 0x5e, 0xdd, 0x09, 0x15, 0x5e]);
let (next_header, payload) = if fragmented {
let mut p = vec![58, 0, 0, 0, 0, 0, 0, 1]; p.extend_from_slice(&icmpv6);
(44u8, p)
} else {
(58u8, icmpv6)
};
let mut frame = vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x86, 0xdd,
0x60, 0x00, 0x00, 0x00,
];
frame.extend_from_slice(&(payload.len() as u16).to_be_bytes());
frame.push(next_header);
frame.push(255); frame.extend_from_slice(&[
0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x02, ]);
frame.extend_from_slice(&[
0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, ]);
frame.extend_from_slice(&payload);
frame
}
fn linux_sll_ipv4_tcp() -> Vec<u8> {
vec![
0x00, 0x00, 0x00, 0x01, 0x00, 0x06, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x00,
0x08, 0x00, 0x45, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1,
100, 93, 184, 216, 34, 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]
}
fn linux_sll2_ipv4_udp() -> Vec<u8> {
vec![
0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x06, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff, 0x00, 0x00, 0x45, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, 192, 168, 1,
100, 8, 8, 8, 8, 0x04, 0xd2, 0x00, 0x35, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
]
}
#[test]
fn test_ethernet_ipv4_tcp_parsing() {
let parser = create_parser_with_linktype(1); let packet = ethernet_ipv4_tcp_syn();
let parsed = parser.parse_packet(&packet);
assert!(
parsed.is_some(),
"Should parse valid Ethernet IPv4 TCP packet"
);
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Tcp);
assert_eq!(p.local_addr.port(), 1234, "Local port should be 1234");
assert_eq!(p.remote_addr.port(), 80, "Remote port should be 80");
assert!(p.tcp_header.is_some());
assert!(p.tcp_header.unwrap().flags.syn, "SYN flag should be set");
}
#[test]
fn ndp_is_learned_at_hop_limit_255_but_never_from_fragments() {
let parser = create_parser_with_linktype(1);
let parsed = parser
.parse_packet(ðernet_ipv6_ndp_solicitation(false))
.expect("NDP solicitation should parse");
match &parsed.protocol_state {
ProtocolState::Icmp {
ndp_neighbor: Some(neighbor),
..
} => {
assert_eq!(neighbor.ip, "fe80::2".parse::<IpAddr>().unwrap());
assert_eq!(neighbor.mac, "68:5e:dd:09:15:5e");
}
other => panic!("expected a learned NDP neighbor, got {:?}", other),
}
let parsed = parser
.parse_packet(ðernet_ipv6_ndp_solicitation(true))
.expect("fragmented solicitation should still parse as ICMPv6");
assert!(matches!(
&parsed.protocol_state,
ProtocolState::Icmp {
ndp_neighbor: None,
..
}
));
}
#[test]
fn test_ethernet_ipv4_udp_parsing() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv4_udp_dns();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some());
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Udp);
assert_eq!(p.local_addr.port(), 1234);
assert_eq!(p.remote_addr.port(), 53, "Should detect DNS port");
}
#[test]
fn test_ethernet_ipv6_tcp_parsing() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv6_tcp();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should parse IPv6 packets");
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Tcp);
assert!(matches!(p.local_addr.ip(), IpAddr::V6(_)), "Should be IPv6");
}
#[test]
fn test_truncated_ethernet_packet() {
let parser = create_parser_with_linktype(1);
let truncated = vec![0x00, 0x11, 0x22];
let parsed = parser.parse_packet(&truncated);
assert!(parsed.is_none(), "Should reject truncated packets");
}
#[test]
fn vlan_metadata_survives_ethernet_and_cooked_ipv4_ipv6_and_arp() {
let parser = create_parser_with_linktype(1);
let mut arp = vec![0xff; 6];
arp.extend_from_slice(&[0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x06]);
arp.extend_from_slice(&[
0, 1, 0x08, 0, 6, 4, 0, 1, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 192, 168, 1, 100, 0, 0, 0, 0, 0, 0, 192, 168, 1, 1,
]);
for frame in [
ethernet_ipv4_tcp_syn(),
ethernet_ipv4_udp_dns(),
ethernet_ipv6_tcp(),
arp,
] {
let untagged = parser.parse_packet(&frame).unwrap();
assert_eq!(untagged.vlan_id, None);
for (linktype, header_len, proto_offset) in [(113, 16, 14), (276, 20, 0)] {
let cooked_parser = create_parser_with_linktype(linktype);
let mut cooked = vec![0; header_len];
cooked[proto_offset..proto_offset + 2].copy_from_slice(&frame[12..14]);
cooked.extend_from_slice(&frame[14..]);
let plain = cooked_parser.parse_packet(&cooked).unwrap();
assert_eq!(plain.vlan_id, None);
for vlan_id in [0u16, 42, 4094] {
let mut tagged = cooked.clone();
tagged[proto_offset..proto_offset + 2].copy_from_slice(&[0x81, 0x00]);
let tci = (0xf000 | vlan_id).to_be_bytes();
tagged.splice(
header_len..header_len,
[tci[0], tci[1], frame[12], frame[13]],
);
let parsed = cooked_parser.parse_packet(&tagged).unwrap();
assert_eq!(parsed.vlan_id, Some(vlan_id));
assert_eq!(parsed.connection_key(), plain.connection_key());
}
}
for vlan_id in [0u16, 42, 4094] {
let mut tagged = frame.clone();
let tci = (0xf000 | vlan_id).to_be_bytes();
tagged.splice(12..12, [0x81, 0x00, tci[0], tci[1]]);
let parsed = parser.parse_packet(&tagged).unwrap();
assert_eq!(parsed.vlan_id, Some(vlan_id));
assert_eq!(parsed.connection_key(), untagged.connection_key());
assert_eq!(parsed.packet_len, untagged.packet_len + 4);
}
}
}
#[test]
fn test_unknown_ethertype() {
let parser = create_parser_with_linktype(1);
let packet = vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xff,
0xff, ];
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_none(), "Should reject unknown EtherType");
}
#[test]
fn test_linux_sll_ipv4_tcp_parsing() {
let parser = create_parser_with_linktype(113); let packet = linux_sll_ipv4_tcp();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should parse Linux SLL packets");
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Tcp);
assert_eq!(p.local_addr.port(), 1234);
assert_eq!(p.remote_addr.port(), 80);
}
#[test]
fn test_linux_sll_truncated() {
let parser = create_parser_with_linktype(113);
let truncated = vec![0x00, 0x00, 0x00];
let parsed = parser.parse_packet(&truncated);
assert!(parsed.is_none(), "Should reject truncated SLL packets");
}
#[test]
fn test_linux_sll2_ipv4_udp_parsing() {
let parser = create_parser_with_linktype(276); let packet = linux_sll2_ipv4_udp();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should parse Linux SLL2 packets");
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Udp);
assert_eq!(p.local_addr.port(), 1234);
assert_eq!(p.remote_addr.port(), 53);
}
#[test]
fn test_linux_sll2_truncated() {
let parser = create_parser_with_linktype(276);
let truncated = vec![0x08, 0x00];
let parsed = parser.parse_packet(&truncated);
assert!(parsed.is_none(), "Should reject truncated SLL2 packets");
}
#[test]
fn test_parser_default_config() {
let config = ParserConfig::default();
assert!(config.enable_dpi, "DPI should be enabled by default");
}
#[test]
fn test_parser_with_linktype() {
let parser = PacketParser::with_config(ParserConfig::default()).with_linktype(1);
assert_eq!(parser.linktype, Some(1));
}
#[test]
fn test_local_ip_detection() {
let parser = PacketParser::new();
assert!(!parser.local_ips.is_empty(), "Should detect local IPs");
}
#[test]
fn classify_addr_recognizes_broadcast_and_multicast() {
let mut parser = create_parser_with_linktype(1);
parser.v4_broadcasts.insert(Ipv4Addr::new(192, 168, 1, 255));
assert_eq!(
parser.classify_addr(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 255))),
AddrKind::Broadcast,
"subnet-directed broadcast from the interface snapshot"
);
assert_eq!(
parser.classify_addr(IpAddr::V4(Ipv4Addr::BROADCAST)),
AddrKind::Broadcast
);
assert_eq!(
parser.classify_addr(IpAddr::V4(Ipv4Addr::new(224, 0, 0, 251))),
AddrKind::Multicast
);
assert_eq!(
parser.classify_addr(IpAddr::V6(
"ff02::fb".parse().expect("valid fixture address")
)),
AddrKind::Multicast
);
assert_eq!(
parser.classify_addr(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 254))),
AddrKind::Unicast,
"adjacent host must not be mistaken for the broadcast address"
);
assert_eq!(
parser.classify_addr(IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))),
AddrKind::Unicast
);
}
#[test]
fn incoming_subnet_broadcast_is_stamped_and_skips_refresh() {
use std::cell::Cell;
let mut parser = create_parser_with_linktype(1);
parser.v4_broadcasts.insert(Ipv4Addr::new(192, 168, 1, 255));
let packet = ethernet_ipv4_udp([192, 168, 1, 52], [192, 168, 1, 255]);
let collector_calls = Cell::new(0u32);
let parsed = parser
.parse_packet_with_local_ip_collector(&packet, || {
collector_calls.set(collector_calls.get() + 1);
LocalAddresses::default()
})
.expect("packet should parse");
assert_eq!(
parsed.local_addr.ip(),
IpAddr::V4(Ipv4Addr::new(192, 168, 1, 255))
);
assert_eq!(parsed.local_addr_kind, AddrKind::Broadcast);
assert_eq!(parsed.remote_addr_kind, AddrKind::Unicast);
assert_eq!(
collector_calls.get(),
0,
"a recognized subnet broadcast must not re-enumerate interfaces"
);
}
#[test]
fn outgoing_broadcast_marks_the_remote_side() {
let mut parser = create_parser_with_linktype(1);
parser.v4_broadcasts.insert(Ipv4Addr::new(192, 168, 1, 255));
let packet = ethernet_ipv4_udp([192, 168, 1, 100], [192, 168, 1, 255]);
let parsed = parser.parse_packet(&packet).expect("packet should parse");
assert!(parsed.is_outgoing);
assert_eq!(parsed.local_addr_kind, AddrKind::Unicast);
assert_eq!(parsed.remote_addr_kind, AddrKind::Broadcast);
}
#[test]
fn gateway_remote_endpoint_is_stamped() {
let mut parser = create_parser_with_linktype(1);
parser
.gateways
.insert(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1)));
let packet = ethernet_ipv4_udp([192, 168, 1, 100], [192, 168, 1, 1]);
let parsed = parser.parse_packet(&packet).expect("packet should parse");
assert_eq!(parsed.remote_addr_kind, AddrKind::Unicast);
assert!(parsed.remote_is_gateway);
let packet = ethernet_ipv4_udp([192, 168, 1, 100], [192, 168, 1, 52]);
let parsed = parser.parse_packet(&packet).expect("packet should parse");
assert!(!parsed.remote_is_gateway);
}
#[test]
fn broadcast_remote_is_never_marked_as_gateway() {
let mut parser = create_parser_with_linktype(1);
parser.v4_broadcasts.insert(Ipv4Addr::new(192, 168, 1, 255));
parser
.gateways
.insert(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 255)));
let packet = ethernet_ipv4_udp([192, 168, 1, 100], [192, 168, 1, 255]);
let parsed = parser.parse_packet(&packet).expect("packet should parse");
assert_eq!(parsed.remote_addr_kind, AddrKind::Broadcast);
assert!(!parsed.remote_is_gateway);
}
#[test]
fn refresh_picks_up_gateway_changes() {
let mut parser = create_parser_with_linktype(1);
parser.local_ips = [IpAddr::V4(Ipv4Addr::LOCALHOST)].into_iter().collect();
parser.v4_broadcasts.clear();
parser.gateways.clear();
let gateway = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1));
let collector =
|| local_addresses_with_gateways([IpAddr::V4(Ipv4Addr::LOCALHOST)], [gateway]);
assert!(
parser.refresh_local_ips_with(collector),
"a gateway-only change must count as a snapshot change"
);
assert!(parser.gateways.contains(&gateway));
assert!(
!parser.refresh_local_ips_with(collector),
"an unchanged snapshot must not report a change"
);
}
#[test]
fn ambiguous_ipv6_packet_refreshes_local_addresses_and_reorients_endpoints() {
let mut parser = create_parser_with_linktype(1);
parser.local_ips.clear();
parser.local_ips.insert(IpAddr::V4(Ipv4Addr::LOCALHOST));
parser.local_ips.insert(IpAddr::V6(Ipv6Addr::LOCALHOST));
let packet = ethernet_ipv6_tcp();
let stale = parser.parse_packet(&packet).expect("packet should parse");
assert!(!stale.is_outgoing);
assert_eq!(stale.local_addr.port(), 80);
let new_local = IpAddr::V6("2001:db8::1".parse().expect("valid fixture address"));
let corrected = parser
.parse_packet_with_local_ip_collector(&packet, || {
local_addresses([
IpAddr::V4(Ipv4Addr::LOCALHOST),
IpAddr::V6(Ipv6Addr::LOCALHOST),
new_local,
])
})
.expect("packet should be reparsed");
assert!(corrected.is_outgoing);
assert_eq!(corrected.local_addr.ip(), new_local);
assert_eq!(corrected.local_addr.port(), 1234);
assert_eq!(corrected.remote_addr.port(), 80);
}
#[test]
fn refresh_replaces_addresses_that_are_no_longer_assigned() {
let mut parser = create_parser_with_linktype(1);
let old = IpAddr::V6("2001:db8::1".parse().expect("valid old address"));
let new = IpAddr::V6("2001:db8::2".parse().expect("valid new address"));
parser.local_ips = [old].into_iter().collect();
assert!(parser.refresh_local_ips_with(|| local_addresses([new])));
assert!(!parser.local_ips.contains(&old));
assert!(parser.local_ips.contains(&new));
}
#[test]
fn ambiguous_refresh_is_rate_limited_between_packets() {
use std::cell::Cell;
let mut parser = create_parser_with_linktype(1);
parser.local_ips.clear();
parser.local_ips.insert(IpAddr::V4(Ipv4Addr::LOCALHOST));
let packet = ethernet_ipv6_tcp();
let collector_calls = Cell::new(0u32);
let unchanged_collector = || {
collector_calls.set(collector_calls.get() + 1);
local_addresses([IpAddr::V4(Ipv4Addr::LOCALHOST)])
};
parser
.parse_packet_with_local_ip_collector(&packet, unchanged_collector)
.expect("packet should parse");
parser
.parse_packet_with_local_ip_collector(&packet, unchanged_collector)
.expect("packet should parse");
assert_eq!(
collector_calls.get(),
1,
"second ambiguous packet within the refresh interval must not re-enumerate"
);
}
#[test]
fn fruitless_ambiguous_refreshes_back_off_exponentially() {
let mut parser = create_parser_with_linktype(1);
assert_eq!(parser.ambiguous_refresh_interval(), Duration::from_secs(1));
parser.unchanged_ambiguous_refreshes = 3;
assert_eq!(parser.ambiguous_refresh_interval(), Duration::from_secs(8));
parser.unchanged_ambiguous_refreshes = 100;
assert_eq!(
parser.ambiguous_refresh_interval(),
AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL
);
let new = IpAddr::V6("2001:db8::99".parse().expect("valid address"));
assert!(parser.refresh_local_ips_with(|| local_addresses([new])));
assert_eq!(
parser.unchanged_ambiguous_refreshes, 0,
"a refresh that observes a change must reset the backoff"
);
}
#[test]
fn periodic_refresh_waits_for_interval() {
let mut parser = create_parser_with_linktype(1);
let bogus = IpAddr::V6("2001:db8::dead".parse().expect("valid address"));
parser.local_ips = [bogus].into_iter().collect();
assert!(!parser.refresh_local_ips_if_due(Duration::from_secs(3600)));
assert!(
parser.local_ips.contains(&bogus),
"snapshot must be untouched before the interval elapses"
);
assert!(parser.refresh_local_ips_if_due(Duration::ZERO));
assert!(!parser.local_ips.contains(&bogus));
}
#[test]
fn test_empty_packet() {
let parser = create_parser_with_linktype(1);
let empty = vec![];
assert!(parser.parse_packet(&empty).is_none());
}
#[test]
fn test_ipv6_extension_header_overflow_does_not_panic() {
let parser = create_parser_with_linktype(1);
let mut packet = vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x86, 0xdd,
];
packet.extend_from_slice(&[
0x60, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x02,
]);
packet.extend_from_slice(&[0x3b , 0xff]);
let _ = parser.parse_packet(&packet);
}
#[test]
fn test_ipv4_with_options() {
let parser = create_parser_with_linktype(1);
let mut packet = vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
0x46, 0x00, 0x00, 0x2c, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1, 100, 93, 184, 216,
34, 0x01, 0x01, 0x00, 0x00,
];
packet.extend_from_slice(&[
0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]);
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should handle IPv4 with options");
}
#[test]
fn test_packet_length_calculation_ipv4() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv4_tcp_syn();
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.packet_len, 54);
}
#[test]
fn test_packet_length_calculation_ipv6() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv6_tcp();
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.packet_len, 74);
}
#[test]
fn test_ethernet_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
assert_eq!(packet.len(), 54);
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_trailing_bytes_are_not_read_as_tcp_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet.extend_from_slice(b"SSH-2.0-OpenSSH_9.6\r\n");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
assert!(parsed.dpi_result.is_none());
}
#[test]
fn test_ipv6_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv6_tcp();
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_real_payload_is_preserved() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet[16] = 0x00;
packet[17] = 0x2c;
packet.extend_from_slice(b"data");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
}
#[test]
fn test_truncated_capture_keeps_captured_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet[16] = 0x05;
packet[17] = 0xdc;
packet.extend_from_slice(b"data");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
}
#[test]
fn test_sll_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(113); let mut packet = linux_sll_ipv4_tcp();
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_raw_ip_trailing_bytes_are_not_read_as_tcp_payload() {
let parser = create_parser_with_linktype(12); let mut packet = ethernet_ipv4_tcp_syn()[14..].to_vec();
packet.extend_from_slice(b"SSH-2.0-OpenSSH_9.6\r\n");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
assert!(parsed.dpi_result.is_none());
}
#[test]
fn test_raw_ipv6_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(12); let mut packet = ethernet_ipv6_tcp()[14..].to_vec();
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_zero_total_length_keeps_full_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet[16] = 0x00;
packet[17] = 0x00;
packet.extend_from_slice(b"data");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
}
}