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

allerlei...

Browse Source
This commit is contained in:
mux 2025-08-07 17:23:21 +02:00
parent 6a9567c5de
commit 78276e8243
2 changed files with 88 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

279
src/main.rs
View File

@ -4,244 +4,67 @@ use std::fs;
use std::fs::read_to_string; use std::fs::read_to_string;
use std::os::unix::fs::MetadataExt; use std::os::unix::fs::MetadataExt;
//#[derive(PartialEq)] type inode = u64;
//struct Peer { type pid = u64;
// ip_address: String,
// port: usize,
//}
mod socket; mod socket;
//impl Peer { fn get_socket_inodes_by_pid(pid : u64, socket_patt : Regex) -> Vec<inode> {
// fn new() -> Peer { let mut inodes : Vec<inode> = Vec::<inode>::new();
// Peer { let mut path = String::from("/proc/");
// ip_address: "0.0.0.0".to_string(), path.push_str(&pid.to_string());
// port: 0, path.push_str("/fd/");
// } let contents = fs::read_dir(path).expect("upsi 4 (proc kann nicht gelesen werden, Berechtigung?)");
// } for fd in contents {
// match fd {
// fn build_from_hex(hex_ip: &str, hex_port: &str) -> Peer { Ok(fd) => {
// Peer { let name = fs::read_link(fd.path()).unwrap();
// ip_address: Self::convert_ip_hex_dec(hex_ip), let name2 = name.file_name().unwrap().to_str().unwrap();
// port: Self::convert_port_hex_dec(hex_port), if (socket_patt.is_match(name2)){
// } inodes.push(socket_patt.captures(name2).unwrap().get(1).unwrap().as_str().parse::<u64>().unwrap())
// } }
// },
// fn convert_ip_hex_dec(ip_address: &str) -> String { Err(_) => continue,
// let mut buffer: String = String::new(); }
// let mut ip_quads: Vec<String> = vec![]; }
// for (i, v) in ip_address.chars().enumerate() { inodes
// if i % 2 == 1 { }
// buffer.push(v);
// ip_quads.push( fn get_readable_proc_pids(pid_pattern : Regex) -> Vec<pid> {
// u64::from_str_radix(&buffer, 16) let mut pids = Vec::<pid>::new();
// .expect("upsi 2") let dirs = fs::read_dir("/proc/").expect("proc kann nicht gelesen werden, Berechtigung?");
// .to_string(), for dir in dirs {
// ); match dir {
// buffer = String::new();
// } else { Ok(dir) => {
// buffer.push(v); let name = dir.file_name().into_string().unwrap();
// } if !pid_pattern.is_match(&name) {
// } continue;
// ip_quads }
// .iter() pids.push(name.parse().unwrap())
// .rev() },
// .map(|x| x.to_owned()) Err(_) => continue
// .collect::<Vec<String>>() };
// .join(".") }
// } pids
// }
// fn convert_port_hex_dec(port: &str) -> usize {
// usize::from_str_radix(port, 16).expect("upsi 3") fn get_socket_info() -> Vec<socket::socket::Socket> {
// } let mut sockets = Vec::<socket::socket::Socket>::new();
//} sockets
// }
//#[derive(PartialEq)]
//enum SocketState{
// Listening,
// Established,
// Closed
//}
//
//#[derive(PartialEq)]
//struct Socket {
// peer_loc: Peer,
// peer_rem: Peer,
// pids: Vec<u64>,
// state : SocketState,
// user : String,
// group : String,
// inode : u64
//}
//
//impl Socket {
// pub fn new(ip_loc: String, port_loc: usize, ip_rem: String, port_rem: usize, pids : Vec<u64>, state : SocketState, user : String, group : String, inode : u64) -> Socket {
// Socket {
// peer_loc: Peer {
// ip_address: ip_loc,
// port: port_loc,
// },
// peer_rem: Peer {
// ip_address: ip_rem,
// port: port_rem,
// },
// pids : pids,
// state : state,
// user : user,
// group : group,
// inode : inode,
// }
// }
//
// fn get_tcp_file_inode(pid: u64) -> u64 {
// let mut path = String::from("/proc/");
// path.push_str(&pid.to_string());
// path.push_str("/net/tcp");
//
// let inode = fs::metadata(&path)
// .expect("Cannot read metadata")
// .ino();
// return inode;
// }
//
// fn check_inode_seen(seen_inodes : &HashSet<u64>, pid : u64) -> bool {
// let inode = Socket::get_tcp_file_inode(pid);
// return seen_inodes.contains(&inode);
// }
//
// fn add_inode(seen_inodes : &mut HashSet<u64>, pid: u64){
// let inode = Socket::get_tcp_file_inode(pid);
// seen_inodes.insert(inode);
// }
//
//// fn get_unique_inodes() -> HashSet<u64> {
//// let mut unique_inodes = HashSet::new();
//// let pattern = Regex::new(r"^[1-4]?[0-9]{1,6}$").expect("kannst kein regex??");
//// let dirs = fs::read_dir("/proc").expect("Cannot access /proc");
//// for dir in dirs{
//// match dir {
//// Ok(dir) => {
//// if !pattern.is_match(
//// &dir.file_name()
//// .into_string()
//// .expect("Dateiname ist kein gueltiger Unicode-String")[..],
//// ) {
//// continue;
//// }
////
//// if !unique_inodes.contains(&inode){
//// println!("{}", &inode);
//// unique_inodes.insert(inode);
//// }
//// else{
//// continue;
//// }
//// },
//// Err(_) => continue,
//// };
//// }
//// unique_inodes
//// }
//
// pub fn to_string (socket : Socket) -> String {
// let mut ret_str = String::from("");
// ret_str.push_str(&socket.peer_loc.ip_address);
// ret_str.push(':');
// let loc_port_str = socket.peer_loc.port.clone().to_string();
// ret_str.push_str(if socket.peer_loc.port == 0 { "*" } else { &loc_port_str });
// ret_str.push(' ');
// ret_str.push_str(&socket.peer_rem.ip_address);
// ret_str.push(':');
// let rem_port_str = socket.peer_rem.port.clone().to_string();
// ret_str.push_str(if socket.peer_rem.port == 0 { "*" } else { &rem_port_str });
// ret_str.push('\n');
// return ret_str;
// }
//
//// fn convert_line(line : String) -> HashSet<Socket>{
//// let mut sockets : HashSet<Socket>;
//// let line_vec = line.split_whitespace().collect::<Vec<&str>>();
//// conv_str.push_str(&Peer::convert_ip_hex_dec(line_vec[1].split(":").nth(0).unwrap()));
//// conv_str.push_str(":");
//// let loc_port = Peer::convert_port_hex_dec(line_vec[1].split(":").nth(1).expect("gehtnd3"));
//// let loc_port_str = loc_port.clone().to_string();
//// conv_str.push_str(if loc_port == 0 { "*" } else { &loc_port_str } );
//// conv_str.push_str(" ");
//// conv_str.push_str(&Peer::convert_ip_hex_dec(line_vec[2].split(":").nth(0).expect("gehtnd2")));
//// conv_str.push_str(":");
//// let loc_port = Peer::convert_port_hex_dec(line_vec[2].split(":").nth(1).expect("gehtnd3"));
//// let loc_port_str = loc_port.clone().to_string();
//// conv_str.push_str(if loc_port == 0 { "*" } else { &loc_port_str } );
//// conv_str.push('\n');
//// return conv_str;
//// }
//
// fn get_all_unique_socket_infos() -> String {
// let pattern = Regex::new(r"^[1-4]?[0-9]{1,6}$").expect("kannst kein regex??");
// let contents =
// fs::read_dir("/proc/").expect("upsi 4 (proc kann nicht gelesen werden, Berechtigung?)");
// let mut seen_inodes = HashSet::<u64>::new();
// let mut complete_file: String = String::new();
// for dir in contents {
// match dir {
// Ok(dir) => {
// if !pattern.is_match(
// &dir.file_name()
// .into_string()
// .expect("Dateiname ist kein gueltiger Unicode-String")[..],
// ) {
// continue;
// }
// let mut path = dir.path().into_os_string().into_string().expect("gehtnd");
// path.push_str("/net/tcp");
// let pid = &path.split("/").nth(2).expect("gesplittert");
// if !Socket::check_inode_seen(&seen_inodes, pid.parse::<u64>().unwrap()) {
// Socket::add_inode(& mut seen_inodes, pid.parse::<u64>().unwrap());
// let test = &fs::read_to_string(path)
// .expect("Could not read proc/pid/net/tcp")
// .lines()
// .skip(1)
//// .map(|x| Socket::convert_line(x.to_string()))
// .map(|x| x.to_owned())
// .collect::<Vec<String>>()
// .join("\n");
// complete_file.push_str(test);
// }
// else{
// continue;
// }
// },
// Err(_) => continue,
// };
// }
// // complete_file
// complete_file
// }
//
// fn get_pids (complete_file : String) -> Vec<u64>{
// return Vec::<u64>::new();
// }
//}
fn get_index(line: String, index: usize) -> String { fn get_index(line: String, index: usize) -> String {
line.split_whitespace().nth(index).expect("upsi").to_owned() line.split_whitespace().nth(index).expect("upsi").to_owned()
} }
//fn get_local_addresses_and_ports(proc_string : &mut String){
// let local_addresses : Vec<String> = Vec::new();
// let tcp_file : String = get_socket_info();
// tcp.lines().
// println!("{:?}", local_addresses);
//}
//fn get_local_port(){
// proc_string.lines().for_each( |x| {
// local_addresses.push(i64::from_str_radix(&get_index_and_convert_to_dec(x.to_owned(), 2), 16))
// });
//}
fn get_remote_address() {} fn get_remote_address() {}
fn get_remote_port() {} fn get_remote_port() {}
fn main() { fn main() {
// let complete_file = Socket::get_all_unique_socket_infos(); let socket_patt : 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 mut socket_infos : Vec<socket::socket::Socket>;
println!("{:?}", get_socket_inodes_by_pid(55238, socket_patt));
println!("{:?}", get_readable_proc_pids(pid_pattern));
} }

85
src/socket.rs
View File

@ -1,5 +1,5 @@
mod Socket { pub mod socket {
use regex::Regex; use regex::Regex;
use std::collections::HashSet; use std::collections::HashSet;
@ -8,16 +8,11 @@ mod Socket {
use std::os::unix::fs::MetadataExt; use std::os::unix::fs::MetadataExt;
#[derive(PartialEq)] #[derive(PartialEq)]
struct Peer { #[derive(Clone)]
ip_address: String, #[derive(Debug)]
port: usize, pub struct Peer {
} pub ip_address: String,
pub port: usize,
impl Clone for Peer {
fn clone(&self) -> Self {
Self {
}
}
} }
impl Peer { impl Peer {
@ -28,7 +23,7 @@ mod Socket {
} }
} }
fn build_from_hex(hex_ip: &str, hex_port: &str) -> Peer { pub fn build_from_hex(hex_ip: &str, hex_port: &str) -> Peer {
Peer { Peer {
ip_address: Self::convert_ip_hex_dec(hex_ip), ip_address: Self::convert_ip_hex_dec(hex_ip),
port: Self::convert_port_hex_dec(hex_port), port: Self::convert_port_hex_dec(hex_port),
@ -65,6 +60,7 @@ mod Socket {
} }
#[derive(PartialEq)] #[derive(PartialEq)]
#[derive(Clone)]
pub enum SocketState{ pub enum SocketState{
Listening, Listening,
Established, Established,
@ -72,6 +68,7 @@ mod Socket {
} }
#[derive(PartialEq)] #[derive(PartialEq)]
#[derive(Clone)]
pub struct Socket { pub struct Socket {
peer_loc: Peer, peer_loc: Peer,
peer_rem: Peer, peer_rem: Peer,
@ -82,20 +79,6 @@ mod Socket {
inode : u64 inode : u64
} }
impl Clone for Socket {
fn clone(&self) -> Self {
Self {
peer_loc : self.peer_loc.clone(),
peer_rem : self.peer_rem .clone(),
pids : self.pids.clone(),
state : self.state.clone(),
user : self.user.clone(),
group : self.user.clone(),
inode : self.inode.clone()
}
}
}
impl Socket { impl Socket {
pub fn new(ip_loc: &str, port_loc: usize, ip_rem: &str, port_rem: usize, pids : Vec<u64>, state : SocketState, user : &str, group : &str, inode : u64) -> Socket { pub fn new(ip_loc: &str, port_loc: usize, ip_rem: &str, port_rem: usize, pids : Vec<u64>, state : SocketState, user : &str, group : &str, inode : u64) -> Socket {
Socket { Socket {
@ -107,11 +90,11 @@ mod Socket {
ip_address: ip_rem.to_string(), ip_address: ip_rem.to_string(),
port: port_rem, port: port_rem,
}, },
pids : pids, pids,
state : state, state,
user : user.to_string(), user : user.to_string(),
group : group.to_string(), group : group.to_string(),
inode : inode, inode,
} }
} }
@ -123,15 +106,15 @@ mod Socket {
let inode = fs::metadata(&path) let inode = fs::metadata(&path)
.expect("Cannot read metadata") .expect("Cannot read metadata")
.ino(); .ino();
return inode; inode
} }
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 = Socket::get_tcp_file_inode(pid); let inode = Socket::get_tcp_file_inode(pid);
return seen_inodes.contains(&inode); seen_inodes.contains(&inode)
} }
fn add_inode(seen_inodes : &mut HashSet<u64>, pid: u64){ pub fn add_inode(seen_inodes : &mut HashSet<u64>, pid: u64){
let inode = Socket::get_tcp_file_inode(pid); let inode = Socket::get_tcp_file_inode(pid);
seen_inodes.insert(inode); seen_inodes.insert(inode);
} }
@ -148,7 +131,7 @@ mod Socket {
let rem_port_str = self.peer_rem.port.clone().to_string(); 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_str(if self.peer_rem.port == 0 { "*" } else { &rem_port_str });
ret_str.push('\n'); ret_str.push('\n');
return ret_str; ret_str
} }
fn get_all_unique_socket_infos() -> String { fn get_all_unique_socket_infos() -> String {
@ -176,7 +159,7 @@ mod Socket {
.expect("Could not read proc/pid/net/tcp") .expect("Could not read proc/pid/net/tcp")
.lines() .lines()
.skip(1) .skip(1)
// .map(|x| Socket::convert_line(x.to_string())) // .map(|x| socket::convert_line(x.to_string()))
.map(|x| x.to_owned()) .map(|x| x.to_owned())
.collect::<Vec<String>>() .collect::<Vec<String>>()
.join("\n"); .join("\n");
@ -199,21 +182,27 @@ mod Socket {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::socket::Socket::*; use super::*;
fn init_sockets() -> Vec<Socket> { fn init_sockets() -> Vec<socket::Socket> {
let sockets = Vec::<Socket>::new(); let mut sockets = Vec::<socket::Socket>::new();
sockets.push(Socket::new("93.83.160.12", 21345, "0.0.0.0", 0, Vec::<u64>::new(), Socket::SocketState::Listening, "root", "root", 123123)); sockets.push(socket::Socket::new("93.83.160.12", 21345, "0.0.0.0", 0, Vec::<u64>::new(), socket::SocketState::Listening, "root", "root", 123123));
sockets.push(Socket::new("195.201.90.97", 8843, "0.0.0.0", 443, Vec::<u64>::new(), Socket::SocketState::Established, "apache", "apache", 218389)); sockets.push(socket::Socket::new("195.201.90.97", 8843, "0.0.0.0", 443, Vec::<u64>::new(), socket::SocketState::Established, "apache", "apache", 218389));
sockets.push(Socket::new("255.255.255.255", 193193, "0.0.0.0", 8080, Vec::<u64>::new(), Socket::SocketState::Listening, "node", "node", 1301011)); sockets.push(socket::Socket::new("255.255.255.255", 193193, "0.0.0.0", 8080, Vec::<u64>::new(), socket::SocketState::Listening, "node", "node", 1301011));
return sockets; sockets
} }
#[test]
#[cfg(test)] fn test_build_from_hex() -> () {
pub fn test_to_string() -> (){ let hex_val = "0100007F";
assert_eq!(socket::Peer::build_from_hex("0100007F", "F168"), socket::Peer { ip_address: "127.0.0.1".to_owned(), port: 61800 });
assert_eq!(socket::Peer::build_from_hex("980FB23E", "ACCE"), socket::Peer { ip_address: "62.178.15.152".to_owned(), port: 44238 });
assert_eq!(socket::Peer::build_from_hex("00000000", "30C8"), socket::Peer { ip_address: "0.0.0.0".to_owned(), port: 12488 });
}
#[test]
fn test_to_string() -> () {
let sockets = init_sockets(); let sockets = init_sockets();
assert_eq!("93.83.160.12:21345 0.0.0.0:*", sockets[0].clone().to_string()); assert_eq!("93.83.160.12:21345 0.0.0.0:*\n", sockets[0].clone().to_string());
assert_eq!("195.201.90.97:8843 0.0.0.0:443", sockets[1].clone().to_string()); assert_eq!("195.201.90.97:8843 0.0.0.0:443\n", sockets[1].clone().to_string());
assert_eq!("255.255.255.255:193193 0.0.0.0:8080", sockets[2].clone().to_string()); assert_eq!("255.255.255.255:193193 0.0.0.0:8080\n", sockets[2].clone().to_string());
} }
} }