1use crate::model::ip::range::IpRange::{self, V4, V6};
43use crate::model::ip::range::{Ipv4Range, Ipv6Range};
44use crate::model::ip::scoped::ScopedIp;
45use crate::model::ip::set::IpSet;
46use crate::system::interface::source::{
47 RouteAnswer, ask_route, plausible_source, refuses_neighbour, viable_interfaces,
48};
49use crate::system::interface::{Link, LinkAddress};
50use rayon::prelude::*;
51use std::collections::{HashMap, HashSet};
52use std::net::IpAddr;
53
54#[non_exhaustive]
57#[derive(Debug, Clone, Copy, PartialEq, Eq)]
58pub struct RoutedTarget {
59 pub target: IpAddr,
61 pub source: IpAddr,
63}
64
65impl RoutedTarget {
66 pub const fn new(target: IpAddr, source: IpAddr) -> Self {
68 Self { target, source }
69 }
70}
71
72pub const MAX_ENUMERABLE_ADDRESSES: u128 = 1 << 16;
90
91#[non_exhaustive]
94#[derive(Debug, Default)]
95pub struct RoutedTargets {
96 pub local: HashMap<Link, IpSet>,
104 pub routed: Vec<RoutedTarget>,
108 pub unmapped: IpSet,
112 pub ours: IpSet,
118 pub ambiguous: Vec<Ipv6Range>,
125 pub unenumerable: Vec<Ipv6Range>,
130}
131
132pub fn map_ips_to_interfaces(ip_set: IpSet) -> RoutedTargets {
140 map_ips_to_interfaces_with(ip_set, viable_interfaces(), &[])
141}
142
143pub(crate) fn map_ips_to_interfaces_forced(ip_set: IpSet, forced: &[IpAddr]) -> RoutedTargets {
147 map_ips_to_interfaces_with(ip_set, viable_interfaces(), forced)
148}
149
150enum Classification {
153 Local(usize),
155 Routed(IpAddr),
157 Ours,
159 Unmapped,
161}
162
163pub(crate) fn map_ips_to_interfaces_with(
168 ip_set: IpSet,
169 interfaces: Vec<Link>,
170 forced: &[IpAddr],
171) -> RoutedTargets {
172 map_ips_to_interfaces_asking(ip_set, interfaces, forced, ask_route)
173}
174
175fn map_ips_to_interfaces_asking(
179 ip_set: IpSet,
180 interfaces: Vec<Link>,
181 forced: &[IpAddr],
182 route: fn(IpAddr) -> RouteAnswer,
183) -> RoutedTargets {
184 let owned_ips: HashSet<IpAddr> = interfaces
185 .iter()
186 .flat_map(|link| link.addresses().iter().map(|held| held.address()))
187 .collect();
188
189 let mut local: HashMap<usize, IpSet> = HashMap::new();
190 let mut routed: Vec<RoutedTarget> = Vec::new();
191 let mut unmapped = IpSet::new();
192 let mut ours = IpSet::new();
193 let mut unenumerable: Vec<Ipv6Range> = Vec::new();
194 let mut ambiguous: Vec<Ipv6Range> = Vec::new();
195 let mut singles_to_route: Vec<IpAddr> = Vec::new();
196
197 for range in ip_set.v4() {
200 let start = IpAddr::V4(range.start_addr());
201 let end = IpAddr::V4(range.end_addr());
202 match owning_interface(&interfaces, start, end) {
203 Some(idx) => local.entry(idx).or_default().insert_range(V4(*range)),
204 None => singles_to_route.extend(range.iter()),
205 }
206 }
207 for range in ip_set.v6() {
208 let start = IpAddr::V6(range.start_addr());
209 let end = IpAddr::V6(range.end_addr());
210
211 if range.is_ambiguous() {
213 ambiguous.push(*range);
214 continue;
215 }
216 if let Some(zone) = range.zone() {
218 match interfaces.iter().position(|link| link.index() == zone) {
219 Some(idx) => local.entry(idx).or_default().insert_range(V6(*range)),
220 None => ambiguous.push(*range),
221 }
222 continue;
223 }
224
225 match owning_interface(&interfaces, start, end) {
226 Some(idx) => local.entry(idx).or_default().insert_range(V6(*range)),
230 None if !is_enumerable(range) => unenumerable.push(*range),
233 None => singles_to_route.extend(range.iter()),
234 }
235 }
236
237 let processed: Vec<(IpAddr, Classification)> = singles_to_route
238 .par_iter()
239 .map(|&target| {
240 if target.is_loopback() {
245 return (target, Classification::Unmapped);
246 }
247 if is_ipv4_mapped(target) {
251 return (target, Classification::Unmapped);
252 }
253 if owned_ips.contains(&target) {
256 return (target, Classification::Ours);
257 }
258
259 if let Some((idx, held)) = holding_prefix(&interfaces, target) {
264 return if interfaces[idx].carries_frames() {
265 (target, Classification::Local(idx))
266 } else {
267 (target, Classification::Routed(held.address()))
268 };
269 }
270
271 let answer = route(target);
277 if matches!(answer, RouteAnswer::Forbidden) {
278 return (target, Classification::Unmapped);
279 }
280
281 if let Some(source) = forced
284 .iter()
285 .copied()
286 .find(|s| s.is_ipv4() == target.is_ipv4())
287 {
288 return (target, Classification::Routed(source));
289 }
290
291 if let RouteAnswer::From(source) = answer
292 && owned_ips.contains(&source)
293 {
294 return (target, Classification::Routed(source));
295 }
296
297 if let Some(source) = plausible_source(&interfaces, target) {
301 return (target, Classification::Routed(source));
302 }
303
304 (target, Classification::Unmapped)
305 })
306 .collect();
307
308 for (target, class) in processed {
309 match class {
310 Classification::Local(idx) => local.entry(idx).or_default().insert(target),
311 Classification::Routed(source) => routed.push(RoutedTarget { target, source }),
312 Classification::Unmapped => unmapped.insert(target),
313 Classification::Ours => ours.insert(target),
314 }
315 }
316
317 for address in &owned_ips {
321 let mut one = IpSet::new();
322 one.insert(*address);
323
324 for targets in local.values_mut() {
325 if targets.contains(address) {
326 targets.subtract(&one);
327 ours.insert(*address);
328 }
329 }
330 }
331 local.retain(|_, targets| !targets.is_empty());
333
334 let local = local
335 .into_iter()
336 .map(|(idx, ips)| (interfaces[idx].clone(), ips))
337 .collect();
338
339 RoutedTargets {
340 local,
341 routed,
342 unmapped,
343 ours,
344 ambiguous,
345 unenumerable,
346 }
347}
348
349pub(crate) fn refused_neighbours(link: &Link, targets: &IpSet) -> IpSet {
362 refused_neighbours_asking(link, targets, refuses_neighbour)
363}
364
365fn refused_neighbours_asking(link: &Link, targets: &IpSet, refuses: fn(IpAddr) -> bool) -> IpSet {
368 let edges: HashSet<IpAddr> = link
369 .addresses()
370 .iter()
371 .filter_map(|held| match held.network() {
372 IpRange::V4(range) => Some([range.start_addr(), range.end_addr()]),
373 IpRange::V6(_) => None,
374 })
375 .flatten()
376 .map(IpAddr::V4)
377 .collect();
378 let v4 = targets.v4().iter().flat_map(Ipv4Range::iter);
379 let v6 = targets
380 .v6()
381 .iter()
382 .filter(|range| range.zone().is_none() && is_enumerable(range))
383 .flat_map(Ipv6Range::iter);
384 let walked = v4.chain(v6);
385
386 let refused: Vec<IpAddr> = walked
387 .filter(|target| !edges.contains(target) && !ScopedIp::needs_zone(target))
388 .par_bridge()
389 .map(|target| refuses(target).then_some(target))
390 .flatten()
391 .collect();
392
393 let mut set = IpSet::new();
394 for address in refused {
395 set.insert(address);
396 }
397 set.canonicalize();
398 set
399}
400
401#[derive(Debug, Clone, Copy, PartialEq, Eq)]
407pub(crate) enum FrameSender {
408 Sweep,
410 Probe,
413}
414
415#[derive(Debug, Clone, PartialEq, Eq)]
417pub(crate) enum Unframed {
418 Loopback,
420 Ours,
423 Tunnel(String),
427 NoRoute,
429 Neighbour(String),
432 Mapped,
435}
436
437impl std::fmt::Display for Unframed {
439 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
440 match self {
441 Self::Loopback => f.write_str("loopback"),
442 Self::Ours => f.write_str("own address"),
443 Self::Tunnel(link) => write!(f, "via {link}"),
444 Self::NoRoute => f.write_str("no route"),
445 Self::Neighbour(link) => write!(f, "IPv6 neighbour on {link}, no NDP"),
446 Self::Mapped => f.write_str("IPv4-mapped"),
447 }
448 }
449}
450
451#[derive(Debug, Default)]
458pub(crate) struct BeyondFrames {
459 pub(crate) targets: IpSet,
461 reasons: Vec<(Unframed, IpSet)>,
464}
465
466impl BeyondFrames {
467 pub(crate) fn is_empty(&self) -> bool {
469 self.targets.is_empty()
470 }
471
472 pub(crate) fn summary(&self) -> Vec<(Unframed, IpAddr, u128)> {
475 self.reasons
476 .iter()
477 .filter_map(|(reason, targets)| {
478 let first = targets.iter().next()?;
479 Some((reason.clone(), first, targets.len()))
480 })
481 .collect()
482 }
483
484 pub(crate) fn is_a_fallback(&self) -> bool {
493 self.reasons.iter().any(|(reason, _)| {
494 matches!(
495 reason,
496 Unframed::Tunnel(_) | Unframed::Neighbour(_) | Unframed::NoRoute
497 )
498 })
499 }
500
501 pub(crate) fn reasons(&self) -> String {
504 let named: Vec<String> = self
505 .reasons
506 .iter()
507 .map(|(reason, _)| reason.to_string())
508 .collect();
509 named.join(", ")
510 }
511
512 pub(crate) fn and_unmapped(mut self, unmapped: &IpSet) -> Self {
520 let mut rest = unmapped.clone();
521 rest.subtract(&self.targets);
522 for (reason, targets) in unmapped_reasons(rest) {
523 self.note(reason, targets);
524 }
525 self.targets.canonicalize();
526 self
527 }
528
529 fn note(&mut self, reason: Unframed, mut targets: IpSet) {
532 targets.canonicalize();
533 if targets.is_empty() {
534 return;
535 }
536 extend(&mut self.targets, &targets);
537 match self.reasons.iter_mut().find(|(held, _)| *held == reason) {
538 Some((_, held)) => {
539 extend(held, &targets);
540 held.canonicalize();
541 }
542 None => self.reasons.push((reason, targets)),
543 }
544 }
545}
546
547fn unmapped_reasons(unmapped: IpSet) -> Vec<(Unframed, IpSet)> {
554 let block = |ranges: &[IpRange]| {
555 let mut set = IpSet::new();
556 for range in ranges {
557 set.insert_range(*range);
558 }
559 set
560 };
561 let v4 = |start: [u8; 4], end: [u8; 4]| {
562 V4(Ipv4Range::new(start.into(), end.into()).expect("an ordered range"))
563 };
564 let v6 = |start: u128, end: u128| {
565 V6(Ipv6Range::new(start.into(), end.into()).expect("an ordered range"))
566 };
567 let blocks = [
568 (
569 Unframed::Loopback,
570 block(&[v4([127, 0, 0, 0], [127, 255, 255, 255]), v6(1, 1)]),
571 ),
572 (
573 Unframed::Mapped,
574 block(&[v6(0xffff_0000_0000, 0xffff_ffff_ffff)]),
575 ),
576 ];
577
578 let mut reasons = Vec::new();
579 let mut rest = unmapped;
580 for (reason, block) in blocks {
581 let mut outside = rest.clone();
582 outside.subtract(&block);
583 let mut inside = rest;
584 inside.subtract(&outside);
585 reasons.push((reason, inside));
586 rest = outside;
587 }
588 reasons.push((Unframed::NoRoute, rest));
589 reasons.retain(|(_, targets)| !targets.is_empty());
590 reasons
591}
592
593fn is_ipv4_mapped(target: IpAddr) -> bool {
596 matches!(target, IpAddr::V6(v6) if v6.to_ipv4_mapped().is_some())
597}
598
599fn extend(into: &mut IpSet, from: &IpSet) {
601 for range in from.v4() {
602 into.push_v4_range(*range);
603 }
604 for range in from.v6() {
605 into.push_v6_range(*range);
606 }
607}
608
609pub(crate) fn beyond_frames(ip_set: IpSet, forced: &[IpAddr], sender: FrameSender) -> BeyondFrames {
616 beyond_frames_with(ip_set, viable_interfaces(), forced, sender)
617}
618
619pub(crate) fn beyond_frames_with(
622 ip_set: IpSet,
623 interfaces: Vec<Link>,
624 forced: &[IpAddr],
625 sender: FrameSender,
626) -> BeyondFrames {
627 let links = interfaces.clone();
628 let RoutedTargets {
629 local,
630 routed,
631 unmapped,
632 ours,
633 ..
634 } = map_ips_to_interfaces_with(ip_set, interfaces, forced);
635
636 let mut groups: Vec<(Unframed, IpSet)> = Vec::new();
639 let mut add = |reason: Unframed, range: IpRange| match groups
640 .iter_mut()
641 .find(|(held, _)| *held == reason)
642 {
643 Some((_, targets)) => targets.insert_range(range),
644 None => {
645 let mut targets = IpSet::new();
646 targets.insert_range(range);
647 groups.push((reason, targets));
648 }
649 };
650
651 for (reason, targets) in unmapped_reasons(unmapped) {
652 for range in targets.v4() {
653 add(reason.clone(), V4(*range));
654 }
655 for range in targets.v6() {
656 add(reason.clone(), V6(*range));
657 }
658 }
659 for range in ours.v4() {
660 add(Unframed::Ours, V4(*range));
661 }
662 for range in ours.v6() {
663 add(Unframed::Ours, V6(*range));
664 }
665
666 let mut local: Vec<(Link, IpSet)> = local.into_iter().collect();
668 local.sort_by(|(a, _), (b, _)| a.name().cmp(b.name()));
669 for (link, targets) in &local {
670 if !link.carries_frames() {
673 for range in targets.v4() {
674 add(Unframed::Tunnel(link.name().to_string()), V4(*range));
675 }
676 for range in targets.v6() {
677 add(Unframed::Tunnel(link.name().to_string()), V6(*range));
678 }
679 } else if sender == FrameSender::Probe {
680 for range in targets.v6() {
681 add(Unframed::Neighbour(link.name().to_string()), V6(*range));
682 }
683 }
684 }
685
686 for RoutedTarget { target, source } in routed {
687 let Some(owner) = links
691 .iter()
692 .find(|link| link.addresses().iter().any(|held| held.address() == source))
693 else {
694 continue;
695 };
696 if !owner.carries_frames() {
697 add(Unframed::Tunnel(owner.name().to_string()), single(target));
698 }
699 }
700
701 let mut beyond = BeyondFrames::default();
702 for (reason, targets) in groups {
703 beyond.note(reason, targets);
704 }
705 beyond.targets.canonicalize();
706 beyond
707}
708
709fn single(address: IpAddr) -> IpRange {
711 match address {
712 IpAddr::V4(v4) => V4(Ipv4Range::single(v4)),
713 IpAddr::V6(v6) => V6(Ipv6Range::single(v6)),
714 }
715}
716
717pub fn is_enumerable(range: &Ipv6Range) -> bool {
722 range.len() <= MAX_ENUMERABLE_ADDRESSES
723}
724
725fn owning_interface(links: &[Link], start: IpAddr, end: IpAddr) -> Option<usize> {
736 let (idx, owner) = holding_prefix(links, start)?;
737 let narrower_inside = links
738 .iter()
739 .enumerate()
740 .filter(|(other, _)| *other != idx)
741 .flat_map(|(_, link)| link.addresses())
742 .filter(|held| held.prefix() > owner.prefix())
743 .map(|held| held.network())
744 .filter(|network| network.len() > 1)
745 .any(|network| {
746 let (low, high) = (network.start_addr(), network.end_addr());
747 low.is_ipv4() == start.is_ipv4() && low <= end && start <= high
748 });
749
750 (links[idx].carries_frames() && owner.contains(&end) && !narrower_inside).then_some(idx)
751}
752
753fn holding_prefix(links: &[Link], target: IpAddr) -> Option<(usize, LinkAddress)> {
766 let mut best: Option<(usize, LinkAddress)> = None;
767 for (idx, link) in links.iter().enumerate() {
768 for held in link.addresses() {
769 if held.contains(&target) && best.is_none_or(|(_, b)| held.prefix() > b.prefix()) {
770 best = Some((idx, *held));
771 }
772 }
773 }
774 best
775}
776
777#[cfg(test)]
787mod tests {
788 use super::*;
789 use crate::model::ip::range::{IpRange, Ipv4Range, Ipv6Range};
790 use crate::model::mac::MacAddr;
791 use std::net::{Ipv4Addr, Ipv6Addr};
792
793 fn mock_named(name: &str, index: u32, ip: IpAddr, prefix: u8) -> Link {
795 Link::new(name, index)
796 .with_mac(MacAddr::new(0x02, 0, 0, 0, 0, index as u8))
797 .with_addressing(crate::system::interface::Addressing::Broadcast)
798 .with_addresses(vec![crate::system::interface::LinkAddress::new(ip, prefix)])
799 }
800
801 fn mock_interface(ip: IpAddr, prefix: u8) -> Link {
802 mock_named("test0", 0, ip, prefix)
803 }
804
805 #[test]
806 fn the_interface_holding_a_targets_prefix_is_found() {
807 let interfaces = vec![
808 mock_interface(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 100)), 24),
809 mock_interface(IpAddr::V4(Ipv4Addr::new(198, 51, 100, 5)), 24),
810 ];
811 let holder = |target: [u8; 4]| {
812 holding_prefix(&interfaces, IpAddr::V4(Ipv4Addr::from(target))).map(|(idx, _)| idx)
813 };
814
815 assert_eq!(holder([192, 0, 2, 50]), Some(0));
816 assert_eq!(holder([198, 51, 100, 200]), Some(1));
817 assert_eq!(holder([203, 0, 113, 1]), None, "held by neither");
818 }
819
820 #[test]
825 fn a_routed_target_a_route_forbids_is_left_to_the_connect_fallback() {
826 let global = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 5));
827 let lan = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
828 let interfaces = || vec![mock_interface(global, 64), mock_interface(lan, 24)];
829 let v6 = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 9, 0, 0, 0, 0, 1));
830 let v4 = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 1));
831 let targets = || {
832 let mut set = IpSet::new();
833 set.insert(v6);
834 set.insert(v4);
835 set
836 };
837
838 let forbidden = map_ips_to_interfaces_asking(targets(), interfaces(), &[lan], |_| {
839 RouteAnswer::Forbidden
840 });
841 assert!(forbidden.routed.is_empty(), "{:?}", forbidden.routed);
842 assert!(forbidden.unmapped.contains(&v6) && forbidden.unmapped.contains(&v4));
843
844 let missing =
845 map_ips_to_interfaces_asking(targets(), interfaces(), &[], |_| RouteAnswer::NoRoute);
846 assert!(
847 missing
848 .routed
849 .iter()
850 .any(|routed| routed.target == v6 && routed.source == global),
851 "{:?}",
852 missing.routed
853 );
854 }
855
856 #[test]
860 fn a_neighbour_the_routing_table_refuses_is_told_apart_from_the_segment() {
861 let link = mock_interface(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24);
862 let mut targets = IpSet::new();
863 targets.insert_range(IpRange::V4(
864 Ipv4Range::new(Ipv4Addr::new(192, 0, 2, 0), Ipv4Addr::new(192, 0, 2, 255)).unwrap(),
865 ));
866 targets.insert(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 13)));
867 targets.insert(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 13)));
868
869 let refused = refused_neighbours_asking(&link, &targets, |target| match target {
872 IpAddr::V4(v4) => matches!(v4.octets()[3], 0 | 13 | 255),
873 IpAddr::V6(v6) => v6.segments()[7] == 13,
874 });
875
876 let mut expected = IpSet::new();
877 expected.insert(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 13)));
878 expected.insert(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 13)));
879 expected.canonicalize();
880 assert_eq!(refused, expected);
881 }
882
883 #[test]
884 fn on_link_v4_range_stays_intact_and_local() {
885 let interfaces = vec![mock_interface(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24)];
886 let mut set = IpSet::new();
887 set.insert_range(IpRange::V4(
888 Ipv4Range::new(Ipv4Addr::new(192, 0, 2, 10), Ipv4Addr::new(192, 0, 2, 20)).unwrap(),
889 ));
890
891 let result = map_ips_to_interfaces_with(set, interfaces, &[]);
892
893 assert!(result.routed.is_empty());
894 assert!(result.unmapped.is_empty());
895 assert_eq!(result.local.len(), 1);
896 let (_, ips) = result.local.into_iter().next().unwrap();
897 assert_eq!(ips.len(), 11);
898 }
899
900 #[test]
903 fn the_enumeration_ceiling_is_a_112() {
904 let base = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
905 let at_ceiling = Ipv6Range::new(base, Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0xffff));
906 let over_ceiling = Ipv6Range::new(base, Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 1, 0));
907
908 let at_ceiling = at_ceiling.unwrap();
909 assert_eq!(at_ceiling.len(), MAX_ENUMERABLE_ADDRESSES);
910 assert!(is_enumerable(&at_ceiling), "a /112 is 65536 addresses");
911 assert!(
912 !is_enumerable(&over_ceiling.unwrap()),
913 "one address more is not"
914 );
915 }
916
917 #[test]
921 fn a_routed_v6_prefix_too_large_to_walk_is_refused_rather_than_expanded() {
922 let interfaces = vec![mock_interface(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24)];
923 let mut set = IpSet::new();
924 set.insert_range(IpRange::V6(
925 Ipv6Range::new(
926 Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0),
927 Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0xffff, 0xffff, 0xffff, 0xffff),
928 )
929 .unwrap(),
930 ));
931
932 let result = map_ips_to_interfaces_with(set, interfaces, &[]);
933
934 assert_eq!(result.unenumerable.len(), 1, "the /64 is reported whole");
935 assert!(result.routed.is_empty());
936 assert!(result.unmapped.is_empty());
937 assert!(result.local.is_empty());
938 }
939
940 #[test]
944 fn a_link_local_target_naming_no_interface_is_refused() {
945 let link_local = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
946 let interfaces = vec![
947 mock_interface(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1)), 64),
948 mock_interface(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 2)), 64),
949 ];
950 let mut set = IpSet::new();
951 set.insert(IpAddr::V6(link_local));
952
953 let result = map_ips_to_interfaces_with(set, interfaces, &[]);
954
955 assert_eq!(result.ambiguous.len(), 1);
956 assert!(
957 result.local.is_empty(),
958 "guessing an interface is what this prevents"
959 );
960 }
961
962 #[test]
965 fn a_link_local_target_goes_to_the_interface_it_names() {
966 let link_local = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
967 let first = mock_named(
968 "en3",
969 3,
970 IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1)),
971 64,
972 );
973 let second = mock_named(
974 "en9",
975 9,
976 IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 2)),
977 64,
978 );
979
980 let mut set = IpSet::new();
981 set.insert_range(IpRange::V6(
982 Ipv6Range::scoped(link_local, link_local, Some(9)).unwrap(),
983 ));
984
985 let result = map_ips_to_interfaces_with(set, vec![first, second], &[]);
986
987 assert!(result.ambiguous.is_empty());
988 assert_eq!(result.local.len(), 1);
989 let (intf, ips) = result.local.into_iter().next().unwrap();
990 assert_eq!(intf.name(), "en9", "the second interface was the one named");
991 assert_eq!(ips.len(), 1);
992 }
993
994 #[test]
995 fn on_link_v6_range_is_classified_local() {
996 let base = Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 0);
997 let interfaces = vec![mock_interface(IpAddr::V6(base), 64)];
998 let mut set = IpSet::new();
999 set.insert_range(IpRange::V6(
1000 Ipv6Range::new(
1001 Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 1),
1002 Ipv6Addr::new(0xfd00, 0, 0, 0, 0, 0, 0, 5),
1003 )
1004 .unwrap(),
1005 ));
1006
1007 let result = map_ips_to_interfaces_with(set, interfaces, &[]);
1008
1009 assert!(result.routed.is_empty());
1010 assert!(result.unmapped.is_empty());
1011 assert_eq!(result.local.len(), 1);
1012 let (_, ips) = result.local.into_iter().next().unwrap();
1013 assert_eq!(ips.len(), 5);
1014 }
1015
1016 #[test]
1020 fn an_address_this_host_holds_is_ours_rather_than_on_link() {
1021 let own: IpAddr = "203.0.113.160".parse().unwrap();
1022 let interfaces = vec![mock_interface(own, 24)];
1023
1024 let mut targets = IpSet::new();
1025 targets.insert(own);
1026
1027 let routed = map_ips_to_interfaces_with(targets, interfaces, &[]);
1028
1029 assert!(routed.ours.contains(&own), "the address is this host's own");
1030 assert!(
1031 routed.local.is_empty(),
1032 "and must not be handed to a link-layer strategy"
1033 );
1034 }
1035
1036 #[test]
1038 fn a_neighbour_on_the_same_segment_is_still_on_link() {
1039 let own: IpAddr = "203.0.113.160".parse().unwrap();
1040 let neighbour: IpAddr = "203.0.113.101".parse().unwrap();
1041 let interfaces = vec![mock_interface(own, 24)];
1042
1043 let mut targets = IpSet::new();
1044 targets.insert(neighbour);
1045
1046 let routed = map_ips_to_interfaces_with(targets, interfaces, &[]);
1047
1048 assert!(routed.ours.is_empty());
1049 assert_eq!(
1050 routed.local.values().next().map(IpSet::len),
1051 Some(1u128),
1052 "the neighbour is on-link"
1053 );
1054 }
1055
1056 fn ethernet(addresses: &[(&str, u8)]) -> Link {
1058 Link::new("en0", 4)
1059 .with_mac(crate::model::mac::MacAddr::new(0x02, 0, 0, 0, 0, 0x10))
1060 .with_kind(crate::system::interface::LinkKind::Wired)
1061 .with_addressing(crate::system::interface::Addressing::Broadcast)
1062 .with_link_up(true)
1063 .with_addresses(held(addresses))
1064 }
1065
1066 fn tunnel(addresses: &[(&str, u8)]) -> Link {
1069 Link::new("utun9", 20)
1070 .with_addressing(crate::system::interface::Addressing::PointToPoint)
1071 .with_link_up(true)
1072 .with_addresses(held(addresses))
1073 }
1074
1075 fn held(addresses: &[(&str, u8)]) -> Vec<crate::system::interface::LinkAddress> {
1076 addresses
1077 .iter()
1078 .map(|(address, prefix)| {
1079 crate::system::interface::LinkAddress::new(
1080 address.parse().expect("a literal"),
1081 *prefix,
1082 )
1083 })
1084 .collect()
1085 }
1086
1087 fn set_of(addresses: &[&str]) -> IpSet {
1088 let mut set = IpSet::new();
1089 for address in addresses {
1090 set.insert(address.parse().expect("a literal"));
1091 }
1092 set
1093 }
1094
1095 fn ip(literal: &str) -> IpAddr {
1096 literal.parse().expect("a literal")
1097 }
1098
1099 #[test]
1105 fn loopback_is_unmapped_in_both_families_whatever_is_forced() {
1106 let interfaces = vec![ethernet(&[("192.0.2.10", 24), ("2001:db8:1::10", 64)])];
1107 let forced = [ip("192.0.2.10"), ip("2001:db8:1::10")];
1108
1109 for forced in [&forced[..], &[]] {
1110 let routed = map_ips_to_interfaces_with(
1111 set_of(&["127.0.0.1", "::1"]),
1112 interfaces.clone(),
1113 forced,
1114 );
1115
1116 assert!(
1117 routed.routed.is_empty(),
1118 "loopback is not behind a gateway: {:?}",
1119 routed.routed
1120 );
1121 assert!(routed.unmapped.contains(&ip("127.0.0.1")));
1122 assert!(routed.unmapped.contains(&ip("::1")));
1123 }
1124 }
1125
1126 #[test]
1130 fn a_mapped_address_is_unmapped_whatever_is_forced() {
1131 let interfaces = vec![ethernet(&[("192.0.2.10", 24), ("2001:db8:1::10", 64)])];
1132 let forced = [ip("192.0.2.10"), ip("2001:db8:1::10")];
1133
1134 for forced in [&forced[..], &[]] {
1135 let routed = map_ips_to_interfaces_with(
1136 set_of(&["::ffff:127.0.0.1", "::ffff:198.51.100.7"]),
1137 interfaces.clone(),
1138 forced,
1139 );
1140
1141 assert!(
1142 routed.routed.is_empty(),
1143 "a mapped address is not behind a gateway: {:?}",
1144 routed.routed
1145 );
1146 assert!(routed.unmapped.contains(&ip("::ffff:127.0.0.1")));
1147 assert!(routed.unmapped.contains(&ip("::ffff:198.51.100.7")));
1148 }
1149 }
1150
1151 #[test]
1153 fn a_mapped_address_is_beyond_frames_as_what_it_is() {
1154 let beyond = beyond_frames_with(
1155 set_of(&["::ffff:198.51.100.7"]),
1156 vec![ethernet(&[("192.0.2.10", 24), ("2001:db8:1::10", 64)])],
1157 &[],
1158 FrameSender::Probe,
1159 );
1160
1161 assert_eq!(
1162 beyond.summary(),
1163 vec![(Unframed::Mapped, ip("::ffff:198.51.100.7"), 1)]
1164 );
1165 }
1166
1167 #[test]
1172 fn what_no_route_leads_to_is_named_for_what_it_is() {
1173 let held = beyond_frames_with(
1174 set_of(&["::ffff:198.51.100.7"]),
1175 vec![ethernet(&[("192.0.2.10", 24), ("2001:db8:1::10", 64)])],
1176 &[],
1177 FrameSender::Probe,
1178 );
1179
1180 let all = held.and_unmapped(&set_of(&[
1181 "::ffff:198.51.100.7",
1182 "127.0.0.2",
1183 "::1",
1184 "::ffff:127.0.0.1",
1185 "203.0.113.9",
1186 "203.0.113.10",
1187 ]));
1188
1189 assert_eq!(
1190 all.summary(),
1191 vec![
1192 (Unframed::Mapped, ip("::ffff:127.0.0.1"), 2),
1193 (Unframed::Loopback, ip("127.0.0.2"), 2),
1194 (Unframed::NoRoute, ip("203.0.113.9"), 2),
1195 ]
1196 );
1197 assert_eq!(all.targets.len(), 6);
1198 }
1199
1200 #[test]
1203 fn a_frame_reaches_an_ipv4_neighbour_and_a_target_routed_over_ethernet() {
1204 let beyond = beyond_frames_with(
1205 set_of(&["192.0.2.50", "203.0.113.9"]),
1206 vec![ethernet(&[("192.0.2.10", 24)])],
1207 &[ip("192.0.2.10")],
1208 FrameSender::Probe,
1209 );
1210
1211 assert!(beyond.is_empty(), "nothing out of reach: {beyond:?}");
1212 }
1213
1214 #[test]
1217 fn a_target_routed_through_a_tunnel_is_beyond_frames() {
1218 let beyond = beyond_frames_with(
1219 set_of(&["203.0.113.23"]),
1220 vec![
1221 ethernet(&[("192.0.2.10", 24)]),
1222 tunnel(&[("198.51.100.2", 32)]),
1223 ],
1224 &[ip("198.51.100.2")],
1225 FrameSender::Sweep,
1226 );
1227
1228 assert!(beyond.targets.contains(&ip("203.0.113.23")));
1229 assert_eq!(
1230 beyond.summary(),
1231 vec![(Unframed::Tunnel("utun9".into()), ip("203.0.113.23"), 1)]
1232 );
1233 assert!(beyond.is_a_fallback(), "a raw socket reaches it");
1234 }
1235
1236 #[test]
1239 fn a_tunnels_own_subnet_is_beyond_frames_under_the_same_reason() {
1240 let beyond = beyond_frames_with(
1241 set_of(&["198.51.100.7", "203.0.113.23"]),
1242 vec![tunnel(&[("198.51.100.2", 24)])],
1243 &[ip("198.51.100.2")],
1244 FrameSender::Sweep,
1245 );
1246
1247 assert_eq!(beyond.targets.len(), 2);
1248 assert_eq!(
1249 beyond.summary(),
1250 vec![(Unframed::Tunnel("utun9".into()), ip("198.51.100.7"), 2)]
1251 );
1252 }
1253
1254 #[test]
1258 fn a_host_on_a_tunnels_own_subnet_is_routed_through_the_tunnel() {
1259 let interfaces = vec![
1260 ethernet(&[("192.0.2.10", 24)]),
1261 tunnel(&[("198.51.100.2", 24), ("2001:db8:66::2", 64)]),
1262 ];
1263
1264 let routed = map_ips_to_interfaces_with(
1265 set_of(&["198.51.100.1", "2001:db8:66::1"]),
1266 interfaces,
1267 &[],
1268 );
1269
1270 assert!(
1271 routed.local.is_empty(),
1272 "a tunnel has no segment to sweep: {:?}",
1273 routed.local
1274 );
1275 assert_eq!(
1276 routed.routed,
1277 vec![
1278 RoutedTarget {
1279 target: ip("198.51.100.1"),
1280 source: ip("198.51.100.2"),
1281 },
1282 RoutedTarget {
1283 target: ip("2001:db8:66::1"),
1284 source: ip("2001:db8:66::2"),
1285 },
1286 ]
1287 );
1288 }
1289
1290 #[test]
1293 fn a_forced_source_does_not_take_a_host_off_its_tunnels_subnet() {
1294 let routed = map_ips_to_interfaces_with(
1295 set_of(&["198.51.100.1"]),
1296 vec![
1297 ethernet(&[("192.0.2.10", 24)]),
1298 tunnel(&[("198.51.100.2", 24)]),
1299 ],
1300 &[ip("192.0.2.10")],
1301 );
1302
1303 assert_eq!(
1304 routed.routed,
1305 vec![RoutedTarget {
1306 target: ip("198.51.100.1"),
1307 source: ip("198.51.100.2"),
1308 }]
1309 );
1310 }
1311
1312 #[test]
1315 fn a_tunnels_subnet_as_a_range_is_routed_address_by_address() {
1316 let mut targets = IpSet::new();
1317 targets.insert_range(V4(Ipv4Range::new(
1318 "198.51.100.0".parse().unwrap(),
1319 "198.51.100.3".parse().unwrap(),
1320 )
1321 .expect("an ordered range")));
1322
1323 let routed =
1324 map_ips_to_interfaces_with(targets, vec![tunnel(&[("198.51.100.2", 24)])], &[]);
1325
1326 assert!(routed.local.is_empty(), "{:?}", routed.local);
1327 let probed: Vec<IpAddr> = routed.routed.iter().map(|r| r.target).collect();
1328 assert_eq!(
1329 probed,
1330 ["198.51.100.0", "198.51.100.1", "198.51.100.3"].map(ip)
1331 );
1332 assert!(routed.routed.iter().all(|r| r.source == ip("198.51.100.2")));
1333 assert!(routed.ours.contains(&ip("198.51.100.2")));
1334 assert_eq!(routed.ours.len(), 1);
1335 }
1336
1337 #[test]
1341 fn the_most_specific_prefix_decides_between_a_segment_and_a_tunnel() {
1342 let interfaces = vec![
1343 ethernet(&[("198.51.100.10", 24), ("2001:db8:0:1::10", 64)]),
1344 tunnel(&[("198.51.100.130", 25), ("2001:db8::2", 40)]),
1345 ];
1346
1347 let routed = map_ips_to_interfaces_with(
1348 set_of(&[
1349 "198.51.100.7",
1350 "198.51.100.200",
1351 "2001:db8:0:1::20",
1352 "2001:db8:5::1",
1353 ]),
1354 interfaces,
1355 &[],
1356 );
1357
1358 let swept: Vec<IpAddr> = routed.local.values().flat_map(IpSet::iter).collect();
1359 assert_eq!(swept, ["198.51.100.7", "2001:db8:0:1::20"].map(ip));
1360 assert_eq!(
1361 routed.routed,
1362 vec![
1363 RoutedTarget {
1364 target: ip("198.51.100.200"),
1365 source: ip("198.51.100.130"),
1366 },
1367 RoutedTarget {
1368 target: ip("2001:db8:5::1"),
1369 source: ip("2001:db8::2"),
1370 },
1371 ]
1372 );
1373 }
1374
1375 #[test]
1378 fn a_host_prefix_inside_a_segments_range_leaves_the_range_whole() {
1379 let mut lan = ethernet(&[("2001:db8:1::10", 64)]);
1380 lan = lan.with_addresses(held(&[("2001:db8:1::10", 64), ("2001:db8:1::abcd", 128)]));
1381 let interfaces = vec![lan, tunnel(&[("2001:db8:1::99", 128)])];
1382
1383 let mut targets = IpSet::new();
1384 targets.insert_range(V6(Ipv6Range::new(
1385 "2001:db8:1::".parse().unwrap(),
1386 "2001:db8:1::ffff:ffff:ffff:ffff".parse().unwrap(),
1387 )
1388 .expect("an ordered range")));
1389
1390 let routed = map_ips_to_interfaces_with(targets, interfaces, &[]);
1391
1392 assert!(routed.unenumerable.is_empty(), "{:?}", routed.unenumerable);
1393 assert_eq!(routed.local.len(), 1, "the /64 is swept on its segment");
1394 }
1395
1396 #[test]
1399 fn an_ipv6_neighbour_is_within_the_sweep_and_beyond_the_probe_sender() {
1400 let interfaces = vec![ethernet(&[("192.0.2.10", 24), ("2001:db8:1::10", 64)])];
1401 let targets = set_of(&["2001:db8:1::20", "192.0.2.50"]);
1402
1403 let swept =
1404 beyond_frames_with(targets.clone(), interfaces.clone(), &[], FrameSender::Sweep);
1405 assert!(swept.is_empty(), "the sweep reaches both: {swept:?}");
1406
1407 let probed = beyond_frames_with(targets, interfaces, &[], FrameSender::Probe);
1408 assert_eq!(
1409 probed.summary(),
1410 vec![(Unframed::Neighbour("en0".into()), ip("2001:db8:1::20"), 1)],
1411 "and the probe sender only the IPv4 one"
1412 );
1413 }
1414
1415 #[test]
1418 fn loopback_and_this_hosts_own_addresses_are_beyond_frames() {
1419 let beyond = beyond_frames_with(
1420 set_of(&["127.0.0.1", "::1", "192.0.2.10"]),
1421 vec![ethernet(&[("192.0.2.10", 24)])],
1422 &[],
1423 FrameSender::Probe,
1424 );
1425
1426 assert_eq!(
1427 beyond.summary(),
1428 vec![
1429 (Unframed::Loopback, ip("127.0.0.1"), 2),
1430 (Unframed::Ours, ip("192.0.2.10"), 1),
1431 ]
1432 );
1433 assert!(!beyond.is_a_fallback(), "connect is their route");
1434 }
1435
1436 #[test]
1440 fn one_tunnelled_target_makes_a_connect_a_fallback() {
1441 let mut beyond = BeyondFrames::default();
1442 beyond.note(Unframed::Ours, set_of(&["192.0.2.10"]));
1443 assert!(!beyond.is_a_fallback());
1444
1445 beyond.note(Unframed::Tunnel("utun9".into()), set_of(&["192.0.2.11"]));
1446 assert!(beyond.is_a_fallback());
1447 assert_eq!(beyond.reasons(), "own address, via utun9");
1448 }
1449
1450 #[test]
1454 fn a_forced_source_outranks_the_routing_table_for_a_routed_target() {
1455 let lan: IpAddr = "203.0.113.160".parse().unwrap();
1456 let public: IpAddr = "1.1.1.1".parse().unwrap();
1457 let interfaces = vec![mock_interface(lan, 24)];
1458
1459 let mut targets = IpSet::new();
1460 targets.insert(public);
1461
1462 let routed = map_ips_to_interfaces_with(targets, interfaces, &[lan]);
1463
1464 assert_eq!(
1465 routed.routed,
1466 vec![RoutedTarget {
1467 target: public,
1468 source: lan
1469 }],
1470 "the off-link target is probed from the forced source"
1471 );
1472 }
1473}