use std::collections::HashMap;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, UdpSocket};
use pnet::datalink::{self, NetworkInterface};
use pnet::ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
pub(crate) fn viable_interfaces() -> Vec<NetworkInterface> {
datalink::interfaces()
.into_iter()
.filter(|i| i.is_up() && !i.is_loopback() && !i.ips.is_empty())
.collect()
}
pub struct OnLinkTable {
v4: Vec<(Ipv4Network, Ipv4Addr)>,
v6: Vec<(Ipv6Network, Ipv6Addr)>,
}
impl OnLinkTable {
pub fn from_interfaces(interfaces: &[NetworkInterface]) -> Self {
let mut v4: Vec<(Ipv4Network, Ipv4Addr)> = Vec::new();
let mut v6: Vec<(Ipv6Network, Ipv6Addr)> = Vec::new();
for iface in interfaces {
for net in &iface.ips {
match net {
IpNetwork::V4(n) => v4.push((*n, n.ip())),
IpNetwork::V6(n) => v6.push((*n, n.ip())),
}
}
}
v4.sort_by_key(|(net, _)| std::cmp::Reverse(net.prefix()));
v6.sort_by_key(|(net, _)| std::cmp::Reverse(net.prefix()));
Self { v4, v6 }
}
pub fn source_for(&self, target: IpAddr) -> Option<IpAddr> {
match target {
IpAddr::V4(t) => self
.v4
.iter()
.find(|(net, _)| net.contains(t))
.map(|(_, src)| IpAddr::V4(*src)),
IpAddr::V6(t) => self
.v6
.iter()
.find(|(net, _)| net.contains(t))
.map(|(_, src)| IpAddr::V6(*src)),
}
}
pub fn is_empty(&self) -> bool {
self.v4.is_empty() && self.v6.is_empty()
}
}
#[derive(Default)]
pub struct ProbeSockets {
v4: Option<UdpSocket>,
v6: Option<UdpSocket>,
}
pub(crate) fn plausible_source(interfaces: &[NetworkInterface], target: IpAddr) -> Option<IpAddr> {
let IpAddr::V6(target_v6) = target else {
return None;
};
let wants_link_local = target_v6.is_unicast_link_local();
interfaces
.iter()
.flat_map(|iface| iface.ips.iter())
.filter_map(|net| match net.ip() {
IpAddr::V6(addr) => Some(addr),
IpAddr::V4(_) => None,
})
.find(|addr| addr.is_unicast_link_local() == wants_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>>,
interfaces: Vec<NetworkInterface>,
}
impl SourceResolver {
pub fn from_system() -> Self {
Self::from_interfaces(&viable_interfaces())
}
pub fn from_interfaces(interfaces: &[NetworkInterface]) -> Self {
Self {
onlink: OnLinkTable::from_interfaces(interfaces),
sockets: ProbeSockets::default(),
cache: HashMap::new(),
interfaces: interfaces.to_vec(),
}
}
pub fn has_sources(&self) -> bool {
!self.onlink.is_empty()
}
pub fn resolve(&mut self, target: IpAddr) -> Option<IpAddr> {
if let Some(cached) = self.cache.get(&target) {
return *cached;
}
let source = self
.onlink
.source_for(target)
.or_else(|| probe_route_source(target, &mut self.sockets))
.or_else(|| plausible_source(&self.interfaces, target));
self.cache.insert(target, source);
source
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{Ipv4Addr, Ipv6Addr};
fn mock_interface(nets: Vec<IpNetwork>) -> NetworkInterface {
NetworkInterface {
name: "test0".to_string(),
description: "".to_string(),
index: 0,
mac: None,
ips: nets,
flags: 0,
}
}
fn v4net(a: u8, b: u8, c: u8, d: u8, prefix: u8) -> IpNetwork {
IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(a, b, c, d), prefix).unwrap())
}
#[test]
fn on_link_target_uses_that_subnet_source() {
let intf = mock_interface(vec![v4net(192, 168, 1, 50, 24)]);
let table = OnLinkTable::from_interfaces(&[intf]);
assert_eq!(
table.source_for(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 200))),
Some(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 50)))
);
}
#[test]
fn off_link_target_has_no_on_link_source() {
let intf = mock_interface(vec![v4net(192, 168, 1, 50, 24)]);
let table = OnLinkTable::from_interfaces(&[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(10, 0, 0, 1, 8), v4net(10, 1, 2, 3, 24)]);
let table = OnLinkTable::from_interfaces(&[intf]);
assert_eq!(
table.source_for(IpAddr::V4(Ipv4Addr::new(10, 1, 2, 200))),
Some(IpAddr::V4(Ipv4Addr::new(10, 1, 2, 3)))
);
}
#[test]
fn v6_and_v4_are_kept_separate() {
let v6 = IpNetwork::V6(
Ipv6Network::new(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1), 64).unwrap(),
);
let intf = mock_interface(vec![v4net(192, 168, 1, 50, 24), v6]);
let table = OnLinkTable::from_interfaces(&[intf]);
assert_eq!(
table.source_for(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 99))),
Some(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1)))
);
assert_eq!(
table.source_for(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1))),
None
);
}
#[test]
fn resolver_caches_and_reports_sources() {
let intf = mock_interface(vec![v4net(192, 168, 1, 50, 24)]);
let mut resolver = SourceResolver::from_interfaces(&[intf]);
assert!(resolver.has_sources());
let target = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 200));
assert_eq!(
resolver.resolve(target),
Some(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 50)))
);
assert_eq!(
resolver.resolve(target),
Some(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 50)))
);
}
#[test]
fn empty_host_has_no_sources() {
let resolver = SourceResolver::from_interfaces(&[]);
assert!(!resolver.has_sources());
}
fn v6net(addr: Ipv6Addr, prefix: u8) -> IpNetwork {
IpNetwork::V6(Ipv6Network::new(addr, prefix).unwrap())
}
#[test]
fn a_global_target_the_kernel_will_not_route_still_gets_a_global_source() {
let global = Ipv6Addr::new(0x2a02, 0x908, 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_gets_a_link_local_source() {
let link_local = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x50);
let intf = mock_interface(vec![
v6net(Ipv6Addr::new(0x2a02, 0x908, 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, Some(IpAddr::V6(link_local)));
}
#[test]
fn an_unroutable_v4_target_is_not_second_guessed() {
let intf = mock_interface(vec![v4net(192, 168, 1, 50, 24)]);
assert_eq!(
plausible_source(
std::slice::from_ref(&intf),
IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))
),
None
);
}
}