use std::collections::HashMap;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::panic::{RefUnwindSafe, UnwindSafe};
use std::sync::Mutex;
use std::time::{Duration, Instant};
use crate::model::mac::MacAddr;
use crate::system::interface::LinkAddress;
use crate::system::interface::probe_route_source;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LinkRoute {
pub interface: String,
pub src_ip: IpAddr,
pub src_mac: MacAddr,
pub next_hop: IpAddr,
pub next_hop_mac: Option<MacAddr>,
pub on_link: bool,
}
#[derive(Debug, Clone)]
struct InterfaceInfo {
name: String,
mac: MacAddr,
v4: Vec<LinkAddress>,
v6: Vec<LinkAddress>,
gateway_v4: Option<(Ipv4Addr, MacAddr)>,
gateway_v6: Option<(Ipv6Addr, MacAddr)>,
}
type KernelRoute = Box<dyn Fn(IpAddr) -> Option<IpAddr> + Send + Sync + UnwindSafe + RefUnwindSafe>;
pub struct NeighborResolver {
interfaces: Vec<InterfaceInfo>,
cache: HashMap<(String, IpAddr), MacAddr>,
unframed: Vec<IpAddr>,
kernel: KernelRoute,
}
impl NeighborResolver {
pub fn from_system() -> Self {
let mut interfaces = Vec::new();
let mut unframed = Vec::new();
for iface in crate::system::interface::host_table().unwrap_or_default() {
let held: Vec<IpAddr> = iface
.ipv4
.iter()
.map(|net| IpAddr::V4(net.addr()))
.chain(iface.ipv6.iter().map(|net| IpAddr::V6(net.addr())))
.collect();
match interface_info(iface) {
Some(info) => interfaces.push(info),
None => unframed.extend(held),
}
}
Self::from_interfaces(interfaces, unframed, Box::new(probe_route_source))
}
fn from_interfaces(
interfaces: Vec<InterfaceInfo>,
unframed: Vec<IpAddr>,
kernel: KernelRoute,
) -> Self {
Self {
interfaces,
cache: HashMap::new(),
unframed,
kernel,
}
}
#[cfg(test)]
pub(crate) fn on_segment(interface: &str, mac: MacAddr, address: LinkAddress) -> Self {
let held = address.address();
let info = InterfaceInfo {
name: interface.to_owned(),
mac,
v4: vec![address],
v6: vec![],
gateway_v4: None,
gateway_v6: None,
};
Self::from_interfaces(vec![info], vec![], Box::new(move |_| Some(held)))
}
pub fn has_ethernet(&self) -> bool {
!self.interfaces.is_empty()
}
#[cfg(test)]
pub fn resolve(&self, dst: IpAddr) -> Option<LinkRoute> {
if dst.is_loopback() {
return None;
}
let chosen = (self.kernel)(dst)?;
let iface = self.holding(chosen)?;
self.route_via(iface, chosen, dst)
}
pub fn resolve_from(&self, src: IpAddr, dst: IpAddr) -> Option<LinkRoute> {
if dst.is_loopback() {
return None;
}
if let Some(iface) = self.holding(src) {
return self.route_via(iface, src, dst);
}
if src.is_loopback() || self.unframed.contains(&src) {
return None;
}
let chosen = (self.kernel)(dst)?;
let iface = self.holding(chosen)?;
self.route_via(iface, chosen, dst)
}
pub fn remember(&mut self, interface: &str, next_hop: IpAddr, mac: MacAddr) {
self.cache.insert((interface.to_string(), next_hop), mac);
}
fn holding(&self, address: IpAddr) -> Option<&InterfaceInfo> {
self.interfaces.iter().find(|iface| {
iface
.v4
.iter()
.chain(&iface.v6)
.any(|held| held.address() == address)
})
}
fn route_via(&self, iface: &InterfaceInfo, anchor: IpAddr, dst: IpAddr) -> Option<LinkRoute> {
if anchor.is_ipv4() != dst.is_ipv4() {
return None;
}
let on_link = match dst {
IpAddr::V4(_) => iface.v4.iter().any(|held| held.contains(&dst)),
IpAddr::V6(_) => iface.v6.iter().any(|held| held.contains(&dst)),
};
if on_link {
return Some(LinkRoute {
interface: iface.name.clone(),
src_ip: anchor,
src_mac: iface.mac,
next_hop: dst,
next_hop_mac: self.cache.get(&(iface.name.clone(), dst)).copied(),
on_link: true,
});
}
let (next_hop, gw_mac) = match (dst, anchor) {
(IpAddr::V4(_), _) => {
let (gw_ip, mac) = iface.gateway_v4?;
(IpAddr::V4(gw_ip), mac)
}
(IpAddr::V6(_), IpAddr::V6(from)) if from.is_unicast_link_local() => return None,
(IpAddr::V6(_), _) => {
let (gw_ip, mac) = iface.gateway_v6?;
(IpAddr::V6(gw_ip), mac)
}
};
let next_hop_mac = resolved_gateway_mac(gw_mac)
.or_else(|| self.cache.get(&(iface.name.clone(), next_hop)).copied());
Some(LinkRoute {
interface: iface.name.clone(),
src_ip: anchor,
src_mac: iface.mac,
next_hop,
next_hop_mac,
on_link: false,
})
}
}
const LEARNED_NEIGHBOR_TTL: Duration = Duration::from_secs(120);
static LEARNED_NEIGHBORS: Mutex<LearnedNeighbors> = Mutex::new(LearnedNeighbors::new());
struct LearnedNeighbors {
heard: Option<HashMap<(String, IpAddr), (MacAddr, Instant)>>,
}
impl LearnedNeighbors {
const fn new() -> Self {
Self { heard: None }
}
fn learn(&mut self, interface: &str, address: IpAddr, mac: MacAddr, at: Instant) {
self.heard
.get_or_insert_with(HashMap::new)
.insert((interface.to_owned(), address), (mac, at));
}
fn recall(&self, interface: &str, address: IpAddr, now: Instant) -> Option<MacAddr> {
let (mac, at) = self.heard.as_ref()?.get(&(interface.to_owned(), address))?;
(now.saturating_duration_since(*at) < LEARNED_NEIGHBOR_TTL).then_some(*mac)
}
fn last_heard(&self, interface: &str, address: IpAddr) -> Option<MacAddr> {
let (mac, _) = self.heard.as_ref()?.get(&(interface.to_owned(), address))?;
Some(*mac)
}
}
pub(crate) fn learn_neighbor(interface: &str, address: IpAddr, mac: MacAddr) {
learn_neighbor_at(interface, address, mac, Instant::now());
}
pub(crate) fn learn_neighbor_at(interface: &str, address: IpAddr, mac: MacAddr, at: Instant) {
if mac.is_broadcast() || mac.is_multicast() || mac == MacAddr::ZERO {
return;
}
LEARNED_NEIGHBORS
.lock()
.unwrap_or_else(|held| held.into_inner())
.learn(interface, address, mac, at);
}
pub(crate) fn heard_neighbor(interface: &str, address: IpAddr) -> Option<MacAddr> {
LEARNED_NEIGHBORS
.lock()
.unwrap_or_else(|held| held.into_inner())
.last_heard(interface, address)
}
pub(crate) fn learned_neighbor(interface: &str, address: IpAddr) -> Option<MacAddr> {
LEARNED_NEIGHBORS
.lock()
.unwrap_or_else(|held| held.into_inner())
.recall(interface, address, Instant::now())
}
fn interface_info(iface: netdev::Interface) -> Option<InterfaceInfo> {
let mac = iface.mac_addr.map(to_pnet_mac)?;
if iface.ipv4.is_empty() && iface.ipv6.is_empty() {
return None;
}
let v4 = iface
.ipv4
.iter()
.map(|net| LinkAddress::new(IpAddr::V4(net.addr()), net.prefix_len()))
.collect();
let v6 = iface
.ipv6
.iter()
.map(|net| LinkAddress::new(IpAddr::V6(net.addr()), net.prefix_len()))
.collect();
let (gateway_v4, gateway_v6) = match iface.gateway {
Some(gw) => {
let mac = to_pnet_mac(gw.mac_addr);
(
gw.ipv4.first().map(|ip| (*ip, mac)),
gw.ipv6.first().map(|ip| (*ip, mac)),
)
}
None => (None, None),
};
Some(InterfaceInfo {
name: iface.name,
mac,
v4,
v6,
gateway_v4,
gateway_v6,
})
}
fn resolved_gateway_mac(mac: MacAddr) -> Option<MacAddr> {
(mac != MacAddr::ZERO).then_some(mac)
}
fn to_pnet_mac(mac: netdev::MacAddr) -> MacAddr {
let [a, b, c, d, e, f] = mac.octets();
MacAddr::new(a, b, c, d, e, f)
}
#[cfg(test)]
mod tests {
use super::*;
const IFACE_MAC: MacAddr = MacAddr::new(0x02, 0, 0, 0, 0, 0x01);
const GW_MAC: MacAddr = MacAddr::new(0x02, 0, 0, 0, 0, 0xFE);
const EN0: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 50));
const TUNNEL: IpAddr = IpAddr::V4(Ipv4Addr::new(198, 51, 100, 2));
fn ethernet_iface() -> InterfaceInfo {
InterfaceInfo {
name: "en0".to_string(),
mac: IFACE_MAC,
v4: vec![LinkAddress::new(EN0, 24)],
v6: vec![],
gateway_v4: Some((Ipv4Addr::new(192, 0, 2, 1), GW_MAC)),
gateway_v6: None,
}
}
fn second_iface() -> InterfaceInfo {
InterfaceInfo {
name: "en1".to_string(),
mac: MacAddr::new(0x02, 0, 0, 0, 0, 0x02),
v4: vec![LinkAddress::new(
IpAddr::V4(Ipv4Addr::new(203, 0, 113, 50)),
24,
)],
v6: vec![],
gateway_v4: Some((
Ipv4Addr::new(203, 0, 113, 1),
MacAddr::new(0x02, 0, 0, 0, 0, 0xFD),
)),
gateway_v6: None,
}
}
fn resolver_with(interfaces: Vec<InterfaceInfo>, kernel: Option<IpAddr>) -> NeighborResolver {
NeighborResolver::from_interfaces(interfaces, vec![TUNNEL], Box::new(move |_| kernel))
}
fn resolver(interfaces: Vec<InterfaceInfo>) -> NeighborResolver {
resolver_with(interfaces, Some(EN0))
}
fn v4(a: u8, b: u8, c: u8, d: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(a, b, c, d))
}
#[test]
fn on_link_target_routes_to_itself_and_needs_arp() {
let route = resolver(vec![ethernet_iface()])
.resolve_from(EN0, v4(192, 0, 2, 200))
.unwrap();
assert!(route.on_link);
assert_eq!(route.next_hop, v4(192, 0, 2, 200));
assert_eq!(route.src_ip, EN0);
assert_eq!(route.src_mac, IFACE_MAC);
assert_eq!(route.next_hop_mac, None); }
#[test]
fn loopback_has_no_ethernet_route() {
let resolver = resolver(vec![ethernet_iface()]);
assert!(resolver.resolve(IpAddr::V4(Ipv4Addr::LOCALHOST)).is_none());
assert!(
resolver
.resolve_from(EN0, IpAddr::V4(Ipv4Addr::LOCALHOST))
.is_none()
);
assert!(resolver.resolve(IpAddr::V6(Ipv6Addr::LOCALHOST)).is_none());
assert!(
resolver.resolve_from(EN0, v4(127, 0, 0, 53)).is_none(),
"the whole 127/8 block, not just the one address"
);
}
#[test]
fn off_link_target_routes_via_gateway_with_known_mac() {
let route = resolver(vec![ethernet_iface()])
.resolve_from(EN0, v4(1, 1, 1, 1))
.unwrap();
assert!(!route.on_link);
assert_eq!(route.next_hop, v4(192, 0, 2, 1));
assert_eq!(route.next_hop_mac, Some(GW_MAC));
assert_eq!(route.src_ip, EN0);
}
#[test]
fn cached_on_link_mac_is_returned() {
let mut resolver = resolver(vec![ethernet_iface()]);
let target = v4(192, 0, 2, 200);
let learned = MacAddr::new(0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF);
assert_eq!(
resolver.resolve_from(EN0, target).unwrap().next_hop_mac,
None
);
resolver.remember("en0", target, learned);
assert_eq!(
resolver.resolve_from(EN0, target).unwrap().next_hop_mac,
Some(learned)
);
}
#[test]
fn a_probe_leaves_by_the_interface_holding_its_source() {
let resolver = resolver(vec![ethernet_iface(), second_iface()]);
let route = resolver
.resolve_from(v4(203, 0, 113, 50), v4(1, 1, 1, 1))
.expect("en1 has a gateway");
assert_eq!(route.interface, "en1");
assert_eq!(route.next_hop, v4(203, 0, 113, 1));
}
#[test]
fn a_probe_sourced_from_a_tunnel_has_no_ethernet_route() {
let resolver = resolver(vec![ethernet_iface()]);
assert!(resolver.resolve_from(TUNNEL, v4(10, 10, 11, 23)).is_none());
}
#[test]
fn a_destination_the_kernel_sends_through_a_tunnel_has_no_ethernet_route() {
let resolver = resolver_with(vec![ethernet_iface()], Some(TUNNEL));
assert!(resolver.resolve(v4(1, 1, 1, 1)).is_none());
let direct = resolver_with(vec![ethernet_iface()], Some(EN0));
assert_eq!(direct.resolve(v4(1, 1, 1, 1)).unwrap().interface, "en0");
}
#[test]
fn a_spoofed_source_leaves_the_way_the_kernel_routes_the_target() {
let spoofed = v4(198, 51, 100, 77);
let kernel_says_en1 = resolver_with(
vec![ethernet_iface(), second_iface()],
Some(v4(203, 0, 113, 50)),
);
let route = kernel_says_en1
.resolve_from(spoofed, v4(1, 1, 1, 1))
.expect("the kernel routes it over en1");
assert_eq!(route.interface, "en1");
assert_eq!(route.src_ip, v4(203, 0, 113, 50));
let kernel_says_tunnel = resolver_with(vec![ethernet_iface()], Some(TUNNEL));
assert!(
kernel_says_tunnel
.resolve_from(spoofed, v4(1, 1, 1, 1))
.is_none()
);
}
#[test]
fn an_unknown_gateway_mac_is_read_as_unresolved() {
assert_eq!(resolved_gateway_mac(MacAddr::ZERO), None);
assert_eq!(resolved_gateway_mac(GW_MAC), Some(GW_MAC));
}
#[test]
fn an_off_link_gateway_with_an_unknown_mac_is_resolved_not_sent_to_zeros() {
let mut iface = ethernet_iface();
iface.gateway_v4 = Some((Ipv4Addr::new(192, 0, 2, 1), MacAddr::ZERO));
let route = resolver(vec![iface])
.resolve_from(EN0, v4(1, 1, 1, 1))
.expect("a gateway exists, only its MAC is unknown");
assert!(!route.on_link, "the target is still off-link");
assert_eq!(
route.next_hop,
v4(192, 0, 2, 1),
"the gateway is the next hop"
);
assert_eq!(
route.next_hop_mac, None,
"an unknown gateway MAC is resolved, never framed as 00:00:00:00:00:00"
);
}
#[test]
fn a_learned_gateway_mac_is_served_from_the_cache() {
let mut iface = ethernet_iface();
iface.gateway_v4 = Some((Ipv4Addr::new(192, 0, 2, 1), MacAddr::ZERO));
let mut resolver = resolver(vec![iface]);
let learned = MacAddr::new(0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF);
assert_eq!(
resolver
.resolve_from(EN0, v4(1, 1, 1, 1))
.unwrap()
.next_hop_mac,
None
);
resolver.remember("en0", v4(192, 0, 2, 1), learned);
assert_eq!(
resolver
.resolve_from(EN0, v4(1, 1, 1, 1))
.unwrap()
.next_hop_mac,
Some(learned),
"the gateway is resolved once, then read from the cache"
);
}
#[test]
fn off_link_without_gateway_is_unresolvable() {
let mut iface = ethernet_iface();
iface.gateway_v4 = None;
assert!(
resolver(vec![iface])
.resolve_from(EN0, v4(8, 8, 8, 8))
.is_none()
);
}
#[test]
fn a_link_local_source_has_no_off_link_route() {
let link_local = IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x50));
let iface = InterfaceInfo {
name: "en0".to_string(),
mac: IFACE_MAC,
v4: vec![],
v6: vec![LinkAddress::new(link_local, 64)],
gateway_v4: None,
gateway_v6: Some((Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1), GW_MAC)),
};
assert!(
resolver(vec![iface])
.resolve_from(
link_local,
IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1))
)
.is_none()
);
}
#[test]
fn an_off_link_v6_probe_routes_via_the_v6_gateway() {
let global = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0xb1a0));
let gateway = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1);
let iface = InterfaceInfo {
name: "en0".to_string(),
mac: IFACE_MAC,
v4: vec![],
v6: vec![
LinkAddress::new(
IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x50)),
64,
),
LinkAddress::new(global, 64),
],
gateway_v4: None,
gateway_v6: Some((gateway, GW_MAC)),
};
let route = resolver(vec![iface])
.resolve_from(
global,
IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0xffff, 0, 0, 0, 0, 1)),
)
.expect("a host with a v6 gateway has a route");
assert_eq!(route.src_ip, global);
assert_eq!(route.next_hop, IpAddr::V6(gateway));
}
#[test]
fn no_ethernet_interfaces_resolves_nothing() {
let resolver = resolver(vec![]);
assert!(!resolver.has_ethernet());
assert!(resolver.resolve(v4(1, 1, 1, 1)).is_none());
}
#[test]
fn a_heard_neighbour_serves_until_it_ages_out_on_its_own_link() {
let mut table = LearnedNeighbors::new();
let t0 = Instant::now();
let mac = MacAddr::new(0x02, 0, 0, 0, 0, 0x40);
let address = v4(192, 0, 2, 40);
assert_eq!(table.recall("en0", address, t0), None, "nothing heard yet");
table.learn("en0", address, mac, t0);
assert_eq!(table.recall("en0", address, t0), Some(mac));
assert_eq!(
table.recall(
"en0",
address,
t0 + LEARNED_NEIGHBOR_TTL - Duration::from_secs(1)
),
Some(mac)
);
assert_eq!(
table.recall("en0", address, t0 + LEARNED_NEIGHBOR_TTL),
None,
"aged out"
);
assert_eq!(table.recall("en1", address, t0), None, "another link");
}
#[test]
fn a_group_address_is_not_learned_as_a_neighbour() {
let address = v4(192, 0, 2, 41);
learn_neighbor("test-group0", address, MacAddr::BROADCAST);
learn_neighbor("test-group0", address, MacAddr::new(0x01, 0, 0x5e, 0, 0, 1));
assert_eq!(learned_neighbor("test-group0", address), None);
}
}