Add: H3 support - incomplete

crates/wtfnet-platform-linux/src/lib.rs

@@ -5,8 +5,8 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use wtfnet_core::ErrorCode;
 use wtfnet_platform::{
-    CertProvider, DnsConfigSnapshot, ListenSocket, NeighborEntry, NeighProvider, NetInterface,
-    Platform, PlatformError, PortsProvider, RootCert, RouteEntry, SysProvider,
+    CertProvider, ConnSocket, DnsConfigSnapshot, ListenSocket, NeighborEntry, NeighProvider,
+    NetInterface, Platform, PlatformError, PortsProvider, RootCert, RouteEntry, SysProvider,
 };
 use x509_parser::oid_registry::{
     OID_KEY_TYPE_DSA, OID_KEY_TYPE_EC_PUBLIC_KEY, OID_KEY_TYPE_GOST_R3410_2012_256,
@@ -240,6 +240,63 @@ fn parse_linux_tcp_with_inode_map(
     Ok(sockets)
 }
 
+fn parse_linux_tcp_conns(
+    path: &str,
+    is_v6: bool,
+    inode_map: &HashMap<String, ProcInfo>,
+) -> Result<Vec<ConnSocket>, PlatformError> {
+    let contents = std::fs::read_to_string(path)
+        .map_err(|err| PlatformError::new(ErrorCode::IoError, err.to_string()))?;
+    let mut sockets = Vec::new();
+    for (idx, line) in contents.lines().enumerate() {
+        if idx == 0 {
+            continue;
+        }
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        if parts.len() < 4 {
+            continue;
+        }
+        let local = parts[1];
+        let remote = parts[2];
+        let state = parts[3];
+        let inode = parts.get(9).copied();
+        if state == "0A" {
+            continue;
+        }
+        let local_addr = match parse_proc_socket_addr(local, is_v6) {
+            Some(addr) => addr,
+            None => continue,
+        };
+        let remote_addr = match parse_proc_socket_addr(remote, is_v6) {
+            Some(addr) => addr,
+            None => continue,
+        };
+        let (pid, ppid, process_name, process_path) =
+            inode.and_then(|value| inode_map.get(value)).map_or(
+                (None, None, None, None),
+                |info| {
+                    (
+                        Some(info.pid),
+                        info.ppid,
+                        info.name.clone(),
+                        info.path.clone(),
+                    )
+                },
+            );
+        sockets.push(ConnSocket {
+            proto: "tcp".to_string(),
+            local_addr,
+            remote_addr,
+            state: Some(map_tcp_state(state)),
+            pid,
+            ppid,
+            process_name,
+            process_path,
+        });
+    }
+    Ok(sockets)
+}
+
 fn parse_linux_udp_with_inode_map(
     path: &str,
     is_v6: bool,
@@ -286,6 +343,24 @@ fn parse_linux_udp_with_inode_map(
     Ok(sockets)
 }
 
+fn map_tcp_state(value: &str) -> String {
+    match value {
+        "01" => "ESTABLISHED",
+        "02" => "SYN_SENT",
+        "03" => "SYN_RECV",
+        "04" => "FIN_WAIT1",
+        "05" => "FIN_WAIT2",
+        "06" => "TIME_WAIT",
+        "07" => "CLOSE",
+        "08" => "CLOSE_WAIT",
+        "09" => "LAST_ACK",
+        "0A" => "LISTEN",
+        "0B" => "CLOSING",
+        _ => "UNKNOWN",
+    }
+    .to_string()
+}
+
 fn parse_proc_socket_addr(value: &str, is_v6: bool) -> Option<String> {
     let mut parts = value.split(':');
     let addr_hex = parts.next()?;
@@ -518,6 +593,22 @@ impl PortsProvider for LinuxPortsProvider {
             .filter(|socket| extract_port(&socket.local_addr) == Some(port))
             .collect())
     }
+
+    async fn connections(&self) -> Result<Vec<ConnSocket>, PlatformError> {
+        let inode_map = build_inode_map();
+        let mut sockets = Vec::new();
+        sockets.extend(parse_linux_tcp_conns(
+            "/proc/net/tcp",
+            false,
+            &inode_map,
+        )?);
+        sockets.extend(parse_linux_tcp_conns(
+            "/proc/net/tcp6",
+            true,
+            &inode_map,
+        )?);
+        Ok(sockets)
+    }
 }
 
 #[async_trait]