use std::collections::HashMap;
use std::net::{IpAddr, UdpSocket};
use crate::model::ip::scoped::{ScopedIp, ZoneMap};
use crate::system::interface::{Link, LinkAddress};
pub(crate) fn viable_interfaces() -> Vec<Link> {
crate::system::interface::interfaces()
.into_iter()
.filter(|link| link.is_up() && !link.is_loopback() && !link.addresses().is_empty())
.collect()
}
pub struct OnLinkTable {
held: Vec<LinkAddress>,
}
impl OnLinkTable {
pub fn from_links(links: &[Link]) -> Self {
let mut held: Vec<LinkAddress> = links
.iter()
.flat_map(|link| link.addresses().iter().copied())
.collect();
held.sort_by_key(|address| std::cmp::Reverse(address.prefix()));
Self { held }
}
pub fn source_for(&self, target: IpAddr) -> Option<IpAddr> {
if ScopedIp::needs_zone(&target) {
return None;
}
self.held
.iter()
.find(|held| held.contains(&target))
.map(LinkAddress::address)
}
pub fn is_empty(&self) -> bool {
self.held.is_empty()
}
}
#[derive(Default)]
pub struct ProbeSockets {
v4: Option<UdpSocket>,
v6: Option<UdpSocket>,
}
pub(crate) fn plausible_source(links: &[Link], target: IpAddr) -> Option<IpAddr> {
let IpAddr::V6(target_v6) = target else {
return None;
};
if target_v6.is_unicast_link_local() {
return None;
}
links
.iter()
.flat_map(|link| link.ipv6())
.map(|(addr, _)| addr)
.find(|addr| !addr.is_unicast_link_local() && !addr.is_loopback())
.map(IpAddr::V6)
}
pub fn probe_route_source(target: IpAddr, sockets: &mut ProbeSockets) -> Option<IpAddr> {
let slot = match target {
IpAddr::V4(_) => &mut sockets.v4,
IpAddr::V6(_) => &mut sockets.v6,
};
if slot.is_none() {
let bind_addr = if target.is_ipv4() {
"0.0.0.0:0"
} else {
"[::]:0"
};
*slot = UdpSocket::bind(bind_addr).ok();
}
let socket = slot.as_ref()?;
socket.connect((target, 53)).ok()?;
socket.local_addr().ok().map(|addr| addr.ip())
}
pub struct SourceResolver {
onlink: OnLinkTable,
sockets: ProbeSockets,
cache: HashMap<IpAddr, Option<IpAddr>>,
links: Vec<Link>,
zones: ZoneMap,
forced: Vec<IpAddr>,
}
impl SourceResolver {
pub fn from_system() -> Self {
Self::from_links(&viable_interfaces())
}
pub fn from_links(links: &[Link]) -> Self {
Self {
onlink: OnLinkTable::from_links(links),
sockets: ProbeSockets::default(),
cache: HashMap::new(),
links: links.to_vec(),
zones: ZoneMap::new(),
forced: Vec::new(),
}
}
pub fn with_zones(mut self, zones: ZoneMap) -> Self {
self.zones = zones;
self
}
pub fn with_forced(mut self, forced: Vec<IpAddr>) -> Self {
self.forced = forced;
self
}
pub fn zone_of(&self, target: IpAddr) -> Option<u32> {
self.zones.zone_of(&target)
}
fn scoped_source(&self, target: IpAddr) -> Option<IpAddr> {
let zone = self.zones.zone_of(&target)?;
self.links
.iter()
.find(|link| link.index() == zone)?
.addresses()
.iter()
.map(LinkAddress::address)
.find(|address| matches!(address, IpAddr::V6(v6) if v6.is_unicast_link_local()))
}
pub fn has_sources(&self) -> bool {
!self.onlink.is_empty()
}
fn forced_source(&self, target: IpAddr) -> Option<IpAddr> {
self.forced
.iter()
.copied()
.find(|source| source.is_ipv4() == target.is_ipv4())
}
pub fn resolve(&mut self, target: IpAddr) -> Option<IpAddr> {
if let Some(cached) = self.cache.get(&target) {
return *cached;
}
let scoped = self.scoped_source(target);
let source = scoped
.or_else(|| self.forced_source(target))
.or_else(|| self.onlink.source_for(target))
.or_else(|| probe_route_source(target, &mut self.sockets))
.or_else(|| plausible_source(&self.links, target));
self.cache.insert(target, source);
source
}
}
#[cfg(test)]
mod tests {
#[test]
fn a_link_local_target_that_named_an_interface_is_sourced_from_it() {
use crate::model::ip::range::Ipv6Range;
use crate::model::ip::scoped::ZoneMap;
let mine = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xa);
let en1 = Link::new("en1", 15).with_addresses(vec![v6net(mine, 64)]);
let elsewhere = Link::new("en0", 16).with_addresses(vec![v6net(
Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xb),
64,
)]);
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x99);
let mut zones = ZoneMap::new();
zones.insert(
Ipv6Range::scoped(target, target, Some(15)).expect("a scoped range"),
&[(15, "en1")],
);
let mut resolver = SourceResolver::from_links(&[elsewhere, en1]).with_zones(zones);
assert_eq!(
resolver.resolve(IpAddr::V6(target)),
Some(IpAddr::V6(mine)),
"the interface named, not whichever was listed first"
);
assert_eq!(
resolver.zone_of(IpAddr::V6(target)),
Some(15),
"and the scope id the send has to carry"
);
}
#[test]
fn a_bare_link_local_target_has_no_source_rather_than_an_arbitrary_one() {
let en0 = mock_interface(vec![v6net(
Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xa),
64,
)]);
let en1 = mock_interface(vec![v6net(
Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xb),
64,
)]);
let target = IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x99));
assert_eq!(
OnLinkTable::from_links(&[en0.clone(), en1.clone()]).source_for(target),
None
);
assert_eq!(
OnLinkTable::from_links(&[en1, en0]).source_for(target),
None,
"and the answer does not depend on the order, because there is none"
);
}
#[test]
fn the_fallback_declines_a_link_local_and_still_answers_a_global() {
let links = [mock_interface(vec![
v6net(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xa), 64),
v6net(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 5), 64),
])];
assert_eq!(
plausible_source(
&links,
IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x99))
),
None
);
assert_eq!(
plausible_source(
&links,
IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 9, 0, 0, 0, 0, 1))
),
Some(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 5))),
"a global target still gets the global address the host holds"
);
}
#[test]
fn an_on_link_target_still_resolves_to_its_own_segment() {
let table = OnLinkTable::from_links(&[mock_interface(vec![v4net(192, 0, 2, 10, 24)])]);
assert_eq!(
table.source_for(IpAddr::V4(std::net::Ipv4Addr::new(192, 0, 2, 50))),
Some(IpAddr::V4(std::net::Ipv4Addr::new(192, 0, 2, 10)))
);
assert_eq!(
table.source_for(IpAddr::V4(std::net::Ipv4Addr::new(198, 51, 100, 1))),
None
);
}
#[test]
fn a_zoned_link_local_is_not_what_this_declines() {
use crate::model::ip::scoped::ScopedIp;
let bare: IpAddr = "fe80::1".parse().expect("literal");
assert!(ScopedIp::needs_zone(&bare), "bare is the case declined");
let global: IpAddr = "2001:db8::1".parse().expect("literal");
assert!(!ScopedIp::needs_zone(&global));
}
use super::*;
use std::net::{Ipv4Addr, Ipv6Addr};
fn mock_interface(nets: Vec<LinkAddress>) -> Link {
Link::new("test0", 0).with_addresses(nets)
}
fn v4net(a: u8, b: u8, c: u8, d: u8, prefix: u8) -> LinkAddress {
LinkAddress::new(IpAddr::V4(Ipv4Addr::new(a, b, c, d)), prefix)
}
#[test]
fn on_link_target_uses_that_subnet_source() {
let intf = mock_interface(vec![v4net(192, 0, 2, 50, 24)]);
let table = OnLinkTable::from_links(&[intf]);
assert_eq!(
table.source_for(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 200))),
Some(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 50)))
);
}
#[test]
fn off_link_target_has_no_on_link_source() {
let intf = mock_interface(vec![v4net(192, 0, 2, 50, 24)]);
let table = OnLinkTable::from_links(&[intf]);
assert_eq!(
table.source_for(IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))),
None
);
}
#[test]
fn longest_prefix_wins() {
let intf = mock_interface(vec![
v4net(198, 51, 100, 1, 24),
v4net(198, 51, 100, 130, 25),
]);
let table = OnLinkTable::from_links(&[intf]);
assert_eq!(
table.source_for(IpAddr::V4(Ipv4Addr::new(198, 51, 100, 200))),
Some(IpAddr::V4(Ipv4Addr::new(198, 51, 100, 130)))
);
}
#[test]
fn v6_and_v4_are_kept_separate() {
let v6 = v6net(Ipv6Addr::new(0x2001, 0xdb8, 0, 1, 0, 0, 0, 1), 64);
let intf = mock_interface(vec![v4net(192, 0, 2, 50, 24), v6]);
let table = OnLinkTable::from_links(&[intf]);
assert_eq!(
table.source_for(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 1, 0, 0, 0, 99))),
Some(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 1, 0, 0, 0, 1)))
);
assert_eq!(
table.source_for(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 9, 0, 0, 0, 1))),
None,
"a prefix the host does not hold is not on-link"
);
}
#[test]
fn resolver_caches_and_reports_sources() {
let intf = mock_interface(vec![v4net(192, 0, 2, 50, 24)]);
let mut resolver = SourceResolver::from_links(&[intf]);
assert!(resolver.has_sources());
let target = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 200));
assert_eq!(
resolver.resolve(target),
Some(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 50)))
);
assert_eq!(
resolver.resolve(target),
Some(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 50)))
);
}
#[test]
fn empty_host_has_no_sources() {
let resolver = SourceResolver::from_links(&[]);
assert!(!resolver.has_sources());
}
#[test]
fn a_forced_source_answers_a_routed_target_by_family() {
let v4 = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 50));
let v6 = IpAddr::V6(Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 1));
let intf = mock_interface(vec![v4net(192, 0, 2, 50, 24)]);
let mut resolver = SourceResolver::from_links(&[intf]).with_forced(vec![v6, v4]);
let public = IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1));
assert_eq!(resolver.resolve(public), Some(v4));
}
fn v6net(addr: Ipv6Addr, prefix: u8) -> LinkAddress {
LinkAddress::new(IpAddr::V6(addr), prefix)
}
#[test]
fn a_global_target_the_kernel_will_not_route_still_gets_a_global_source() {
let global = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0xb1a0);
let intf = mock_interface(vec![
v6net(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x50), 64),
v6net(global, 64),
]);
let source = plausible_source(
std::slice::from_ref(&intf),
IpAddr::V6(Ipv6Addr::new(0x2606, 0x4700, 0x4700, 0, 0, 0, 0, 0x1111)),
);
assert_eq!(source, Some(IpAddr::V6(global)));
}
#[test]
fn a_link_local_target_is_offered_no_source_at_all() {
let link_local = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x50);
let intf = mock_interface(vec![
v6net(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 64),
v6net(link_local, 64),
]);
let source = plausible_source(
std::slice::from_ref(&intf),
IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA)),
);
assert_eq!(
source, None,
"a global was never offered, and now nor is a guess"
);
}
#[test]
fn an_unroutable_v4_target_is_not_second_guessed() {
let intf = mock_interface(vec![v4net(192, 0, 2, 50, 24)]);
assert_eq!(
plausible_source(
std::slice::from_ref(&intf),
IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))
),
None
);
}
}