use pnet::datalink;
use pnet::datalink::{Channel, Config, DataLinkReceiver, DataLinkSender, NetworkInterface};
use std::thread;
use std::time::Duration;
use tokio::sync::mpsc;
const READ_TIMEOUT_MS: u64 = 50;
pub struct EthernetHandle {
pub tx: Box<dyn DataLinkSender>,
pub rx: mpsc::UnboundedReceiver<Vec<u8>>,
}
impl EthernetHandle {
#[cfg(any(test, feature = "test-support"))]
pub fn from_parts(tx: Box<dyn DataLinkSender>, rx: mpsc::UnboundedReceiver<Vec<u8>>) -> Self {
Self { tx, rx }
}
}
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum ChannelError {
#[error("opening a link-layer channel on {interface} failed: {source}")]
Open {
interface: String,
#[source]
source: std::io::Error,
},
#[error("{interface} is not an Ethernet interface")]
NotEthernet {
interface: String,
},
}
pub fn start_capture(intf: &NetworkInterface) -> Result<EthernetHandle, ChannelError> {
let cfg = Config {
read_timeout: Some(Duration::from_millis(READ_TIMEOUT_MS)),
..Default::default()
};
let (tx, rx_socket) = open_eth_channel(intf, datalink::channel, cfg)?;
let (queue_tx, queue_rx) = mpsc::unbounded_channel();
spawn_eth_listener(queue_tx, rx_socket);
Ok(EthernetHandle { tx, rx: queue_rx })
}
pub type EthernetChannel = (Box<dyn DataLinkSender>, Box<dyn DataLinkReceiver>);
pub fn open_eth_channel<F>(
intf: &NetworkInterface,
channel_opener: F,
cfg: Config,
) -> Result<EthernetChannel, ChannelError>
where
F: FnOnce(&NetworkInterface, Config) -> std::io::Result<datalink::Channel>,
{
let ch: Channel = channel_opener(intf, cfg).map_err(|source| ChannelError::Open {
interface: intf.name.clone(),
source,
})?;
match ch {
Channel::Ethernet(tx, rx) => Ok((tx, rx)),
_ => Err(ChannelError::NotEthernet {
interface: intf.name.clone(),
}),
}
}
pub fn spawn_eth_listener(
eth_tx: mpsc::UnboundedSender<Vec<u8>>,
eth_rx: Box<dyn DataLinkReceiver>,
) {
thread::spawn(move || {
let mut eth_iter = eth_rx;
loop {
if let Ok(frame) = eth_iter.next()
&& eth_tx.send(frame.to_vec()).is_err()
{
break;
}
}
});
}