use std::collections::HashSet;
use std::ffi::{c_char, c_void};
use std::mem::size_of;
use std::net::IpAddr;
use std::sync::Mutex;
use crate::netif::{IpNet, NicSnapshot};
static BLOCKS: Mutex<Option<HashSet<usize>>> = Mutex::new(None);
fn remember(block: *mut u8) {
let mut blocks = BLOCKS.lock().unwrap_or_else(|e| e.into_inner());
blocks
.get_or_insert_with(HashSet::new)
.insert(block as usize);
}
pub(crate) fn release(block: *mut u8) -> bool {
let mut blocks = BLOCKS.lock().unwrap_or_else(|e| e.into_inner());
let ours = blocks
.as_mut()
.is_some_and(|set| set.remove(&(block as usize)));
if ours {
unsafe { libc::free(block.cast::<c_void>()) };
}
ours
}
pub(crate) fn flags(nic: &NicSnapshot) -> u32 {
let mut flags = 0u32;
if nic.spec.admin_up {
flags |= libc::IFF_UP as u32;
}
if nic.running() {
flags |= libc::IFF_RUNNING as u32;
#[cfg(target_os = "linux")]
{
flags |= libc::IFF_LOWER_UP as u32;
}
}
flags |= if nic.loopback {
libc::IFF_LOOPBACK as u32
} else {
libc::IFF_BROADCAST as u32
};
if !nic.loopback || cfg!(target_os = "macos") {
flags |= libc::IFF_MULTICAST as u32;
}
flags
}
fn bytes_of<T>(value: &T) -> Vec<u8> {
unsafe { std::slice::from_raw_parts((value as *const T).cast::<u8>(), size_of::<T>()) }.to_vec()
}
fn sockaddr(ip: IpAddr, scope: u32) -> Vec<u8> {
match ip {
IpAddr::V4(v4) => {
let mut sa: libc::sockaddr_in = unsafe { std::mem::zeroed() };
#[cfg(target_os = "macos")]
{
sa.sin_len = size_of::<libc::sockaddr_in>() as u8;
}
sa.sin_family = libc::AF_INET as libc::sa_family_t;
sa.sin_addr.s_addr = u32::from(v4).to_be();
bytes_of(&sa)
}
IpAddr::V6(v6) => {
let mut sa: libc::sockaddr_in6 = unsafe { std::mem::zeroed() };
#[cfg(target_os = "macos")]
{
sa.sin6_len = size_of::<libc::sockaddr_in6>() as u8;
}
sa.sin6_family = libc::AF_INET6 as libc::sa_family_t;
sa.sin6_addr.s6_addr = v6.octets();
if v6.segments()[0] & 0xffc0 == 0xfe80 {
sa.sin6_scope_id = scope;
}
bytes_of(&sa)
}
}
}
fn mask_of(net: &IpNet) -> IpAddr {
let bits = |width: u32| -> u128 {
if net.prefix == 0 {
0
} else {
(!0u128 << (width - net.prefix as u32)) & (!0u128 >> (128 - width))
}
};
match net.addr {
IpAddr::V4(_) => IpAddr::V4((bits(32) as u32).into()),
IpAddr::V6(_) => IpAddr::V6(bits(128).into()),
}
}
#[cfg(target_os = "linux")]
fn link_entry(nic: &NicSnapshot) -> Entry {
const ARPHRD_ETHER: u16 = 1;
const ARPHRD_LOOPBACK: u16 = 772;
let ll = |mac: [u8; 6]| {
let mut sa: libc::sockaddr_ll = unsafe { std::mem::zeroed() };
sa.sll_family = libc::AF_PACKET as u16;
sa.sll_ifindex = nic.index as i32;
sa.sll_hatype = if nic.loopback {
ARPHRD_LOOPBACK
} else {
ARPHRD_ETHER
};
sa.sll_halen = 6;
sa.sll_addr[..6].copy_from_slice(&mac);
bytes_of(&sa)
};
let c = &nic.counters;
let mut stats = [0u32; 24];
let fields = [
(0, c.rx_packets),
(1, c.tx_packets),
(2, c.rx_bytes),
(3, c.tx_bytes),
(4, c.rx_errors),
(5, c.tx_errors),
(6, c.rx_dropped),
(7, c.tx_dropped),
(8, c.multicast),
(17, c.tx_carrier_errors),
(23, c.rx_nohandler),
];
for (i, v) in fields {
stats[i] = v as u32;
}
Entry {
name: nic.spec.name.clone(),
flags: flags(nic),
addr: ll(nic.hw_addr()),
netmask: None,
broadaddr: (!nic.loopback).then(|| ll([0xff; 6])),
data: Some(stats.iter().flat_map(|v| v.to_ne_bytes()).collect()),
}
}
#[cfg(target_os = "macos")]
fn link_entry(nic: &NicSnapshot) -> Entry {
const IFT_ETHER: u8 = 6;
const IFT_LOOP: u8 = 24;
let name = nic.spec.name.as_bytes();
let alen = if nic.loopback { 0 } else { 6 };
let len = (8 + name.len() + alen).max(size_of::<libc::sockaddr_dl>());
let mut dl = vec![0u8; len.next_multiple_of(4)];
dl[0] = len as u8;
dl[1] = libc::AF_LINK as u8;
dl[2..4].copy_from_slice(&(nic.index as u16).to_ne_bytes());
dl[4] = if nic.loopback { IFT_LOOP } else { IFT_ETHER };
dl[5] = name.len() as u8;
dl[6] = alen as u8;
dl[8..8 + name.len()].copy_from_slice(name);
if alen > 0 {
dl[8 + name.len()..8 + name.len() + 6].copy_from_slice(&nic.hw_addr());
}
let mut data: libc::if_data = unsafe { std::mem::zeroed() };
data.ifi_type = dl[4];
data.ifi_addrlen = alen as u8;
data.ifi_hdrlen = if nic.loopback { 0 } else { 14 };
data.ifi_mtu = nic.spec.mtu;
data.ifi_baudrate = nic.spec.speed_mbps.unwrap_or(0).saturating_mul(1_000_000);
let c = &nic.counters;
data.ifi_ipackets = c.rx_packets as u32;
data.ifi_ierrors = c.rx_errors as u32;
data.ifi_opackets = c.tx_packets as u32;
data.ifi_oerrors = c.tx_errors as u32;
data.ifi_ibytes = c.rx_bytes as u32;
data.ifi_obytes = c.tx_bytes as u32;
data.ifi_imcasts = c.multicast as u32;
data.ifi_iqdrops = c.rx_dropped as u32;
Entry {
name: nic.spec.name.clone(),
flags: flags(nic),
addr: dl,
netmask: None,
broadaddr: None,
data: Some(bytes_of(&data)),
}
}
fn ip_entries(nic: &NicSnapshot, v4: bool) -> impl Iterator<Item = Entry> + '_ {
nic.spec
.addresses
.iter()
.filter(move |net| net.addr.is_ipv4() == v4)
.map(move |net| {
let broadcast = net.broadcast().filter(|_| !nic.loopback && v4);
Entry {
name: nic.spec.name.clone(),
flags: flags(nic),
addr: sockaddr(net.addr, nic.index),
netmask: Some(sockaddr(mask_of(net), 0)),
broadaddr: broadcast.map(|b| sockaddr(b, 0)),
data: None,
}
})
}
struct Entry {
name: String,
flags: u32,
addr: Vec<u8>,
netmask: Option<Vec<u8>>,
broadaddr: Option<Vec<u8>>,
data: Option<Vec<u8>>,
}
fn entries(mut nics: Vec<NicSnapshot>) -> Vec<Entry> {
nics.sort_by_key(|n| n.index);
if cfg!(target_os = "linux") {
let mut out: Vec<Entry> = nics.iter().map(link_entry).collect();
out.extend(nics.iter().flat_map(|n| ip_entries(n, true)));
out.extend(nics.iter().flat_map(|n| ip_entries(n, false)));
out
} else {
nics.iter()
.flat_map(|n| {
std::iter::once(link_entry(n))
.chain(ip_entries(n, true))
.chain(ip_entries(n, false))
})
.collect()
}
}
fn align(n: usize) -> usize {
n.next_multiple_of(8)
}
pub(crate) fn getifaddrs(nics: Vec<NicSnapshot>) -> Result<*mut libc::ifaddrs, i32> {
let entries = entries(nics);
if entries.is_empty() {
return Ok(std::ptr::null_mut());
}
let head = align(entries.len() * size_of::<libc::ifaddrs>());
let payload: usize = entries
.iter()
.map(|e| {
align(e.name.len() + 1)
+ align(e.addr.len())
+ e.netmask.as_ref().map_or(0, |m| align(m.len()))
+ e.broadaddr.as_ref().map_or(0, |b| align(b.len()))
+ e.data.as_ref().map_or(0, |d| align(d.len()))
})
.sum();
let total = head + payload;
let block = unsafe { libc::calloc(1, total) }.cast::<u8>();
if block.is_null() {
return Err(libc::ENOMEM);
}
let ifs = block.cast::<libc::ifaddrs>();
let mut at = head;
let mut put = |bytes: &[u8]| -> *mut u8 {
let dst = unsafe { block.add(at) };
unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), dst, bytes.len()) };
at += align(bytes.len());
dst
};
let n = entries.len();
for (i, e) in entries.iter().enumerate() {
let mut name = e.name.as_bytes().to_vec();
name.push(0);
let name = put(&name);
let addr = put(&e.addr);
let netmask = e.netmask.as_ref().map_or(std::ptr::null_mut(), |m| put(m));
let broad = e
.broadaddr
.as_ref()
.map_or(std::ptr::null_mut(), |b| put(b));
let data = e.data.as_ref().map_or(std::ptr::null_mut(), |d| put(d));
unsafe {
let ifa = &mut *ifs.add(i);
ifa.ifa_next = if i + 1 < n {
ifs.add(i + 1)
} else {
std::ptr::null_mut()
};
ifa.ifa_name = name.cast::<c_char>();
ifa.ifa_flags = e.flags as _;
ifa.ifa_addr = addr.cast();
ifa.ifa_netmask = netmask.cast();
#[cfg(target_os = "linux")]
{
ifa.ifa_ifu = broad.cast();
}
#[cfg(target_os = "macos")]
{
ifa.ifa_dstaddr = broad.cast();
}
ifa.ifa_data = data.cast();
}
}
remember(block);
Ok(ifs)
}
pub(crate) fn nameindex(mut nics: Vec<NicSnapshot>) -> Result<*mut libc::if_nameindex, i32> {
nics.sort_by_key(|n| n.index);
let head = align((nics.len() + 1) * size_of::<libc::if_nameindex>());
let total = head
+ nics
.iter()
.map(|n| align(n.spec.name.len() + 1))
.sum::<usize>();
let block = unsafe { libc::calloc(1, total) }.cast::<u8>();
if block.is_null() {
return Err(libc::ENOBUFS);
}
let array = block.cast::<libc::if_nameindex>();
let mut at = head;
for (i, nic) in nics.iter().enumerate() {
let name = unsafe { block.add(at) };
let bytes = nic.spec.name.as_bytes();
unsafe {
std::ptr::copy_nonoverlapping(bytes.as_ptr(), name, bytes.len());
let slot = &mut *array.add(i);
slot.if_index = nic.index as _;
slot.if_name = name.cast::<c_char>();
}
at += align(bytes.len() + 1);
}
remember(block);
Ok(array)
}