Refactor OpenSockets to provide cross OS compatibility

Cargo.toml

@@ -34,6 +34,10 @@ trust-dns-resolver = "0.18.1"
 async-trait = "0.1.21"
 unicode-width = "0.1.8"
 
+[target.'cfg(target_os="windows")'.dependencies]
+netstat2 = "0.9.0"
+sysinfo = "0.15.1"
+
 [target.'cfg(target_os="linux")'.dependencies]
 procfs = "0.7.4"
 
@@ -43,3 +47,8 @@ pnet_base = "0.26.0"
 cargo-insta = "0.11.0"
 packet-builder = "0.5.0"
 regex = "1"
+
+[build-dependencies]
+#[target.'cfg(target_os="windows")'.build-dependencies]
+http_req = "0.7.0"
+zip = "0.5.6"

build.rs

@@ -0,0 +1,54 @@
+fn main() {
+    #[cfg(target_os = "windows")]
+    download_winpcap_sdk()
+}
+
+#[cfg(target_os = "windows")]
+fn download_winpcap_sdk() {
+    use http_req::request;
+    use std::env;
+    use std::fs::File;
+    use std::io::prelude::*;
+
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let out_dir = env::var("OUT_DIR").unwrap();
+
+    let mut reader = Vec::new();
+    let _res = request::get(
+        "https://nmap.org/npcap/dist/npcap-sdk-1.05.zip",
+        &mut reader,
+    )
+    .unwrap();
+
+    let mut pcapzip = File::create(format!("{}{}", out_dir, "/npcap.zip")).unwrap();
+    pcapzip.write_all(reader.as_slice()).unwrap();
+    pcapzip.flush().unwrap();
+
+    pcapzip = File::open(format!("{}{}", out_dir, "/npcap.zip")).unwrap();
+
+    let lib_name = "Packet.lib";
+    #[cfg(target_arch = "x86_64")]
+    let lib_dir = "Lib/x64";
+    #[cfg(target_arch = "x86")]
+    let lib_dir = "Lib";
+
+    let lib_path = format!("{}/{}", lib_dir, lib_name);
+    let mut zip_archive = zip::ZipArchive::new(pcapzip).unwrap();
+    let mut pcaplib = match zip_archive.by_name(lib_path.as_str()) {
+        Ok(pcaplib) => pcaplib,
+        Err(err) => {
+            panic!(err);
+        }
+    };
+
+    let mut pcaplib_bytes = Vec::new();
+    pcaplib.read_to_end(&mut pcaplib_bytes).unwrap();
+
+    std::fs::create_dir_all(format!("{}/{}", out_dir, lib_dir)).unwrap();
+    let mut pcaplib_file = File::create(format!("{}/{}", out_dir, lib_path)).unwrap();
+    pcaplib_file.write_all(pcaplib_bytes.as_slice()).unwrap();
+    pcaplib_file.flush().unwrap();
+
+    println!("cargo:rustc-link-search=native={}/{}", out_dir, lib_dir);
+}

src/main.rs

@@ -9,7 +9,7 @@ mod tests;
 use display::{elapsed_time, RawTerminalBackend, Ui};
 use network::{
     dns::{self, IpTable},
-    Connection, LocalSocket, Sniffer, Utilization,
+    LocalSocket, Sniffer, Utilization,
 };
 use os::OnSigWinch;
 
@@ -75,9 +75,6 @@ fn main() {
 }
 
 fn try_main() -> Result<(), failure::Error> {
-    #[cfg(target_os = "windows")]
-    compile_error!("Sorry, no implementations for Windows yet :( - PRs welcome!");
-
     use os::get_input;
     let opts = Opt::from_args();
     let os_input = get_input(&opts.interface, !opts.no_resolve)?;
@@ -101,7 +98,6 @@ fn try_main() -> Result<(), failure::Error> {
 
 pub struct OpenSockets {
     sockets_to_procs: HashMap<LocalSocket, String>,
-    connections: Vec<Connection>,
 }
 
 pub struct OsInputOutput {
@@ -190,19 +186,16 @@ where
                 while running.load(Ordering::Acquire) {
                     let render_start_time = Instant::now();
                     let utilization = { network_utilization.lock().unwrap().clone_and_reset() };
-                    let OpenSockets {
-                        sockets_to_procs,
-                        connections,
-                    } = get_open_sockets();
+                    let OpenSockets { sockets_to_procs } = get_open_sockets();
                     let mut ip_to_host = IpTable::new();
                     if let Some(dns_client) = dns_client.as_mut() {
                         ip_to_host = dns_client.cache();
-                        let unresolved_ips = connections
-                            .iter()
+                        let unresolved_ips = utilization
+                            .connections
+                            .keys()
                             .filter(|conn| !ip_to_host.contains_key(&conn.remote_socket.ip))
                             .map(|conn| conn.remote_socket.ip)
                             .collect::<Vec<_>>();
-
                         dns_client.resolve(unresolved_ips);
                     }
                     {

src/os/linux.rs

@@ -2,12 +2,11 @@ use ::std::collections::HashMap;
 
 use ::procfs::process::FDTarget;
 
-use crate::network::{Connection, Protocol};
+use crate::network::{LocalSocket, Protocol};
 use crate::OpenSockets;
 
 pub(crate) fn get_open_sockets() -> OpenSockets {
     let mut open_sockets = HashMap::new();
-    let mut connections = std::vec::Vec::new();
     let mut inode_to_procname = HashMap::new();
 
     if let Ok(all_procs) = procfs::process::all_processes() {
@@ -28,14 +27,15 @@ pub(crate) fn get_open_sockets() -> OpenSockets {
             tcp.append(&mut tcp6);
         }
         for entry in tcp.into_iter() {
-            let local_port = entry.local_address.port();
-            let local_ip = entry.local_address.ip();
-            if let (connection, Some(procname)) = (
-                Connection::new(entry.remote_address, local_ip, local_port, Protocol::Tcp),
-                inode_to_procname.get(&entry.inode),
-            ) {
-                open_sockets.insert(connection.local_socket, procname.clone());
-                connections.push(connection);
+            if let Some(procname) = inode_to_procname.get(&entry.inode) {
+                open_sockets.insert(
+                    LocalSocket {
+                        ip: entry.local_address.ip(),
+                        port: entry.local_address.port(),
+                        protocol: Protocol::Tcp,
+                    },
+                    procname.clone(),
+                );
             };
         }
     }
@@ -45,19 +45,20 @@ pub(crate) fn get_open_sockets() -> OpenSockets {
             udp.append(&mut udp6);
         }
         for entry in udp.into_iter() {
-            let local_port = entry.local_address.port();
-            let local_ip = entry.local_address.ip();
-            if let (connection, Some(procname)) = (
-                Connection::new(entry.remote_address, local_ip, local_port, Protocol::Udp),
-                inode_to_procname.get(&entry.inode),
-            ) {
-                open_sockets.insert(connection.local_socket, procname.clone());
-                connections.push(connection);
+            if let Some(procname) = inode_to_procname.get(&entry.inode) {
+                open_sockets.insert(
+                    LocalSocket {
+                        ip: entry.local_address.ip(),
+                        port: entry.local_address.port(),
+                        protocol: Protocol::Udp,
+                    },
+                    procname.clone(),
+                );
             };
         }
     }
+
     OpenSockets {
         sockets_to_procs: open_sockets,
-        connections,
     }
 }

src/os/lsof.rs

@@ -1,10 +1,9 @@
 use ::std::collections::HashMap;
 
-use crate::network::Connection;
+use crate::network::LocalSocket;
 use crate::OpenSockets;
 
 use super::lsof_utils;
-use std::net::SocketAddr;
 
 #[derive(Debug)]
 struct RawConnection {
@@ -17,26 +16,21 @@ struct RawConnection {
 
 pub(crate) fn get_open_sockets() -> OpenSockets {
     let mut open_sockets = HashMap::new();
-    let mut connections_vec = std::vec::Vec::new();
 
     let connections = lsof_utils::get_connections();
 
     for raw_connection in connections {
-        let protocol = raw_connection.get_protocol();
-        let remote_ip = raw_connection.get_remote_ip();
-        let local_ip = raw_connection.get_local_ip();
-        let remote_port = raw_connection.get_remote_port();
-        let local_port = raw_connection.get_local_port();
-
-        let socket_addr = SocketAddr::new(remote_ip, remote_port);
-        let connection = Connection::new(socket_addr, local_ip, local_port, protocol);
-
-        open_sockets.insert(connection.local_socket, raw_connection.process_name.clone());
-        connections_vec.push(connection);
+        open_sockets.insert(
+            LocalSocket {
+                ip: raw_connection.get_local_ip(),
+                port: raw_connection.get_local_port(),
+                protocol: raw_connection.get_protocol(),
+            },
+            raw_connection.process_name.clone(),
+        );
     }
 
     OpenSockets {
         sockets_to_procs: open_sockets,
-        connections: connections_vec,
     }
 }

src/os/lsof_utils.rs

@@ -106,14 +106,6 @@ impl RawConnection {
         Protocol::from_str(&self.protocol).unwrap()
     }
 
-    pub fn get_remote_ip(&self) -> IpAddr {
-        self.remote_ip.parse().unwrap()
-    }
-
-    pub fn get_remote_port(&self) -> u16 {
-        self.remote_port.parse::<u16>().unwrap()
-    }
-
     pub fn get_local_ip(&self) -> IpAddr {
         self.local_ip.parse().unwrap()
     }
@@ -203,19 +195,6 @@ com.apple   590 etoledom  204u  IPv4 0x28ffb9c04111253f      0t0  TCP 192.168.1.
         assert!(connection.is_none());
     }
 
-    #[test]
-    fn test_raw_connection_parse_remote_port_ipv4() {
-        test_raw_connection_parse_remote_port(LINE_RAW_OUTPUT);
-    }
-    #[test]
-    fn test_raw_connection_parse_remote_port_ipv6() {
-        test_raw_connection_parse_remote_port(IPV6_LINE_RAW_OUTPUT);
-    }
-    fn test_raw_connection_parse_remote_port(raw_output: &str) {
-        let connection = RawConnection::new(raw_output).unwrap();
-        assert_eq!(connection.get_remote_port(), 2222);
-    }
-
     #[test]
     fn test_raw_connection_parse_local_port_ipv4() {
         test_raw_connection_parse_local_port(LINE_RAW_OUTPUT);
@@ -229,19 +208,6 @@ com.apple   590 etoledom  204u  IPv4 0x28ffb9c04111253f      0t0  TCP 192.168.1.
         assert_eq!(connection.get_local_port(), 1111);
     }
 
-    #[test]
-    fn test_raw_connection_parse_ip_address_ipv4() {
-        test_raw_connection_parse_ip_address(LINE_RAW_OUTPUT, "198.252.206.25");
-    }
-    #[test]
-    fn test_raw_connection_parse_ip_address_ipv6() {
-        test_raw_connection_parse_ip_address(IPV6_LINE_RAW_OUTPUT, "fe80:4::aede:48ff:fe33:4455");
-    }
-    fn test_raw_connection_parse_ip_address(raw_output: &str, ip: &str) {
-        let connection = RawConnection::new(raw_output).unwrap();
-        assert_eq!(connection.get_remote_ip().to_string(), String::from(ip));
-    }
-
     #[test]
     fn test_raw_connection_parse_protocol_ipv4() {
         test_raw_connection_parse_protocol(LINE_RAW_OUTPUT);

src/os/mod.rs

@@ -7,6 +7,9 @@ pub(self) mod lsof;
 #[cfg(any(target_os = "macos", target_os = "freebsd"))]
 mod lsof_utils;
 
+#[cfg(target_os = "windows")]
+pub(self) mod windows;
+
 mod errors;
 mod shared;
 

src/os/shared.rs

@@ -9,12 +9,16 @@ use ::tokio::runtime::Runtime;
 use ::std::time;
 
 use crate::os::errors::GetInterfaceErrorKind;
+#[cfg(not(target_os = "windows"))]
 use signal_hook::iterator::Signals;
 
 #[cfg(target_os = "linux")]
 use crate::os::linux::get_open_sockets;
 #[cfg(any(target_os = "macos", target_os = "freebsd"))]
 use crate::os::lsof::get_open_sockets;
+#[cfg(target_os = "windows")]
+use crate::os::windows::get_open_sockets;
+
 use crate::{network::dns, OsInputOutput};
 
 pub type OnSigWinch = dyn Fn(Box<dyn Fn()>) + Send;
@@ -63,6 +67,7 @@ fn get_interface(interface_name: &str) -> Option<NetworkInterface> {
         .find(|iface| iface.name == interface_name)
 }
 
+#[cfg(not(target_os = "windows"))]
 fn sigwinch() -> (Box<OnSigWinch>, Box<SigCleanup>) {
     let signals = Signals::new(&[signal_hook::SIGWINCH]).unwrap();
     let on_winch = {
@@ -82,6 +87,15 @@ fn sigwinch() -> (Box<OnSigWinch>, Box<SigCleanup>) {
     (Box::new(on_winch), Box::new(cleanup))
 }
 
+#[cfg(any(target_os = "windows"))]
+fn sigwinch() -> (Box<OnSigWinch>, Box<SigCleanup>) {
+    let on_winch = { move |_cb: Box<dyn Fn()>| {} };
+    let cleanup = move || {
+        println!("Fake signal cleanup");
+    };
+    (Box::new(on_winch), Box::new(cleanup))
+}
+
 fn create_write_to_stdout() -> Box<dyn FnMut(String) + Send> {
     Box::new({
         let mut stdout = io::stdout();
@@ -180,6 +194,12 @@ pub fn get_input(
         datalink::interfaces()
     };
 
+    #[cfg(any(target_os = "windows"))]
+    let network_frames = network_interfaces
+        .iter()
+        .filter(|iface| !iface.ips.is_empty())
+        .map(|iface| (iface, get_datalink_channel(iface)));
+    #[cfg(not(target_os = "windows"))]
     let network_frames = network_interfaces
         .iter()
         .filter(|iface| iface.is_up() && !iface.ips.is_empty())
@@ -257,3 +277,9 @@ fn eperm_message() -> &'static str {
         `cap_sys_ptrace,cap_dac_read_search,cap_net_raw,cap_net_admin+ep`
     "#
 }
+
+#[inline]
+#[cfg(any(target_os = "windows"))]
+fn eperm_message() -> &'static str {
+    "Insufficient permissions to listen on network interface(s). Try running with administrator rights."
+}