feat: Implement Linux Port Scanner (#58)

poyotanp · web-flow · commit cce43ee48138 · 2025-12-20T09:25:15.000+03:00
* refactor: move get_process_commands to utils.rs

* feat: Implement Linux Port Scanner
diff --git a/backend/core/src/scanner/darwin.rs b/backend/core/src/scanner/darwin.rs
@@ -13,6 +13,8 @@ use super::Scanner;
 /// macOS-specific port scanner using lsof.
 pub struct DarwinScanner;
 
+use super::utils::Utils;
+
 impl DarwinScanner {
     /// Create a new macOS scanner.
     pub fn new() -> Self {
@@ -139,7 +141,7 @@ impl DarwinScanner {
                 .unwrap_or_else(|| process_name.clone());
 
             // Parse address and port
-            let (address, port) = match self.parse_address(&address_part) {
+            let (address, port) = match Utils::parse_address(&address_part) {
                 Some((a, p)) => (a, p),
                 None => continue,
             };
@@ -164,33 +166,6 @@ impl DarwinScanner {
         ports.sort_by_key(|p| p.port);
         ports
     }
-
-    /// Parse an address:port string.
-    ///
-    /// Handles multiple address formats:
-    /// - IPv4: "127.0.0.1:3000" or "*:8080"
-    /// - IPv6: "[::1]:3000" or "[fe80::1]:8080"
-    fn parse_address(&self, address: &str) -> Option<(String, u16)> {
-        if address.starts_with('[') {
-            // IPv6 format: [::1]:3000
-            let bracket_end = address.find(']')?;
-            if bracket_end + 1 >= address.len() || address.as_bytes()[bracket_end + 1] != b':' {
-                return None;
-            }
-            let addr = &address[..=bracket_end];
-            let port_str = &address[bracket_end + 2..];
-            let port: u16 = port_str.parse().ok()?;
-            Some((addr.to_string(), port))
-        } else {
-            // IPv4 format: 127.0.0.1:3000 or *:8080
-            let last_colon = address.rfind(':')?;
-            let addr = &address[..last_colon];
-            let port_str = &address[last_colon + 1..];
-            let port: u16 = port_str.parse().ok()?;
-            let addr = if addr.is_empty() { "*" } else { addr };
-            Some((addr.to_string(), port))
-        }
-    }
 }
 
 impl Default for DarwinScanner {
@@ -231,32 +206,6 @@ impl Scanner for DarwinScanner {
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_parse_ipv4_address() {
-        let scanner = DarwinScanner::new();
-
-        let (addr, port) = scanner.parse_address("127.0.0.1:3000").unwrap();
-        assert_eq!(addr, "127.0.0.1");
-        assert_eq!(port, 3000);
-
-        let (addr, port) = scanner.parse_address("*:8080").unwrap();
-        assert_eq!(addr, "*");
-        assert_eq!(port, 8080);
-    }
-
-    #[test]
-    fn test_parse_ipv6_address() {
-        let scanner = DarwinScanner::new();
-
-        let (addr, port) = scanner.parse_address("[::1]:3000").unwrap();
-        assert_eq!(addr, "[::1]");
-        assert_eq!(port, 3000);
-
-        let (addr, port) = scanner.parse_address("[fe80::1]:8080").unwrap();
-        assert_eq!(addr, "[fe80::1]");
-        assert_eq!(port, 8080);
-    }
-
     #[test]
     fn test_parse_lsof_output() {
         let scanner = DarwinScanner::new();
diff --git a/backend/core/src/scanner/linux.rs b/backend/core/src/scanner/linux.rs
@@ -5,17 +5,153 @@
 
 use crate::error::{Error, Result};
 use crate::models::PortInfo;
-
+use regex::Regex;
+use std::collections::{HashMap, HashSet};
+use std::process::Stdio;
+use tokio::process::Command;
+use super::utils::Utils;
 use super::Scanner;
 
 /// Linux-specific port scanner.
 pub struct LinuxScanner;
 
+struct LinuxProcessInfo {
+    user: String,
+    command: String
+}
+
 impl LinuxScanner {
+
     /// Create a new Linux scanner.
     pub fn new() -> Self {
         Self
     }
+
+    /// Get full command information and user for all processes using the ps command.
+    ///
+    /// Executes: `ps -axo pid.user.command --no-headers`
+    ///
+    /// Commands longer than 200 characters are truncated.
+    async fn get_process_infos(&self) -> HashMap<u32, LinuxProcessInfo> {
+        let output = match Command::new("/bin/ps")
+            .args(["-axo", "pid,user,command", "--no-headers"])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::null())
+            .output()
+            .await
+        {
+            Ok(output) => output,
+            Err(_) => return HashMap::new(),
+        };
+
+        let stdout = match String::from_utf8(output.stdout) {
+            Ok(s) => s,
+            Err(_) => return HashMap::new(),
+        };
+
+        let mut infos = HashMap::new();
+
+        for line in stdout.lines() {
+            // Split into PID and user
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.len() != 3 {
+                continue;
+            }
+
+            let pid: u32 = match parts[0].parse() {
+                Ok(p) => p,
+                Err(_) => continue,
+            };
+
+            let user = parts[1].to_string();
+
+            let command = parts[2].to_string();
+            let command = if command.len() > 200 {
+                format!("{}...", &command[..200])
+            } else {
+                command.to_string()
+            };
+
+            let info = LinuxProcessInfo { user, command };
+            infos.insert(pid, info);
+        }
+
+        infos
+    }
+
+    /// Parse ss output into PortInfo objects.
+    ///
+    /// Expected ss output format:
+    /// ```text
+    /// State      Recv-Q     Send-Q              Local Address:Port          Peer Address:Port     Process
+    /// LISTEN     0          4096           [::ffff:127.0.0.1]:63342                    *:*         users:(("rustrover",pid=53561,fd=54))
+    /// ```
+    fn parse_ss_output(&self, output: &str, process_infos: &HashMap<u32, LinuxProcessInfo>) -> Vec<PortInfo> {
+        let mut ports = Vec::new();
+        let mut seen: HashSet<(u16, u32)> = HashSet::new();
+
+        for line in output.lines() {
+            if line.is_empty() {
+                continue;
+            }
+
+            // Parse columns: [State] [Recv-Q] [Send-Q] [Local Address:Port] [Peer Address:Port] [Process]
+            let components: Vec<&str> = line.split_whitespace().collect();
+            if components.len() < 6 {
+                continue;
+            }
+
+            let regex = Regex::new(r#"users:\(\("(.+?)",pid=(\d*),fd=(.+?)\)"#).unwrap();
+            let Some(caps) = regex.captures(components[5]) else {
+                continue;
+            };
+
+            // Extract process name
+            let process_name = caps[1].to_string();
+
+            // Parse PID
+            let pid: u32 = match caps[2].parse() {
+                Ok(p) => p,
+                Err(_) => continue,
+            };
+
+            // Get process info from pid
+            let Some(info) = process_infos.get(&pid) else {
+                continue;
+            };
+
+            let user = info.user.clone();
+            let fd = caps[2].to_string();
+
+            // Get full command from process info
+            let command = info.command.clone();
+
+            // Parse address and port
+            let (address, port) = match Utils::parse_address(&components[3]) {
+                Some((a, p)) => (a, p),
+                None => continue,
+            };
+
+            // Deduplicate by (port, pid)
+            if !seen.insert((port, pid)) {
+                continue;
+            }
+
+            ports.push(PortInfo::active(
+                port,
+                pid,
+                process_name,
+                address,
+                user,
+                command,
+                fd,
+            ));
+        }
+
+        // Sort by port number
+        ports.sort_by_key(|p| p.port);
+        ports
+    }
 }
 
 impl Default for LinuxScanner {
@@ -27,11 +163,77 @@ impl Default for LinuxScanner {
 impl Scanner for LinuxScanner {
     /// Scan all listening TCP ports.
     ///
-    /// Uses `ss -tlnp` command on Linux.
+    /// Executes: `ss -Htlnp`
+    ///
+    /// Flags explained:
+    /// -H, --no-header     Suppress header line
+    /// -t, --tcp           display only TCP sockets
+    /// -l, --listening     display listening sockets
+    /// -n, --numeric       don't resolve service names
+    /// -p, --processes     show process using socket
     async fn scan(&self) -> Result<Vec<PortInfo>> {
-        // TODO: Implement Linux-specific scanning using ss or netstat
-        Err(Error::UnsupportedPlatform(
-            "Linux scanner not yet implemented".to_string(),
-        ))
+        let output = Command::new("/usr/sbin/ss")
+            .args(["-Htlnp"])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::null())
+            .output()
+            .await
+            .map_err(|e| Error::CommandFailed(format!("Failed to run ss: {}", e)))?;
+
+        let stdout = String::from_utf8(output.stdout)
+            .map_err(|e| Error::ParseError(format!("Invalid UTF-8 in ss output: {}", e)))?;
+
+        let process_infos = self.get_process_infos().await;
+
+        Ok(self.parse_ss_output(&stdout, &process_infos))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_ss_output() {
+        let scanner = LinuxScanner::new();
+        let mut commands = HashMap::new();
+        commands.insert(55316, LinuxProcessInfo {
+            user: "user".to_string(),
+            command: "nginx".to_string(),
+        });
+        commands.insert(53561, LinuxProcessInfo {
+            user: "user".to_string(),
+            command: "node".to_string(),
+        });
+
+        let output = r#"LISTEN 0 4096 [::ffff:127.0.0.1]:80 *:* users:(("nginx",pid=55316,fd=6))
+LISTEN 0 50 [::ffff:127.0.0.1]:3000 *:* users:(("node",pid=53561,fd=187))"#;
+
+        let ports = scanner.parse_ss_output(output, &commands);
+        assert_eq!(ports.len(), 2);
+
+        // Should be sorted by port
+        assert_eq!(ports[0].port, 80);
+        assert_eq!(ports[0].process_name, "nginx");
+
+        assert_eq!(ports[1].port, 3000);
+        assert_eq!(ports[1].process_name, "node");
+    }
+
+    #[test]
+    fn test_deduplication() {
+        let scanner = LinuxScanner::new();
+        let mut commands = HashMap::new();
+        commands.insert(1234, LinuxProcessInfo {
+            user: "user".to_string(),
+            command: "code linux.rs".to_string(),
+        });
+
+        // Same port and PID should be deduplicated
+        let output = r#"LISTEN 0 4096 127.0.0.1:3000 :* users:(("code",pid=1234,fd=54))
+LISTEN 0 4096 [::ffff:127.0.0.1]:3000 *:* users:(("code",pid=1234,fd=54))"#;
+
+        let ports = scanner.parse_ss_output(output, &commands);
+        assert_eq!(ports.len(), 1);
     }
 }
diff --git a/backend/core/src/scanner/mod.rs b/backend/core/src/scanner/mod.rs
@@ -8,6 +8,7 @@ mod linux;
 
 #[cfg(target_os = "windows")]
 mod windows;
+mod utils;
 
 use crate::error::Result;
 use crate::models::PortInfo;
diff --git a/backend/core/src/scanner/utils.rs b/backend/core/src/scanner/utils.rs
@@ -0,0 +1,58 @@
+pub struct Utils;
+
+impl Utils {
+    /// Parse an address:port string.
+    ///
+    /// Handles multiple address formats:
+    /// - IPv4: "127.0.0.1:3000" or "*:8080"
+    /// - IPv6: "\[::1]:3000" or "\[fe80::1]:8080"
+    pub fn parse_address(address: &str) -> Option<(String, u16)> {
+        if address.starts_with('[') {
+            // IPv6 format: [::1]:3000
+            let bracket_end = address.find(']')?;
+            if bracket_end + 1 >= address.len() || address.as_bytes()[bracket_end + 1] != b':' {
+                return None;
+            }
+            let addr = &address[..=bracket_end];
+            let port_str = &address[bracket_end + 2..];
+            let port: u16 = port_str.parse().ok()?;
+            Some((addr.to_string(), port))
+        } else {
+            // IPv4 format: 127.0.0.1:3000 or *:8080
+            let last_colon = address.rfind(':')?;
+            let addr = &address[..last_colon];
+            let port_str = &address[last_colon + 1..];
+            let port: u16 = port_str.parse().ok()?;
+            let addr = if addr.is_empty() { "*" } else { addr };
+            Some((addr.to_string(), port))
+        }
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_ipv4_address() {
+        let (addr, port) = Utils::parse_address("127.0.0.1:3000").unwrap();
+        assert_eq!(addr, "127.0.0.1");
+        assert_eq!(port, 3000);
+
+        let (addr, port) = Utils::parse_address("*:8080").unwrap();
+        assert_eq!(addr, "*");
+        assert_eq!(port, 8080);
+    }
+
+    #[test]
+    fn test_parse_ipv6_address() {
+        let (addr, port) = Utils::parse_address("[::1]:3000").unwrap();
+        assert_eq!(addr, "[::1]");
+        assert_eq!(port, 3000);
+
+        let (addr, port) = Utils::parse_address("[fe80::1]:8080").unwrap();
+        assert_eq!(addr, "[fe80::1]");
+        assert_eq!(port, 8080);
+    }
+}
