use std::net::Ipv4Addr;
use crate::RawPacket;
pub(crate) fn rate_limiter_from_pps(rate_pps: u64) -> Option<ratelimit::TokenBucket> {
if rate_pps == 0 {
return None;
}
let clamped = rate_pps.min(u32::MAX as u64);
let rate = clamped as f64;
let burst = clamped as u32;
ratelimit::TokenBucket::new(rate, burst)
.inspect_err(|e| tracing::warn!("invalid rate_pps {rate_pps}, disabling rate limit: {e}"))
.ok()
}
#[derive(Debug, Clone)]
pub struct EngineConfig {
pub source_ip: Ipv4Addr,
pub source_port_start: u16,
pub source_port_end: u16,
pub rate_pps: u64,
pub interface: Option<String>,
pub tx_ring_size: u32,
pub rx_ring_size: u32,
}
impl Default for EngineConfig {
fn default() -> Self {
Self {
source_ip: Ipv4Addr::UNSPECIFIED,
source_port_start: 49152,
source_port_end: 65535,
rate_pps: 1_000_000, interface: None,
tx_ring_size: 4096,
rx_ring_size: 4096,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct EngineStats {
pub tx_packets: u64,
pub rx_packets: u64,
pub tx_drops: u64,
pub rx_drops: u64,
pub tx_pps: u64,
pub rx_pps: u64,
}
#[derive(Debug, Clone)]
pub struct RxPacket {
pub packet: RawPacket,
pub src_ip: Ipv4Addr,
pub src_port: u16,
pub dst_port: u16,
pub tcp_flags: u8,
pub ack_num: u32,
pub seq_num: u32,
pub ttl: u8,
pub window: u16,
pub payload: Vec<u8>,
}
pub mod tcp_flags {
pub const FIN: u8 = 0x01;
pub const SYN: u8 = 0x02;
pub const RST: u8 = 0x04;
pub const PSH: u8 = 0x08;
pub const ACK: u8 = 0x10;
pub const SYN_ACK: u8 = SYN | ACK;
}
#[derive(Debug, thiserror::Error)]
pub enum EngineError {
#[error("insufficient privileges: {0} (need CAP_NET_RAW or root)")]
PermissionDenied(String),
#[error("interface error: {0}")]
InterfaceError(String),
#[error("I/O error: {0}")]
Io(#[from] std::io::Error),
#[error("invalid configuration: {0}")]
InvalidConfig(String),
#[error("packet exceeds MTU: {size} > {mtu}")]
PacketTooLarge {
size: usize,
mtu: usize,
},
}
pub trait PacketEngine: Send + Sync {
fn tx_batch(&self, packets: &[RawPacket]) -> Result<usize, EngineError>;
fn rx_batch(&self, buf: &mut [RxPacket]) -> Result<usize, EngineError>;
fn stats(&self) -> EngineStats;
fn name(&self) -> &'static str;
}
pub fn auto_select(config: EngineConfig) -> Result<Box<dyn PacketEngine>, EngineError> {
#[cfg(all(target_os = "linux", feature = "xdp-backend"))]
{
match crate::backend_xdp::XdpEngine::new(config.clone()) {
Ok(eng) => {
tracing::info!(backend = "xdp", "netforge selected AF_XDP backend");
return Ok(Box::new(eng) as Box<dyn PacketEngine>);
}
Err(EngineError::PermissionDenied(e)) => {
tracing::debug!(error = %e, "xdp backend unavailable; trying sendmmsg");
}
Err(e) => return Err(e),
}
}
#[cfg(all(target_os = "linux", feature = "sendmmsg-backend"))]
{
match crate::backend_sendmmsg::SendmmsgEngine::new(config.clone()) {
Ok(eng) => {
tracing::info!(backend = "sendmmsg", "netforge selected sendmmsg backend");
return Ok(Box::new(eng) as Box<dyn PacketEngine>);
}
Err(EngineError::PermissionDenied(e)) => {
tracing::warn!(error = %e, "sendmmsg backend unavailable; falling back");
}
Err(e) => return Err(e),
}
}
#[cfg(feature = "pnet-backend")]
{
let eng = crate::backend_pnet::PnetEngine::new(config)?;
tracing::info!(backend = "pnet", "netforge selected pnet backend");
return Ok(Box::new(eng) as Box<dyn PacketEngine>);
}
#[cfg(not(feature = "pnet-backend"))]
{
Err(EngineError::PermissionDenied(
"no packet backend compiled in (need sendmmsg-backend or pnet-backend)".into(),
))
}
}