use std::io;
use std::net::{IpAddr, Ipv4Addr};
use std::sync::Mutex;
use std::time::Duration;
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::tcp::TcpPacket;
use pnet::packet::Packet;
use pnet::transport::{
tcp_packet_iter, transport_channel, TransportChannelType::Layer4,
TransportProtocol::Ipv4, TransportReceiver, TransportSender,
};
use crate::engine::{rate_limiter_from_pps, EngineConfig, EngineError, EngineStats, PacketEngine, RxPacket};
use crate::packet::{RawPacket, MAX_PACKET_SIZE, offsets};
use crate::stats_window::PpsTracker;
use crate::checksum::ip_checksum;
pub trait PnetSender: Send + Sync {
fn send_segment(&mut self, segment: &[u8], dst: Ipv4Addr) -> io::Result<usize>;
}
pub trait PnetReceiver: Send + Sync {
fn next_segment(&mut self, timeout: Duration) -> io::Result<Option<(Vec<u8>, Ipv4Addr)>>;
}
impl PnetSender for TransportSender {
fn send_segment(&mut self, segment: &[u8], dst: Ipv4Addr) -> io::Result<usize> {
let tcp = TcpPacket::new(segment).ok_or_else(|| {
io::Error::new(io::ErrorKind::InvalidData, "invalid TCP segment")
})?;
self.send_to(tcp, IpAddr::V4(dst))
}
}
impl PnetReceiver for TransportReceiver {
fn next_segment(&mut self, timeout: Duration) -> io::Result<Option<(Vec<u8>, Ipv4Addr)>> {
let mut iter = tcp_packet_iter(self);
match iter.next_with_timeout(timeout)? {
None => Ok(None),
Some((tcp, addr)) => {
let bytes = tcp.packet().to_vec();
let IpAddr::V4(src_ip) = addr else {
return Ok(None);
};
Ok(Some((bytes, src_ip)))
}
}
}
}
pub struct PnetEngine<S = TransportSender, R = TransportReceiver> {
tx: Mutex<S>,
rx: Mutex<R>,
#[allow(dead_code)]
config: EngineConfig,
tx_stats: PpsTracker,
rx_stats: PpsTracker,
rate_limiter: Option<ratelimit::TokenBucket>,
}
impl PnetEngine<TransportSender, TransportReceiver> {
pub fn new(config: EngineConfig) -> Result<Self, EngineError> {
let protocol = Layer4(Ipv4(IpNextHeaderProtocols::Tcp));
let (tx, rx) = transport_channel(65536, protocol).map_err(|e| {
EngineError::PermissionDenied(format!(
"failed to open raw socket: {e}. Run with CAP_NET_RAW or as root."
))
})?;
Ok(Self::with_senders(config, tx, rx))
}
}
impl<S, R> PnetEngine<S, R> {
pub fn with_senders(config: EngineConfig, tx: S, rx: R) -> Self {
let rate_limiter = rate_limiter_from_pps(config.rate_pps);
Self {
tx: Mutex::new(tx),
rx: Mutex::new(rx),
config,
tx_stats: PpsTracker::new(),
rx_stats: PpsTracker::new(),
rate_limiter,
}
}
}
impl<S: PnetSender, R: PnetReceiver> PacketEngine for PnetEngine<S, R> {
fn tx_batch(&self, packets: &[RawPacket]) -> Result<usize, EngineError> {
let mut tx = self.tx.lock().map_err(|_| {
EngineError::Io(std::io::Error::new(
std::io::ErrorKind::Other,
"TX lock poisoned",
))
})?;
let mut sent = 0usize;
for (i, pkt) in packets.iter().enumerate() {
if pkt.len < 40 {
self.tx_stats.record_drop(1);
continue;
}
if let Some(ref bucket) = self.rate_limiter {
if !bucket.try_acquire() {
self.tx_stats.record_drop((packets.len() - i) as u64);
break;
}
}
let dst_ip = Ipv4Addr::new(
pkt.buf[offsets::IP_DST],
pkt.buf[offsets::IP_DST + 1],
pkt.buf[offsets::IP_DST + 2],
pkt.buf[offsets::IP_DST + 3],
);
let tcp_data = &pkt.buf[offsets::TCP_START..pkt.clamped_len()];
match tx.send_segment(tcp_data, dst_ip) {
Ok(_) => {
sent += 1;
self.tx_stats.record(1);
}
Err(_) => {
self.tx_stats.record_drop(1);
}
}
}
Ok(sent)
}
fn rx_batch(&self, buf: &mut [RxPacket]) -> Result<usize, EngineError> {
let mut rx = self.rx.lock().map_err(|_| {
EngineError::Io(std::io::Error::new(
std::io::ErrorKind::Other,
"RX lock poisoned",
))
})?;
let mut received = 0usize;
while received < buf.len() {
match rx.next_segment(Duration::from_millis(0)) {
Ok(Some((raw_bytes, src_ip))) => {
if raw_bytes.len() < 20 {
self.rx_stats.record_drop(1);
continue;
}
let tcp_data_offset = {
let data_offset_words = (raw_bytes.get(12).copied().unwrap_or(0) >> 4) as usize;
data_offset_words * 4
};
if tcp_data_offset < 20 || tcp_data_offset > raw_bytes.len() {
self.rx_stats.record_drop(1);
continue;
}
let payload = raw_bytes[tcp_data_offset..].to_vec();
let total_len = (20 + raw_bytes.len()) as u16;
let mut ip_header = [0u8; 20];
ip_header[0] = 0x45; ip_header[2..4].copy_from_slice(&total_len.to_be_bytes());
ip_header[8] = 64; ip_header[9] = 6; ip_header[12..16].copy_from_slice(&src_ip.octets());
ip_header[16..20].copy_from_slice(&self.config.source_ip.octets());
let checksum = ip_checksum(&ip_header);
ip_header[10..12].copy_from_slice(&checksum.to_be_bytes());
let Some(packet) = reconstruct_l3_packet(&ip_header, &raw_bytes) else {
self.rx_stats.record_drop(1);
continue;
};
let src_port = u16::from_be_bytes([raw_bytes[0], raw_bytes[1]]);
let dst_port = u16::from_be_bytes([raw_bytes[2], raw_bytes[3]]);
let seq_num = u32::from_be_bytes([raw_bytes[4], raw_bytes[5], raw_bytes[6], raw_bytes[7]]);
let ack_num = u32::from_be_bytes([raw_bytes[8], raw_bytes[9], raw_bytes[10], raw_bytes[11]]);
let tcp_flags = raw_bytes[13];
let window = u16::from_be_bytes([raw_bytes[14], raw_bytes[15]]);
buf[received] = RxPacket {
packet,
src_ip,
src_port,
dst_port,
tcp_flags,
ack_num,
seq_num,
ttl: 64, window,
payload,
};
received += 1;
self.rx_stats.record(1);
}
Ok(None) => break, Err(e) => {
return Err(EngineError::Io(e));
}
}
}
Ok(received)
}
fn stats(&self) -> EngineStats {
EngineStats {
tx_packets: self.tx_stats.total(),
rx_packets: self.rx_stats.total(),
tx_drops: self.tx_stats.drops(),
rx_drops: self.rx_stats.drops(),
tx_pps: self.tx_stats.snapshot_pps(),
rx_pps: self.rx_stats.snapshot_pps(),
}
}
fn name(&self) -> &'static str {
"pnet"
}
}
fn reconstruct_l3_packet(ip_header: &[u8; 20], tcp_segment: &[u8]) -> Option<RawPacket> {
let l3_len = ip_header.len() + tcp_segment.len();
if l3_len > MAX_PACKET_SIZE {
return None;
}
let mut packet = RawPacket::empty();
packet.buf[..ip_header.len()].copy_from_slice(ip_header);
packet.buf[ip_header.len()..l3_len].copy_from_slice(tcp_segment);
packet.len = l3_len as u16;
Some(packet)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::packet::{build_syn_template, stamp_syn};
use std::alloc::{GlobalAlloc, Layout, System};
thread_local! {
static THREAD_ALLOCS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
struct CountingAlloc;
unsafe impl GlobalAlloc for CountingAlloc {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
let _ = THREAD_ALLOCS.try_with(|c| c.set(c.get().wrapping_add(1)));
System.alloc(layout)
}
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
System.dealloc(ptr, layout);
}
}
#[global_allocator]
static COUNTING_ALLOCATOR: CountingAlloc = CountingAlloc;
fn thread_alloc_count() -> usize {
THREAD_ALLOCS.with(|c| c.get())
}
#[test]
fn reconstruct_l3_packet_writes_ip_header_then_tcp_segment() {
let mut ip_header = [0u8; 20];
ip_header[0] = 0x45; ip_header[9] = 6; let tcp_segment = [0x11u8, 0x22, 0x33, 0x44, 0x55];
let packet = reconstruct_l3_packet(&ip_header, &tcp_segment).expect("fits");
assert_eq!(packet.len as usize, 25);
assert_eq!(&packet.as_bytes()[..20], &ip_header);
assert_eq!(&packet.as_bytes()[20..], &tcp_segment);
}
#[test]
fn reconstruct_l3_packet_does_not_heap_allocate() {
let ip_header = [0u8; 20];
let tcp_segment = [0xABu8; 40];
let before = thread_alloc_count();
let packet = reconstruct_l3_packet(&ip_header, &tcp_segment).expect("fits");
let after = thread_alloc_count();
assert_eq!(
after - before,
0,
"L3 reconstruction must not heap-allocate in the hot RX path"
);
assert_eq!(packet.len as usize, 60);
}
#[test]
fn reconstruct_l3_packet_rejects_oversized_segment_at_the_boundary() {
let ip_header = [0u8; 20];
let too_big = vec![0u8; MAX_PACKET_SIZE - 20 + 1];
assert!(
reconstruct_l3_packet(&ip_header, &too_big).is_none(),
"a packet exceeding MAX_PACKET_SIZE must be rejected, not truncated"
);
let exact = vec![0u8; MAX_PACKET_SIZE - 20];
let packet = reconstruct_l3_packet(&ip_header, &exact).expect("boundary fits");
assert_eq!(packet.len as usize, MAX_PACKET_SIZE);
}
struct MockSender {
sent: Vec<(Vec<u8>, Ipv4Addr)>,
fail_next: bool,
}
impl MockSender {
fn new() -> Self {
Self {
sent: Vec::new(),
fail_next: false,
}
}
}
impl PnetSender for MockSender {
fn send_segment(&mut self, segment: &[u8], dst: Ipv4Addr) -> io::Result<usize> {
if self.fail_next {
return Err(io::Error::new(io::ErrorKind::Other, "injected send failure"));
}
self.sent.push((segment.to_vec(), dst));
Ok(segment.len())
}
}
struct MockReceiver {
segments: Vec<(Vec<u8>, Ipv4Addr)>,
}
impl MockReceiver {
fn new(segments: Vec<(Vec<u8>, Ipv4Addr)>) -> Self {
Self { segments }
}
}
impl PnetReceiver for MockReceiver {
fn next_segment(&mut self, _timeout: Duration) -> io::Result<Option<(Vec<u8>, Ipv4Addr)>> {
if self.segments.is_empty() {
return Ok(None);
}
Ok(Some(self.segments.remove(0)))
}
}
fn make_syn_packet(dst_ip: Ipv4Addr, dst_port: u16) -> RawPacket {
let src_ip = Ipv4Addr::new(10, 0, 0, 1);
let mut pkt = build_syn_template(src_ip, 49152);
stamp_syn(&mut pkt, dst_ip, dst_port, 0x12345678);
pkt
}
fn build_tcp_segment(
src_port: u16,
dst_port: u16,
seq: u32,
ack: u32,
data_offset_words: u8,
flags: u8,
window: u16,
payload: &[u8],
) -> Vec<u8> {
let header_len = (data_offset_words as usize) * 4;
let mut seg = Vec::with_capacity(header_len + payload.len());
seg.extend_from_slice(&src_port.to_be_bytes());
seg.extend_from_slice(&dst_port.to_be_bytes());
seg.extend_from_slice(&seq.to_be_bytes());
seg.extend_from_slice(&ack.to_be_bytes());
seg.push(data_offset_words << 4);
seg.push(flags);
seg.extend_from_slice(&window.to_be_bytes());
seg.extend_from_slice(&[0u8, 0u8]); seg.extend_from_slice(&[0u8, 0u8]); seg.resize(header_len, 0);
seg.extend_from_slice(payload);
seg
}
fn empty_rx_slot() -> RxPacket {
RxPacket {
packet: RawPacket::empty(),
src_ip: Ipv4Addr::UNSPECIFIED,
src_port: 0,
dst_port: 0,
tcp_flags: 0,
ack_num: 0,
seq_num: 0,
ttl: 0,
window: 0,
payload: Vec::new(),
}
}
#[test]
fn tx_batch_sends_valid_syn_and_counts_it() {
let dst = Ipv4Addr::new(1, 2, 3, 4);
let pkt = make_syn_packet(dst, 443);
let sender = MockSender::new();
let receiver = MockReceiver::new(vec![]);
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let sent = engine.tx_batch(std::slice::from_ref(&pkt)).unwrap();
assert_eq!(sent, 1);
let stats = engine.stats();
assert_eq!(stats.tx_packets, 1);
assert_eq!(stats.tx_drops, 0);
let guard = engine.tx.lock().unwrap();
assert_eq!(guard.sent.len(), 1);
assert_eq!(guard.sent[0].1, dst);
assert_eq!(guard.sent[0].0, &pkt.buf[offsets::TCP_START..pkt.len as usize]);
}
#[test]
fn tx_batch_drops_short_packets() {
let mut pkt = RawPacket::empty();
pkt.len = 30; pkt.buf[offsets::TCP_START..offsets::TCP_START + 10].copy_from_slice(&[0u8; 10]);
let sender = MockSender::new();
let receiver = MockReceiver::new(vec![]);
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let sent = engine.tx_batch(&[pkt]).unwrap();
assert_eq!(sent, 0);
let guard = engine.tx.lock().unwrap();
assert!(guard.sent.is_empty());
assert_eq!(engine.stats().tx_drops, 1);
}
#[test]
fn tx_batch_records_drop_on_send_error() {
let dst = Ipv4Addr::new(1, 2, 3, 4);
let pkt = make_syn_packet(dst, 443);
let mut sender = MockSender::new();
sender.fail_next = true;
let receiver = MockReceiver::new(vec![]);
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let sent = engine.tx_batch(&[pkt]).unwrap();
assert_eq!(sent, 0);
assert_eq!(engine.stats().tx_drops, 1);
}
#[test]
fn rx_batch_reconstructs_l3_packet_and_populates_rx_packet() {
let src_ip = Ipv4Addr::new(192, 0, 2, 1);
let segment = build_tcp_segment(443, 12345, 0xdeadbeef, 0xcafebabe, 5, 0x12, 64240, b"payload");
let receiver = MockReceiver::new(vec![(segment, src_ip)]);
let sender = MockSender::new();
let mut config = EngineConfig::default();
config.source_ip = Ipv4Addr::new(10, 0, 0, 1);
let engine = PnetEngine::with_senders(config, sender, receiver);
let mut buf = vec![RxPacket {
packet: RawPacket::empty(),
src_ip: Ipv4Addr::UNSPECIFIED,
src_port: 0,
dst_port: 0,
tcp_flags: 0,
ack_num: 0,
seq_num: 0,
ttl: 0,
window: 0,
payload: Vec::new(),
}; 4];
let received = engine.rx_batch(&mut buf).unwrap();
assert_eq!(received, 1);
let rx = &buf[0];
assert_eq!(rx.src_ip, src_ip);
assert_eq!(rx.src_port, 443);
assert_eq!(rx.dst_port, 12345);
assert_eq!(rx.seq_num, 0xdeadbeef);
assert_eq!(rx.ack_num, 0xcafebabe);
assert_eq!(rx.tcp_flags, 0x12);
assert_eq!(rx.window, 64240);
assert_eq!(rx.payload, b"payload");
assert_eq!(rx.packet.len, 20 + 20 + 7);
assert_eq!(rx.packet.buf[0], 0x45);
assert_eq!(rx.packet.buf[9], 6);
let stats = engine.stats();
assert_eq!(stats.rx_packets, 1);
assert_eq!(stats.rx_drops, 0);
}
#[test]
fn rx_batch_skips_malformed_tcp_data_offset() {
let segment = build_tcp_segment(443, 12345, 0, 0, 4, 0x10, 0, &[]);
let receiver = MockReceiver::new(vec![(segment, Ipv4Addr::new(192, 0, 2, 1))]);
let sender = MockSender::new();
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let mut buf = vec![empty_rx_slot()];
let received = engine.rx_batch(&mut buf).unwrap();
assert_eq!(received, 0);
assert_eq!(engine.stats().rx_drops, 1);
}
#[test]
fn rx_batch_skips_segment_with_data_offset_past_end() {
let mut segment = build_tcp_segment(443, 12345, 0, 0, 5, 0x10, 0, &[]);
segment.truncate(20);
segment[12] = 0xF0; let receiver = MockReceiver::new(vec![(segment, Ipv4Addr::new(192, 0, 2, 1))]);
let sender = MockSender::new();
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let mut buf = vec![empty_rx_slot()];
let received = engine.rx_batch(&mut buf).unwrap();
assert_eq!(received, 0);
assert_eq!(engine.stats().rx_drops, 1);
}
#[test]
fn rx_batch_stops_when_buffer_is_full() {
let src_ip = Ipv4Addr::new(192, 0, 2, 1);
let segments = vec![
(build_tcp_segment(443, 1, 1, 0, 5, 0x10, 0, &[]), src_ip),
(build_tcp_segment(443, 2, 2, 0, 5, 0x10, 0, &[]), src_ip),
];
let receiver = MockReceiver::new(segments);
let sender = MockSender::new();
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let mut buf = vec![RxPacket {
packet: RawPacket::empty(),
src_ip: Ipv4Addr::UNSPECIFIED,
src_port: 0,
dst_port: 0,
tcp_flags: 0,
ack_num: 0,
seq_num: 0,
ttl: 0,
window: 0,
payload: Vec::new(),
}; 1];
let received = engine.rx_batch(&mut buf).unwrap();
assert_eq!(received, 1);
assert_eq!(buf[0].src_port, 443);
assert_eq!(buf[0].dst_port, 1);
}
#[test]
fn rx_batch_stops_on_empty_receiver() {
let receiver = MockReceiver::new(vec![]);
let sender = MockSender::new();
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let mut buf: Vec<RxPacket> = Vec::new();
let received = engine.rx_batch(&mut buf).unwrap();
assert_eq!(received, 0);
}
struct FailAfterOneReceiver {
first: Option<(Vec<u8>, Ipv4Addr)>,
}
impl PnetReceiver for FailAfterOneReceiver {
fn next_segment(&mut self, _timeout: Duration) -> io::Result<Option<(Vec<u8>, Ipv4Addr)>> {
match self.first.take() {
Some(segment) => Ok(Some(segment)),
None => Err(io::Error::new(io::ErrorKind::Other, "injected recv failure")),
}
}
}
#[test]
fn rx_batch_propagates_socket_read_error_instead_of_reporting_short_batch() {
let src_ip = Ipv4Addr::new(192, 0, 2, 1);
let segment = build_tcp_segment(443, 12345, 1, 0, 5, 0x12, 0, &[]);
let receiver = FailAfterOneReceiver {
first: Some((segment, src_ip)),
};
let sender = MockSender::new();
let engine = PnetEngine::with_senders(EngineConfig::default(), sender, receiver);
let mut buf = vec![empty_rx_slot(); 4];
let result = engine.rx_batch(&mut buf);
let err = result.expect_err("a socket read error must surface, not a short Ok batch");
assert!(
matches!(err, EngineError::Io(_)),
"expected EngineError::Io from the propagated recv failure, got {err:?}"
);
assert!(
err.to_string().contains("injected recv failure"),
"the underlying io error must be preserved: {err}"
);
}
#[test]
fn tx_batch_rate_limits_to_rate_pps() {
let dst = Ipv4Addr::new(1, 2, 3, 4);
let pkts = vec![
make_syn_packet(dst, 443),
make_syn_packet(dst, 444),
make_syn_packet(dst, 445),
];
let mut config = EngineConfig::default();
config.rate_pps = 2; let sender = MockSender::new();
let receiver = MockReceiver::new(vec![]);
let engine = PnetEngine::with_senders(config, sender, receiver);
let sent = engine.tx_batch(&pkts).unwrap();
assert_eq!(sent, 2);
let guard = engine.tx.lock().unwrap();
assert_eq!(guard.sent.len(), 2);
drop(guard);
let stats = engine.stats();
assert_eq!(stats.tx_packets, 2);
assert_eq!(stats.tx_drops, 1);
}
#[test]
fn tx_batch_rate_pps_zero_is_unlimited() {
let dst = Ipv4Addr::new(1, 2, 3, 4);
let pkts = vec![
make_syn_packet(dst, 443),
make_syn_packet(dst, 444),
make_syn_packet(dst, 445),
];
let mut config = EngineConfig::default();
config.rate_pps = 0;
let sender = MockSender::new();
let receiver = MockReceiver::new(vec![]);
let engine = PnetEngine::with_senders(config, sender, receiver);
let sent = engine.tx_batch(&pkts).unwrap();
assert_eq!(sent, 3);
let guard = engine.tx.lock().unwrap();
assert_eq!(guard.sent.len(), 3);
drop(guard);
let stats = engine.stats();
assert_eq!(stats.tx_packets, 3);
assert_eq!(stats.tx_drops, 0);
}
}