use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use pnet::datalink::MacAddr;
use crate::model::ip::range::{Ipv4Range, Ipv6Range};
use crate::model::ip::set::IpSet;
use crate::protocols::{arp, ndp};
type Bytes = Vec<u8>;
type PacketIter = Box<dyn Iterator<Item = (Bytes, IpAddr)> + Send>;
pub fn eth_packet_iter(
local_mac: &MacAddr,
src_v4: &Option<Ipv4Addr>,
link_local: &Option<Ipv6Addr>,
ip_set: &IpSet,
) -> PacketIter {
let arp_iter = src_v4
.as_ref()
.map(|v4| create_arp_iter(local_mac, v4, ip_set))
.into_iter()
.flatten();
let ndp_iter = link_local
.as_ref()
.map(|v6| create_ndp_iter(local_mac, v6, ip_set))
.into_iter()
.flatten();
Box::new(Interleave::new(
Box::new(arp_iter),
ip_set.v4_len(),
Box::new(ndp_iter),
ip_set.v6_len(),
))
}
struct Interleave {
left: PacketIter,
right: PacketIter,
credit: i128,
left_len: i128,
right_len: i128,
}
impl Interleave {
fn new(left: PacketIter, left_len: u128, right: PacketIter, right_len: u128) -> Self {
Self {
left,
right,
credit: 0,
left_len: left_len.min(i128::MAX as u128) as i128,
right_len: right_len.min(i128::MAX as u128) as i128,
}
}
}
impl Iterator for Interleave {
type Item = (Bytes, IpAddr);
fn next(&mut self) -> Option<Self::Item> {
if self.left_len <= 0 || self.right_len <= 0 {
return self.left.next().or_else(|| self.right.next());
}
if self.credit >= 0 {
self.credit -= self.right_len;
if let Some(item) = self.left.next() {
return Some(item);
}
}
self.credit += self.left_len;
self.right.next().or_else(|| self.left.next())
}
}
fn create_ndp_iter(local_mac: &MacAddr, src_addr: &Ipv6Addr, ip_set: &IpSet) -> PacketIter {
let local_mac = *local_mac;
let src_addr = *src_addr;
let ranges: Vec<Ipv6Range> = ip_set.v6().to_vec();
let iter = ranges
.into_iter()
.flat_map(|range| {
let start: u128 = range.start_addr().into();
let end: u128 = range.end_addr().into();
(start..=end).map(Ipv6Addr::from)
})
.map(move |target| {
let packet = ndp::create_neighbor_solicitation(&local_mac, &src_addr, target);
(packet, IpAddr::V6(target))
});
Box::new(iter)
}
pub fn create_arp_iter(local_mac: &MacAddr, src_ip: &Ipv4Addr, ip_set: &IpSet) -> PacketIter {
let local_mac = *local_mac;
let src_ip = *src_ip;
let ranges: Vec<Ipv4Range> = ip_set.v4().to_vec();
let iter = ranges
.into_iter()
.flat_map(|range| {
let start: u32 = range.start_addr().into();
let end: u32 = range.end_addr().into();
(start..=end).map(Ipv4Addr::from)
})
.map(move |dst_addr| {
let packet = arp::create_request(&local_mac, &src_ip, dst_addr);
(packet, IpAddr::V4(dst_addr))
});
Box::new(iter)
}
#[cfg(test)]
mod tests {
use super::*;
fn stream(count: u32, v6: bool) -> PacketIter {
Box::new((0..count).map(move |i| {
let ip = if v6 {
IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, i as u16))
} else {
IpAddr::V4(Ipv4Addr::new(10, 0, 0, i as u8))
};
(Vec::new(), ip)
}))
}
fn interleaved(left: u32, right: u32) -> Vec<IpAddr> {
Interleave::new(
stream(left, false),
left as u128,
stream(right, true),
right as u128,
)
.map(|(_, ip)| ip)
.collect()
}
#[test]
fn interleaving_emits_every_probe_exactly_once() {
for (left, right) in [(254, 27), (27, 254), (1, 1), (0, 5), (5, 0), (0, 0), (7, 3)] {
let out = interleaved(left, right);
assert_eq!(out.len(), (left + right) as usize, "{left} and {right}");
assert_eq!(
out.iter().filter(|ip| ip.is_ipv4()).count(),
left as usize,
"{left} and {right}"
);
}
}
#[test]
fn interleaving_spreads_the_smaller_stream_across_the_whole_sweep() {
let out = interleaved(254, 27);
let positions: Vec<usize> = out
.iter()
.enumerate()
.filter(|(_, ip)| ip.is_ipv6())
.map(|(i, _)| i)
.collect();
assert_eq!(positions.len(), 27);
let smallest_gap = positions
.windows(2)
.map(|pair| pair[1] - pair[0])
.min()
.expect("more than one solicitation");
assert!(
smallest_gap >= 8,
"solicitations {smallest_gap} apart is a burst, not a spread: {positions:?}"
);
assert!(
positions.last().expect("a last solicitation") > &(out.len() - 20),
"the stream should reach the end of the sweep, not finish early"
);
}
}