Feature Flags and shit codex did idfk

ipjs/Cargo.toml

@@ -5,6 +5,10 @@ version = "0.0.2"
 edition = "2024"
 publish = ["gitea"]
 
+[features]
+default = []
+experimental-nl = ["dep:rtnetlink"]
+
 [dependencies]
 macaddr = { version = "1", features = ["serde", "serde_std"] }
 strum = { version = "0", features = ["derive", "strum_macros"] }
@@ -13,7 +17,15 @@ serde = { version = "1", features = ["derive"] }
 serde_with = { version = "3", features = ["json"] }
 thiserror = "2"
 anyhow = "1"
-tokio = { version = "1", features = ["fs", "process", "rt-multi-thread", "io-util", "macros"] }
-rtnetlink = "0"
+tokio = { version = "1", features = [
+    "fs",
+    "process",
+    "rt-multi-thread",
+    "io-util",
+    "macros",
+] }
 futures = "0"
 
+
+[target.'cfg(unix)'.dependencies]
+rtnetlink = { version = "0", optional = true }

ipjs/src/lib.rs

@@ -13,7 +13,6 @@
 //! i also need to see devices and idk MAYBE maybe not MAYBE UHHHHHH maybe broadcast
 //!
 //! LOWK if this were to be calls to kernel or some bullshit then PLEASE because doing ts parsing its hell cuh
-
 pub mod subcommands;
 pub mod utils;
 

ipjs/src/subcommands/address/mod.rs

@@ -5,8 +5,10 @@
 //! lowk why its free but its indirection and its ass
 
 pub mod json;
+#[cfg(all(unix, feature = "experimental-nl"))]
 pub mod nl;
 
+pub use crate::subcommands::Backend;
 use crate::utils::serialize::mac::option_mac;
 use macaddr::MacAddr;
 use serde::{Deserialize, Serialize};
@@ -40,3 +42,18 @@ pub struct AddrInfo {
     pub label: Option<String>,
     // many more exist; we only take what we need
 }
+
+pub async fn get(dev: Option<&str>) -> anyhow::Result<Vec<AddrOutput>> {
+    get_with_backend(Backend::Json, dev).await
+}
+
+pub async fn get_with_backend(
+    backend: Backend,
+    dev: Option<&str>,
+) -> anyhow::Result<Vec<AddrOutput>> {
+    match backend {
+        Backend::Json => json::get(dev).await,
+        #[cfg(all(unix, feature = "experimental-nl"))]
+        Backend::Netlink => nl::get(dev).await,
+    }
+}

ipjs/src/subcommands/address/nl.rs

@@ -1,5 +1,5 @@
 //! i said i aint doing ts no more why am i still here
-
+#![cfg(unix)]
 use futures::TryStreamExt;
 
 use crate::subcommands::address::AddrOutput;

ipjs/src/subcommands/mod.rs

@@ -1,2 +1,9 @@
 pub mod address;
 pub mod neighbor;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Backend {
+    Json,
+    #[cfg(all(unix, feature = "experimental-nl"))]
+    Netlink,
+}

ipjs/src/subcommands/neighbor/mod.rs

@@ -5,8 +5,10 @@
 //! yes. this is a real call.
 
 pub mod json;
+#[cfg(all(unix, feature = "experimental-nl"))]
 pub mod nl;
 
+pub use crate::subcommands::Backend;
 use crate::utils::serialize::mac::option_mac;
 use std::net::IpAddr;
 
@@ -80,3 +82,28 @@ pub struct NeighborItem {
     #[serde(default)]
     pub state: Vec<NUDState>,
 }
+
+pub async fn get(
+    ip: Option<IpAddr>,
+    dev: Option<&str>,
+    nud: &[NUDState],
+) -> anyhow::Result<Vec<NeighborItem>> {
+    get_with_backend(Backend::Json, ip, dev, nud).await
+}
+
+pub async fn get_with_backend(
+    backend: Backend,
+    ip: Option<IpAddr>,
+    dev: Option<&str>,
+    nud: &[NUDState],
+) -> anyhow::Result<Vec<NeighborItem>> {
+    match backend {
+        Backend::Json => json::get(ip, dev, nud).await,
+        #[cfg(all(unix, feature = "experimental-nl"))]
+        Backend::Netlink => {
+            let ips: Vec<IpAddr> = ip.into_iter().collect();
+            let devs: Vec<&str> = dev.into_iter().collect();
+            nl::get(&ips, &devs, nud, &[]).await
+        }
+    }
+}

ipjs/src/subcommands/neighbor/nl.rs

@@ -1,5 +1,5 @@
 //! rtnetlink-based neighbor table query. One syscall, filter in userspace.
-
+#![cfg(unix)]
 use std::{
     collections::{HashMap, HashSet},
     net::IpAddr,

ipjs/tests/test.rs

@@ -2,16 +2,17 @@ use std::collections::HashSet;
 
 use lda_ipjs::subcommands::{address, neighbor};
 
+#[cfg(all(unix, feature = "experimental-nl"))]
 #[tokio::test] // ← Use tokio::test instead of manual #[tokio::main]
 async fn ball1() -> anyhow::Result<()> {
-    let result = neighbor::nl::get(&[], &[] as &[&str], &[], &[]).await?;
+    let result = neighbor::get_with_backend(neighbor::Backend::Netlink, None, None, &[]).await?;
     println!("netlink results: {:?}", result);
     Ok(()) // ← Don't force error, let it succeed
 }
 
 #[tokio::test]
 async fn ball2() -> anyhow::Result<()> {
-    let result = neighbor::json::get(None, None, &[]).await?;
+    let result = neighbor::get_with_backend(neighbor::Backend::Json, None, None, &[]).await?;
     println!("json results: {:?}", result);
     Ok(())
 }
@@ -91,30 +92,34 @@ impl TypeName for serde_json::Value {
 #[tokio::test]
 async fn ball_compare_backends() -> anyhow::Result<()> {
     println!("=== JSON Backend ===");
-    let json_result = neighbor::json::get(None, None, &[]).await?;
+    let json_result = neighbor::get_with_backend(neighbor::Backend::Json, None, None, &[]).await?;
     println!("Got {} entries from JSON", json_result.len());
 
-    println!("\n=== Netlink Backend ===");
-    let nl_result = neighbor::nl::get(&[], &[] as &[&str], &[], &[]).await?;
-    println!("Got {} entries from netlink", nl_result.len());
+    #[cfg(all(unix, feature = "experimental-nl"))]
+    {
+        println!("\n=== Netlink Backend ===");
+        let nl_result =
+            neighbor::get_with_backend(neighbor::Backend::Netlink, None, None, &[]).await?;
+        println!("Got {} entries from netlink", nl_result.len());
 
-    // Compare counts
-    if json_result.len() != nl_result.len() {
+        // Compare counts
+        if json_result.len() != nl_result.len() {
+            println!(
+                "\n⚠️ Count mismatch! JSON: {}, Netlink: {}",
+                json_result.len(),
+                nl_result.len()
+            );
+        } else {
+            println!("\n✅ Both backends returned same count");
+        }
+        let a: HashSet<neighbor::NeighborItem> = HashSet::from_iter(json_result);
+        let b: HashSet<neighbor::NeighborItem> = HashSet::from_iter(nl_result);
         println!(
-            "\n⚠️ Count mismatch! JSON: {}, Netlink: {}",
-            json_result.len(),
-            nl_result.len()
+            "istg {len1} == {len2} or else",
+            len1 = a.len(),
+            len2 = b.len()
         );
-    } else {
-        println!("\n✅ Both backends returned same count");
     }
-    let a: HashSet<neighbor::NeighborItem> = HashSet::from_iter(json_result);
-    let b: HashSet<neighbor::NeighborItem> = HashSet::from_iter(nl_result);
-    println!(
-        "istg {len1} == {len2} or else",
-        len1 = a.len(),
-        len2 = b.len()
-    );
 
     Ok(())
 }
@@ -126,7 +131,7 @@ async fn ball_compare_backends() -> anyhow::Result<()> {
 
 #[tokio::test]
 async fn ipjas() -> anyhow::Result<()> {
-    let cuh = address::json::get(None).await?;
+    let cuh = address::get_with_backend(address::Backend::Json, None).await?;
     println!("{cuh:#?}");
     Ok(())
 }