netforge 0.1.0

High-performance raw packet I/O engine with AF_XDP, sendmmsg, and pnet backends
Documentation
//! `pnet` raw socket backend — portable, ~1M pps.
//!
//! Uses `pnet::transport` for Layer 4 raw TCP packet TX/RX.
//! This is the fallback backend that works on any Linux with CAP_NET_RAW.
//! Performance is limited by per-packet `sendto()` syscall overhead.

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;

/// `pnet`-based raw socket packet engine.
///
/// Sends TCP packets via Layer 4 raw sockets (kernel handles IP header).
/// Note: `pnet` Layer4 only sends the TCP portion; the kernel adds the IP
/// header. For full control, we'd need Layer3, but Layer4 is sufficient
/// for SYN scanning.
pub struct PnetEngine {
    tx: Mutex<TransportSender>,
    rx: Mutex<TransportReceiver>,
    config: EngineConfig,
    tx_stats: PpsTracker,
    rx_stats: PpsTracker,
}

impl PnetEngine {
    /// Create a new `pnet` engine.
    ///
    /// Requires `CAP_NET_RAW` or root privileges.
    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;
            }

            // Extract destination IP from the packet's IP header
            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],
            );

            // pnet Layer4 expects just the TCP portion
            let tcp_data = &pkt.buf[offsets::TCP_START..pkt.len as usize];

            // Build an immutable TCP packet view for pnet
            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);

        // Non-blocking drain: try to fill the buffer
        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, // Not accessible via pnet Layer4 — use 64 as default
                        window: tcp.get_window(),
                        payload,
                    };

                    received += 1;
                    self.rx_stats.record(1);
                }
                Ok(None) => break, // Timeout, no more packets
                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"
    }
}