From 6d0f5d71ae57e0cb5c9a62a1ca0047aba6f719e6 Mon Sep 17 00:00:00 2001 From: mux Date: Tue, 19 Aug 2025 16:47:20 +0200 Subject: [PATCH] removed useless code --- src/main.rs | 58 +++++---------------- src/socket.rs | 136 ++++++++++++++++++-------------------------------- 2 files changed, 62 insertions(+), 132 deletions(-) diff --git a/src/main.rs b/src/main.rs index 8ad1e87..fb12e6f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -52,7 +52,7 @@ fn get_tcp_file_by_pid(pid: Pid) -> String { } fn parse_tcp_file_line(line : String) -> Tcp_Socket { - Tcp_Socket::new(Peer::build_from_hex(&get_index(&line.clone(),1)), Peer::build_from_hex(&get_index(&line.clone(),2)), HashSet::::new(), Tcp_SocketState::new(Peer::convert_port_hex_dec(&get_index(&line.clone(), 3))), Id::create_def(), Id::create_def(), get_index(&line, 9).parse().unwrap()) + Tcp_Socket::new(Peer::build_from_hex(&get_index(&line.clone(),1)), Peer::build_from_hex(&get_index(&line.clone(),2)), HashSet::::new(), Tcp_SocketState::new(Peer::convert_port_hex_dec(&get_index(&line.clone(), 3))), get_index(&line, 9).parse().unwrap(), String::from("nix")) } fn get_readable_proc_pids(pid_pattern : &Regex) -> Vec { @@ -73,20 +73,6 @@ fn get_readable_proc_pids(pid_pattern : &Regex) -> Vec { pids } -//noinspection ALL -fn get_uid_guid_by_pid(pid : Pid) -> (Id, Id) { - let mut status_path = String::from("/proc/"); - status_path.push_str(&pid.to_string()); - status_path.push_str("/status"); - let status_file = fs::read_to_string(status_path).unwrap(); - let mut iter = status_file.lines(); - let uid_str = iter.find(|x| x.starts_with("Uid:")).unwrap().to_owned(); - let gid_str = iter.find(|x| x.starts_with("Gid:")).unwrap().to_owned(); - (Id::new(get_index(&uid_str.clone(), 1).parse().unwrap(), get_index(&uid_str.clone(), 2).parse().unwrap(),get_index(&uid_str.clone(), 3).parse().unwrap(), get_index(&uid_str, 4).parse().unwrap()), - Id::new(get_index(&gid_str.clone(), 1).parse().unwrap(), get_index(&gid_str.clone(), 2).parse().unwrap(),get_index(&gid_str.clone(), 3).parse().unwrap(), get_index(&gid_str, 4).parse().unwrap())) - -} - fn add_pid_to_tcp_sockets(sockets : &mut Vec, inodes : HashSet, pid : Pid) -> (){ let s2 = sockets.clone(); for (i, v) in s2.iter().enumerate(){ @@ -102,22 +88,16 @@ pub fn format_output(combination : Combination, sockets : &Vec) -> S let header_rem_ip = "Remote Address"; let header_state = "State"; let header_rem_port = header_loc_port; - let header_uid_real = "real-uid"; - let header_uid_eff = "effective-uid"; - let header_gid_real = "real-gid"; - let header_gid_eff = "effective-gid"; let header_pids = "PIDs"; + let header_inode = "inode"; let mut ret_str = String::from(""); let mut max_loc_ip_len = header_loc_ip.len(); let mut max_loc_port_len = header_loc_port.len(); let mut max_rem_ip_len = header_rem_ip.len(); let mut max_rem_port_len = max_loc_port_len; let mut max_state_len = header_state.len(); - let mut max_real_uid_len = header_uid_real.len(); - let mut max_eff_uid_len = header_uid_eff.len(); - let mut max_real_gid_len = header_gid_real.len(); - let mut max_eff_gid_len = header_gid_eff.len(); let mut max_pids_len = header_pids.len(); + let mut max_inode_len = header_inode.len(); sockets.clone().iter().for_each(|x| { let curr_loc_ip_len = x.get_loc_ip_string().len(); @@ -125,34 +105,25 @@ pub fn format_output(combination : Combination, sockets : &Vec) -> S let curr_rem_ip_len = x.get_rem_ip_string().len(); let curr_rem_port_len = x.get_rem_port_string().len(); let curr_state_len = x.get_state().to_string().len(); - let (curr_real_uid,curr_eff_uid) = x.get_real_eff_uid_string(); - let curr_real_uid_len = curr_real_uid.len(); - let curr_eff_uid_len = curr_eff_uid.len(); - let (curr_real_gid, curr_eff_gid) = x.get_real_eff_gid_String(); - let curr_real_gid_len = curr_real_gid.len(); - let curr_eff_gid_len = curr_eff_gid.len(); let curr_pids_len = pids_to_string(&x.pids).len(); + let curr_inode_len = x.inode.to_string().len(); max_loc_ip_len = if curr_loc_ip_len > max_loc_ip_len { curr_loc_ip_len } else { max_loc_ip_len }; max_loc_port_len = if curr_loc_port_len > max_loc_port_len { curr_loc_port_len } else { max_loc_port_len }; max_rem_ip_len = if curr_rem_ip_len > max_rem_ip_len { curr_rem_ip_len } else { max_rem_ip_len }; max_rem_port_len = if curr_rem_port_len > max_rem_port_len { curr_rem_port_len } else { max_rem_port_len }; max_state_len = if curr_state_len > max_state_len { curr_state_len } else { max_state_len }; + max_inode_len = if curr_inode_len > max_inode_len { curr_inode_len } else { max_inode_len }; + max_pids_len = if curr_pids_len > max_pids_len { curr_pids_len } else { max_pids_len }; if combination == Combination::tnap{ - max_real_uid_len = if curr_real_uid_len > max_real_uid_len { curr_real_uid_len } else { max_real_uid_len }; - max_eff_uid_len = if curr_eff_uid_len > max_eff_uid_len { curr_eff_uid_len } else { max_eff_uid_len }; - max_real_gid_len = if curr_real_gid_len > max_real_gid_len { curr_real_gid_len } else { max_real_gid_len }; - max_eff_gid_len = if curr_eff_gid_len > max_eff_gid_len { curr_eff_gid_len } else { max_eff_gid_len }; - max_pids_len = if curr_pids_len > max_pids_len { curr_pids_len } else { max_pids_len }; + } }); max_loc_ip_len = max_loc_ip_len + 3; max_rem_ip_len = max_rem_ip_len + 3; - max_real_uid_len = max_real_uid_len + 3; - max_real_gid_len = max_real_gid_len + 3; - max_pids_len = max_pids_len + 3; + max_pids_len = max_pids_len + 5; match combination { Combination::tna => { @@ -163,11 +134,9 @@ pub fn format_output(combination : Combination, sockets : &Vec) -> S }); } Combination::tnap => { - ret_str.push_str(&format!("{:>max_state_len$} {:>max_loc_ip_len$}:{:max_rem_ip_len$}:{:max_real_uid_len$}|{:max_real_gid_len$}|{:max_pids_len$}\n", header_state , header_loc_ip , header_loc_port, header_rem_ip,header_rem_port, header_uid_real, header_uid_eff, header_gid_real, header_gid_eff, header_pids )); + ret_str.push_str(&format!("{:max_loc_ip_len$}:{:max_rem_ip_len$}:{:max_pids_len$}|{:max_state_len$} {:>max_loc_ip_len$}:{:max_rem_ip_len$}:{:max_real_uid_len$}|{:max_real_gid_len$}|{:max_pids_len$}\n", x.get_state().to_string(), x.get_loc_ip_string(), x.get_loc_port_string(), x.get_rem_ip_string(), x.get_rem_port_string(), real_uid, eff_uid , real_gid , eff_gid, pids_to_string(&x.pids))) + ret_str.push_str(&format!("{:max_loc_ip_len$}:{:max_rem_ip_len$}:{:max_pids_len$}|{: Vec String { } fn main() { - let socket_patt : Regex = Regex::new(r"socket:\[([0-9]+)]").expect("kannst kein regex?? xd"); + let socket_pattern : Regex = Regex::new(r"socket:\[([0-9]+)]").expect("kannst kein regex?? xd"); let pid_pattern = Regex::new(r"^[1-4]?[0-9]{1,6}$").expect("kannst kein regex??"); - let sockets = get_all_tcp_sockets(&pid_pattern, &socket_patt); + let sockets = get_all_tcp_sockets(&pid_pattern, &socket_pattern); println!("{}", format_output(Combination::tnap, &sockets)); } + diff --git a/src/socket.rs b/src/socket.rs index e801563..b087e2f 100644 --- a/src/socket.rs +++ b/src/socket.rs @@ -10,27 +10,7 @@ pub mod socket { pub ip_address: String, pub port: usize, } - #[derive(PartialEq, Copy, Clone, Debug)] - pub struct Id { - pub real: usize, - pub effective: usize, - pub saved_set: usize, - pub fs: usize, - } - impl Id { - pub fn new(real: usize, effective: usize, saved_set: usize, fs: usize) -> Id { - Id { - real, - effective, - saved_set, - fs, - } - } - pub fn create_def() -> Id { - Id::new(0, 0, 0, 0) - } - } impl Peer { fn new() -> Peer { @@ -91,7 +71,7 @@ pub mod socket { } } - #[derive(PartialEq, Clone, Debug)] + #[derive(PartialEq, Clone, Debug, Copy)] pub enum Tcp_SocketState { Established, SYN_Sent, @@ -175,8 +155,7 @@ pub mod socket { impl Hash for Tcp_Socket { fn hash(&self, state: &mut H) -> () { - let mut state = self.inode * 31; - state = state + 11; + self.inode.hash(state); } } @@ -186,9 +165,8 @@ pub mod socket { peer_rem: Peer, pub pids: HashSet, state: Tcp_SocketState, - user: Id, - group: Id, pub inode: u64, + cmdline : String, } #[derive(Clone, Copy, PartialEq)] @@ -203,18 +181,16 @@ pub mod socket { peer_rem: Peer, pids: HashSet, state: Tcp_SocketState, - user: Id, - group: Id, inode: u64, + cmdline : String, ) -> Tcp_Socket { Tcp_Socket { peer_loc, peer_rem, pids, state, - user, - group, inode, + cmdline, } } @@ -231,11 +207,6 @@ pub mod socket { socket.pids.insert(pid); } - pub fn add_uid_gid(socket: &mut Tcp_Socket, uid: Id, gid: Id) -> () { - socket.user = uid; - socket.group = gid; - } - pub fn check_inode_seen(seen_inodes: &HashSet, pid: u64) -> bool { let inode = Tcp_Socket::get_tcp_file_inode(pid); seen_inodes.contains(&inode) @@ -262,61 +233,52 @@ pub mod socket { self.peer_rem.get_port_string() } - pub fn get_real_eff_uid_string(&self) -> (String, String) { - (self.user.real.to_string(), self.user.effective.to_string()) - } - - pub fn get_real_eff_gid_String(&self) -> (String, String) { - (self.group.real.to_string(), self.group.effective.to_string()) - } - - - pub fn to_string(&self, combination: Combination) -> String { - let mut ret_str = String::from(""); - match combination { - Combination::tnap => { - //state rem_ip:rem_port loc_ip:loc_port real|effective-uid real|effective-gid pids(.,.,.,.) - ret_str.push_str(&self.clone().to_string(Combination::tna)); - ret_str.push(' '); - ret_str.push_str(&self.user.real.to_string()); - ret_str.push('|'); - ret_str.push_str(&self.user.effective.to_string()); - ret_str.push(' '); - ret_str.push_str(&self.group.real.to_string()); - ret_str.push('|'); - ret_str.push_str(&self.group.effective.to_string()); - ret_str.push_str(&pids_to_string(&self.clone().pids)); - ret_str - } - Combination::tna => { - //state rem_ip:rem_port loc_ip:loc_port - ret_str.push_str(&self.state.to_string()); - ret_str.push(' '); - ret_str.push_str(&self.peer_loc.ip_address); - ret_str.push(':'); - let loc_port_str = self.peer_loc.port.clone().to_string(); - ret_str.push_str(if self.peer_loc.port == 0 { - "*" - } else { - &loc_port_str - }); - ret_str.push(' '); - ret_str.push_str(&self.peer_rem.ip_address); - ret_str.push(':'); - let rem_port_str = self.peer_rem.port.clone().to_string(); - ret_str.push_str(if self.peer_rem.port == 0 { - "*" - } else { - &rem_port_str - }); - ret_str.push('\n'); - ret_str - } - } - } + // pub fn to_string(&self, combination: Combination) -> String { + // let mut ret_str = String::from(""); + // match combination { + // Combination::tnap => { + // //state rem_ip:rem_port loc_ip:loc_port real|effective-uid real|effective-gid pids(.,.,.,.) + // ret_str.push_str(&self.clone().to_string(Combination::tna)); + // ret_str.push(' '); + // ret_str.push_str(&self.user.real.to_string()); + // ret_str.push('|'); + // ret_str.push_str(&self.user.effective.to_string()); + // ret_str.push(' '); + // ret_str.push_str(&self.group.real.to_string()); + // ret_str.push('|'); + // ret_str.push_str(&self.group.effective.to_string()); + // ret_str.push_str(&pids_to_string(&self.clone().pids)); + // ret_str + // } + // Combination::tna => { + // //state rem_ip:rem_port loc_ip:loc_port + // ret_str.push_str(&self.state.to_string()); + // ret_str.push(' '); + // ret_str.push_str(&self.peer_loc.ip_address); + // ret_str.push(':'); + // let loc_port_str = self.peer_loc.port.clone().to_string(); + // ret_str.push_str(if self.peer_loc.port == 0 { + // "*" + // } else { + // &loc_port_str + // }); + // ret_str.push(' '); + // ret_str.push_str(&self.peer_rem.ip_address); + // ret_str.push(':'); + // let rem_port_str = self.peer_rem.port.clone().to_string(); + // ret_str.push_str(if self.peer_rem.port == 0 { + // "*" + // } else { + // &rem_port_str + // }); + // ret_str.push('\n'); + // ret_str + // } + // } + // } pub fn get_state(&self) -> Tcp_SocketState { - self.state.clone() + self.state } } }