use std::net::{SocketAddrV4, SocketAddrV6};
use crate::error::{Error, Result};
use crate::util::parse;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TcpState {
Established,
SynSent,
SynRecv,
FinWait1,
FinWait2,
TimeWait,
Close,
CloseWait,
LastAck,
Listen,
Closing,
NewSynRecv,
}
impl TcpState {
fn from_hex(code: u32) -> Self {
match code {
0x01 => TcpState::Established,
0x02 => TcpState::SynSent,
0x03 => TcpState::SynRecv,
0x04 => TcpState::FinWait1,
0x05 => TcpState::FinWait2,
0x06 => TcpState::TimeWait,
0x07 => TcpState::Close,
0x08 => TcpState::CloseWait,
0x09 => TcpState::LastAck,
0x0A => TcpState::Listen,
0x0B => TcpState::Closing,
0x0C => TcpState::NewSynRecv,
_ => TcpState::Close,
}
}
}
#[derive(Debug)]
pub struct TcpEntry {
pub local: SocketAddrV4,
pub remote: SocketAddrV4,
pub state: TcpState,
pub inode: u64,
pub uid: u32,
pub rx_queue: u32,
pub tx_queue: u32,
}
#[derive(Debug)]
pub struct Tcp6Entry {
pub local: SocketAddrV6,
pub remote: SocketAddrV6,
pub state: TcpState,
pub inode: u64,
pub uid: u32,
pub rx_queue: u32,
pub tx_queue: u32,
}
fn parse_ipv4(s: &[u8]) -> Result<SocketAddrV4> {
let colon = parse::memchr(b':', s).ok_or_else(|| Error::Parse {
path: std::path::PathBuf::from("<tcp>"),
line: 0,
msg: "missing colon in address",
})?;
let addr_hex = &s[..colon];
let port_hex = &s[colon + 1..];
if addr_hex.len() != 8 {
return Err(Error::Parse {
path: std::path::PathBuf::from("<tcp>"),
line: 0,
msg: "invalid IPv4 hex length",
});
}
let bytes = parse::decode_ipv4_fast(addr_hex);
let port = parse::parse_hex_fast(port_hex) as u16;
Ok(SocketAddrV4::new(std::net::Ipv4Addr::from(bytes), port))
}
fn parse_ipv6(s: &[u8]) -> Result<SocketAddrV6> {
let colon = parse::memchr(b':', s).ok_or_else(|| Error::Parse {
path: std::path::PathBuf::from("<tcp6>"),
line: 0,
msg: "missing colon in address",
})?;
let addr_hex = &s[..colon];
let port_hex = &s[colon + 1..];
if addr_hex.len() != 32 {
return Err(Error::Parse {
path: std::path::PathBuf::from("<tcp6>"),
line: 0,
msg: "invalid IPv6 hex length",
});
}
let bytes = parse::decode_ipv6_fast(addr_hex);
let port = parse::parse_hex_fast(port_hex) as u16;
Ok(SocketAddrV6::new(
std::net::Ipv6Addr::from(bytes),
port,
0,
0,
))
}
fn parse_tcp_file(path: &str, is_v6: bool) -> impl Iterator<Item = Result<TcpEntry>> {
let bytes = match parse::read_file(std::path::Path::new(path)) {
Ok(b) => b,
Err(e) => return vec![Err(e)].into_iter(),
};
let mut entries = Vec::with_capacity(parse::count_byte(b'\n', &bytes));
for line in bytes
.split(|&b| b == b'\n')
.filter(|l| !l.is_empty())
.skip(1)
{
let fields = parse::SplitFields::<12>::new(line);
if fields.len() < 12 {
entries.push(Err(Error::Parse {
path: std::path::PathBuf::from(path),
line: 0,
msg: "not enough fields",
}));
continue;
}
let local = if is_v6 {
match parse_ipv6(fields[1]) {
Ok(v6) => {
if let Some(v4) = v6.ip().to_ipv4_mapped() {
SocketAddrV4::new(v4, v6.port())
} else {
entries.push(Err(Error::Parse {
path: std::path::PathBuf::from(path),
line: 0,
msg: "cannot map IPv6 to IPv4",
}));
continue;
}
}
Err(e) => {
entries.push(Err(e));
continue;
}
}
} else {
match parse_ipv4(fields[1]) {
Ok(addr) => addr,
Err(e) => {
entries.push(Err(e));
continue;
}
}
};
let remote = if is_v6 {
match parse_ipv6(fields[2]) {
Ok(v6) => {
if let Some(v4) = v6.ip().to_ipv4_mapped() {
SocketAddrV4::new(v4, v6.port())
} else {
entries.push(Err(Error::Parse {
path: std::path::PathBuf::from(path),
line: 0,
msg: "cannot map IPv6 to IPv4",
}));
continue;
}
}
Err(e) => {
entries.push(Err(e));
continue;
}
}
} else {
match parse_ipv4(fields[2]) {
Ok(addr) => addr,
Err(e) => {
entries.push(Err(e));
continue;
}
}
};
let state_code = parse::parse_hex_fast(fields[3]) as u32;
let state = TcpState::from_hex(state_code);
let (tx_queue_raw, rx_queue_raw) = parse::split_at_byte(fields[4], b':');
let tx_queue = parse::parse_hex_fast(tx_queue_raw) as u32;
let rx_queue = parse::parse_hex_fast(rx_queue_raw) as u32;
let uid = parse::parse_dec_fast(fields[7]) as u32;
let inode = parse::parse_dec_fast(fields[9]);
entries.push(Ok(TcpEntry {
local,
remote,
state,
inode,
uid,
rx_queue,
tx_queue,
}));
}
entries.into_iter()
}
pub fn tcp() -> impl Iterator<Item = Result<TcpEntry>> {
parse_tcp_file("/proc/net/tcp", false)
}
pub fn tcp6() -> impl Iterator<Item = Result<TcpEntry>> {
parse_tcp_file("/proc/net/tcp6", true)
}
pub fn parse_tcp6_entries() -> impl Iterator<Item = Result<Tcp6Entry>> {
let path = "/proc/net/tcp6";
let bytes = match parse::read_file(std::path::Path::new(path)) {
Ok(b) => b,
Err(e) => return vec![Err(e)].into_iter(),
};
let mut entries = Vec::with_capacity(parse::count_byte(b'\n', &bytes));
for line in bytes
.split(|&b| b == b'\n')
.filter(|l| !l.is_empty())
.skip(1)
{
let fields = parse::SplitFields::<12>::new(line);
if fields.len() < 12 {
entries.push(Err(Error::Parse {
path: std::path::PathBuf::from(path),
line: 0,
msg: "not enough fields",
}));
continue;
}
let local = match parse_ipv6(fields[1]) {
Ok(addr) => addr,
Err(e) => {
entries.push(Err(e));
continue;
}
};
let remote = match parse_ipv6(fields[2]) {
Ok(addr) => addr,
Err(e) => {
entries.push(Err(e));
continue;
}
};
let state_code = parse::parse_hex_fast(fields[3]) as u32;
let state = TcpState::from_hex(state_code);
let (tx_queue_raw, rx_queue_raw) = parse::split_at_byte(fields[4], b':');
let tx_queue = parse::parse_hex_fast(tx_queue_raw) as u32;
let rx_queue = parse::parse_hex_fast(rx_queue_raw) as u32;
let uid = parse::parse_dec_fast(fields[7]) as u32;
let inode = parse::parse_dec_fast(fields[9]);
entries.push(Ok(Tcp6Entry {
local,
remote,
state,
inode,
uid,
rx_queue,
tx_queue,
}));
}
entries.into_iter()
}