fuhh

ipjs/src/subcommands/address/json.rs

@@ -32,7 +32,7 @@ pub async fn get(dev: Option<&str>) -> anyhow::Result<Vec<AddrOutput>> {
         anyhow::bail!(String::from_utf8_lossy(&output.stderr).into_owned());
     }
 
-    Ok(serde_json::from_slice(&output.stdout)?)
+    serde_json::from_slice(&output.stdout).context("Deserialize failed")
 }
 pub async fn _get(dev: Option<&str>) -> io::Result<Output> {
     let mut cmd = tokio::process::Command::new("ip");

ipjs/src/subcommands/neighbor/json.rs

@@ -24,7 +24,18 @@ pub async fn get(
     if !output.status.success() {
         bail!(String::from_utf8_lossy(&output.stderr).into_owned())
     } else {
-        Ok(serde_json::from_slice(&output.stdout)?)
+        let mut fuckass: Vec<NeighborItem> =
+            serde_json::from_slice(&output.stdout).context("Deserialize failed")?;
+
+        // i hate ts.
+        if let Some(dev) = dev {
+            for item in &mut fuckass {
+                if item.dev.is_none() {
+                    item.dev = Some(dev.to_owned());
+                }
+            }
+        };
+        Ok(fuckass)
     }
 }
 
@@ -33,6 +44,7 @@ pub async fn _get(ip: Option<IpAddr>, dev: Option<&str>, nud: &[NUDState]) -> io
     cmd.args(["-j", "neigh", "show"]);
 
     if let Some(ip) = ip {
+        // cmd.arg("to");
         cmd.arg(ip.to_canonical().to_string());
     };
 

ipjs/src/subcommands/neighbor/mod.rs

@@ -73,7 +73,8 @@ pub enum NUDState {
 pub struct NeighborItem {
     #[serde(rename(deserialize = "dst"))]
     pub ip: IpAddr,
-    pub dev: String,
+    #[serde(default)]
+    pub dev: Option<String>,
     #[serde(with = "option_mac", default, rename(deserialize = "lladdr"))]
     pub mac: Option<MacAddr>,
     #[serde(default)]

ipjs/src/subcommands/neighbor/nl.rs

@@ -93,7 +93,7 @@ pub async fn get(
             name
         };
 
-        let Some((ip, dev)) = ip.zip(dev) else {
+        let (Some(ip), Some(dev)) = (ip, dev) else {
             continue 'big;
         };
 
@@ -116,7 +116,7 @@ pub async fn get(
 
         result.push(NeighborItem {
             ip,
-            dev,
+            dev: Some(dev),
             mac,
             state,
         });

ipjs/src/utils/mod.rs

@@ -1,2 +1,2 @@
-pub mod iter;
+// pub mod iter;
 pub mod serialize;

ipjs/src/utils/serialize/mac.rs

@@ -1,6 +1,6 @@
 use macaddr::MacAddr;
 use serde::{self, Deserialize, Deserializer, de::Error as DeError};
-use serde::{Serialize, Serializer, de};
+use serde::{Serialize, Serializer};
 
 pub fn serialize_macs<S>(macs: &[MacAddr], serializer: S) -> Result<S::Ok, S::Error>
 where
@@ -33,14 +33,18 @@ pub mod option_mac {
     pub fn serialize<S: Serializer>(bro: &Option<MacAddr>, ser: S) -> Result<S::Ok, S::Error> {
         Option::<String>::serialize(&bro.as_ref().map(ToString::to_string), ser)
     }
-    /// deserialize an [`Option<MacAddr>`]
+    /// deserialize an [`Option<MacAddr>`], returns None for invalid input (::, 0.0.0.0)
     pub fn deserialize<'de, D>(des: D) -> Result<Option<MacAddr>, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
-        Option::<&str>::deserialize(des)?
-            .map(str::parse)
-            .transpose()
-            .map_err(de::Error::custom)
+        let s: Option<&str> = Option::<&str>::deserialize(des)?;
+        match s {
+            Some(val) => match val.parse::<MacAddr>() {
+                Ok(mac) => Ok(Some(mac)),
+                Err(_) => Ok(None),
+            },
+            None => Ok(None),
+        }
     }
 }

ipjs/tests/test.rs

@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 
-use lda_ipjs::subcommands::neighbor;
+use lda_ipjs::subcommands::{address, neighbor};
 
 #[tokio::test] // ← Use tokio::test instead of manual #[tokio::main]
 async fn ball1() -> anyhow::Result<()> {
@@ -119,7 +119,21 @@ async fn ball_compare_backends() -> anyhow::Result<()> {
     Ok(())
 }
 
+// #[tokio::test]
+// async fn cidr_filter() {
+//     unimplemented!("never. i aint add what i dont need")
+// }
+
 #[tokio::test]
-async fn cidr_filter() {
-    unimplemented!("never. i aint add what i dont need")
+async fn ipjas() -> anyhow::Result<()> {
+    let cuh = address::json::get(None).await?;
+    println!("{cuh:#?}");
+    Ok(())
+}
+
+#[tokio::test]
+async fn ipjas_raw() -> anyhow::Result<()> {
+    let cuh = address::json::_get(None).await?;
+    println!("{cuh:#?}");
+    Ok(())
 }

scripts/dev_push.ps1

@@ -1,4 +1,5 @@
-[System.Diagnostics.CodeAnalysis.SuppressMessage('PSAvoidDefaultValueSwitchParameter', 'Default true is intentional for fast dev loop')]
+[System.Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSAvoidDefaultValueSwitchParameter', "", 
+    Justification = 'Default true is intentional for fast dev loop')]
 param(
     [string]$Pass,
     [string]$HostName = "192.168.100.1",

scripts/test_remote.ps1

@@ -34,9 +34,9 @@ ForEach-Object { $_.Matches.Groups[1].Value } |
 Get-Item
 
 if ($testBinaries.Count -eq 0) {
-    Write-Error "No test binaries found!"
-    Write-Host "Cargo output:" -ForegroundColor Yellow
-    $cargoOutput | ForEach-Object { Write-Host $_ }
+    Write-Error "No test binaries found! Exiting..."
+    # Write-Host "Cargo output:" -ForegroundColor Yellow
+    # $cargoOutput | ForEach-Object { Write-Host $_ }
     exit 1
 }
 

src/arpparse/impls.rs

@@ -53,13 +53,19 @@ impl From<NUDState> for ipjs_neigh::NUDState {
 }
 
 impl From<NeighborItem> for IpNeighLine {
-    fn from(item: NeighborItem) -> Self {
+    fn from(
+        NeighborItem {
+            ip,
+            dev,
+            mac,
+            state,
+        }: NeighborItem,
+    ) -> Self {
         IpNeighLine {
-            ip: item.ip,
-            dev: Some(item.dev),
-            mac: item.mac,
-            state: item
-                .state
+            ip,
+            dev,
+            mac,
+            state: state
                 .first()
                 .copied()
                 .map(Into::into)

src/route/status.rs

@@ -50,45 +50,35 @@ pub struct Filters {
 pub async fn get_status_json(
     Query(DeviceQuery {
         name,
-        filter:
-            Filters {
-                ips,
-                devs,
-                nuds,
-                macs,
-            },
+        filter: filters,
         ..
     }): Query<DeviceQuery>,
 ) -> impl IntoResponse {
     match get_macs(
-        &name.iter().collect::<Vec<_>>(),
-        &ips,
-        &devs.iter().collect::<Vec<_>>(),
-        &nuds,
-        &macs,
+        name.as_slice(),
+        &filters.ips,
+        &filters.devs,
+        &filters.nuds,
+        &filters.macs,
     )
     .await
     {
-        Ok(table) => {
-            let filters = Filters {
-                ips,
-                devs,
-                nuds,
-                macs,
-            };
-            (
-                StatusCode::OK,
-                Json(Status {
-                    name,
-                    table,
-                    filters,
-                }),
-            )
-                .into_response()
-        }
+        Ok(table) => (
+            StatusCode::OK,
+            Json(Status {
+                name,
+                table,
+                filters,
+            }),
+        )
+            .into_response(),
         Err(error) => ApiError {
             code: StatusCode::BAD_GATEWAY,
-            error: error.to_string(),
+            error: error
+                .chain()
+                .map(ToString::to_string)
+                .collect::<Vec<_>>()
+                .join(": "),
         }
         .into_response(),
     }

src/utils/query/macs.rs

@@ -107,20 +107,7 @@ pub async fn get_mac(
         .await
         .context("Calling ip -j neigh failed")?;
 
-    let lines = items
-        .into_iter()
-        .map(|item| IpNeighLine {
-            ip: item.ip,
-            dev: Some(item.dev),
-            mac: item.mac,
-            state: item
-                .state
-                .first()
-                .copied()
-                .map(Into::into)
-                .unwrap_or(NUDState::None),
-        })
-        .collect();
+    let lines = items.into_iter().map(Into::into).collect();
 
     Ok(lines)
 }