use std::collections::HashMap;
use std::net::{IpAddr, Ipv4Addr};
use std::sync::Mutex;
use std::time::{Duration, Instant};
use anyhow::Context;
use pnet::datalink::{self, Config, DataLinkReceiver, DataLinkSender, NetworkInterface};
use pnet::packet::Packet;
use pnet::packet::arp::{ArpOperations, ArpPacket};
use pnet::packet::ethernet::{EtherTypes, EthernetPacket};
use pnet::packet::ip::IpNextHeaderProtocol;
use pnet::util::MacAddr;
use crate::network::channel::open_eth_channel;
use crate::network::frame;
use crate::network::neighbor::{LinkRoute, NeighborResolver};
use crate::network::probe::ProbeSender;
use crate::protocols::arp;
const ARP_TIMEOUT: Duration = Duration::from_millis(500);
const CHANNEL_READ_TIMEOUT: Duration = Duration::from_millis(50);
struct InterfaceChannel {
tx: Box<dyn DataLinkSender>,
rx: Box<dyn DataLinkReceiver>,
}
pub struct EthernetSender {
resolver: Mutex<NeighborResolver>,
channels: Mutex<HashMap<String, InterfaceChannel>>,
protocol: IpNextHeaderProtocol,
}
impl EthernetSender {
pub fn from_system(protocol: IpNextHeaderProtocol) -> Option<Self> {
let resolver = NeighborResolver::from_system();
if !resolver.has_ethernet() {
return None;
}
Some(Self {
resolver: Mutex::new(resolver),
channels: Mutex::new(HashMap::new()),
protocol,
})
}
fn next_hop_mac(&self, route: &LinkRoute) -> anyhow::Result<MacAddr> {
if let Some(mac) = route.next_hop_mac {
return Ok(mac);
}
let target_v4 = match route.next_hop {
IpAddr::V4(v4) => v4,
IpAddr::V6(_) => {
anyhow::bail!("on-link IPv6 next-hop resolution (NDP) is not yet implemented")
}
};
let src_v4 = match route.src_ip {
IpAddr::V4(v4) => v4,
IpAddr::V6(_) => anyhow::bail!("IPv4 target with IPv6 source is invalid"),
};
let mac = self.arp_resolve(&route.interface, route.src_mac, src_v4, target_v4)?;
self.resolver
.lock()
.unwrap()
.remember(&route.interface, route.next_hop, mac);
Ok(mac)
}
fn arp_resolve(
&self,
interface: &str,
src_mac: MacAddr,
src_ip: Ipv4Addr,
target: Ipv4Addr,
) -> anyhow::Result<MacAddr> {
let mut channels = self.channels.lock().unwrap();
let channel = self.channel_for(&mut channels, interface)?;
let request = arp::create_packet(&src_mac, MacAddr::zero(), &src_ip, target)
.context("building ARP request")?;
channel
.tx
.send_to(&request, None)
.context("no ARP send result")?
.context("sending ARP request")?;
let deadline = Instant::now() + ARP_TIMEOUT;
while Instant::now() < deadline {
let Ok(frame) = channel.rx.next() else {
continue; };
if let Some(mac) = parse_arp_reply(frame, target) {
return Ok(mac);
}
}
anyhow::bail!("ARP timed out resolving {target} on {interface}")
}
fn channel_for<'a>(
&self,
channels: &'a mut HashMap<String, InterfaceChannel>,
interface: &str,
) -> anyhow::Result<&'a mut InterfaceChannel> {
if !channels.contains_key(interface) {
let intf = find_interface(interface)
.with_context(|| format!("interface {interface} not found"))?;
let cfg = Config {
read_timeout: Some(CHANNEL_READ_TIMEOUT),
..Default::default()
};
let (tx, rx) = open_eth_channel(&intf, datalink::channel, cfg)?;
channels.insert(interface.to_string(), InterfaceChannel { tx, rx });
}
Ok(channels.get_mut(interface).unwrap())
}
}
impl ProbeSender for EthernetSender {
fn send(&self, segment: &[u8], src: IpAddr, dst: IpAddr) -> anyhow::Result<()> {
let route = self
.resolver
.lock()
.unwrap()
.resolve(dst)
.with_context(|| format!("no Ethernet route to {dst}"))?;
let dst_mac = self.next_hop_mac(&route)?;
let frame =
frame::build_ethernet_frame(route.src_mac, dst_mac, src, dst, self.protocol, segment)?;
let mut channels = self.channels.lock().unwrap();
let channel = self.channel_for(&mut channels, &route.interface)?;
channel
.tx
.send_to(&frame, None)
.context("no frame send result")?
.context("sending frame")?;
Ok(())
}
}
fn find_interface(name: &str) -> Option<NetworkInterface> {
datalink::interfaces().into_iter().find(|i| i.name == name)
}
fn parse_arp_reply(frame: &[u8], target: Ipv4Addr) -> Option<MacAddr> {
let eth = EthernetPacket::new(frame)?;
if eth.get_ethertype() != EtherTypes::Arp {
return None;
}
let arp = ArpPacket::new(eth.payload())?;
if arp.get_operation() == ArpOperations::Reply && arp.get_sender_proto_addr() == target {
Some(arp.get_sender_hw_addr())
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
use pnet::packet::arp::{ArpHardwareTypes, ArpOperations, MutableArpPacket};
use pnet::packet::ethernet::MutableEthernetPacket;
fn arp_reply(sender_ip: Ipv4Addr, sender_mac: MacAddr) -> Vec<u8> {
let mut buf = vec![0u8; 42];
{
let mut eth = MutableEthernetPacket::new(&mut buf[..14]).unwrap();
eth.set_ethertype(EtherTypes::Arp);
eth.set_source(sender_mac);
eth.set_destination(MacAddr::broadcast());
}
{
let mut a = MutableArpPacket::new(&mut buf[14..]).unwrap();
a.set_hardware_type(ArpHardwareTypes::Ethernet);
a.set_protocol_type(EtherTypes::Ipv4);
a.set_hw_addr_len(6);
a.set_proto_addr_len(4);
a.set_operation(ArpOperations::Reply);
a.set_sender_hw_addr(sender_mac);
a.set_sender_proto_addr(sender_ip);
a.set_target_proto_addr(Ipv4Addr::new(192, 168, 1, 50));
}
buf
}
#[test]
fn parses_matching_arp_reply() {
let ip = Ipv4Addr::new(192, 168, 1, 200);
let mac = MacAddr::new(0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01);
assert_eq!(parse_arp_reply(&arp_reply(ip, mac), ip), Some(mac));
}
#[test]
fn ignores_arp_reply_from_other_ip() {
let mac = MacAddr::new(0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01);
let reply = arp_reply(Ipv4Addr::new(192, 168, 1, 201), mac);
assert_eq!(
parse_arp_reply(&reply, Ipv4Addr::new(192, 168, 1, 200)),
None
);
}
#[test]
fn ignores_non_arp_frame() {
let mut buf = vec![0u8; 42];
let mut eth = MutableEthernetPacket::new(&mut buf).unwrap();
eth.set_ethertype(EtherTypes::Ipv4);
assert_eq!(parse_arp_reply(&buf, Ipv4Addr::new(192, 168, 1, 200)), None);
}
}