feat: added tcp

sorry Judah

sparse-windows-beacon/src/lib.rs

@@ -1,6 +1,6 @@
 use windows::{
-    core::*,
     Win32::{System::SystemServices::DLL_PROCESS_ATTACH, UI::WindowsAndMessaging::*},
+    core::*,
 };
 
 #[unsafe(no_mangle)]

sparse-windows-beacon/src/main.rs

@@ -0,0 +1,144 @@
+fn main() -> anyhow::Result<()> {
+    let devs = pcap_sys::PcapDevIterator::new()?;
+
+    for dev in devs {
+        println!("{dev}");
+    }
+
+    unsafe {
+        use std::ffi::CStr;
+
+        use windows::Win32::{
+            NetworkManagement::IpHelper::{
+                GAA_FLAG_INCLUDE_GATEWAYS, GET_ADAPTERS_ADDRESSES_FLAGS, GetAdaptersAddresses,
+                IP_ADAPTER_ADDRESSES_LH,
+            },
+            Networking::WinSock::AF_INET,
+        };
+
+        let mut size_pointer: u32 = 0;
+
+        let err = GetAdaptersAddresses(
+            2,
+            GET_ADAPTERS_ADDRESSES_FLAGS(0),
+            None,
+            None,
+            &mut size_pointer as *mut _,
+        );
+
+        let mut address_buffer = vec![0; size_pointer as usize];
+
+        let err2 = GetAdaptersAddresses(
+            2,
+            GAA_FLAG_INCLUDE_GATEWAYS,
+            None,
+            Some(address_buffer.as_mut_ptr() as *mut _),
+            &mut size_pointer as *mut _,
+        );
+
+        if err2 != 0 {
+            eprintln!("Error code received for second one: {err2}");
+            Err(std::io::Error::last_os_error())?;
+        }
+
+        let mut current_address = address_buffer.as_mut_ptr() as *mut IP_ADAPTER_ADDRESSES_LH;
+
+        fn pwstr_to_string(pwstr: *mut u16) -> String {
+            use std::ffi::OsString;
+            use std::os::windows::ffi::OsStringExt;
+            use std::slice;
+
+            if pwstr.is_null() {
+                return String::new();
+            }
+
+            // Find the length of the null-terminated UTF-16 string
+            let mut len = 0;
+            unsafe {
+                while *pwstr.add(len) != 0 {
+                    len += 1;
+                }
+
+                // Convert UTF-16 slice to Rust String
+                let wide_slice = slice::from_raw_parts(pwstr, len);
+                OsString::from_wide(wide_slice)
+                    .to_string_lossy()
+                    .into_owned()
+            }
+        }
+
+        while !current_address.is_null() {
+            println!("-----");
+            println!(
+                "Name: {:?} ({:?})",
+                CStr::from_ptr((*current_address).AdapterName.0 as *const _),
+                pwstr_to_string((*current_address).FriendlyName.0)
+            );
+
+            println!("Mtu: {:?}", (*current_address).Mtu);
+            println!(
+                "Physical address: {:X?}",
+                &(*current_address).PhysicalAddress
+                    [..(*current_address).PhysicalAddressLength as usize]
+            );
+
+            println!("IP addresses:");
+            let mut unicast_address = (*current_address).FirstUnicastAddress;
+
+            while !unicast_address.is_null() {
+                let address = (*(*unicast_address).Address.lpSockaddr).sa_data;
+
+                println!(
+                    "\tIP address: {}.{}.{}.{}/{}",
+                    address[2] as u8,
+                    address[3] as u8,
+                    address[4] as u8,
+                    address[5] as u8,
+                    (*unicast_address).OnLinkPrefixLength
+                );
+
+                unicast_address = (*unicast_address).Next;
+            }
+
+            println!("Gateways:");
+            let mut gateway = (*current_address).FirstGatewayAddress;
+
+            while !gateway.is_null() {
+                let address = (*(*gateway).Address.lpSockaddr).sa_data;
+
+                println!(
+                    "\tIP address: {}.{}.{}.{}",
+                    address[2] as u8, address[3] as u8, address[4] as u8, address[5] as u8
+                );
+
+                gateway = (*gateway).Next;
+            }
+
+            println!("Routes:");
+            let mut route = (*current_address).FirstPrefix;
+
+            while !route.is_null() {
+                let address = (*(*route).Address.lpSockaddr).sa_data;
+
+                println!(
+                    "\tRoute: {}.{}.{}.{}/{}",
+                    address[2] as u8,
+                    address[3] as u8,
+                    address[4] as u8,
+                    address[5] as u8,
+                    (*route).PrefixLength
+                );
+
+                route = (*route).Next;
+            }
+
+            println!("\n");
+
+            current_address = (*current_address).Next;
+        }
+
+        drop(address_buffer);
+    }
+
+    Ok(())
+}