use std::net::IpAddr;
use pnet::util::MacAddr;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Neighbor {
pub ip: IpAddr,
pub mac: Option<MacAddr>,
pub interface_index: u32,
}
pub fn ipv6_neighbors() -> Vec<Neighbor> {
platform::ipv6_neighbors()
}
#[cfg(any(target_os = "macos", target_os = "ios", target_os = "freebsd"))]
mod platform {
use std::mem;
use std::net::{IpAddr, Ipv6Addr};
use libc::{
AF_INET6, AF_LINK, CTL_NET, NET_RT_FLAGS, PF_ROUTE, RTA_DST, RTA_GATEWAY, RTF_LLINFO,
c_int, c_void, rt_msghdr, size_t, sockaddr, sockaddr_dl, sockaddr_in6,
};
use pnet::util::MacAddr;
use super::Neighbor;
use crate::warn;
const SA_ALIGN: usize = mem::size_of::<u32>();
fn roundup(len: usize) -> usize {
if len == 0 {
SA_ALIGN
} else {
(len + (SA_ALIGN - 1)) & !(SA_ALIGN - 1)
}
}
pub(super) fn ipv6_neighbors() -> Vec<Neighbor> {
let mut mib: [c_int; 6] = [
CTL_NET,
PF_ROUTE,
0,
AF_INET6,
NET_RT_FLAGS,
RTF_LLINFO as c_int,
];
let buffer = match dump(&mut mib) {
Ok(buffer) => buffer,
Err(e) => {
warn!(
verbosity = 1,
"could not read the IPv6 neighbour table: {e}"
);
return Vec::new();
}
};
parse(&buffer)
}
fn dump(mib: &mut [c_int]) -> std::io::Result<Vec<u8>> {
for _ in 0..2 {
let mut len: size_t = 0;
let sized = unsafe {
libc::sysctl(
mib.as_mut_ptr(),
mib.len() as u32,
std::ptr::null_mut(),
&mut len,
std::ptr::null_mut(),
0,
)
};
if sized < 0 {
return Err(std::io::Error::last_os_error());
}
if len == 0 {
return Ok(Vec::new());
}
let mut buffer = vec![0u8; len];
let read = unsafe {
libc::sysctl(
mib.as_mut_ptr(),
mib.len() as u32,
buffer.as_mut_ptr() as *mut c_void,
&mut len,
std::ptr::null_mut(),
0,
)
};
if read < 0 {
let err = std::io::Error::last_os_error();
if err.raw_os_error() == Some(libc::ENOMEM) {
continue;
}
return Err(err);
}
buffer.truncate(len);
return Ok(buffer);
}
Err(std::io::Error::other(
"the neighbour table kept growing while it was being read",
))
}
fn parse(buffer: &[u8]) -> Vec<Neighbor> {
let mut neighbors = Vec::new();
let mut offset = 0usize;
while offset + mem::size_of::<rt_msghdr>() <= buffer.len() {
let header: rt_msghdr =
unsafe { std::ptr::read_unaligned(buffer[offset..].as_ptr() as *const rt_msghdr) };
let message_len = header.rtm_msglen as usize;
if message_len == 0 || offset + message_len > buffer.len() {
break;
}
if let Some(neighbor) = entry(
&buffer[offset + mem::size_of::<rt_msghdr>()..offset + message_len],
header.rtm_addrs,
header.rtm_index as u32,
) {
neighbors.push(neighbor);
}
offset += message_len;
}
neighbors
}
fn entry(mut block: &[u8], addrs: c_int, interface_index: u32) -> Option<Neighbor> {
let mut ip: Option<IpAddr> = None;
let mut mac: Option<MacAddr> = None;
for bit in 0..8 {
let flag = 1 << bit;
if addrs & flag == 0 {
continue;
}
if block.len() < mem::size_of::<sockaddr>() {
break;
}
let sa: sockaddr =
unsafe { std::ptr::read_unaligned(block.as_ptr() as *const sockaddr) };
let sa_len = roundup(sa.sa_len as usize);
if sa_len == 0 || sa_len > block.len() {
break;
}
match (flag, c_int::from(sa.sa_family)) {
(RTA_DST, AF_INET6) => ip = read_ipv6(&block[..sa_len]),
(RTA_GATEWAY, AF_LINK) => mac = read_mac(&block[..sa_len]),
_ => {}
}
block = &block[sa_len..];
}
ip.map(|ip| Neighbor {
ip,
mac,
interface_index,
})
}
fn read_ipv6(bytes: &[u8]) -> Option<IpAddr> {
if bytes.len() < mem::size_of::<sockaddr_in6>() {
return None;
}
let sin6: sockaddr_in6 =
unsafe { std::ptr::read_unaligned(bytes.as_ptr() as *const sockaddr_in6) };
let mut octets = sin6.sin6_addr.s6_addr;
if octets[0] == 0xfe && (octets[1] & 0xc0) == 0x80 {
octets[2] = 0;
octets[3] = 0;
}
Some(IpAddr::V6(Ipv6Addr::from(octets)))
}
fn read_mac(bytes: &[u8]) -> Option<MacAddr> {
if bytes.len() < mem::size_of::<sockaddr_dl>() {
return None;
}
let sdl: sockaddr_dl =
unsafe { std::ptr::read_unaligned(bytes.as_ptr() as *const sockaddr_dl) };
const ETHER_ADDR_LEN: usize = 6;
if sdl.sdl_alen as usize != ETHER_ADDR_LEN {
return None;
}
let start = sdl.sdl_nlen as usize;
let data = &sdl.sdl_data;
let end = start + ETHER_ADDR_LEN;
if end > data.len() {
return None;
}
let octets: Vec<u8> = data[start..end].iter().map(|b| *b as u8).collect();
Some(MacAddr::new(
octets[0], octets[1], octets[2], octets[3], octets[4], octets[5],
))
}
}
#[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "freebsd")))]
mod platform {
use super::Neighbor;
use crate::warn;
pub(super) fn ipv6_neighbors() -> Vec<Neighbor> {
warn!(
verbosity = 1,
"reading the IPv6 neighbour table is not implemented on this platform; \
discovery will not use it as a source of candidate addresses"
);
Vec::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reading_the_table_is_infallible() {
let neighbors = ipv6_neighbors();
for neighbor in &neighbors {
assert!(
neighbor.ip.is_ipv6(),
"the IPv6 table yielded {}",
neighbor.ip
);
}
}
#[test]
fn every_link_local_entry_names_its_interface() {
for neighbor in ipv6_neighbors() {
let IpAddr::V6(v6) = neighbor.ip else {
continue;
};
if v6.is_unicast_link_local() {
assert_ne!(
neighbor.interface_index, 0,
"{v6} came back with no interface, so nothing could probe it"
);
}
}
}
}