use std::net::IpAddr;
use std::sync::atomic::{AtomicU64, Ordering};
use crate::scope::{self, SimShared};
use crate::sockets::SocketKind;
#[derive(Default)]
pub(crate) struct UdpMib {
pub(crate) out: AtomicU64,
pub(crate) received: AtomicU64,
pub(crate) read: AtomicU64,
pub(crate) rcvbuf_errors: AtomicU64,
pub(crate) no_ports: AtomicU64,
pub(crate) ignored_multi: AtomicU64,
}
#[derive(Default)]
pub(crate) struct TcpMib {
pub(crate) active_opens: AtomicU64,
pub(crate) passive_opens: AtomicU64,
pub(crate) attempt_fails: AtomicU64,
pub(crate) estab_resets: AtomicU64,
pub(crate) in_segs: AtomicU64,
pub(crate) out_segs: AtomicU64,
pub(crate) out_rsts: AtomicU64,
}
#[derive(Default)]
pub(crate) struct ProtoStats {
udp4: UdpMib,
udp6: UdpMib,
tcp4: TcpMib,
tcp6: TcpMib,
}
fn is_v6(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(_) => false,
IpAddr::V6(v6) => v6.to_ipv4_mapped().is_none(),
}
}
impl ProtoStats {
pub(crate) fn udp(&self, ip: IpAddr) -> &UdpMib {
if is_v6(ip) { &self.udp6 } else { &self.udp4 }
}
pub(crate) fn tcp(&self, ip: IpAddr) -> &TcpMib {
if is_v6(ip) { &self.tcp6 } else { &self.tcp4 }
}
}
pub(crate) fn bump(counter: &AtomicU64) {
counter.fetch_add(1, Ordering::Relaxed);
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct UdpCounters {
pub sent: u64,
pub received: u64,
pub read: u64,
pub rcvbuf_errors: u64,
pub no_ports: u64,
pub ignored_multi: u64,
pub sockets: u64,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct TcpCounters {
pub active_opens: u64,
pub passive_opens: u64,
pub attempt_fails: u64,
pub estab_resets: u64,
pub curr_estab: u64,
pub in_segs: u64,
pub out_segs: u64,
pub out_rsts: u64,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct ProtoCounters {
pub udp4: UdpCounters,
pub udp6: UdpCounters,
pub tcp4: TcpCounters,
pub tcp6: TcpCounters,
}
#[track_caller]
pub fn proto_counters() -> ProtoCounters {
scope::here().proto_counters()
}
impl SimShared {
pub(crate) fn count_reset(&self, ip: IpAddr, sent_by_host: bool, ends: [bool; 2]) {
let tcp = self.stats.tcp(ip);
if sent_by_host {
bump(&tcp.out_rsts);
}
for _ in ends.into_iter().filter(|cut| *cut) {
bump(&tcp.estab_resets);
}
}
pub(crate) fn proto_counters(&self) -> ProtoCounters {
let (mut udp, mut estab) = ([0u64; 2], [0u64; 2]);
snare_interpose::real(|| {
for rec in self.sockets.live_recs() {
rec.land();
let state = rec.state();
let Some(local) = state.local else {
continue;
};
let family = is_v6(local.ip()) as usize;
match state.kind {
SocketKind::Udp => udp[family] += 1,
SocketKind::TcpStream if state.tcp_established => estab[family] += 1,
_ => {}
}
}
});
let load = |c: &AtomicU64| c.load(Ordering::Relaxed);
let udp_of = |m: &UdpMib, sockets: u64| UdpCounters {
sent: load(&m.out),
received: load(&m.received),
read: load(&m.read),
rcvbuf_errors: load(&m.rcvbuf_errors),
no_ports: load(&m.no_ports),
ignored_multi: load(&m.ignored_multi),
sockets,
};
let tcp_of = |m: &TcpMib, curr_estab: u64| TcpCounters {
active_opens: load(&m.active_opens),
passive_opens: load(&m.passive_opens),
attempt_fails: load(&m.attempt_fails),
estab_resets: load(&m.estab_resets),
curr_estab,
in_segs: load(&m.in_segs),
out_segs: load(&m.out_segs),
out_rsts: load(&m.out_rsts),
};
ProtoCounters {
udp4: udp_of(&self.stats.udp4, udp[0]),
udp6: udp_of(&self.stats.udp6, udp[1]),
tcp4: tcp_of(&self.stats.tcp4, estab[0]),
tcp6: tcp_of(&self.stats.tcp6, estab[1]),
}
}
}
impl UdpCounters {
#[cfg_attr(windows, allow(dead_code))]
fn arrived(&self) -> u64 {
self.received + self.rcvbuf_errors + self.no_ports + self.ignored_multi
}
}
#[cfg(target_os = "linux")]
pub(crate) mod linux {
use super::{ProtoCounters, TcpCounters, UdpCounters};
use std::fmt::Write;
const IP: &str = "Forwarding DefaultTTL InReceives InHdrErrors InAddrErrors ForwDatagrams \
InUnknownProtos InDiscards InDelivers OutRequests OutDiscards OutNoRoutes ReasmTimeout \
ReasmReqds ReasmOKs ReasmFails FragOKs FragFails FragCreates OutTransmits";
const ICMP: &str = "InMsgs InErrors InCsumErrors InDestUnreachs InTimeExcds InParmProbs \
InSrcQuenchs InRedirects InEchos InEchoReps InTimestamps InTimestampReps InAddrMasks \
InAddrMaskReps OutMsgs OutErrors OutRateLimitGlobal OutRateLimitHost OutDestUnreachs \
OutTimeExcds OutParmProbs OutSrcQuenchs OutRedirects OutEchos OutEchoReps OutTimestamps \
OutTimestampReps OutAddrMasks OutAddrMaskReps";
const TCP: &str = "RtoAlgorithm RtoMin RtoMax MaxConn ActiveOpens PassiveOpens AttemptFails \
EstabResets CurrEstab InSegs OutSegs RetransSegs InErrs OutRsts InCsumErrors";
const UDP: &str = "InDatagrams NoPorts InErrors OutDatagrams RcvbufErrors SndbufErrors \
InCsumErrors IgnoredMulti MemErrors";
const IP6: &[&str] = &[
"InReceives",
"InHdrErrors",
"InTooBigErrors",
"InNoRoutes",
"InAddrErrors",
"InUnknownProtos",
"InTruncatedPkts",
"InDiscards",
"InDelivers",
"OutForwDatagrams",
"OutRequests",
"OutDiscards",
"OutNoRoutes",
"ReasmTimeout",
"ReasmReqds",
"ReasmOKs",
"ReasmFails",
"FragOKs",
"FragFails",
"FragCreates",
"InMcastPkts",
"OutMcastPkts",
"InOctets",
"OutOctets",
"InMcastOctets",
"OutMcastOctets",
"InBcastOctets",
"OutBcastOctets",
"InNoECTPkts",
"InECT1Pkts",
"InECT0Pkts",
"InCEPkts",
"OutTransmits",
];
const ICMP6: &[&str] = &[
"InMsgs",
"InErrors",
"OutMsgs",
"OutErrors",
"InCsumErrors",
"OutRateLimitHost",
"InDestUnreachs",
"InPktTooBigs",
"InTimeExcds",
"InParmProblems",
"InEchos",
"InEchoReplies",
"InGroupMembQueries",
"InGroupMembResponses",
"InGroupMembReductions",
"InRouterSolicits",
"InRouterAdvertisements",
"InNeighborSolicits",
"InNeighborAdvertisements",
"InRedirects",
"InMLDv2Reports",
"OutDestUnreachs",
"OutPktTooBigs",
"OutTimeExcds",
"OutParmProblems",
"OutEchos",
"OutEchoReplies",
"OutGroupMembQueries",
"OutGroupMembResponses",
"OutGroupMembReductions",
"OutRouterSolicits",
"OutRouterAdvertisements",
"OutNeighborSolicits",
"OutNeighborAdvertisements",
"OutRedirects",
"OutMLDv2Reports",
];
fn pair(out: &mut String, name: &str, fields: &str, values: &[i64]) {
let header: Vec<&str> = fields.split_whitespace().collect();
let _ = writeln!(out, "{name}: {}", header.join(" "));
let values: Vec<String> = values.iter().map(i64::to_string).collect();
let _ = writeln!(out, "{name}: {}", values.join(" "));
}
fn values(fields: &str, set: &[(&str, u64)]) -> Vec<i64> {
fields
.split_whitespace()
.map(|f| {
set.iter()
.find(|(n, _)| *n == f)
.map_or(0, |(_, v)| *v as i64)
})
.collect()
}
fn udp_values(u: &UdpCounters) -> Vec<i64> {
values(
UDP,
&[
("InDatagrams", u.read),
("NoPorts", u.no_ports),
("InErrors", u.rcvbuf_errors),
("OutDatagrams", u.sent),
("RcvbufErrors", u.rcvbuf_errors),
("IgnoredMulti", u.ignored_multi),
],
)
}
pub(crate) fn snmp(c: &ProtoCounters) -> Vec<u8> {
let mut out = String::new();
let (u, t4, t6) = (&c.udp4, &c.tcp4, &c.tcp6);
let tin = u.arrived() + t4.in_segs;
let tout = u.sent + t4.out_segs;
let mut ip = values(
IP,
&[
("InReceives", tin),
("InDelivers", tin),
("OutRequests", tout),
("OutTransmits", tout),
],
);
ip[0] = 2;
ip[1] = 64;
pair(&mut out, "Ip", IP, &ip);
pair(
&mut out,
"Icmp",
ICMP,
&values(
ICMP,
&[("OutMsgs", u.no_ports), ("OutDestUnreachs", u.no_ports)],
),
);
let sum = |f: fn(&TcpCounters) -> u64| f(t4) + f(t6);
let mut tcp = values(
TCP,
&[
("ActiveOpens", sum(|t| t.active_opens)),
("PassiveOpens", sum(|t| t.passive_opens)),
("AttemptFails", sum(|t| t.attempt_fails)),
("EstabResets", sum(|t| t.estab_resets)),
("CurrEstab", sum(|t| t.curr_estab)),
("InSegs", sum(|t| t.in_segs)),
("OutSegs", sum(|t| t.out_segs)),
("OutRsts", sum(|t| t.out_rsts)),
],
);
tcp[..4].copy_from_slice(&[1, 200, 120_000, -1]);
pair(&mut out, "Tcp", TCP, &tcp);
pair(&mut out, "Udp", UDP, &udp_values(u));
pair(&mut out, "UdpLite", UDP, &values(UDP, &[]));
out.into_bytes()
}
pub(crate) fn snmp6(c: &ProtoCounters) -> Vec<u8> {
let mut out = String::new();
let mut line = |name: String, v: u64| {
let _ = writeln!(out, "{name:<32}\t{v}");
};
let (u, t) = (&c.udp6, &c.tcp6);
let tin = u.arrived() + t.in_segs;
let tout = u.sent + t.out_segs;
for f in IP6 {
let v = match *f {
"InReceives" | "InDelivers" => tin,
"OutRequests" | "OutTransmits" => tout,
_ => 0,
};
line(format!("Ip6{f}"), v);
}
for f in ICMP6 {
let v = match *f {
"OutMsgs" | "OutDestUnreachs" => u.no_ports,
_ => 0,
};
line(format!("Icmp6{f}"), v);
}
let udp = udp_values(u);
for (f, v) in UDP.split_whitespace().zip(&udp) {
line(format!("Udp6{f}"), *v as u64);
}
for f in UDP.split_whitespace().filter(|f| *f != "IgnoredMulti") {
line(format!("UdpLite6{f}"), 0);
}
out.into_bytes()
}
}
#[cfg(target_os = "macos")]
pub(crate) mod macos {
use std::sync::Arc;
use snare_interpose::{Host, NetResult as HostResult};
use super::ProtoCounters;
use crate::scope::SimShared;
const UDPSTAT_LEN: usize = 104;
const UDP_STATS_MIB: [i32; 4] = [4, 2, 17, 2];
const UDP_STATS_NAME: &str = "net.inet.udp.stats";
pub(crate) unsafe fn read(
shared: &SimShared,
mib: &[i32],
oldp: *mut u8,
oldlenp: *mut usize,
newp: *const u8,
) -> Option<HostResult> {
if mib != UDP_STATS_MIB {
return None;
}
if !newp.is_null() {
return Some(HostResult::Err(libc::EPERM));
}
if oldlenp.is_null() {
return Some(HostResult::Err(libc::EINVAL));
}
let bytes = udpstat(&shared.proto_counters());
unsafe {
if oldp.is_null() {
*oldlenp = bytes.len();
} else {
let n = (*oldlenp).min(bytes.len());
std::ptr::copy_nonoverlapping(bytes.as_ptr(), oldp, n);
*oldlenp = n;
}
}
Some(HostResult::Ok(0))
}
pub(crate) fn mib_of(name: &str) -> Option<[i32; 4]> {
(name == UDP_STATS_NAME).then_some(UDP_STATS_MIB)
}
pub(crate) unsafe fn name_to_mib(
name: &str,
mib: *mut i32,
sizep: *mut usize,
) -> Option<HostResult> {
let words = mib_of(name)?;
if mib.is_null() || sizep.is_null() {
return Some(HostResult::Err(libc::EINVAL));
}
unsafe {
if *sizep < words.len() {
return Some(HostResult::Err(libc::ENOMEM));
}
std::ptr::copy_nonoverlapping(words.as_ptr(), mib, words.len());
*sizep = words.len();
}
Some(HostResult::Ok(0))
}
pub(crate) unsafe fn name_str<'a>(name: *const std::ffi::c_char) -> Option<&'a str> {
if name.is_null() {
return None;
}
unsafe { std::ffi::CStr::from_ptr(name) }.to_str().ok()
}
pub(crate) struct StatsHost(pub(crate) Arc<SimShared>);
impl Host for StatsHost {
unsafe fn sysctl(
&self,
name: *const i32,
namelen: u32,
oldp: *mut u8,
oldlenp: *mut usize,
newp: *const u8,
_newlen: usize,
) -> Option<HostResult> {
if name.is_null() {
return None;
}
let mib = unsafe { std::slice::from_raw_parts(name, namelen as usize) };
unsafe { read(&self.0, mib, oldp, oldlenp, newp) }
}
unsafe fn sysctlbyname(
&self,
name: *const std::ffi::c_char,
oldp: *mut u8,
oldlenp: *mut usize,
newp: *const u8,
_newlen: usize,
) -> Option<HostResult> {
let mib = mib_of(unsafe { name_str(name) }?)?;
unsafe { read(&self.0, &mib, oldp, oldlenp, newp) }
}
unsafe fn sysctlnametomib(
&self,
name: *const std::ffi::c_char,
mib: *mut i32,
sizep: *mut usize,
) -> Option<HostResult> {
unsafe { name_to_mib(name_str(name)?, mib, sizep) }
}
}
fn udpstat(c: &ProtoCounters) -> Vec<u8> {
let (a, b) = (&c.udp4, &c.udp6);
let mut words = [0u32; UDPSTAT_LEN / 4];
let w = |v: u64| v as u32;
words[0] = w(a.arrived() + b.arrived());
words[4] = w(a.no_ports + b.no_ports);
words[5] = w(a.ignored_multi + b.ignored_multi);
words[6] = w(a.rcvbuf_errors + b.rcvbuf_errors);
words[9] = w(a.sent + b.sent);
words.iter().flat_map(|v| v.to_ne_bytes()).collect()
}
}
#[cfg(windows)]
pub(crate) mod windows {
use super::{TcpCounters, UdpCounters};
use windows_sys::Win32::NetworkManagement::IpHelper::{
MIB_TCPSTATS_LH, MIB_TCPSTATS2, MIB_UDPSTATS, MIB_UDPSTATS2,
};
pub(crate) fn udp(u: &UdpCounters) -> MIB_UDPSTATS {
MIB_UDPSTATS {
dwInDatagrams: u.received as u32,
dwNoPorts: u.no_ports as u32,
dwInErrors: u.rcvbuf_errors as u32,
dwOutDatagrams: u.sent as u32,
dwNumAddrs: u.sockets as u32,
}
}
pub(crate) fn udp2(u: &UdpCounters) -> MIB_UDPSTATS2 {
MIB_UDPSTATS2 {
dw64InDatagrams: u.received,
dwNoPorts: u.no_ports as u32,
dwInErrors: u.rcvbuf_errors as u32,
dw64OutDatagrams: u.sent,
dwNumAddrs: u.sockets as u32,
}
}
const RTO_VANJ: i32 = 4;
pub(crate) fn tcp(t: &TcpCounters) -> MIB_TCPSTATS_LH {
let mut s: MIB_TCPSTATS_LH = unsafe { std::mem::zeroed() };
s.Anonymous.RtoAlgorithm = RTO_VANJ;
s.dwRtoMin = 5;
s.dwRtoMax = u32::MAX;
s.dwMaxConn = u32::MAX;
s.dwActiveOpens = t.active_opens as u32;
s.dwPassiveOpens = t.passive_opens as u32;
s.dwAttemptFails = t.attempt_fails as u32;
s.dwEstabResets = t.estab_resets as u32;
s.dwCurrEstab = t.curr_estab as u32;
s.dwInSegs = t.in_segs as u32;
s.dwOutSegs = t.out_segs as u32;
s.dwOutRsts = t.out_rsts as u32;
s.dwNumConns = t.curr_estab as u32;
s
}
pub(crate) fn tcp2(t: &TcpCounters) -> MIB_TCPSTATS2 {
let mut s: MIB_TCPSTATS2 = unsafe { std::mem::zeroed() };
s.RtoAlgorithm = RTO_VANJ;
s.dwRtoMin = 5;
s.dwRtoMax = u32::MAX;
s.dwMaxConn = u32::MAX;
s.dwActiveOpens = t.active_opens as u32;
s.dwPassiveOpens = t.passive_opens as u32;
s.dwAttemptFails = t.attempt_fails as u32;
s.dwEstabResets = t.estab_resets as u32;
s.dwCurrEstab = t.curr_estab as u32;
s.dw64InSegs = t.in_segs;
s.dw64OutSegs = t.out_segs;
s.dwOutRsts = t.out_rsts as u32;
s.dwNumConns = t.curr_estab as u32;
s
}
}