use crate::network::types::{ArpInfo, ArpOperation, NdpNeighbor};
use dashmap::DashMap;
use rustc_hash::FxBuildHasher;
use std::net::IpAddr;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{Duration, SystemTime};
const MAX_ENTRIES: usize = 4096;
const STALE_AFTER: Duration = Duration::from_secs(30 * 60);
const SWEEP_MIN_INTERVAL: Duration = Duration::from_secs(60);
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NeighborEntry {
pub mac: String,
pub vendor: Option<String>,
pub last_seen: SystemTime,
}
#[derive(Debug, Default)]
pub(crate) struct NeighborCache {
entries: DashMap<IpAddr, NeighborEntry, FxBuildHasher>,
last_sweep_epoch_secs: AtomicU64,
}
impl NeighborCache {
pub(crate) fn learn_from_arp(&self, arp: &ArpInfo, now: SystemTime) {
self.learn(arp.sender_ip, &arp.sender_mac, &arp.sender_vendor, now);
if arp.operation == ArpOperation::Reply {
self.learn(arp.target_ip, &arp.target_mac, &arp.target_vendor, now);
}
}
pub(crate) fn learn_from_ndp(&self, neighbor: &NdpNeighbor, now: SystemTime) {
self.learn(neighbor.ip, &neighbor.mac, &neighbor.vendor, now);
}
pub(crate) fn get(&self, ip: &IpAddr) -> Option<NeighborEntry> {
self.entries.get(ip).map(|entry| entry.clone())
}
pub(crate) fn clear(&self) {
self.entries.clear();
}
fn learn(&self, ip: IpAddr, mac: &str, vendor: &Option<String>, now: SystemTime) {
let is_v4_broadcast = matches!(ip, IpAddr::V4(v4) if v4.is_broadcast());
if ip.is_unspecified()
|| ip.is_multicast()
|| is_v4_broadcast
|| !is_unicast_hardware_mac(mac)
{
return;
}
if !self.entries.contains_key(&ip) && self.entries.len() >= MAX_ENTRIES {
self.sweep_stale(now);
if self.entries.len() >= MAX_ENTRIES {
return;
}
}
match self.entries.entry(ip) {
dashmap::Entry::Occupied(mut entry) => {
let entry = entry.get_mut();
if entry.last_seen <= now {
if entry.mac != mac {
entry.mac = mac.to_string();
}
if entry.vendor.as_deref() != vendor.as_deref() {
entry.vendor = vendor.clone();
}
entry.last_seen = now;
}
}
dashmap::Entry::Vacant(entry) => {
entry.insert(NeighborEntry {
mac: mac.to_string(),
vendor: vendor.clone(),
last_seen: now,
});
}
}
}
fn sweep_stale(&self, now: SystemTime) {
let now_secs = now
.duration_since(SystemTime::UNIX_EPOCH)
.map_or(0, |d| d.as_secs());
let last = self.last_sweep_epoch_secs.load(Ordering::Relaxed);
if now_secs < last.saturating_add(SWEEP_MIN_INTERVAL.as_secs()) {
return;
}
if self
.last_sweep_epoch_secs
.compare_exchange(last, now_secs, Ordering::Relaxed, Ordering::Relaxed)
.is_err()
{
return;
}
self.entries
.retain(|_, entry| match now.duration_since(entry.last_seen) {
Ok(age) => age < STALE_AFTER,
Err(_) => true,
});
}
}
fn is_unicast_hardware_mac(mac: &str) -> bool {
match crate::network::oui::mac_first_octet(mac) {
Some(first) => first & 0x01 == 0 && !is_zero_mac(mac),
None => false,
}
}
fn is_zero_mac(mac: &str) -> bool {
let mut zero_digits = 0usize;
for c in mac.trim().chars() {
match c {
'0' => zero_digits += 1,
':' | '-' => {}
_ => return false,
}
}
zero_digits == 12
}
#[cfg(test)]
mod tests {
use super::*;
fn arp(operation: ArpOperation, sender: (&str, &str), target: (&str, &str)) -> ArpInfo {
ArpInfo {
operation,
sender_mac: sender.1.to_string(),
sender_ip: sender.0.parse().unwrap(),
target_mac: target.1.to_string(),
target_ip: target.0.parse().unwrap(),
sender_vendor: Some("Sender Corp".to_string()),
target_vendor: None,
}
}
fn ip(s: &str) -> IpAddr {
s.parse().unwrap()
}
#[test]
fn request_learns_sender_only() {
let cache = NeighborCache::default();
cache.learn_from_arp(
&arp(
ArpOperation::Request,
("192.168.0.132", "68:5e:dd:09:15:5e"),
("192.168.0.1", "00:00:00:00:00:00"),
),
SystemTime::now(),
);
let entry = cache.get(&ip("192.168.0.132")).unwrap();
assert_eq!(entry.mac, "68:5e:dd:09:15:5e");
assert_eq!(entry.vendor.as_deref(), Some("Sender Corp"));
assert!(cache.get(&ip("192.168.0.1")).is_none());
}
#[test]
fn reply_learns_sender_and_target() {
let cache = NeighborCache::default();
cache.learn_from_arp(
&arp(
ArpOperation::Reply,
("192.168.0.1", "04:d9:f5:c5:ed:e8"),
("192.168.0.132", "68:5e:dd:09:15:5e"),
),
SystemTime::now(),
);
assert_eq!(
cache.get(&ip("192.168.0.1")).unwrap().mac,
"04:d9:f5:c5:ed:e8"
);
assert_eq!(
cache.get(&ip("192.168.0.132")).unwrap().mac,
"68:5e:dd:09:15:5e"
);
}
#[test]
fn probe_and_group_macs_are_rejected() {
let cache = NeighborCache::default();
cache.learn_from_arp(
&arp(
ArpOperation::Request,
("0.0.0.0", "68:5e:dd:09:15:5e"),
("192.168.0.7", "00:00:00:00:00:00"),
),
SystemTime::now(),
);
cache.learn_from_arp(
&arp(
ArpOperation::Request,
("192.168.0.9", "00:00:00:00:00:00"),
("192.168.0.1", "00:00:00:00:00:00"),
),
SystemTime::now(),
);
cache.learn_from_arp(
&arp(
ArpOperation::Request,
("192.168.0.10", "ff:ff:ff:ff:ff:ff"),
("192.168.0.1", "00:00:00:00:00:00"),
),
SystemTime::now(),
);
cache.learn_from_arp(
&arp(
ArpOperation::Request,
("192.168.0.11", "01:00:5e:00:00:fb"),
("192.168.0.1", "00:00:00:00:00:00"),
),
SystemTime::now(),
);
assert!(cache.get(&ip("0.0.0.0")).is_none());
assert!(cache.get(&ip("192.168.0.9")).is_none());
assert!(cache.get(&ip("192.168.0.10")).is_none());
assert!(cache.get(&ip("192.168.0.11")).is_none());
}
#[test]
fn newer_arp_overwrites_same_ip() {
let cache = NeighborCache::default();
let when = SystemTime::now();
cache.learn_from_arp(
&arp(
ArpOperation::Request,
("192.168.0.50", "aa:aa:aa:00:00:01"),
("192.168.0.1", "00:00:00:00:00:00"),
),
when,
);
cache.learn_from_arp(
&arp(
ArpOperation::Request,
("192.168.0.50", "ce:ce:ce:00:00:02"),
("192.168.0.1", "00:00:00:00:00:00"),
),
when,
);
assert_eq!(
cache.get(&ip("192.168.0.50")).unwrap().mac,
"ce:ce:ce:00:00:02"
);
}
#[test]
fn stale_arp_does_not_overwrite_newer_entry() {
let cache = NeighborCache::default();
let newer = SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(10);
let older = SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(5);
cache.learn(ip("192.168.0.50"), "aa:aa:aa:00:00:01", &None, newer);
cache.learn(ip("192.168.0.50"), "ce:ce:ce:00:00:02", &None, older);
let entry = cache.get(&ip("192.168.0.50")).unwrap();
assert_eq!(entry.mac, "aa:aa:aa:00:00:01");
assert_eq!(entry.last_seen, newer);
}
#[test]
fn cap_drops_new_keys_but_still_refreshes_known_ones() {
let cache = NeighborCache::default();
let base = SystemTime::UNIX_EPOCH;
for i in 0..MAX_ENTRIES {
let octets = [10u8, (i >> 16) as u8, (i >> 8) as u8, i as u8];
cache.learn(
IpAddr::from(octets),
"aa:bb:cc:00:00:01",
&None,
base + std::time::Duration::from_secs(1),
);
}
assert_eq!(cache.entries.len(), MAX_ENTRIES);
cache.learn(
ip("192.168.0.200"),
"aa:bb:cc:00:00:02",
&None,
base + std::time::Duration::from_secs(100),
);
assert_eq!(cache.entries.len(), MAX_ENTRIES);
assert!(cache.get(&ip("192.168.0.200")).is_none());
assert!(cache.get(&ip("10.0.0.0")).is_some());
cache.learn(
ip("10.0.0.0"),
"aa:bb:cc:00:00:03",
&None,
base + std::time::Duration::from_secs(200),
);
assert_eq!(cache.get(&ip("10.0.0.0")).unwrap().mac, "aa:bb:cc:00:00:03");
}
#[test]
fn full_table_sweeps_stale_entries_to_admit_new_ones() {
let cache = NeighborCache::default();
let base = SystemTime::UNIX_EPOCH;
for i in 0..MAX_ENTRIES {
let octets = [10u8, (i >> 16) as u8, (i >> 8) as u8, i as u8];
cache.learn(
IpAddr::from(octets),
"aa:bb:cc:00:00:01",
&None,
base + std::time::Duration::from_secs(1),
);
}
assert_eq!(cache.entries.len(), MAX_ENTRIES);
let later = base + STALE_AFTER + std::time::Duration::from_secs(120);
cache.learn(ip("192.168.0.200"), "aa:bb:cc:00:00:02", &None, later);
assert_eq!(
cache.get(&ip("192.168.0.200")).unwrap().mac,
"aa:bb:cc:00:00:02"
);
assert!(cache.get(&ip("10.0.0.0")).is_none());
}
#[test]
fn clear_forgets_learned_neighbors() {
let cache = NeighborCache::default();
cache.learn(
ip("192.168.0.7"),
"68:5e:dd:09:15:5e",
&None,
SystemTime::now(),
);
assert!(cache.get(&ip("192.168.0.7")).is_some());
cache.clear();
assert!(cache.get(&ip("192.168.0.7")).is_none());
}
#[test]
fn broadcast_ip_is_rejected() {
let cache = NeighborCache::default();
cache.learn(
ip("255.255.255.255"),
"68:5e:dd:09:15:5e",
&None,
SystemTime::now(),
);
assert!(cache.get(&ip("255.255.255.255")).is_none());
}
#[test]
fn unchanged_refresh_updates_timestamp_in_place() {
let cache = NeighborCache::default();
let earlier = SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(5);
let later = SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(10);
let vendor = Some("Sender Corp".to_string());
cache.learn(ip("192.168.0.50"), "68:5e:dd:09:15:5e", &vendor, earlier);
cache.learn(ip("192.168.0.50"), "68:5e:dd:09:15:5e", &vendor, later);
let entry = cache.get(&ip("192.168.0.50")).unwrap();
assert_eq!(entry.mac, "68:5e:dd:09:15:5e");
assert_eq!(entry.vendor.as_deref(), Some("Sender Corp"));
assert_eq!(entry.last_seen, later);
}
#[test]
fn multicast_ip_is_rejected() {
let cache = NeighborCache::default();
cache.learn(ip("ff02::1"), "68:5e:dd:09:15:5e", &None, SystemTime::now());
cache.learn(
ip("224.0.0.251"),
"68:5e:dd:09:15:5e",
&None,
SystemTime::now(),
);
assert!(cache.get(&ip("ff02::1")).is_none());
assert!(cache.get(&ip("224.0.0.251")).is_none());
}
#[test]
fn zero_mac_is_rejected_in_any_format() {
assert!(is_zero_mac("00:00:00:00:00:00"));
assert!(is_zero_mac("00-00-00-00-00-00"));
assert!(is_zero_mac("000000000000"));
assert!(!is_zero_mac("00:00:00:00:00:01"));
assert!(!is_zero_mac("68:5e:dd:09:15:5e"));
}
}