use crate::core::models::ip::range::IpRange::{V4, V6};
use crate::core::models::ip::set::IpSet;
use crate::system::interface::source::{ProbeSockets, probe_route_source, viable_interfaces};
use pnet::datalink::NetworkInterface;
use rayon::prelude::*;
use std::collections::{HashMap, HashSet};
use std::net::IpAddr;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RoutedTarget {
pub target: IpAddr,
pub source: IpAddr,
}
#[derive(Debug, Default)]
pub struct RoutedTargets {
pub local: HashMap<NetworkInterface, IpSet>,
pub routed: Vec<RoutedTarget>,
pub unmapped: IpSet,
}
pub fn map_ips_to_interfaces(ip_set: IpSet) -> RoutedTargets {
map_ips_to_interfaces_with(ip_set, viable_interfaces())
}
enum Classification {
Local(usize),
Routed(IpAddr),
Unmapped,
}
pub(crate) fn map_ips_to_interfaces_with(
ip_set: IpSet,
interfaces: Vec<NetworkInterface>,
) -> RoutedTargets {
let owned_ips: HashSet<IpAddr> = interfaces
.iter()
.flat_map(|iface| iface.ips.iter().map(|ip_net| ip_net.ip()))
.collect();
let mut local: HashMap<usize, IpSet> = HashMap::new();
let mut routed: Vec<RoutedTarget> = Vec::new();
let mut unmapped = IpSet::new();
let mut singles_to_route: Vec<IpAddr> = Vec::new();
for range in ip_set.v4() {
let start = IpAddr::V4(range.start_addr);
let end = IpAddr::V4(range.end_addr);
match owning_interface(&interfaces, start, end) {
Some(idx) => local.entry(idx).or_default().insert_range(V4(*range)),
None => singles_to_route.extend(range.to_iter()),
}
}
for range in ip_set.v6() {
let start = IpAddr::V6(range.start_addr);
let end = IpAddr::V6(range.end_addr);
match owning_interface(&interfaces, start, end) {
Some(idx) => local.entry(idx).or_default().insert_range(V6(*range)),
None => singles_to_route.extend(range.to_iter()),
}
}
let processed: Vec<(IpAddr, Classification)> = singles_to_route
.par_iter()
.map_init(ProbeSockets::default, |sockets, &target| {
if let Some(idx) = find_local_index(&interfaces, target) {
return (target, Classification::Local(idx));
}
if let Some(source) = probe_route_source(target, sockets)
&& owned_ips.contains(&source)
{
return (target, Classification::Routed(source));
}
(target, Classification::Unmapped)
})
.collect();
for (target, class) in processed {
match class {
Classification::Local(idx) => local.entry(idx).or_default().insert(target),
Classification::Routed(source) => routed.push(RoutedTarget { target, source }),
Classification::Unmapped => unmapped.insert(target),
}
}
let local = local
.into_iter()
.map(|(idx, ips)| (interfaces[idx].clone(), ips))
.collect();
RoutedTargets {
local,
routed,
unmapped,
}
}
fn owning_interface(interfaces: &[NetworkInterface], start: IpAddr, end: IpAddr) -> Option<usize> {
interfaces.iter().position(|iface| {
iface
.ips
.iter()
.any(|net| net.contains(start) && net.contains(end))
})
}
fn find_local_index(interfaces: &[NetworkInterface], target: IpAddr) -> Option<usize> {
interfaces.iter().position(|iface| {
iface.ips.iter().any(|ip_net| match (target, ip_net.ip()) {
(IpAddr::V4(_), IpAddr::V4(_)) | (IpAddr::V6(_), IpAddr::V6(_)) => {
ip_net.contains(target)
}
_ => false,
})
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::models::ip::range::{IpRange, Ipv4Range, Ipv6Range};
use pnet::ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
use std::net::{Ipv4Addr, Ipv6Addr};
fn mock_interface(ip: IpAddr, prefix: u8) -> NetworkInterface {
let net = match ip {
IpAddr::V4(v4) => IpNetwork::V4(Ipv4Network::new(v4, prefix).unwrap()),
IpAddr::V6(v6) => IpNetwork::V6(Ipv6Network::new(v6, prefix).unwrap()),
};
NetworkInterface {
name: "test0".to_string(),
description: "".to_string(),
index: 0,
mac: None,
ips: vec![net],
flags: 0,
}
}
#[test]
fn test_find_local_index() {
let interfaces = vec![
mock_interface(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 100)), 24),
mock_interface(IpAddr::V4(Ipv4Addr::new(10, 0, 0, 5)), 8),
];
assert_eq!(
find_local_index(&interfaces, IpAddr::V4(Ipv4Addr::new(192, 168, 1, 50))),
Some(0)
);
assert_eq!(
find_local_index(&interfaces, IpAddr::V4(Ipv4Addr::new(10, 50, 0, 1))),
Some(1)
);
assert_eq!(
find_local_index(&interfaces, IpAddr::V4(Ipv4Addr::new(172, 16, 0, 1))),
None
);
}
#[test]
fn on_link_v4_range_stays_intact_and_local() {
let interfaces = vec![mock_interface(
IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1)),
24,
)];
let mut set = IpSet::new();
set.insert_range(IpRange::V4(
Ipv4Range::new(
Ipv4Addr::new(192, 168, 1, 10),
Ipv4Addr::new(192, 168, 1, 20),
)
.unwrap(),
));
let result = map_ips_to_interfaces_with(set, interfaces);
assert!(result.routed.is_empty());
assert!(result.unmapped.is_empty());
assert_eq!(result.local.len(), 1);
let (_, ips) = result.local.into_iter().next().unwrap();
assert_eq!(ips.len(), 11);
}
#[test]
fn on_link_v6_range_is_classified_local() {
let base = Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0);
let interfaces = vec![mock_interface(IpAddr::V6(base), 64)];
let mut set = IpSet::new();
set.insert_range(IpRange::V6(
Ipv6Range::new(
Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 1),
Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 5),
)
.unwrap(),
));
let result = map_ips_to_interfaces_with(set, interfaces);
assert!(result.routed.is_empty());
assert!(result.unmapped.is_empty());
assert_eq!(result.local.len(), 1);
let (_, ips) = result.local.into_iter().next().unwrap();
assert_eq!(ips.len(), 5);
}
}