use std::collections::{HashMap, HashSet};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::time::Instant;
use crate::collect::conn::{Conn, IPPROTO_TCP, IPPROTO_UDP, TCP_ESTABLISHED, TCP_LISTEN};
use crate::collect::udp::UdpDelta;
const UDP_STATE: u8 = 7;
pub const NO_UID: u32 = u32::MAX;
#[derive(Debug, PartialEq)]
pub struct NetProcRow {
pub pid: u32,
pub name: String,
pub rx: u64,
pub tx: u64,
}
#[derive(Debug, PartialEq)]
pub struct NetFlowRow {
pub proto: u8,
pub local: (IpAddr, u16),
pub remote: (IpAddr, u16),
pub is_listen: bool,
pub rx: u64,
pub tx: u64,
}
pub fn parse_dump(out: &str) -> (Vec<NetProcRow>, Vec<NetFlowRow>) {
let mut procs = Vec::new();
let mut flows = Vec::new();
for line in out.lines() {
if line.starts_with("time,") {
continue; }
let f: Vec<&str> = line.split(',').collect();
if f.len() < 6 {
continue;
}
let label = f[1];
let rx = f[4].parse().unwrap_or(0);
let tx = f[5].parse().unwrap_or(0);
if let Some((lhs, rhs)) = label.split_once("<->") {
let Some((kind, l)) = lhs.split_once(' ') else {
continue;
};
let (proto, v6) = match kind {
"tcp4" => (IPPROTO_TCP, false),
"tcp6" => (IPPROTO_TCP, true),
"udp4" => (IPPROTO_UDP, false),
"udp6" => (IPPROTO_UDP, true),
_ => continue,
};
let (Some(local), Some(remote)) = (parse_endpoint(l, v6), parse_endpoint(rhs, v6))
else {
continue;
};
let state = f[3];
if proto == IPPROTO_TCP
&& !state.is_empty()
&& state != "Established"
&& state != "Listen"
{
continue;
}
flows.push(NetFlowRow {
proto,
local,
remote,
is_listen: state == "Listen",
rx,
tx,
});
} else if let Some((name, pid)) = label.rsplit_once('.') {
if let Ok(pid) = pid.parse() {
procs.push(NetProcRow {
pid,
name: name.to_string(),
rx,
tx,
});
}
}
}
(procs, flows)
}
pub fn parse_endpoint(s: &str, v6: bool) -> Option<(IpAddr, u16)> {
let (ip, port) = if v6 {
s.rsplit_once('.')?
} else {
s.rsplit_once(':')?
};
let port: u16 = match port {
"*" => 0,
p => p.parse().ok()?,
};
let host = ip.split('%').next()?; let ip = match host {
"*" => {
if v6 {
IpAddr::V6(Ipv6Addr::UNSPECIFIED)
} else {
IpAddr::V4(Ipv4Addr::UNSPECIFIED)
}
}
_ => host.parse().ok()?,
};
Some((ip, port))
}
pub fn flow_inode(proto: u8, local: &(IpAddr, u16), remote: &(IpAddr, u16)) -> u64 {
let mut key = vec![proto];
for (ip, port) in [local, remote] {
match ip {
IpAddr::V4(v4) => key.extend_from_slice(&v4.octets()),
IpAddr::V6(v6) => key.extend_from_slice(&v6.octets()),
}
key.extend_from_slice(&port.to_be_bytes());
}
let mut h: u64 = 0xcbf2_9ce4_8422_2325;
for b in key {
h ^= b as u64;
h = h.wrapping_mul(0x100_0000_01b3);
}
h
}
pub fn flows_to_conns(flows: &[NetFlowRow]) -> Vec<Conn> {
let mut out: Vec<Conn> = Vec::new();
let mut seen: HashSet<u64> = HashSet::new();
for f in flows {
let inode = flow_inode(f.proto, &f.local, &f.remote);
if !seen.insert(inode) {
continue;
}
let state = if f.proto == IPPROTO_TCP {
if f.is_listen {
TCP_LISTEN
} else {
TCP_ESTABLISHED
}
} else {
UDP_STATE
};
out.push(Conn {
proto: f.proto,
local: f.local,
remote: f.remote,
state,
uid: NO_UID,
inode,
bytes_recv: f.rx,
bytes_sent: f.tx,
rate_recv: 0.0,
rate_sent: 0.0,
pid: None,
proc: None,
dead: false,
first_seen: None,
dead_at: None,
});
}
out
}
#[cfg_attr(target_os = "linux", allow(dead_code))]
pub struct NettopCollector {
prev_all: HashMap<u32, (u64, u64, Instant)>,
prev_udp: HashMap<u32, (u64, u64, Instant)>,
pub flows: Vec<Conn>,
pub net: Vec<UdpDelta>,
pub udp: Vec<UdpDelta>,
}
#[cfg_attr(target_os = "linux", allow(dead_code))]
impl NettopCollector {
pub fn new() -> Self {
Self {
prev_all: HashMap::new(),
prev_udp: HashMap::new(),
flows: Vec::new(),
net: Vec::new(),
udp: Vec::new(),
}
}
#[cfg(target_os = "macos")]
pub fn sample(&mut self) {
let Ok((procs_all, flows)) = dump_mode(&[]) else {
return;
};
self.flows = flows_to_conns(&flows);
self.net = diff_procs(&mut self.prev_all, procs_all, Instant::now());
self.udp = match dump_mode(&["-m", "udp"]) {
Ok((procs_udp, _)) => diff_procs(&mut self.prev_udp, procs_udp, Instant::now()),
Err(_) => Vec::new(),
};
}
}
#[cfg_attr(target_os = "linux", allow(dead_code))]
impl Default for NettopCollector {
fn default() -> Self {
Self::new()
}
}
#[cfg_attr(target_os = "linux", allow(dead_code))]
fn diff_procs(
prev: &mut HashMap<u32, (u64, u64, Instant)>,
cur: Vec<NetProcRow>,
now: Instant,
) -> Vec<UdpDelta> {
let old = std::mem::take(prev);
let mut out = Vec::new();
let mut new: HashMap<u32, (u64, u64, Instant)> = HashMap::new();
for r in cur {
new.insert(r.pid, (r.rx, r.tx, now));
if let Some(&(pr, pt, t0)) = old.get(&r.pid) {
let dt = now.duration_since(t0).as_secs_f64().max(1e-6);
out.push(UdpDelta {
pid: r.pid,
recv: r.rx.saturating_sub(pr),
sent: r.tx.saturating_sub(pt),
dt,
});
}
}
*prev = new;
out
}
#[cfg(target_os = "macos")]
fn dump_mode(extra: &[&str]) -> std::io::Result<(Vec<NetProcRow>, Vec<NetFlowRow>)> {
let out = std::process::Command::new("nettop")
.args(["-L", "1", "-x", "-n"])
.args(extra)
.output()?;
if !out.status.success() {
return Err(std::io::Error::other("nettop failed"));
}
Ok(parse_dump(&String::from_utf8_lossy(&out.stdout)))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::collect::conn::TCP_LISTEN;
use std::net::Ipv6Addr;
const SAMPLE: &str = "\
time,,interface,state,bytes_in,bytes_out,rx_dupe,rx_ooo,re-tx,rtt_avg,rcvsize,tx_win,tc_class,tc_mgt,cc_algo,P,C,R,W,arch,
23:09:55.103078,launchd.1,,,0,0,0,0,0,,,,,,,,,,,,
23:09:55.100019,tcp4 *:22<->*:*,,Listen,,,,,,,,,,-,cubic,-,-,-,-,so,
23:09:55.100000,tcp6 *.22<->*.*,,Listen,,,,,,,,,,-,cubic,-,-,-,-,so,
23:09:55.099965,udp4 *:68<->*:*,,,0,0,,,,,786896,,CTL,,,,,,,so,
23:09:55.103094,remoted.367,,,3978,2558,0,0,0,,,,,,,,,,,,
23:09:55.208376,tcp6 fe80::c48a:a1ff:feae:cd4%anri0.58783<->fe80::c48a:a1ff:feae:c2b%anri0.59067,anri0,Established,3978,2558,0,0,0,1.00 ms,131072,131072,BE,-,cubic,-,-,-,-,so,
23:09:55.207910,tcp4 192.168.121.111:50012<->17.57.145.134:5223,en0,Established,5093128,4927378,55222,89204,46306,117.62 ms,131072,249728,RD,-,cubic,-,-,-,-,ch,
23:09:55.194177,udp4 *:5353<->*:*,en0,,34390403,28503582,,,,,786896,,CTL,,,,,,,so,
23:09:55.207780,udp4 *:*<->*:*,,,,,,,,,,,,,,,,,,so,
23:09:55.101366,tcp6 fe80::c48a:a1ff:feae:c2b%anri0.59069<->*.*,anri0,Listen,,,,,,,,,,-,cubic,-,-,-,-,so,
23:09:55.207943,tcp4 1.2.3.4:5<->6.7.8.9:10,en0,SynSent,0,0,0,0,0,0.00 ms,131072,0,BE,-,cubic,-,1,-,-,so,
";
#[test]
fn parses_process_and_flow_rows_from_one_dump() {
let (procs, flows) = parse_dump(SAMPLE);
assert!(procs.contains(&NetProcRow {
pid: 367,
name: "remoted".into(),
rx: 3978,
tx: 2558,
}));
assert!(procs.contains(&NetProcRow {
pid: 1,
name: "launchd".into(),
rx: 0,
tx: 0,
}));
assert_eq!(procs.len(), 2);
let est = flows
.iter()
.find(|f| f.local == ("192.168.121.111".parse().unwrap(), 50012))
.expect("tcp4 established row");
assert_eq!(est.proto, IPPROTO_TCP);
assert_eq!(est.remote, ("17.57.145.134".parse().unwrap(), 5223));
assert_eq!(est.rx, 5_093_128);
assert_eq!(est.tx, 4_927_378);
assert!(!est.is_listen);
let v6 = flows
.iter()
.find(|f| f.local.0.is_ipv6() && !f.is_listen)
.expect("v6 flow");
assert_eq!(
v6.local,
(
IpAddr::V6("fe80::c48a:a1ff:feae:cd4".parse::<Ipv6Addr>().unwrap()),
58783
)
);
assert_eq!(v6.rx, 3978);
let listen = flows
.iter()
.find(|f| f.is_listen && f.local.0.is_ipv4())
.expect("v4 listener");
assert_eq!(listen.local, (IpAddr::V4(Ipv4Addr::UNSPECIFIED), 22));
assert_eq!(listen.remote, (IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0));
assert_eq!(listen.rx, 0);
let l6 = flows
.iter()
.find(|f| f.is_listen && f.local.0.is_ipv6())
.expect("v6 listener");
assert_eq!(l6.local, (IpAddr::V6(Ipv6Addr::UNSPECIFIED), 22));
assert_eq!(l6.remote, (IpAddr::V6(Ipv6Addr::UNSPECIFIED), 0));
let udp = flows
.iter()
.find(|f| f.proto == IPPROTO_UDP && f.rx > 0)
.expect("udp flow");
assert_eq!(udp.local, (IpAddr::V4(Ipv4Addr::UNSPECIFIED), 5353));
assert_eq!(udp.rx, 34_390_403);
assert_eq!(udp.tx, 28_503_582);
}
#[test]
fn flows_to_conns_dedupes_and_synthesizes_stable_inodes() {
let (_, flows) = parse_dump(SAMPLE);
let conns = flows_to_conns(&flows);
let inodes: HashSet<u64> = conns.iter().map(|c| c.inode).collect();
assert_eq!(inodes.len(), conns.len());
let f = &conns[0];
assert_eq!(flow_inode(f.proto, &f.local, &f.remote), f.inode);
assert_eq!(conns.iter().map(|c| c.uid).min(), Some(NO_UID));
assert!(conns.iter().any(|c| c.is_listen()));
assert!(conns.iter().any(|c| !c.is_tcp() && c.state == UDP_STATE));
let listen = conns.iter().find(|c| c.is_listen()).unwrap();
assert_eq!(listen.state, TCP_LISTEN);
}
#[test]
fn endpoint_notation_by_family() {
assert_eq!(
parse_endpoint("192.168.1.5:8080", false),
Some(("192.168.1.5".parse().unwrap(), 8080))
);
assert_eq!(
parse_endpoint("fe80::1%en0.59069", true),
Some(("fe80::1".parse().unwrap(), 59069))
);
assert_eq!(
parse_endpoint("*:22", false),
Some((IpAddr::V4(Ipv4Addr::UNSPECIFIED), 22))
);
assert_eq!(
parse_endpoint("*.*", true),
Some((IpAddr::V6(Ipv6Addr::UNSPECIFIED), 0))
);
assert_eq!(parse_endpoint("garbage", false), None);
}
#[test]
fn diff_procs_baselines_then_deltas_then_rebaselines_on_reset() {
let mut prev = HashMap::new();
let t0 = Instant::now();
let d = diff_procs(
&mut prev,
vec![NetProcRow {
pid: 5,
name: "a".into(),
rx: 100,
tx: 40,
}],
t0,
);
assert!(d.is_empty());
let d = diff_procs(
&mut prev,
vec![NetProcRow {
pid: 5,
name: "a".into(),
rx: 700,
tx: 90,
}],
t0,
);
assert_eq!(d.len(), 1);
assert_eq!(d[0].recv, 600);
assert_eq!(d[0].sent, 50);
let d = diff_procs(
&mut prev,
vec![NetProcRow {
pid: 5,
name: "a".into(),
rx: 10,
tx: 0,
}],
t0,
);
assert_eq!(d.len(), 1);
assert_eq!(d[0].recv, 0);
assert_eq!(d[0].sent, 0);
}
#[test]
#[cfg(target_os = "macos")]
#[ignore = "requires live nettop (CI-flaky); run locally with --ignored"]
fn attribution_joins_nettop_rows_and_socket_info() {
use crate::collect::macproc;
use std::net::TcpListener;
let l = TcpListener::bind("127.0.0.1:0").expect("bind listener");
let port = l.local_addr().unwrap().port();
let (_, flows) = dump_mode(&[]).expect("nettop dump");
let f = flows
.iter()
.find(|f| f.local == ("127.0.0.1".parse().unwrap(), port))
.unwrap_or_else(|| panic!("listener :{port} missing from nettop flows"));
let want = flow_inode(f.proto, &f.local, &f.remote);
let map = macproc::socket_map();
assert_eq!(
map.get(&want).map(|(pid, _)| *pid),
Some(std::process::id()),
"own listener must be attributed via socket_info projection"
);
}
#[test]
#[cfg(target_os = "macos")]
#[ignore = "diagnostic"]
fn conns_attribution_full_junction_debug() {
let mut nt = NettopCollector::new();
nt.sample();
let flows = std::mem::take(&mut nt.flows);
eprintln!("nettop flows: {}", flows.len());
let mut cc = crate::collect::conn::ConnCollector::new();
cc.ingest(flows);
cc.sample();
let attributed = cc.conns.iter().filter(|c| c.pid.is_some()).count();
eprintln!("conns: {} attributed: {}", cc.conns.len(), attributed);
for c in cc.conns.iter().take(10) {
eprintln!(
" {} pid={:?} proc={:?} uid={} ino={:016x}",
crate::collect::conn::sock_str(&c.local),
c.pid,
c.proc,
c.uid,
c.inode
);
}
}
}