use std::path::{Path, PathBuf};
use crate::error::{Error, Result};
use crate::util::parse;
#[derive(Debug, Default)]
pub struct IpStats {
pub forwarding: u64,
pub default_ttl: u64,
pub in_receives: u64,
pub in_hdr_errors: u64,
pub in_addr_errors: u64,
pub forw_datagrams: u64,
pub in_unknown_protos: u64,
pub in_discards: u64,
pub in_delivers: u64,
pub out_requests: u64,
pub out_discards: u64,
pub out_no_routes: u64,
pub reasm_timeout: u64,
pub reasm_reqds: u64,
pub reasm_oks: u64,
pub reasm_fails: u64,
pub frag_oks: u64,
pub frag_fails: u64,
pub frag_creates: u64,
pub out_transmits: u64,
}
#[derive(Debug, Default)]
pub struct IcmpStats {
pub in_msgs: u64,
pub in_errors: u64,
pub in_csum_errors: u64,
pub in_dest_unreachs: u64,
pub in_time_excds: u64,
pub in_parm_probs: u64,
pub in_src_quenchs: u64,
pub in_redirects: u64,
pub in_echos: u64,
pub in_echo_reps: u64,
pub in_timestamps: u64,
pub in_timestamp_reps: u64,
pub in_addr_masks: u64,
pub in_addr_mask_reps: u64,
pub out_msgs: u64,
pub out_errors: u64,
pub out_rate_limit_global: u64,
pub out_rate_limit_host: u64,
pub out_dest_unreachs: u64,
pub out_time_excds: u64,
pub out_parm_probs: u64,
pub out_src_quenchs: u64,
pub out_redirects: u64,
pub out_echos: u64,
pub out_echo_reps: u64,
pub out_timestamps: u64,
pub out_timestamp_reps: u64,
pub out_addr_masks: u64,
pub out_addr_mask_reps: u64,
}
#[derive(Debug, Default)]
pub struct TcpStats {
pub rto_algorithm: u64,
pub rto_min: u64,
pub rto_max: u64,
pub max_conn: i64,
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 retrans_segs: u64,
pub in_errs: u64,
pub out_rsts: u64,
pub in_csum_errors: u64,
}
#[derive(Debug, Default)]
pub struct UdpStats {
pub in_datagrams: u64,
pub no_ports: u64,
pub in_errors: u64,
pub out_datagrams: u64,
pub rcvbuf_errors: u64,
pub sndbuf_errors: u64,
pub in_csum_errors: u64,
pub ignored_multi: u64,
pub mem_errors: u64,
}
#[derive(Debug, Default)]
pub struct SnmpInfo {
pub ip: IpStats,
pub icmp: IcmpStats,
pub tcp: TcpStats,
pub udp: UdpStats,
}
pub type Snmp = SnmpInfo;
pub fn snmp() -> Result<SnmpInfo> {
let path = Path::new("/proc/net/snmp");
let bytes = parse::read_file(path)?;
let mut lines = bytes
.split(|&byte| byte == b'\n')
.filter(|line| !line.is_empty());
let mut info = SnmpInfo::default();
while let Some(header) = lines.next() {
let values = lines
.next()
.ok_or_else(|| parse_error(path, "missing value line"))?;
let (protocol, header_fields) = parse::split_at_byte(header, b':');
let (value_protocol, value_fields) = parse::split_at_byte(values, b':');
if parse::trim(protocol) != parse::trim(value_protocol) {
return Err(parse_error(path, "section names do not match"));
}
let headers = parse::SplitFields::<32>::new(header_fields);
let values = parse::SplitFields::<32>::new(value_fields);
if headers.len() != values.len() {
return Err(parse_error(path, "header and value counts differ"));
}
match parse::trim(protocol) {
b"Ip" => parse_ip(&mut info.ip, &headers, &values)?,
b"Icmp" => parse_icmp(&mut info.icmp, &headers, &values)?,
b"Tcp" => parse_tcp(&mut info.tcp, &headers, &values)?,
b"Udp" => parse_udp(&mut info.udp, &headers, &values)?,
_ => {}
}
}
Ok(info)
}
fn parse_error(path: &Path, msg: &'static str) -> Error {
Error::Parse {
path: PathBuf::from(path),
line: 0,
msg,
}
}
fn find_field(headers: &parse::SplitFields<'_, 32>, name: &[u8]) -> Option<usize> {
headers.iter().position(|header| *header == name)
}
fn value(
headers: &parse::SplitFields<'_, 32>,
values: &parse::SplitFields<'_, 32>,
name: &[u8],
) -> Result<Option<u64>> {
let Some(index) = find_field(headers, name) else {
return Ok(None);
};
parse::parse_dec_u64(values[index])
.map(Some)
.map_err(|_| parse_error(Path::new("/proc/net/snmp"), "invalid counter"))
}
fn signed_value(
headers: &parse::SplitFields<'_, 32>,
values: &parse::SplitFields<'_, 32>,
name: &[u8],
) -> Result<Option<i64>> {
let Some(index) = find_field(headers, name) else {
return Ok(None);
};
std::str::from_utf8(values[index])
.ok()
.and_then(|value| value.parse().ok())
.map(Some)
.ok_or_else(|| parse_error(Path::new("/proc/net/snmp"), "invalid signed counter"))
}
macro_rules! parse_fields {
($target:expr, $headers:expr, $values:expr, { $($field:ident => $name:literal),+ $(,)? }) => {
$(
if let Some(value) = value($headers, $values, $name.as_bytes())? {
$target.$field = value;
}
)+
};
}
fn parse_ip(
target: &mut IpStats,
headers: &parse::SplitFields<'_, 32>,
values: &parse::SplitFields<'_, 32>,
) -> Result<()> {
parse_fields!(target, headers, values, {
forwarding => "Forwarding", default_ttl => "DefaultTTL", in_receives => "InReceives",
in_hdr_errors => "InHdrErrors", in_addr_errors => "InAddrErrors",
forw_datagrams => "ForwDatagrams", in_unknown_protos => "InUnknownProtos",
in_discards => "InDiscards", in_delivers => "InDelivers", out_requests => "OutRequests",
out_discards => "OutDiscards", out_no_routes => "OutNoRoutes", reasm_timeout => "ReasmTimeout",
reasm_reqds => "ReasmReqds", reasm_oks => "ReasmOKs", reasm_fails => "ReasmFails",
frag_oks => "FragOKs", frag_fails => "FragFails", frag_creates => "FragCreates",
out_transmits => "OutTransmits"
});
Ok(())
}
fn parse_icmp(
target: &mut IcmpStats,
headers: &parse::SplitFields<'_, 32>,
values: &parse::SplitFields<'_, 32>,
) -> Result<()> {
parse_fields!(target, headers, values, {
in_msgs => "InMsgs", in_errors => "InErrors", in_csum_errors => "InCsumErrors",
in_dest_unreachs => "InDestUnreachs", in_time_excds => "InTimeExcds",
in_parm_probs => "InParmProbs", in_src_quenchs => "InSrcQuenchs",
in_redirects => "InRedirects", in_echos => "InEchos", in_echo_reps => "InEchoReps",
in_timestamps => "InTimestamps", in_timestamp_reps => "InTimestampReps",
in_addr_masks => "InAddrMasks", in_addr_mask_reps => "InAddrMaskReps",
out_msgs => "OutMsgs", out_errors => "OutErrors",
out_rate_limit_global => "OutRateLimitGlobal", out_rate_limit_host => "OutRateLimitHost",
out_dest_unreachs => "OutDestUnreachs", out_time_excds => "OutTimeExcds",
out_parm_probs => "OutParmProbs", out_src_quenchs => "OutSrcQuenchs",
out_redirects => "OutRedirects", out_echos => "OutEchos", out_echo_reps => "OutEchoReps",
out_timestamps => "OutTimestamps", out_timestamp_reps => "OutTimestampReps",
out_addr_masks => "OutAddrMasks", out_addr_mask_reps => "OutAddrMaskReps"
});
Ok(())
}
fn parse_tcp(
target: &mut TcpStats,
headers: &parse::SplitFields<'_, 32>,
values: &parse::SplitFields<'_, 32>,
) -> Result<()> {
parse_fields!(target, headers, values, {
rto_algorithm => "RtoAlgorithm", rto_min => "RtoMin", rto_max => "RtoMax",
active_opens => "ActiveOpens", passive_opens => "PassiveOpens",
attempt_fails => "AttemptFails", estab_resets => "EstabResets", curr_estab => "CurrEstab",
in_segs => "InSegs", out_segs => "OutSegs", retrans_segs => "RetransSegs",
in_errs => "InErrs", out_rsts => "OutRsts", in_csum_errors => "InCsumErrors"
});
if let Some(value) = signed_value(headers, values, b"MaxConn")? {
target.max_conn = value;
}
Ok(())
}
fn parse_udp(
target: &mut UdpStats,
headers: &parse::SplitFields<'_, 32>,
values: &parse::SplitFields<'_, 32>,
) -> Result<()> {
parse_fields!(target, headers, values, {
in_datagrams => "InDatagrams", no_ports => "NoPorts", in_errors => "InErrors",
out_datagrams => "OutDatagrams", rcvbuf_errors => "RcvbufErrors",
sndbuf_errors => "SndbufErrors", in_csum_errors => "InCsumErrors",
ignored_multi => "IgnoredMulti", mem_errors => "MemErrors"
});
Ok(())
}