get process parsing nettop output on macOS (very WIP)

Author: GyulyVGC

src/gui/pages/overview_page.rs

@@ -413,7 +413,7 @@ fn col_process<'a>(sniffer: &Sniffer) -> Column<'a, Message, StyleType> {
         .iter()
         .map(|&(_, (d, _))| d)
         .max_by(|d1, d2| d1.compare(&d2, SortType::Ascending, chart_type))
-        .unwrap();
+        .unwrap_or_default();
 
     for (process, (data_info, handle)) in &entries {
         let content = simpler_bar(

src/networking/manage_packets.rs

@@ -25,6 +25,8 @@ use iced::widget::image::Handle;
 use image::{GenericImageView, RgbaImage};
 use objc::{class, msg_send, sel, sel_impl};
 use std::fmt::Write;
+use std::path::Path;
+use std::process::Command;
 
 include!(concat!(env!("OUT_DIR"), "/services.rs"));
 
@@ -266,7 +268,7 @@ pub fn modify_or_insert_in_map(
 ) -> (TrafficDirection, Service, String, Option<Handle>) {
     let mut traffic_direction = TrafficDirection::default();
     let mut service = Service::Unknown;
-    let mut process = "-".to_string();
+    let mut process = "?".to_string();
     let mut picon = None;
 
     if !info_traffic_msg.map.contains_key(key) {
@@ -287,43 +289,40 @@ pub fn modify_or_insert_in_map(
         service = get_service(key, traffic_direction, my_interface_addresses);
         // determine process
         if let Some(local_port) = get_local_port(key, traffic_direction) {
-            let processes = listeners::get_processes_by_port(local_port);
-            process = processes
-                .into_iter()
-                .flatten()
-                .next()
-                .map_or("?".to_string(), |p| {
-                    let path = get_executable_path(p.pid as i32);
-                    let mut image: Option<iced::widget::Image> = None;
-                    println!("Process: {} (PID: {})", p.name, p.pid);
-                    if let Some(app_path) = path {
-                        println!("--> Exe path: {}", app_path);
-                        if let Some(bundle_path) = find_app_bundle_path(&app_path) {
-                            println!("--> Bundle path: {}", bundle_path);
-                            if let Some(tiff) = get_icon_tiff_bytes(&bundle_path) {
-                                let img =
-                                    image::load_from_memory(&tiff).expect("Failed to decode image");
-                                // resize the image
-                                let resized =
-                                    img.resize_exact(64, 64, image::imageops::FilterType::Lanczos3);
-                                let (width, height) = resized.dimensions();
-                                println!("--> Icon size: {}x{}", width, height);
-                                // crop the image
-                                let sub =
-                                    image::imageops::crop_imm(&resized, 6, 6, 52, 52).to_image();
-                                let (width, height) = sub.dimensions();
-                                println!("--> Cropped icon size: {}x{}", width, height);
-
-                                picon = Some(iced::widget::image::Handle::from_rgba(
-                                    width,
-                                    height,
-                                    sub.into_raw(),
-                                ));
-                            }
-                        }
+            let processes = get_processes();
+            let pid = processes.get(&local_port).unwrap_or(&0);
+            let path = get_executable_path(*pid as i32);
+            let mut image: Option<iced::widget::Image> = None;
+            // println!("Process: {} (PID: {})", path, p.pid);
+            if let Some(app_path) = path {
+                process = Path::new(&app_path)
+                    .file_name()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    .to_string();
+                // println!("--> Exe path: {}", app_path);
+                if let Some(bundle_path) = find_app_bundle_path(&app_path) {
+                    // println!("--> Bundle path: {}", bundle_path);
+                    if let Some(tiff) = get_icon_tiff_bytes(&bundle_path) {
+                        let img = image::load_from_memory(&tiff).expect("Failed to decode image");
+                        // resize the image
+                        let resized =
+                            img.resize_exact(64, 64, image::imageops::FilterType::Lanczos3);
+                        let (width, height) = resized.dimensions();
+                        // println!("--> Icon size: {}x{}", width, height);
+                        // crop the image
+                        let sub = image::imageops::crop_imm(&resized, 6, 6, 52, 52).to_image();
+                        let (width, height) = sub.dimensions();
+                        // println!("--> Cropped icon size: {}x{}", width, height);
+
+                        picon = Some(iced::widget::image::Handle::from_rgba(
+                            width,
+                            height,
+                            sub.into_raw(),
+                        ));
                     }
-                    p.name
-                });
+                }
+            }
         }
     }
 
@@ -378,6 +377,59 @@ pub fn modify_or_insert_in_map(
     )
 }
 
+fn get_processes() -> HashMap<u16, u32> {
+    let output = Command::new("nettop")
+        .args(&["-n", "-L", "1", "-J", ""])
+        .output()
+        .unwrap();
+
+    if !output.status.success() {
+        return HashMap::new();
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    let mut map = HashMap::new();
+    let mut current_pid: Option<u32> = None;
+
+    for line in stdout.lines() {
+        let line = line.trim().trim_end_matches(',');
+
+        if line.is_empty() {
+            continue;
+        }
+
+        // Detect process line: processName.PID
+        if let Some(dot_pos) = line.rfind('.') {
+            let pid_str = &line[dot_pos + 1..];
+            if let Ok(pid) = pid_str.parse::<u32>() {
+                current_pid = Some(pid);
+                continue;
+            }
+        }
+
+        // Parse connection line
+        if let Some(pid) = current_pid {
+            // Expect format like: tcp4 192.168.1.102:64694<->172.64.155.209:443
+            if let Some(space_pos) = line.find(' ') {
+                let addr = &line[space_pos + 1..];
+                if let Some((local, _remote)) = addr.split_once("<->") {
+                    // Extract port from local address (skip if wildcard)
+                    if let Some((_ip, port_str)) = local.rsplit_once(':') {
+                        if port_str != "*" {
+                            if let Ok(port) = port_str.parse::<u16>() {
+                                map.insert(port, pid);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    map
+}
+
 unsafe extern "C" {
     fn proc_pidpath(pid: c_int, buffer: *mut libc::c_void, buffersize: u32) -> c_int;
 }