#![allow(dead_code)]
#[cfg(target_os = "macos")]
use std::collections::HashMap;
use std::ffi::{c_int, c_void};
#[cfg(target_os = "macos")]
use crate::collect::nettop::flow_inode;
const PROC_PIDLISTFDS: c_int = 1;
const PROC_PIDFDSOCKETINFO: c_int = 3;
const PROX_FDTYPE_SOCKET: u32 = 2;
const KERN_PROC_MIB: c_int = 14;
const KERN_PROC_ALL: c_int = 0;
const SOI_FAMILY: usize = 184; const SOI_PROTOCOL: usize = 180; const INSI_FPORT: usize = 264; const INSI_LPORT: usize = 268;
const INSI_FADDR: usize = 264 + 32;
const INSI_LADDR: usize = 264 + 48;
const SOCKET_INFO_LEN: usize = 792; const AF_INET_DARWIN: libc::c_int = 2;
const AF_INET6_DARWIN: libc::c_int = 30;
pub struct MacPid {
pub pid: u32,
pub comm: String,
pub start_epoch: i64,
}
extern "C" {
fn proc_listallpids(buffer: *mut c_void, buffersize: c_int) -> c_int;
fn proc_pidinfo(
pid: c_int,
flavor: c_int,
arg: u64,
buffer: *mut c_void,
buffersize: c_int,
) -> c_int;
#[cfg(target_os = "macos")]
fn proc_pidfdinfo(
pid: c_int,
fd: c_int,
flavor: c_int,
buffer: *mut c_void,
buffersize: c_int,
) -> c_int;
fn proc_pidpath(pid: c_int, buffer: *mut c_void, buffersize: u32) -> c_int;
#[cfg(target_os = "macos")]
fn proc_pid_rusage(pid: c_int, flavor: c_int, buffer: *mut c_void) -> c_int;
}
pub fn list_pids() -> Vec<MacPid> {
let mut out = Vec::new();
for (pid, comm, start) in kern_proc_all() {
out.push(MacPid {
pid,
comm,
start_epoch: start,
});
}
out
}
fn kern_proc_all() -> Vec<(u32, String, i64)> {
let mut mib = [libc::CTL_KERN, KERN_PROC_MIB, KERN_PROC_ALL];
let mut size: usize = 0;
unsafe {
if libc::sysctl(
mib.as_mut_ptr(),
3,
std::ptr::null_mut(),
&mut size,
std::ptr::null_mut(),
0,
) != 0
{
return Vec::new();
}
}
let mut buf = vec![0u8; size];
let mut len = size;
unsafe {
if libc::sysctl(
mib.as_mut_ptr(),
3,
buf.as_mut_ptr() as *mut c_void,
&mut len,
std::ptr::null_mut(),
0,
) != 0
{
return Vec::new();
}
}
let ent = KINFO_PROC_SIZE;
let count = len / ent;
let mut out = Vec::with_capacity(count);
for i in 0..count {
let base = i * ent;
let tv_sec = i64_at(&buf, base + P_STARTTIME);
let comm = c_str(&buf[base + P_COMM..base + P_COMM + 16]);
out.push((u32_at(&buf, base + P_PID), comm, tv_sec));
}
out
}
mod kp {
pub const P_PID: usize = 40; pub const P_STARTTIME: usize = 0; pub const P_COMM: usize = 243; }
use kp::{P_COMM, P_PID, P_STARTTIME};
const KINFO_PROC_SIZE: usize = 648;
#[cfg(target_os = "macos")]
pub fn disk_io(pid: u32) -> Option<(u64, u64)> {
let mut buf = [0u8; 152];
let rc = unsafe { proc_pid_rusage(pid as c_int, 2, buf.as_mut_ptr() as *mut c_void) };
if rc != 0 {
return None;
}
Some((u64_at(&buf, 136), u64_at(&buf, 144)))
}
pub fn cmdline(pid: u32) -> Option<Vec<String>> {
let mut buf = [0u8; 1024 + 1];
let rc = unsafe { proc_pidpath(pid as c_int, buf.as_mut_ptr() as *mut c_void, 1024) };
if rc <= 0 {
return None;
}
let s = c_str(&buf[..rc.min(1024) as usize]);
if s.is_empty() {
None
} else {
Some(vec![s])
}
}
#[cfg(target_os = "macos")]
pub fn socket_map() -> HashMap<u64, (u32, String)> {
let mut out = HashMap::new();
let pid_count = unsafe { proc_listallpids(std::ptr::null_mut(), 0) };
if pid_count <= 0 {
return out;
}
let mut pids = vec![0i32; pid_count as usize];
let n = unsafe {
proc_listallpids(
pids.as_mut_ptr() as *mut c_void,
(pids.len() * std::mem::size_of::<i32>()) as c_int,
)
};
if n <= 0 {
return out;
}
for &pid in &pids[..n as usize] {
let Some(fds) = socket_fds(pid as u32) else {
continue;
};
if fds.is_empty() {
continue;
}
let mut buf = [0u8; SOCKET_INFO_LEN];
let mut comm: Option<String> = None;
for fd in fds {
#[cfg(target_os = "macos")]
let len = unsafe {
proc_pidfdinfo(
pid as c_int,
fd,
PROC_PIDFDSOCKETINFO,
buf.as_mut_ptr() as *mut c_void,
SOCKET_INFO_LEN as c_int,
)
};
#[cfg(not(target_os = "macos"))]
let len: c_int = 0;
if len <= 0 {
continue;
}
if comm.is_none() {
comm = cmdline(pid as u32)
.and_then(|v| v.into_iter().next())
.map(|p| {
std::path::Path::new(&p)
.file_name()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or(p)
});
}
if let Some((proto, local, remote)) = socket_tuple(&buf) {
let ino = flow_inode(proto, &local, &remote);
out.entry(ino).or_insert_with(|| {
(
pid as u32,
comm.clone().unwrap_or_else(|| "?".into()),
)
});
}
}
}
out
}
#[cfg(target_os = "macos")]
fn socket_fds(pid: u32) -> Option<Vec<i32>> {
let n = unsafe { proc_pidinfo(pid as c_int, PROC_PIDLISTFDS, 0, std::ptr::null_mut(), 0) };
if n <= 0 {
return None;
}
let mut buf = vec![0u8; n as usize * 8];
let got = unsafe {
proc_pidinfo(
pid as c_int,
PROC_PIDLISTFDS,
0,
buf.as_mut_ptr() as *mut c_void,
buf.len() as c_int,
)
};
if got <= 0 {
return None;
}
let mut out = Vec::new();
for i in 0..(got as usize / 8) {
let fd = i32_at(&buf, i * 8);
let fdtype = u32_at(&buf, i * 8 + 4);
if fdtype == PROX_FDTYPE_SOCKET {
out.push(fd);
}
}
Some(out)
}
pub type SockTuple = (u8, (std::net::IpAddr, u16), (std::net::IpAddr, u16));
pub fn socket_tuple(buf: &[u8]) -> Option<SockTuple> {
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
if buf.len() < SOCKET_INFO_LEN {
return None;
}
let family = buf[SOI_FAMILY] as libc::c_int;
let proto = u32_at(buf, SOI_PROTOCOL) as u8;
if proto != 6 && proto != 17 {
return None; }
let port_at = |off: usize| u16::from_be((u32_at(buf, off) & 0xffff) as u16);
let addr_at = |off: usize| -> IpAddr {
let mut o = [0u8; 16];
o.copy_from_slice(&buf[off..off + 16]);
if family == AF_INET6_DARWIN {
let v4 = |b: &[u8; 16]| Ipv4Addr::new(b[12], b[13], b[14], b[15]);
if (o[..10].iter().all(|&b| b == 0) && o[10] == 0xff && o[11] == 0xff)
|| (o[..12].iter().all(|&b| b == 0) && o[12..16].iter().any(|&b| b != 0))
{
IpAddr::V4(v4(&o))
} else {
IpAddr::V6(Ipv6Addr::from(o))
}
} else {
IpAddr::V4(Ipv4Addr::new(o[12], o[13], o[14], o[15]))
}
};
let local = (addr_at(INSI_LADDR), port_at(INSI_LPORT));
let remote = (addr_at(INSI_FADDR), port_at(INSI_FPORT));
Some((proto, local, remote))
}
fn i32_at(b: &[u8], off: usize) -> i32 {
i32::from_ne_bytes([b[off], b[off + 1], b[off + 2], b[off + 3]])
}
fn u32_at(b: &[u8], off: usize) -> u32 {
u32::from_ne_bytes([b[off], b[off + 1], b[off + 2], b[off + 3]])
}
fn u64_at(b: &[u8], off: usize) -> u64 {
u64::from_ne_bytes([
b[off],
b[off + 1],
b[off + 2],
b[off + 3],
b[off + 4],
b[off + 5],
b[off + 6],
b[off + 7],
])
}
fn i64_at(b: &[u8], off: usize) -> i64 {
i64_at_bytes(b, off)
}
fn i64_at_bytes(b: &[u8], off: usize) -> i64 {
let mut v = [0u8; 8];
v.copy_from_slice(&b[off..off + 8]);
i64::from_ne_bytes(v)
}
fn c_str(b: &[u8]) -> String {
let end = b.iter().position(|&c| c == 0).unwrap_or(b.len());
String::from_utf8_lossy(&b[..end]).into_owned()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::collect::nettop::flow_inode;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
fn sample_socket_info(v6: bool, lport: u16, fport: u16) -> Vec<u8> {
let mut b = vec![0u8; SOCKET_INFO_LEN];
b[SOI_FAMILY] = if v6 { 30 } else { 2 }; b[SOI_PROTOCOL..SOI_PROTOCOL + 4].copy_from_slice(&6u32.to_ne_bytes());
b[INSI_LPORT..INSI_LPORT + 2].copy_from_slice(&lport.to_be_bytes());
b[INSI_FPORT..INSI_FPORT + 2].copy_from_slice(&fport.to_be_bytes());
if v6 {
b[INSI_LADDR..INSI_LADDR + 16]
.copy_from_slice(&"2001:db8::1".parse::<Ipv6Addr>().unwrap().octets());
b[INSI_FADDR..INSI_FADDR + 16]
.copy_from_slice(&Ipv6Addr::new(0xfe80, 0, 0, 0, 1, 2, 3, 4).octets());
} else {
b[INSI_LADDR + 12..INSI_LADDR + 16].copy_from_slice(&[127, 0, 0, 1]);
b[INSI_FADDR + 12..INSI_FADDR + 16].copy_from_slice(&[10, 1, 2, 3]);
}
b
}
#[test]
fn projects_tcp_v4_tuple() {
let b = sample_socket_info(false, 22, 51000);
let (proto, local, remote) = socket_tuple(&b).unwrap();
assert_eq!(proto, 6);
assert_eq!(local, (IpAddr::V4(Ipv4Addr::LOCALHOST), 22));
assert_eq!(remote, (IpAddr::V4("10.1.2.3".parse().unwrap()), 51000));
}
#[test]
fn projects_tcp_v6_tuple() {
let b = sample_socket_info(true, 443, 0);
let (proto, local, remote) = socket_tuple(&b).unwrap();
assert_eq!(proto, 6);
assert_eq!(local, (IpAddr::V6("2001:db8::1".parse().unwrap()), 443));
assert_eq!(
remote,
(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 1, 2, 3, 4)), 0)
);
}
#[test]
fn v4_mapped_addresses_normalize_to_v4_like_nettop() {
let mut b = sample_socket_info(true, 22000, 37142);
let octets = |ip: [u8; 4]| {
let mut o = [0u8; 16];
o[12..16].copy_from_slice(&ip);
o
};
b[INSI_LADDR..INSI_LADDR + 16].copy_from_slice(&octets([192, 168, 121, 111]));
let mut mapped = [0u8; 16];
mapped[10] = 0xff;
mapped[11] = 0xff;
mapped[12..16].copy_from_slice(&[192, 168, 121, 190]);
b[INSI_FADDR..INSI_FADDR + 16].copy_from_slice(&mapped);
let (proto, local, remote) = socket_tuple(&b).unwrap();
assert_eq!(
local,
(IpAddr::V4("192.168.121.111".parse().unwrap()), 22000)
);
assert_eq!(
remote,
(IpAddr::V4("192.168.121.190".parse().unwrap()), 37142)
);
assert_eq!(proto, 6);
let nl = crate::collect::nettop::parse_endpoint("192.168.121.111:22000", false).unwrap();
let nr = crate::collect::nettop::parse_endpoint("192.168.121.190:37142", false).unwrap();
assert_eq!(
crate::collect::nettop::flow_inode(6, &local, &remote),
crate::collect::nettop::flow_inode(6, &nl, &nr)
);
let mut b2 = sample_socket_info(true, 443, 0);
b2[INSI_FADDR..INSI_FADDR + 16]
.copy_from_slice(&"2001:db8::1".parse::<Ipv6Addr>().unwrap().octets());
let (_, _, remote2) = socket_tuple(&b2).unwrap();
assert_eq!(remote2.0, IpAddr::V6("2001:db8::1".parse().unwrap()));
}
#[test]
fn socket_tuple_keys_match_nettop_flow_inodes() {
let mut b = sample_socket_info(false, 22, 0);
b[INSI_LADDR..INSI_LADDR + 16].fill(0);
b[INSI_FADDR..INSI_FADDR + 16].fill(0);
let (proto, local, remote) = socket_tuple(&b).unwrap();
let nettop_local = parse_ep("*:22", false);
let nettop_remote = parse_ep("*:*", false);
assert_eq!(
flow_inode(proto, &local, &remote),
flow_inode(6, &nettop_local, &nettop_remote)
);
}
fn parse_ep(s: &str, v6: bool) -> (IpAddr, u16) {
crate::collect::nettop::parse_endpoint(s, v6).unwrap()
}
#[test]
#[cfg(target_os = "macos")]
#[ignore = "diagnostic"]
fn socket_map_debug_lists_own_sockets() {
use std::net::TcpListener;
let l = TcpListener::bind("127.0.0.1:0").unwrap();
let port = l.local_addr().unwrap().port();
let me = std::process::id() as c_int;
let fds = socket_fds(me as u32).expect("own fd list readable");
eprintln!("port={port} own socket fds: {fds:?}");
let mut buf = vec![0u8; SOCKET_INFO_LEN];
for fd in fds {
let rc = unsafe {
proc_pidfdinfo(
me,
fd,
PROC_PIDFDSOCKETINFO,
buf.as_mut_ptr() as *mut c_void,
SOCKET_INFO_LEN as c_int,
)
};
eprintln!("fd {fd} rc={rc} tuple={:?}", socket_tuple(&buf));
}
if let Some(m) = list_pids().into_iter().find(|m| m.comm.starts_with("syncthing")) {
let fds = socket_fds(m.pid).unwrap_or_default();
eprintln!("syncthing pid={} fds={:?} ({} 个)", m.pid, fds, fds.len());
for fd in fds {
let rc = unsafe {
proc_pidfdinfo(
m.pid as c_int,
fd,
PROC_PIDFDSOCKETINFO,
buf.as_mut_ptr() as *mut c_void,
SOCKET_INFO_LEN as c_int,
)
};
if let Some(t) = socket_tuple(&buf) {
eprintln!(
" fd {fd} rc={rc} tuple={t:?} ino={:016x}",
crate::collect::nettop::flow_inode(t.0, &t.1, &t.2)
);
} else {
eprintln!(" fd {fd} rc={rc} tuple=None");
}
}
} else {
eprintln!("syncthing 不在运行");
}
}
}