fuhh

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 {
-        serde_json::from_slice(&output.stdout).context("Deserialize failed")
+        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;

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,
+            ip,
-            dev: Some(item.dev),
+            dev,
-            mac: item.mac,
+            mac,
-            state: item
+            state: state
-                .state
                 .first()
                 .copied()
                 .map(Into::into)

src/route/status.rs

@@ -50,33 +50,20 @@ pub struct Filters {
 pub async fn get_status_json(
     Query(DeviceQuery {
         name,
-        filter:
+        filter: filters,
-            Filters {
-                ips,
-                devs,
-                nuds,
-                macs,
-            },
         ..
     }): Query<DeviceQuery>,
 ) -> impl IntoResponse {
     match get_macs(
-        &name.iter().collect::<Vec<_>>(),
+        name.as_slice(),
-        &ips,
+        &filters.ips,
-        &devs.iter().collect::<Vec<_>>(),
+        &filters.devs,
-        &nuds,
+        &filters.nuds,
-        &macs,
+        &filters.macs,
     )
     .await
     {
-        Ok(table) => {
+        Ok(table) => (
-            let filters = Filters {
-                ips,
-                devs,
-                nuds,
-                macs,
-            };
-            (
             StatusCode::OK,
             Json(Status {
                 name,
@@ -84,11 +71,14 @@ pub async fn get_status_json(
                 filters,
             }),
         )
-                .into_response()
+            .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
+    let lines = items.into_iter().map(Into::into).collect();
-        .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();
 
     Ok(lines)
 }