get process icons on macOS (very WIP)

Author: GyulyVGC

Cargo.lock

@@ -58,6 +58,10 @@ clap = { version = "4.5.41", features = ["derive"] }
 tokio = { version = "1.46.1", features = ["macros"] }
 async-channel = "2.5.0"
 listeners = { git = "https://github.com/islameehassan/listeners" }
+cocoa = "0.24"
+objc = "0.2"
+libc = "0.2.174"
+image = "0.24"
 
 [target.'cfg(windows)'.dependencies]
 gag = "1.0.0"

Cargo.toml

@@ -47,7 +47,7 @@ use iced::widget::scrollable::Direction;
 use iced::widget::text::LineHeight;
 use iced::widget::tooltip::Position;
 use iced::widget::{
-    Button, Column, Container, Row, Rule, Scrollable, Space, Text, Tooltip, button,
+    Button, Column, Container, Image, Row, Rule, Scrollable, Space, Text, Tooltip, button,
     horizontal_space, vertical_space,
 };
 use iced::{Alignment, Font, Length, Padding};
@@ -98,6 +98,8 @@ pub fn overview_page(sniffer: &Sniffer) -> Container<Message, StyleType> {
 
                 let container_info = col_info(sniffer);
 
+                let col_service = col_service(sniffer);
+
                 let container_report = row_report(sniffer);
 
                 body = body
@@ -110,7 +112,14 @@ pub fn overview_page(sniffer: &Sniffer) -> Container<Message, StyleType> {
                             .height(280)
                             .spacing(10)
                             .push(container_info)
-                            .push(container_chart),
+                            .push(container_chart)
+                            .push(
+                                Container::new(col_service)
+                                    .width(350)
+                                    .height(Length::Fill)
+                                    .padding(Padding::new(10.0).top(0).bottom(5))
+                                    .class(ContainerType::BorderedRound),
+                            ),
                     )
                     .push(container_report);
             }
@@ -222,28 +231,20 @@ fn body_pcap_error<'a>(
 
 fn row_report<'a>(sniffer: &Sniffer) -> Row<'a, Message, StyleType> {
     let col_host = col_host(sniffer);
-    let col_service = col_service(sniffer);
     let col_process = col_process(sniffer);
 
     Row::new()
         .spacing(10)
         .push(
             Container::new(col_host)
-                .width(Length::FillPortion(5))
-                .height(Length::Fill)
-                .padding(Padding::new(10.0).top(0).bottom(5))
-                .class(ContainerType::BorderedRound),
-        )
-        .push(
-            Container::new(col_service)
-                .width(Length::FillPortion(2))
+                .width(Length::FillPortion(6))
                 .height(Length::Fill)
                 .padding(Padding::new(10.0).top(0).bottom(5))
                 .class(ContainerType::BorderedRound),
         )
         .push(
             Container::new(col_process)
-                .width(Length::FillPortion(2))
+                .width(Length::FillPortion(4))
                 .height(Length::Fill)
                 .padding(Padding::new(10.0).top(0).bottom(5))
                 .class(ContainerType::BorderedRound),
@@ -410,11 +411,11 @@ fn col_process<'a>(sniffer: &Sniffer) -> Column<'a, Message, StyleType> {
     let entries = get_process_entries(&sniffer.info_traffic, chart_type, sniffer.process_sort_type);
     let first_entry_data_info = entries
         .iter()
-        .map(|&(_, d)| d)
-        .max_by(|d1, d2| d1.compare(d2, SortType::Ascending, chart_type))
-        .unwrap_or_default();
+        .map(|&(_, (d, _))| d)
+        .max_by(|d1, d2| d1.compare(&d2, SortType::Ascending, chart_type))
+        .unwrap();
 
-    for (process, data_info) in &entries {
+    for (process, (data_info, handle)) in &entries {
         let content = simpler_bar(
             process.to_string(),
             data_info,
@@ -424,12 +425,22 @@ fn col_process<'a>(sniffer: &Sniffer) -> Column<'a, Message, StyleType> {
         );
 
         scroll_process = scroll_process.push(
-            button(content)
-                .padding(Padding::new(5.0).right(15).left(10))
-                .on_press(Message::Search(SearchParameters::new_process_search(
-                    process,
-                )))
-                .class(ButtonType::Neutral),
+            button(
+                Row::new()
+                    .spacing(5)
+                    .align_y(Vertical::Center)
+                    .push_maybe(
+                        handle
+                            .clone()
+                            .map(|h| Image::new(h).height(FLAGS_HEIGHT_BIG)),
+                    )
+                    .push(content),
+            )
+            .padding(Padding::new(5.0).right(15).left(10))
+            .on_press(Message::Search(SearchParameters::new_process_search(
+                process,
+            )))
+            .class(ButtonType::Neutral),
         );
     }
 
@@ -588,7 +599,7 @@ fn col_info<'a>(sniffer: &Sniffer) -> Container<'a, Message, StyleType> {
         .push(donut_row.height(Length::Fill));
 
     Container::new(content)
-        .width(400)
+        .width(350)
         .padding(Padding::new(5.0).top(10))
         .align_x(Alignment::Center)
         .class(ContainerType::BorderedRound)

src/gui/pages/overview_page.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::ffi::{CStr, c_int};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
 use etherparse::{EtherType, LaxPacketHeaders, LinkHeader, NetHeaders, TransportHeader};
@@ -17,6 +18,12 @@ use crate::networking::types::service_query::ServiceQuery;
 use crate::networking::types::traffic_direction::TrafficDirection;
 use crate::networking::types::traffic_type::TrafficType;
 use crate::{IpVersion, Protocol};
+use cocoa::base::{id, nil};
+use cocoa::foundation::{NSSize, NSString};
+use iced::widget::Image;
+use iced::widget::image::Handle;
+use image::{GenericImageView, RgbaImage};
+use objc::{class, msg_send, sel, sel_impl};
 use std::fmt::Write;
 
 include!(concat!(env!("OUT_DIR"), "/services.rs"));
@@ -256,10 +263,11 @@ pub fn modify_or_insert_in_map(
     icmp_type: IcmpType,
     arp_type: ArpType,
     exchanged_bytes: u128,
-) -> (TrafficDirection, Service, String) {
+) -> (TrafficDirection, Service, String, Option<Handle>) {
     let mut traffic_direction = TrafficDirection::default();
     let mut service = Service::Unknown;
     let mut process = "-".to_string();
+    let mut picon = None;
 
     if !info_traffic_msg.map.contains_key(key) {
         // first occurrence of key (in this time interval)
@@ -284,7 +292,38 @@ pub fn modify_or_insert_in_map(
                 .into_iter()
                 .flatten()
                 .next()
-                .map_or("?".to_string(), |p| p.name);
+                .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(),
+                                ));
+                            }
+                        }
+                    }
+                    p.name
+                });
         }
     }
 
@@ -335,9 +374,70 @@ pub fn modify_or_insert_in_map(
         new_info.traffic_direction,
         new_info.service,
         new_info.process.clone(),
+        picon,
     )
 }
 
+unsafe extern "C" {
+    fn proc_pidpath(pid: c_int, buffer: *mut libc::c_void, buffersize: u32) -> c_int;
+}
+
+fn get_executable_path(pid: i32) -> Option<String> {
+    let mut buf = vec![0u8; libc::PROC_PIDPATHINFO_MAXSIZE as usize];
+    let ret = unsafe { proc_pidpath(pid, buf.as_mut_ptr() as *mut _, buf.len() as u32) };
+
+    if ret > 0 {
+        let path = CStr::from_bytes_until_nul(&buf).unwrap();
+        Some(path.to_string_lossy().into_owned())
+    } else {
+        None
+    }
+}
+
+fn find_app_bundle_path(exe_path: &str) -> Option<String> {
+    let mut current = std::path::Path::new(exe_path);
+    let mut last_app_dir: Option<std::path::PathBuf> = None;
+
+    // Walk up the path, including the input
+    loop {
+        if let Some(file_name) = current.file_name() {
+            if file_name.to_string_lossy().ends_with(".app") {
+                last_app_dir = Some(current.to_path_buf());
+            }
+        }
+
+        match current.parent() {
+            Some(parent) => current = parent,
+            None => break,
+        }
+    }
+
+    last_app_dir.map(|p| p.to_string_lossy().into_owned())
+}
+
+fn get_icon_tiff_bytes(app_path: &str) -> Option<Vec<u8>> {
+    unsafe {
+        let ns_app_path: id = NSString::alloc(nil).init_str(app_path);
+        let workspace: id = msg_send![class!(NSWorkspace), sharedWorkspace];
+        let icon: id = msg_send![workspace, iconForFile: ns_app_path];
+
+        if icon == nil {
+            return None;
+        }
+
+        // Get TIFF representation (NSData)
+        let tiff_data: id = msg_send![icon, TIFFRepresentation];
+        if tiff_data == nil {
+            return None;
+        }
+
+        // Convert NSData to Vec<u8>
+        let length: usize = msg_send![tiff_data, length];
+        let bytes: *const u8 = msg_send![tiff_data, bytes];
+        Some(std::slice::from_raw_parts(bytes, length).to_vec())
+    }
+}
+
 /// Returns the traffic direction observed (incoming or outgoing)
 fn get_traffic_direction(
     source_ip: &IpAddr,

src/networking/manage_packets.rs

@@ -144,7 +144,7 @@ pub fn parse_packets(
                             file.write(&packet);
                         }
                         // update the map
-                        let (traffic_direction, service, process) = modify_or_insert_in_map(
+                        let (traffic_direction, service, process, picon) = modify_or_insert_in_map(
                             &mut info_traffic_msg,
                             &key,
                             &cs,
@@ -280,10 +280,16 @@ pub fn parse_packets(
                             .processes
                             .entry(process)
                             .and_modify(|data_info| {
-                                data_info.add_packet(exchanged_bytes, traffic_direction);
+                                data_info.0.add_packet(exchanged_bytes, traffic_direction);
                             })
                             .or_insert_with(|| {
-                                DataInfo::new_with_first_packet(exchanged_bytes, traffic_direction)
+                                (
+                                    DataInfo::new_with_first_packet(
+                                        exchanged_bytes,
+                                        traffic_direction,
+                                    ),
+                                    picon,
+                                )
                             });
                     }