portls 0.3.0

Modern cross-platform port inspector - ls for network ports
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::process::Command;

use anyhow::{Context, Result};

use crate::types::{PortInfo, Protocol};

pub fn get_connections() -> Result<Vec<PortInfo>> {
    let output = Command::new("lsof")
        .args(["-i", "-n", "-P"])
        .output()
        .context("Failed to execute lsof")?;

    let stdout = String::from_utf8(output.stdout).context("Invalid UTF-8 from lsof")?;

    Ok(parse_lsof_output(&stdout))
}

fn parse_lsof_output(output: &str) -> Vec<PortInfo> {
    output
        .lines()
        .skip(1)
        .filter_map(parse_lsof_line)
        .filter(|info| info.remote_address.is_some())
        .collect()
}

fn parse_lsof_line(line: &str) -> Option<PortInfo> {
    let parts: Vec<&str> = line.split_whitespace().collect();

    if parts.len() < 10 {
        return None;
    }

    let command = parts[0];
    let pid: u32 = parts[1].parse().ok()?;
    let protocol_type = parts[7];
    let name = parts[8];

    if !name.contains(':') {
        return None;
    }

    let protocol = match protocol_type {
        "TCP" => Protocol::Tcp,
        "UDP" => Protocol::Udp,
        _ => return None,
    };

    let port = extract_local_port(name)?;

    let (local_addr, remote_address) = if let Some((local, remote)) = name.split_once("->") {
        (local.to_string(), Some(remote.to_string()))
    } else {
        (name.to_string(), None)
    };

    Some(PortInfo {
        port,
        protocol,
        pid,
        process_name: command.to_string(),
        address: local_addr,
        remote_address,
        container: None,
        service_name: None,
    })
}

fn extract_local_port(name: &str) -> Option<u16> {
    let local_part = if name.contains("->") {
        name.split("->").next()?
    } else {
        name.trim_end_matches(|c: char| c == ')' || c == '(' || c.is_alphabetic())
    };

    let port_str = local_part.rsplit(':').next()?;
    port_str.parse().ok()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_lsof_line_established() {
        let line = "node      12345 user   23u  IPv4 0x1234567890abcdef      0t0  TCP 127.0.0.1:3000->192.168.1.5:54321 (ESTABLISHED)";

        let result = parse_lsof_line(line).unwrap();

        assert_eq!(result.process_name, "node");
        assert_eq!(result.pid, 12345);
        assert_eq!(result.port, 3000);
        assert_eq!(result.protocol, Protocol::Tcp);
        assert_eq!(result.address, "127.0.0.1:3000");
        assert_eq!(result.remote_address, Some("192.168.1.5:54321".to_string()));
    }

    #[test]
    fn test_parse_lsof_line_listen() {
        let line =
            "node      12345 user   24u  IPv4 0x1234567890abcdef      0t0  TCP *:3000 (LISTEN)";

        let result = parse_lsof_line(line).unwrap();

        assert_eq!(result.port, 3000);
        assert!(result.remote_address.is_none());
    }

    #[test]
    fn test_parse_lsof_output_filters_established() {
        let output = "COMMAND   PID USER  FD  TYPE DEVICE SIZE/OFF NODE NAME
node      12345 user   23u  IPv4 0x123      0t0  TCP 127.0.0.1:3000->192.168.1.5:54321 (ESTABLISHED)
node      12345 user   24u  IPv4 0x456      0t0  TCP *:3000 (LISTEN)";

        let result = parse_lsof_output(output);

        assert_eq!(result.len(), 1);
        assert!(result[0].remote_address.is_some());
    }

    #[test]
    fn test_extract_local_port_established() {
        assert_eq!(
            extract_local_port("127.0.0.1:3000->192.168.1.5:54321"),
            Some(3000)
        );
    }

    #[test]
    fn test_extract_local_port_listen() {
        assert_eq!(extract_local_port("*:8080"), Some(8080));
    }

    #[test]
    fn test_extract_local_port_ipv6() {
        assert_eq!(extract_local_port("[::1]:5432"), Some(5432));
    }
}