mod resolution;
pub(crate) use resolution::ARP_TIMEOUT;
#[cfg(test)]
pub(crate) use resolution::tests::{Answers, Segment};
use std::collections::HashMap;
use std::net::IpAddr;
use std::sync::{Arc, Mutex};
use crate::model::mac::MacAddr;
use crate::transport::capture::{self, FrameSink};
use crate::transport::frame;
use crate::transport::kernel_neighbors::NeighborState;
use crate::transport::neighbor::{LinkRoute, NeighborResolver};
use crate::transport::probe::{Emission, IpProtocols, ProbeSender, SendError};
use resolution::{Ask, Resolutions};
pub struct EthernetSender {
resolver: Arc<Mutex<NeighborResolver>>,
resolutions: Arc<Resolutions>,
channels: Mutex<HashMap<String, capture::FrameSender>>,
protocols: IpProtocols,
loopback: Option<String>,
}
impl EthernetSender {
pub fn from_system(protocols: IpProtocols) -> Option<Self> {
let resolver = NeighborResolver::from_system();
if !resolver.has_ethernet() {
return None;
}
Some(Self {
resolver: Arc::new(Mutex::new(resolver)),
resolutions: Arc::new(Resolutions::from_system()),
channels: Mutex::new(HashMap::new()),
protocols,
loopback: loopback_link(),
})
}
pub(crate) fn neighbors(&self) -> LinkNeighbors {
LinkNeighbors {
resolver: Arc::clone(&self.resolver),
resolutions: Arc::clone(&self.resolutions),
}
}
fn next_hop_mac(&self, route: &LinkRoute) -> Result<MacAddr, SendError> {
if let Some(mac) = route.next_hop_mac {
return Ok(mac);
}
let mac = self.resolutions.resolve(&ask_for(route)?)?;
self.resolver
.lock()
.map_err(|_| poisoned("route resolver"))?
.remember(&route.interface, route.next_hop, mac);
Ok(mac)
}
fn channel_for<'a>(
&self,
channels: &'a mut HashMap<String, capture::FrameSender>,
interface: &str,
) -> Result<&'a mut capture::FrameSender, SendError> {
if !channels.contains_key(interface) {
let channel = capture::FrameSender::open(interface).map_err(|error| {
if error.is_exhausted() {
SendError::OutOfDescriptors
} else {
SendError::Refused(format!("no datalink channel on {interface}: {error}"))
}
})?;
channels.insert(interface.to_string(), channel);
}
Ok(channels.get_mut(interface).unwrap())
}
}
fn ask_for(route: &LinkRoute) -> Result<Ask, SendError> {
let target = match route.next_hop {
IpAddr::V4(v4) => v4,
IpAddr::V6(_) => {
return Err(SendError::Unsupported(
"IPv6 next-hop resolution (NDP) is not yet implemented",
));
}
};
let src_ip = match route.src_ip {
IpAddr::V4(v4) => v4,
IpAddr::V6(_) => {
return Err(SendError::Unsupported(
"an IPv4 target cannot be reached from an IPv6 source",
));
}
};
Ok(Ask {
interface: route.interface.clone(),
src_mac: route.src_mac,
src_ip,
target,
})
}
#[derive(Clone)]
pub(crate) struct LinkNeighbors {
resolver: Arc<Mutex<NeighborResolver>>,
resolutions: Arc<Resolutions>,
}
impl LinkNeighbors {
pub(crate) fn state(&self, src: IpAddr, dst: IpAddr) -> Option<NeighborState> {
self.read(src, dst, Resolutions::state)
}
pub(crate) fn ask_again(&self, src: IpAddr, dst: IpAddr) -> Option<NeighborState> {
self.read(src, dst, Resolutions::ask_again)
}
fn read(
&self,
src: IpAddr,
dst: IpAddr,
ask: fn(&Arc<Resolutions>, &Ask) -> Option<NeighborState>,
) -> Option<NeighborState> {
let route = self.resolver.lock().ok()?.resolve_from(src, dst)?;
if route.next_hop_mac.is_some() {
return Some(NeighborState::Resolved);
}
ask(&self.resolutions, &ask_for(&route).ok()?)
}
}
#[cfg(test)]
impl LinkNeighbors {
pub(crate) fn simulated(
resolver: NeighborResolver,
segment: impl Fn(&str) -> Segment
+ Send
+ Sync
+ std::panic::UnwindSafe
+ std::panic::RefUnwindSafe
+ 'static,
) -> Self {
Self {
resolver: Arc::new(Mutex::new(resolver)),
resolutions: Arc::new(Resolutions::over(Box::new(move |interface| {
Ok(Box::new(segment(interface)) as Box<dyn resolution::ResolutionLink>)
}))),
}
}
pub(crate) fn on_simulated_segment(interface: &str, live: &[std::net::Ipv4Addr]) -> Self {
use crate::system::interface::LinkAddress;
let segment = NeighborResolver::on_segment(
interface,
MacAddr::new(0x02, 0, 0, 0, 0, 0x50),
LinkAddress::new(IpAddr::V4(SIMULATED_HOST), 24),
);
let live = live.to_vec();
Self::simulated(segment, move |_| {
live.iter()
.fold(Segment::new().in_real_time(), |segment, ip| {
let [.., last] = ip.octets();
segment.with(
*ip,
MacAddr::new(0x02, 0, 0, 0, 0, last),
Answers::Request(1),
)
})
})
}
}
#[cfg(test)]
pub(crate) const SIMULATED_HOST: std::net::Ipv4Addr = std::net::Ipv4Addr::new(192, 0, 2, 50);
impl ProbeSender for EthernetSender {
fn send(
&self,
segment: &[u8],
src: IpAddr,
dst: IpAddr,
_zone: Option<u32>,
emission: Emission,
) -> Result<(), SendError> {
if dst.is_loopback()
&& let Some(link) = &self.loopback
{
return self.send_on_loopback(link, segment, src, dst, emission);
}
(|| -> Result<(), SendError> {
let route = self
.resolver
.lock()
.map_err(|_| poisoned("route resolver"))?
.resolve_from(src, dst)
.ok_or_else(|| {
SendError::Unroutable(format!("no Ethernet route from {src} to {dst}"))
})?;
let dst_mac = self.next_hop_mac(&route)?;
let src_mac = spoofed_source_mac(route.src_mac, emission.source_mac);
let protocol = self.protocols.for_destination(dst);
let spec = frame::FrameSpec {
src_mac,
dst_mac,
src,
dst,
protocol,
hop_limit: emission.hop_limit,
};
let frames = match emission.fragment {
Some(mtu) => frame::build_fragmented_ethernet_frames(&spec, segment, mtu),
None => frame::build_ethernet_frame(&spec, segment).map(|frame| vec![frame]),
}
.map_err(|error| {
SendError::Refused(format!("the frame could not be built: {error}"))
})?;
let mut channels = self
.channels
.lock()
.map_err(|_| poisoned("datalink channel"))?;
let channel = self.channel_for(&mut channels, &route.interface)?;
for frame in &frames {
channel.send_frame(frame).map_err(|reason| {
SendError::Refused(format!("the frame could not be sent: {reason}"))
})?;
}
Ok(())
})()
}
}
impl EthernetSender {
fn send_on_loopback(
&self,
link: &str,
segment: &[u8],
src: IpAddr,
dst: IpAddr,
emission: Emission,
) -> Result<(), SendError> {
if emission.source_mac.is_some() {
return Err(SendError::Unsupported(
"loopback carries no hardware address to spoof",
));
}
let spec = frame::IpSpec {
src,
dst,
protocol: self.protocols.for_destination(dst),
hop_limit: emission.hop_limit,
};
let frames =
frame::build_null_loop_frames(&spec, segment, emission.fragment).map_err(|error| {
SendError::Refused(format!("the frame could not be built: {error}"))
})?;
let mut channels = self
.channels
.lock()
.map_err(|_| poisoned("datalink channel"))?;
let channel = self.channel_for(&mut channels, link)?;
for frame in &frames {
channel.send_frame(frame).map_err(|reason| {
SendError::Refused(format!("the frame could not be sent: {reason}"))
})?;
}
Ok(())
}
}
fn loopback_link() -> Option<String> {
if !cfg!(target_os = "macos") {
return None;
}
crate::system::interface::interfaces_or_none()
.into_iter()
.find(|link| link.is_loopback() && link.is_up())
.map(|link| link.name().to_string())
}
fn poisoned(what: &str) -> SendError {
SendError::Refused(format!(
"the {what} lock was poisoned by another thread's panic"
))
}
fn spoofed_source_mac(interface: MacAddr, spoofed: Option<crate::model::mac::MacAddr>) -> MacAddr {
match spoofed {
Some(mac) => {
let octets: [u8; 6] = mac.into();
MacAddr::new(
octets[0], octets[1], octets[2], octets[3], octets[4], octets[5],
)
}
None => interface,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_spoofed_source_mac_replaces_the_interface_and_converts_faithfully() {
let interface = MacAddr::new(0x00, 0x11, 0x22, 0x33, 0x44, 0x55);
assert_eq!(spoofed_source_mac(interface, None), interface);
let spoofed = crate::model::mac::MacAddr::new(0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01);
assert_eq!(
spoofed_source_mac(interface, Some(spoofed)),
MacAddr::new(0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01)
);
}
}