mux/dashboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed useless code

Browse Source
This commit is contained in:
mux 2025-08-19 16:47:20 +02:00
parent 3dc0dc0323
commit 6d0f5d71ae
2 changed files with 62 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
src/main.rs
View File

@ -52,7 +52,7 @@ fn get_tcp_file_by_pid(pid: Pid) -> String {
} }
fn parse_tcp_file_line(line : String) -> Tcp_Socket { 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::<u64>::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::<u64>::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<Pid> { fn get_readable_proc_pids(pid_pattern : &Regex) -> Vec<Pid> {
@ -73,20 +73,6 @@ fn get_readable_proc_pids(pid_pattern : &Regex) -> Vec<Pid> {
pids 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<Tcp_Socket>, inodes : HashSet<Inode>, pid : Pid) -> (){ fn add_pid_to_tcp_sockets(sockets : &mut Vec<Tcp_Socket>, inodes : HashSet<Inode>, pid : Pid) -> (){
let s2 = sockets.clone(); let s2 = sockets.clone();
for (i, v) in s2.iter().enumerate(){ for (i, v) in s2.iter().enumerate(){
@ -102,22 +88,16 @@ pub fn format_output(combination : Combination, sockets : &Vec<Tcp_Socket>) -> S
let header_rem_ip = "Remote Address"; let header_rem_ip = "Remote Address";
let header_state = "State"; let header_state = "State";
let header_rem_port = header_loc_port; 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_pids = "PIDs";
let header_inode = "inode";
let mut ret_str = String::from(""); let mut ret_str = String::from("");
let mut max_loc_ip_len = header_loc_ip.len(); let mut max_loc_ip_len = header_loc_ip.len();
let mut max_loc_port_len = header_loc_port.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_ip_len = header_rem_ip.len();
let mut max_rem_port_len = max_loc_port_len; let mut max_rem_port_len = max_loc_port_len;
let mut max_state_len = header_state.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_pids_len = header_pids.len();
let mut max_inode_len = header_inode.len();
sockets.clone().iter().for_each(|x| { sockets.clone().iter().for_each(|x| {
let curr_loc_ip_len = x.get_loc_ip_string().len(); let curr_loc_ip_len = x.get_loc_ip_string().len();
@ -125,34 +105,25 @@ pub fn format_output(combination : Combination, sockets : &Vec<Tcp_Socket>) -> S
let curr_rem_ip_len = x.get_rem_ip_string().len(); let curr_rem_ip_len = x.get_rem_ip_string().len();
let curr_rem_port_len = x.get_rem_port_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_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_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_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_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_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_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_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{ 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_loc_ip_len = max_loc_ip_len + 3;
max_rem_ip_len = max_rem_ip_len + 3; max_rem_ip_len = max_rem_ip_len + 3;
max_real_uid_len = max_real_uid_len + 3; max_pids_len = max_pids_len + 5;
max_real_gid_len = max_real_gid_len + 3;
max_pids_len = max_pids_len + 3;
match combination { match combination {
Combination::tna => { Combination::tna => {
@ -163,11 +134,9 @@ pub fn format_output(combination : Combination, sockets : &Vec<Tcp_Socket>) -> S
}); });
} }
Combination::tnap => { Combination::tnap => {
ret_str.push_str(&format!("{:>max_state_len$} {:>max_loc_ip_len$}:{:<max_loc_port_len$} {:>max_rem_ip_len$}:{:<max_rem_port_len$} {:>max_real_uid_len$}|{:<max_eff_uid_len$} {:>max_real_gid_len$}|{:<max_eff_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_state_len$} {:>max_loc_ip_len$}:{:<max_loc_port_len$} {:>max_rem_ip_len$}:{:<max_rem_port_len$} {:>max_pids_len$}|{:<max_inode_len$}\n", header_state , header_loc_ip , header_loc_port, header_rem_ip,header_rem_port, header_pids, header_inode ));
sockets.clone().iter().for_each(|x| { sockets.clone().iter().for_each(|x| {
let (real_uid, eff_uid) = x.get_real_eff_uid_string(); ret_str.push_str(&format!("{:<max_state_len$} {:>max_loc_ip_len$}:{:<max_loc_port_len$} {:>max_rem_ip_len$}:{:<max_rem_port_len$} {:>max_pids_len$}|{:<max_inode_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(), pids_to_string(&x.pids), x.inode.to_string()))
let (real_gid,eff_gid) = x.get_real_eff_gid_String();
ret_str.push_str(&format!("{:>max_state_len$} {:>max_loc_ip_len$}:{:<max_loc_port_len$} {:>max_rem_ip_len$}:{:<max_rem_port_len$} {:>max_real_uid_len$}|{:<max_eff_uid_len$} {:>max_real_gid_len$}|{:<max_eff_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)))
}); });
} }
} }
@ -183,12 +152,10 @@ fn get_all_tcp_sockets(pid_pattern : &Regex, socket_patt : &Regex) -> Vec<Tcp_So
add_to_tcp_sockets(&mut sockets, parse_tcp_file_line(y.to_owned())); add_to_tcp_sockets(&mut sockets, parse_tcp_file_line(y.to_owned()));
}); });
inodes = get_socket_inodes_by_pid(*x, socket_patt); inodes = get_socket_inodes_by_pid(*x, socket_patt);
let (uid, gid) = get_uid_guid_by_pid(*x);
for (i, v) in sockets.clone().iter().enumerate() { for (i, v) in sockets.clone().iter().enumerate() {
if inodes.contains(&v.inode){ if inodes.contains(&v.inode){
add_pid_to_tcp_sockets(&mut sockets, inodes.clone(), *x); add_pid_to_tcp_sockets(&mut sockets, inodes.clone(), *x);
} }
Tcp_Socket::add_uid_gid(sockets.get_mut(i).unwrap(),uid, gid);
} }
}); });
sockets sockets
@ -205,8 +172,9 @@ fn get_index(line: &String, index: usize) -> String {
} }
fn main() { 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 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)); println!("{}", format_output(Combination::tnap, &sockets));
} }

136
src/socket.rs
View File

@ -10,27 +10,7 @@ pub mod socket {
pub ip_address: String, pub ip_address: String,
pub port: usize, 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 { impl Peer {
fn new() -> Peer { fn new() -> Peer {
@ -91,7 +71,7 @@ pub mod socket {
} }
} }
#[derive(PartialEq, Clone, Debug)] #[derive(PartialEq, Clone, Debug, Copy)]
pub enum Tcp_SocketState { pub enum Tcp_SocketState {
Established, Established,
SYN_Sent, SYN_Sent,
@ -175,8 +155,7 @@ pub mod socket {
impl Hash for Tcp_Socket { impl Hash for Tcp_Socket {
fn hash<H: Hasher>(&self, state: &mut H) -> () { fn hash<H: Hasher>(&self, state: &mut H) -> () {
let mut state = self.inode * 31; self.inode.hash(state);
state = state + 11;
} }
} }
@ -186,9 +165,8 @@ pub mod socket {
peer_rem: Peer, peer_rem: Peer,
pub pids: HashSet<u64>, pub pids: HashSet<u64>,
state: Tcp_SocketState, state: Tcp_SocketState,
user: Id,
group: Id,
pub inode: u64, pub inode: u64,
cmdline : String,
} }
#[derive(Clone, Copy, PartialEq)] #[derive(Clone, Copy, PartialEq)]
@ -203,18 +181,16 @@ pub mod socket {
peer_rem: Peer, peer_rem: Peer,
pids: HashSet<u64>, pids: HashSet<u64>,
state: Tcp_SocketState, state: Tcp_SocketState,
user: Id,
group: Id,
inode: u64, inode: u64,
cmdline : String,
) -> Tcp_Socket { ) -> Tcp_Socket {
Tcp_Socket { Tcp_Socket {
peer_loc, peer_loc,
peer_rem, peer_rem,
pids, pids,
state, state,
user,
group,
inode, inode,
cmdline,
} }
} }
@ -231,11 +207,6 @@ pub mod socket {
socket.pids.insert(pid); 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<u64>, pid: u64) -> bool { pub fn check_inode_seen(seen_inodes: &HashSet<u64>, pid: u64) -> bool {
let inode = Tcp_Socket::get_tcp_file_inode(pid); let inode = Tcp_Socket::get_tcp_file_inode(pid);
seen_inodes.contains(&inode) seen_inodes.contains(&inode)
@ -262,61 +233,52 @@ pub mod socket {
self.peer_rem.get_port_string() self.peer_rem.get_port_string()
} }
pub fn get_real_eff_uid_string(&self) -> (String, String) { // pub fn to_string(&self, combination: Combination) -> String {
(self.user.real.to_string(), self.user.effective.to_string()) // let mut ret_str = String::from("");
} // match combination {
// Combination::tnap => {
pub fn get_real_eff_gid_String(&self) -> (String, String) { // //state rem_ip:rem_port loc_ip:loc_port real|effective-uid real|effective-gid pids(.,.,.,.)
(self.group.real.to_string(), self.group.effective.to_string()) // 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('|');
pub fn to_string(&self, combination: Combination) -> String { // ret_str.push_str(&self.user.effective.to_string());
let mut ret_str = String::from(""); // ret_str.push(' ');
match combination { // ret_str.push_str(&self.group.real.to_string());
Combination::tnap => { // ret_str.push('|');
//state rem_ip:rem_port loc_ip:loc_port real|effective-uid real|effective-gid pids(.,.,.,.) // ret_str.push_str(&self.group.effective.to_string());
ret_str.push_str(&self.clone().to_string(Combination::tna)); // ret_str.push_str(&pids_to_string(&self.clone().pids));
ret_str.push(' '); // ret_str
ret_str.push_str(&self.user.real.to_string()); // }
ret_str.push('|'); // Combination::tna => {
ret_str.push_str(&self.user.effective.to_string()); // //state rem_ip:rem_port loc_ip:loc_port
ret_str.push(' '); // ret_str.push_str(&self.state.to_string());
ret_str.push_str(&self.group.real.to_string()); // ret_str.push(' ');
ret_str.push('|'); // ret_str.push_str(&self.peer_loc.ip_address);
ret_str.push_str(&self.group.effective.to_string()); // ret_str.push(':');
ret_str.push_str(&pids_to_string(&self.clone().pids)); // let loc_port_str = self.peer_loc.port.clone().to_string();
ret_str // ret_str.push_str(if self.peer_loc.port == 0 {
} // "*"
Combination::tna => { // } else {
//state rem_ip:rem_port loc_ip:loc_port // &loc_port_str
ret_str.push_str(&self.state.to_string()); // });
ret_str.push(' '); // ret_str.push(' ');
ret_str.push_str(&self.peer_loc.ip_address); // ret_str.push_str(&self.peer_rem.ip_address);
ret_str.push(':'); // ret_str.push(':');
let loc_port_str = self.peer_loc.port.clone().to_string(); // let rem_port_str = self.peer_rem.port.clone().to_string();
ret_str.push_str(if self.peer_loc.port == 0 { // ret_str.push_str(if self.peer_rem.port == 0 {
"*" // "*"
} else { // } else {
&loc_port_str // &rem_port_str
}); // });
ret_str.push(' '); // ret_str.push('\n');
ret_str.push_str(&self.peer_rem.ip_address); // ret_str
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 { pub fn get_state(&self) -> Tcp_SocketState {
self.state.clone() self.state
} }
} }
} }