use std::net::{IpAddr, Ipv4Addr};
use std::sync::Mutex;
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::tcp::TcpPacket;
use pnet::packet::Packet;
use pnet::transport::{
transport_channel, TransportChannelType::Layer4, TransportProtocol::Ipv4,
TransportReceiver, TransportSender,
};
use crate::engine::{EngineConfig, EngineError, EngineStats, PacketEngine, RxPacket};
use crate::packet::{RawPacket, offsets};
use crate::stats_window::PpsTracker;
pub struct PnetEngine {
tx: Mutex<TransportSender>,
rx: Mutex<TransportReceiver>,
config: EngineConfig,
tx_stats: PpsTracker,
rx_stats: PpsTracker,
}
impl PnetEngine {
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 {
tx: Mutex::new(tx),
rx: Mutex::new(rx),
config,
tx_stats: PpsTracker::new(),
rx_stats: PpsTracker::new(),
})
}
}
impl PacketEngine for PnetEngine {
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 pkt in packets {
if pkt.len < 40 {
self.tx_stats.record_drop(1);
continue;
}
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.len as usize];
if let Some(tcp_pkt) = TcpPacket::new(tcp_data) {
match tx.send_to(tcp_pkt, IpAddr::V4(dst_ip)) {
Ok(_) => {
sent += 1;
self.tx_stats.record(1);
}
Err(_) => {
self.tx_stats.record_drop(1);
}
}
} else {
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;
let mut iter = pnet::transport::tcp_packet_iter(&mut *rx);
while received < buf.len() {
match iter.next_with_timeout(std::time::Duration::from_millis(0)) {
Ok(Some((tcp, addr))) => {
let IpAddr::V4(src_ip) = addr else { continue };
let tcp_data_offset = tcp.get_data_offset() as usize * 4;
let raw_bytes = tcp.packet();
let payload = if raw_bytes.len() > tcp_data_offset {
raw_bytes[tcp_data_offset..].to_vec()
} else {
Vec::new()
};
buf[received] = RxPacket {
packet: RawPacket::from_bytes(raw_bytes).unwrap_or_default(),
src_ip,
src_port: tcp.get_source(),
dst_port: tcp.get_destination(),
tcp_flags: tcp.get_flags() as u8,
ack_num: tcp.get_acknowledgement(),
seq_num: tcp.get_sequence(),
ttl: 64, window: tcp.get_window(),
payload,
};
received += 1;
self.rx_stats.record(1);
}
Ok(None) => break, Err(_) => break,
}
}
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"
}
}