Feature Flags and shit codex did idfk

"claude do it" type shi

Cargo.lock

@@ -26,6 +26,56 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.100"
@@ -206,6 +256,46 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "clap"
+version = "4.5.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2797f34da339ce31042b27d23607e051786132987f595b02ba4f6a6dffb7030a"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24a241312cea5059b13574bb9b3861cabf758b879c15190b37b6d6fd63ab6876"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
 [[package]]
 name = "color-eyre"
 version = "0.6.5"
@@ -233,6 +323,12 @@ dependencies = [
  "tracing-error",
 ]
 
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -603,6 +699,12 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
 [[package]]
 name = "itoa"
 version = "1.0.17"
@@ -627,7 +729,7 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "lda-ipjs"
-version = "0.0.1"
+version = "0.0.2"
 dependencies = [
  "anyhow",
  "futures",
@@ -800,6 +902,12 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
 [[package]]
 name = "owo-colors"
 version = "4.2.3"
@@ -1369,6 +1477,12 @@ version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
 
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
 [[package]]
 name = "valuable"
 version = "0.1.1"
@@ -1382,6 +1496,7 @@ dependencies = [
  "anyhow",
  "axum",
  "axum-extra",
+ "clap",
  "color-eyre",
  "futures",
  "lda-ipjs",
@@ -1389,12 +1504,35 @@ dependencies = [
  "serde",
  "serde_html_form",
  "serde_json",
- "serde_with",
- "strum",
- "thiserror 2.0.18",
  "tokio",
  "tower-http",
  "urlencoding",
+ "wakey-core",
+ "wakey-linux",
+]
+
+[[package]]
+name = "wakey-core"
+version = "0.1.0"
+dependencies = [
+ "macaddr",
+ "serde",
+ "serde_with",
+ "strum",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "wakey-linux"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "futures",
+ "lda-ipjs",
+ "macaddr",
+ "serde_json",
+ "tokio",
+ "wakey-core",
 ]
 
 [[package]]

Cargo.toml

@@ -8,15 +8,13 @@ publish = ["gitea"]
 anyhow = "1"
 axum = { version = "0", features = ["macros"] }
 axum-extra = { version = "0", features = ["query"] }
+clap = { version = "4", features = ["derive"] }
 color-eyre = "0"
 futures = "0"
 macaddr = { version = "1", features = ["serde", "serde_std"] }
 serde = { version = "1", features = ["derive"] }
 serde_html_form = "0"
 serde_json = "1"
-serde_with = { version = "3", features = ["json"] }
-strum = { version = "0", features = ["derive", "strum_macros"] }
-thiserror = "2"
 tokio = { version = "1", features = [
     "fs",
     "process",
@@ -26,6 +24,8 @@ tokio = { version = "1", features = [
 ] }
 tower-http = { version = "0", features = ["fs"] }
 urlencoding = "2"
+wakey-core = { path = "wakey-core" }
+wakey-linux = { path = "wakey-linux" }
 
 [profile.release]
 opt-level = "z"
@@ -37,7 +37,7 @@ very-smart-parsing = [
 ] # this is the a-bit-redundant parse thing that copilot made
 
 [workspace]
-members = ["ipjs"]
+members = ["ipjs", "wakey-core", "wakey-linux"]
 
 [dependencies.lda-ipjs]
 path = "ipjs"

README.md

@@ -2,19 +2,16 @@
 
 router shit
 
-## usage
+## whatever i did must be BEAUTIFUL
 
-- Build (Windows host OK):
+read [in vietnamese](https://ldlda.com/blogs/else/ssh-ax3000cv2-update-firmware-0-10-2)
-  - cargo build --release --target armv7-unknown-linux-musleabihf
-- Run on a Linux box/router:
-  - copy target/armv7-unknown-linux-musleabihf/release/wakey to the device
-  - chmod +x wakey && ./wakey
-- Install via release asset (OpenWrt):
-  - wget -O- `https://your.gitea/owner/repo/releases/download/vX.Y.Z/wakey-rootfs-vX.Y.Z-armv7-unknown-linux-musleabihf.tgz` | tar -xz -C /
-  - /etc/init.d/wakey enable && /etc/init.d/wakey start
 
-Optional updater (fetch latest automatically on OpenWrt):
+## now i NEED the split arch to be on
 
-```sh
+like RN rn rn so i can have web outside and the lil agent can be sitting here configuring itself (Parse/append to rc.local files? add to init.d? fuhh)
-WAKEY_HOST=git.ldlda.com WAKEY_OWNER=lda WAKEY_REPO=wakey sh /etc/ldlda_help/update_wakey.sh
+
-```
+I NEED IT
+
+I NEEED IT
+
+I NEEEEEED it.

ipjs/Cargo.toml

@@ -1,10 +1,14 @@
 [package]
 name = "lda-ipjs"
 description = "ip -j show schemas"
-version = "0.0.1"
+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"] }
+tokio = { version = "1", features = [
-rtnetlink = "0"
+    "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;
@@ -14,8 +14,9 @@ pub async fn get(dev: Option<&str>) -> anyhow::Result<Vec<AddrOutput>> {
         link = link.match_name(dev.to_owned());
         if let Some(ind) = link.execute().try_next().await?.map(|a| a.header.index) {
             address = address.set_link_index_filter(ind);
-        }
         };
         address.execute().try_next().await?;
-    todo!()
+    } else {
+    };
+    todo!();
 }

ipjs/src/subcommands/link/mod.rs

@@ -0,0 +1 @@
+//! this is for link. You need link; at least to build an index -> name map. i Need It. sometimes.

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,6 +1,5 @@
-//! this is purely experimental. im not doing ts no mo
+//! rtnetlink-based neighbor table query. One syscall, filter in userspace.
-
+#![cfg(unix)]
-// hallo
 use std::{
     collections::{HashMap, HashSet},
     net::IpAddr,
@@ -16,115 +15,113 @@ use rtnetlink::packet_route::{
 
 use super::{NUDState, NeighborItem};
 
-// dont you love https://github.com/rust-netlink/rtnetlink/blob/main/examples/get_neighbours.rs
+/// Fetch neighbors via rtnetlink. Empty slice = no filter (match all).
-// NeighborItem.state guarantees to be a single thing.
+/// Non-empty slice = match ANY in the set.
+// https://github.com/rust-netlink/rtnetlink/blob/main/examples/get_neighbours.rs
 pub async fn get(
-    ip: Option<IpAddr>,
+    ips: &[IpAddr],
-    dev: Option<&str>,
+    devs: &[impl AsRef<str>],
-    nud: &[NUDState],
+    nuds: &[NUDState],
+    macs: &[MacAddr],
 ) -> anyhow::Result<Vec<NeighborItem>> {
-    let (gip, gdev, gnud) = (ip, dev, nud);
     let (conn, handle, _) = rtnetlink::new_connection()?;
-    tokio::spawn(conn); // every time?
+    tokio::spawn(conn);
-    let mut neighbor_data = handle.neighbours().get().execute();
-    let nudset: HashSet<&NUDState> = HashSet::from_iter(gnud);
 
-    // map ifindex to name
+    let mut neighbor_data = handle.neighbours().get().execute();
-    let mut ball: HashMap<u32, String> = HashMap::new();
+
+    // Build filter sets (empty = match all)
+    let ip_set: HashSet<IpAddr> = ips.iter().copied().collect();
+    let dev_set: HashSet<&str> = devs.iter().map(AsRef::as_ref).collect();
+    let nud_set: HashSet<&NUDState> = nuds.iter().collect();
+    let mac_set: HashSet<MacAddr> = macs.iter().copied().collect();
+
+    // Cache ifindex -> name
+    let mut ifname_cache: HashMap<u32, String> = HashMap::new();
     let mut result = vec![];
-    'big: while let Some(neighbour_message_item) = neighbor_data.try_next().await? {
+
-        // Filter by address family
+    'row: while let Some(msg) = neighbor_data.try_next().await? {
+        // Only IPv4/IPv6, skip NOARP
         if !matches!(
-            neighbour_message_item.header.family,
+            msg.header.family,
             AddressFamily::Inet | AddressFamily::Inet6
-        ) || matches!(neighbour_message_item.header.state, NeighbourState::Noarp)
+        ) || matches!(msg.header.state, NeighbourState::Noarp)
-        // copilot says this to match ip -j n s
         {
-            continue 'big;
+            continue 'row;
         }
 
-        let state = vec![
+        let state: NUDState = msg.header.state.try_into().unwrap_or_default();
-            neighbour_message_item
-                .header
-                .state
-                .try_into()
-                .unwrap_or_default(),
-        ]; // ONE ITEM. why tf ts design json.
         let mut ip = None;
         let mut mac = None;
 
-        for neigh_attr in neighbour_message_item.attributes {
+        for attr in msg.attributes {
-            match neigh_attr {
+            match attr {
-                NeighbourAttribute::Destination(neighbour_address) => match neighbour_address {
+                NeighbourAttribute::Destination(addr) => match addr {
-                    NeighbourAddress::Inet(ipv4_addr) => ip = Some(ipv4_addr.into()),
+                    NeighbourAddress::Inet(v4) => ip = Some(IpAddr::from(v4)),
-                    NeighbourAddress::Inet6(ipv6_addr) => ip = Some(ipv6_addr.into()),
+                    NeighbourAddress::Inet6(v6) => ip = Some(IpAddr::from(v6)),
-                    _ => continue 'big,
+                    _ => continue 'row,
                 },
-                NeighbourAttribute::LinkLocalAddress(items) => {
+                NeighbourAttribute::LinkLocalAddress(bytes) => {
-                    mac = match items.len() {
+                    mac = match bytes.len() {
-                        6 => items.first_chunk::<6>().map(|&e| MacAddr::from(e)),
+                        6 => bytes.first_chunk::<6>().map(|&b| MacAddr::from(b)),
-                        8 => items.first_chunk::<8>().map(|&e| MacAddr::from(e)),
+                        8 => bytes.first_chunk::<8>().map(|&b| MacAddr::from(b)),
-                        _ => continue 'big,
+                        _ => continue 'row,
                     }
                 }
-                _ => continue,
+                _ => {}
             }
         }
 
-        // exquisite
+        // Resolve ifindex -> name (cached)
-        let dev = if let Some(cached) = ball.get(&neighbour_message_item.header.ifindex) {
+        let dev = match ifname_cache.get(&msg.header.ifindex) {
-            Some(cached.clone())
+            Some(name) => Some(name.clone()),
-        } else {
+            None => {
-            // Query and cache
                 let name = handle
                     .link()
                     .get()
-                .match_index(neighbour_message_item.header.ifindex)
+                    .match_index(msg.header.ifindex)
                     .execute()
                     .try_next()
                     .await?
-                .and_then(|a| {
+                    .and_then(|link| {
-                    a.attributes.into_iter().find_map(|attr| match attr {
+                        link.attributes.into_iter().find_map(|a| match a {
-                        LinkAttribute::IfName(name) => Some(name),
+                            LinkAttribute::IfName(n) => Some(n),
                             _ => None,
                         })
                     });
-
                 if let Some(ref n) = name {
-                ball.insert(neighbour_message_item.header.ifindex, n.clone());
+                    ifname_cache.insert(msg.header.ifindex, n.clone());
                 }
                 name
+            }
         };
 
         let (Some(ip), Some(dev)) = (ip, dev) else {
-            continue 'big;
+            continue 'row;
         };
 
-        {
+        // Apply filters (empty set = match all)
-            // low block
+        if !ip_set.is_empty() && !ip_set.contains(&ip) {
-            if let Some(fip) = gip
+            continue 'row;
-                && fip != ip
-            {
-                continue 'big;
         }
-            if let Some(fdev) = gdev
+        if !dev_set.is_empty() && !dev_set.contains(dev.as_str()) {
-                && dev != fdev
+            continue 'row;
-            {
-                continue 'big;
         }
-            if !nudset.is_empty() && !nudset.contains(&state[0]) {
+        if !nud_set.is_empty() && !nud_set.contains(&state) {
-                continue 'big;
+            continue 'row;
-            };
+        }
+        if !mac_set.is_empty() && !mac.is_some_and(|m| mac_set.contains(&m)) {
+            continue 'row;
         }
 
         result.push(NeighborItem {
             ip,
             dev: Some(dev),
             mac,
-            state,
+            state: vec![state],
         });
     }
-    Ok(result) // now i need another pass to filter out the uh.
+
+    Ok(result)
 }
 
 impl TryFrom<NeighbourState> for NUDState {
@@ -140,7 +137,7 @@ impl TryFrom<NeighbourState> for NUDState {
             NeighbourState::Permanent => Ok(Self::Permanent),
             NeighbourState::None => Ok(Self::None),
             NeighbourState::Other(e) => Ok(Self::Other(e)),
-            _ => Err(u16::MAX), // idk
+            _ => Err(u16::MAX),
         }
     }
 

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(None, None, &[]).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,11 +92,14 @@ 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());
 
+    #[cfg(all(unix, feature = "experimental-nl"))]
+    {
         println!("\n=== Netlink Backend ===");
-    let nl_result = neighbor::nl::get(None, None, &[]).await?;
+        let nl_result =
+            neighbor::get_with_backend(neighbor::Backend::Netlink, None, None, &[]).await?;
         println!("Got {} entries from netlink", nl_result.len());
 
         // Compare counts
@@ -115,6 +119,7 @@ async fn ball_compare_backends() -> anyhow::Result<()> {
             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(())
 }

remote/copy.ps1

@@ -0,0 +1,18 @@
+# this does one thing
+param(
+    [string]$PASSWD
+)
+
+# idk what this does it works like that then thats how it is
+pscp.exe -l root -scp -pw $PASSWD -r 192.168.100.1:/etc/ldlda_help $PSScriptRoot
+pscp.exe -l root -scp -pw $PASSWD  192.168.100.1:/etc/rc.local $PSScriptRoot
+
+$initDir = Join-Path $PSScriptRoot 'init.d'
+New-Item -ItemType Directory -Force -Path $initDir | Out-Null
+
+# these are sum
+$files = "update_wakey" , "wakey" , "update_tailscale" , "wireguard_setup"
+$remote = $files.ForEach({ "/etc/init.d/$_" })
+$remote | ForEach-Object {
+    pscp.exe -l root -scp -pw $PASSWD "192.168.100.1:$_" "$initDir\"
+}

scripts/dev_push.ps1

@@ -17,6 +17,8 @@ try { $PSStyle.OutputRendering = 'Host' } catch {}
 
 . "$PSScriptRoot/lib.ps1"
 
+$Pass = Get-DefaultPassword $Pass
+
 function Get-DeployScript {
     param($DeployPreferred, $DeployTmp, $RemoteTmp, $RemotePath, $RestartFlag)
     return @"

scripts/init/openwrt/wakey

@@ -9,7 +9,7 @@ BIN=/root/.bin/wakey
 
 start_service() {
     procd_open_instance
-    procd_set_param command "$BIN"
+    procd_set_param command "$BIN" http --host :: --port 12012
     procd_set_param respawn 5 1 0
     procd_set_param stdout 1
     procd_set_param stderr 1

scripts/ldlda_help/update_wakey.sh

@@ -69,10 +69,10 @@ latest_asset_url() {
     HOST=$1 OWNER=$2 REPO=$3 ARCH=$4
     API="https://$HOST/api/v1/repos/$OWNER/$REPO/releases/latest"
     RESP=$(http_get "$API") || return 1
-    # Extract the first browser_download_url ending with our ARCH .tgz (BusyBox-friendly)
+    # Extract the LAST browser_download_url ending with our ARCH .tgz (BusyBox-friendly)
     echo "$RESP" |
         grep -o '"browser_download_url"[[:space:]]*:[[:space:]]*"[^"]*'"$ARCH"'\.tgz"' |
-        head -n1 |
+        tail -n1 |
         cut -d '"' -f 4
 }
 

scripts/lib.ps1

@@ -1,5 +1,20 @@
 # Shared functions for wakey scripts
 
+function Get-DefaultPassword {
+    param([string]$Password)
+
+    if ($Password) {
+        return $Password
+    }
+
+    $pwPath = Join-Path (Split-Path -Parent $PSScriptRoot) 'ar_data/pw'
+    if (-not (Test-Path $pwPath)) {
+        throw "Password not provided and default file not found: $pwPath"
+    }
+
+    return (Get-Content -Raw $pwPath).Trim()
+}
+
 function Invoke-Ext {
     param($Exe, $Arguments, $Label)
     $displayArgs = $Arguments.Clone()

scripts/test_remote.ps1

@@ -16,6 +16,8 @@ $ErrorActionPreference = "Stop"
 
 . "$PSScriptRoot/lib.ps1"
 
+$password = Get-DefaultPassword $password
+
 # Build tests and capture output
 Write-Host "Building tests for $Package..." -ForegroundColor Cyan
 

src/arpparse.rs

@@ -0,0 +1,2 @@
+pub use wakey_core::NeighborEntry as IpNeighLine;
+pub use wakey_core::NeighborState as NUDState;

src/arpparse/error.rs

@@ -1,30 +0,0 @@
-use std::net::AddrParseError;
-
-use strum::Display;
-use thiserror::Error;
-
-#[derive(Debug, Display, Error)]
-pub enum IPNeighParseError {
-    IpWhere, // i never seen a ip neigh where the first thing aint an ip
-    IpParseError(AddrParseError),
-    // DevWhere,
-    MacParseError(macaddr::ParseError),
-    StateWhere, // i never seen a ip neigh without the big FAILED at the end
-    StateParseError(strum::ParseError),
-}
-
-impl From<AddrParseError> for IPNeighParseError {
-    fn from(value: AddrParseError) -> Self {
-        Self::IpParseError(value)
-    }
-}
-impl From<macaddr::ParseError> for IPNeighParseError {
-    fn from(value: macaddr::ParseError) -> Self {
-        Self::MacParseError(value)
-    }
-}
-impl From<strum::ParseError> for IPNeighParseError {
-    fn from(value: strum::ParseError) -> Self {
-        Self::StateParseError(value)
-    }
-}

src/arpparse/impls.rs

@@ -1,75 +0,0 @@
-//! r#impl AHHHHHH
-
-use serde::{Deserialize, Deserializer, de};
-
-use super::NUDState;
-
-// Case-insensitive parsing for NUDState via manual Deserialize
-impl<'de> Deserialize<'de> for NUDState {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s: &str = <&str as Deserialize>::deserialize(deserializer)?;
-        s.parse().map_err(de::Error::custom)
-    }
-}
-
-use crate::arpparse::IpNeighLine;
-
-use lda_ipjs::subcommands::neighbor::{self as ipjs_neigh, NeighborItem};
-
-impl From<ipjs_neigh::NUDState> for NUDState {
-    fn from(value: ipjs_neigh::NUDState) -> Self {
-        match value {
-            ipjs_neigh::NUDState::Permanent => NUDState::Permanent,
-            ipjs_neigh::NUDState::Noarp => NUDState::Noarp,
-            ipjs_neigh::NUDState::Reachable => NUDState::Reachable,
-            ipjs_neigh::NUDState::Stale => NUDState::Stale,
-            ipjs_neigh::NUDState::None => NUDState::None,
-            ipjs_neigh::NUDState::Incomplete => NUDState::Incomplete,
-            ipjs_neigh::NUDState::Delay => NUDState::Delay,
-            ipjs_neigh::NUDState::Probe => NUDState::Probe,
-            ipjs_neigh::NUDState::Failed => NUDState::Failed,
-            ipjs_neigh::NUDState::Other(_) => NUDState::None,
-        }
-    }
-}
-
-impl From<NUDState> for ipjs_neigh::NUDState {
-    fn from(value: NUDState) -> Self {
-        match value {
-            NUDState::Permanent => ipjs_neigh::NUDState::Permanent,
-            NUDState::Noarp => ipjs_neigh::NUDState::Noarp,
-            NUDState::Reachable => ipjs_neigh::NUDState::Reachable,
-            NUDState::Stale => ipjs_neigh::NUDState::Stale,
-            NUDState::None => ipjs_neigh::NUDState::None,
-            NUDState::Incomplete => ipjs_neigh::NUDState::Incomplete,
-            NUDState::Delay => ipjs_neigh::NUDState::Delay,
-            NUDState::Probe => ipjs_neigh::NUDState::Probe,
-            NUDState::Failed => ipjs_neigh::NUDState::Failed,
-        }
-    }
-}
-
-impl From<NeighborItem> for IpNeighLine {
-    fn from(
-        NeighborItem {
-            ip,
-            dev,
-            mac,
-            state,
-        }: NeighborItem,
-    ) -> Self {
-        IpNeighLine {
-            ip,
-            dev,
-            mac,
-            state: state
-                .into_iter()
-                .map(Into::into)
-                .max()
-                .unwrap_or(NUDState::None),
-        }
-    }
-}

src/arpparse/mod.rs

@@ -1,250 +0,0 @@
-// struct arp;
-
-// async fn read_arp() -> io::Result<()> {
-//     let arp_file = tokio::fs::File::open("/proc/net/arp").await?;
-//     let arp_read = BufReader::new(arp_file);
-//     Ok(())
-// }
-
-//! ip neigh pass
-
-use std::{net::IpAddr, str::FromStr};
-
-use crate::utils::parse::mac;
-use macaddr::MacAddr;
-use serde_with::skip_serializing_none;
-use strum::{Display, EnumString};
-
-use crate::arpparse::error::IPNeighParseError;
-mod error;
-mod impls; // custom (de)serialization impls
-
-/// ip neigh has some cool shit.
-///
-/// IP  
-/// dev DEV | None  
-/// lladdr MAC | None  
-/// status  { permanent | noarp | stale | reachable | none | incomplete | delay | probe | failed } (ip neigh help)
-///
-/// so you can see its damn good
-#[skip_serializing_none]
-#[derive(Debug, PartialEq, Eq, Clone, Hash, serde::Serialize)]
-pub struct IpNeighLine {
-    pub ip: IpAddr,
-    pub dev: Option<String>,
-    /// link layer address
-    #[serde(with = "mac::option_mac")]
-    pub mac: Option<MacAddr>,
-    /// Neighbour Unreachability Detection
-    pub state: NUDState,
-}
-
-// NUDState custom Deserialize now lives in arpparse/impl.rs; use serde_with OneOrMany for Vec
-
-#[derive(
-    Debug, PartialEq, Eq, EnumString, Display, Clone, Copy, Hash, serde::Serialize, Default,
-)]
-#[strum(serialize_all = "UPPERCASE", ascii_case_insensitive)]
-#[serde(rename_all = "UPPERCASE")]
-pub enum NUDState {
-    /// the neighbour entry is valid forever and can
-    /// be only be removed administratively.
-    Permanent,
-
-    /// the neighbour entry is valid. No attempts to
-    /// validate this entry will be made but it can
-    /// be removed when its lifetime expires.
-    Noarp,
-
-    /// the neighbour entry is valid until the
-    /// reachability timeout expires.
-    Reachable,
-
-    /// the neighbour entry is valid but suspicious.
-    /// This option to ip neigh does not change the
-    /// neighbour state if it was valid and the
-    /// address is not changed by this command.
-    Stale,
-
-    /// the neighbour entry has not (yet) been
-    /// validated/resolved.
-    Incomplete,
-    /// neighbor entry validation is currently
-    /// delayed.
-    Delay,
-    /// neighbor is being probed.
-    Probe,
-    /// max number of probes exceeded without
-    /// success, neighbor validation has ultimately
-    /// failed.
-    Failed,
-
-    /// this is a pseudo state used when initially
-    /// creating a neighbour entry or after trying to
-    /// remove it before it becomes free to do so.
-    #[serde(other)]
-    #[default]
-    None,
-}
-
-impl NUDState {
-    /// Argument form expected by `ip neigh ... nud <state>` (lowercase)
-    pub const fn as_ip_neigh_arg(self) -> &'static str {
-        match self {
-            NUDState::Permanent => "permanent",
-            NUDState::Reachable => "reachable",
-            NUDState::Stale => "stale",
-            NUDState::Delay => "delay",
-            NUDState::Probe => "probe",
-            NUDState::Incomplete => "incomplete",
-            NUDState::Noarp => "noarp",
-            NUDState::None => "none",
-            NUDState::Failed => "failed",
-        }
-    }
-    /// dumb UI label
-    pub fn _dumber_state(&self) -> &'static str {
-        match self {
-            NUDState::Permanent | NUDState::Reachable => "online",
-            NUDState::Stale => "maybe online",
-            NUDState::Delay | NUDState::Probe | NUDState::Incomplete => "resolving",
-            NUDState::Noarp => "static",
-            NUDState::None => "unknown",
-            NUDState::Failed => "offline",
-        }
-    }
-    /// dumb boolean: Some(true)=on, Some(false)=off, None=shrug
-    pub fn _dumber_state_this_way(&self) -> Option<bool> {
-        match self {
-            NUDState::Permanent | NUDState::Reachable => Some(true),
-            NUDState::Failed => Some(false),
-            _ => None,
-        }
-    }
-}
-// thanks copilot for the PEAK
-pub fn parse_ip_neigh_line(s: &str) -> Result<IpNeighLine, IPNeighParseError> {
-    let mut it = s.split_whitespace();
-    let ip: IpAddr = it.next().ok_or(IPNeighParseError::IpWhere)?.parse()?;
-
-    let mut dev: Option<String> = None;
-    let mut mac: Option<MacAddr> = None;
-    let mut state: Option<NUDState> = None;
-    let mut last_tok: Option<&str> = None;
-
-    while let Some(tok) = it.next() {
-        match tok {
-            "dev" => dev = it.next().map(str::to_string),
-            "lladdr" => {
-                mac = it.next().map(|m| m.parse()).transpose()?;
-            }
-            "nud" => {
-                // we know this aint happening
-                state = it.next().map(|st| st.parse()).transpose()?;
-            }
-            other => last_tok = Some(other),
-        }
-    }
-
-    // If no explicit "nud", many outputs end with STATE
-    if state.is_none()
-        && let Some(st) = last_tok
-    {
-        state = Some(st.parse()?);
-    }
-
-    Ok(IpNeighLine {
-        ip,
-        dev,
-        mac,
-        state: state.ok_or(IPNeighParseError::StateWhere)?,
-    })
-}
-
-impl FromStr for IpNeighLine {
-    type Err = IPNeighParseError;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        parse_ip_neigh_line(s)
-    }
-}
-/// pls dont touch ts
-impl IpNeighLine {
-    /* // these are some not needed fns
-    pub fn set_ip(&mut self, ip: IpAddr) {
-        self.ip = ip;
-    }
-    pub fn set_state(&mut self, state: NUDState) {
-        self.state = state;
-    }
-    pub fn ip(self, ip: IpAddr) -> Self {
-        Self { ip, ..self }
-    }
-    pub fn state(self, state: NUDState) -> Self {
-        Self { state, ..self }
-    }
-    */
-    pub fn _with_dev(dev: impl Into<String>) -> impl FnMut(Self) -> Self {
-        let dev = dev.into();
-        move |self_| Self {
-            dev: Some(dev.clone()),
-            ..self_
-        }
-    }
-    pub fn _with_mac(mac: MacAddr) -> impl FnMut(Self) -> Self {
-        move |self_| Self {
-            mac: Some(mac),
-            ..self_
-        }
-    }
-}
-
-// ideas from copilot:
-
-impl NUDState {
-    // higher is "better"/more online
-    pub const fn rank(self) -> u8 {
-        match self {
-            NUDState::Permanent | NUDState::Reachable => 5,
-            NUDState::Stale => 4,
-            NUDState::Delay | NUDState::Probe | NUDState::Incomplete => 3,
-            NUDState::Noarp => 2,
-            NUDState::None => 1,
-            NUDState::Failed => 0,
-        }
-    }
-}
-impl PartialOrd for NUDState {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-impl Ord for NUDState {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.rank().cmp(&other.rank())
-    }
-}
-
-impl IpNeighLine {
-    // score for “local and online”: state, has-mac, v4, iface preference
-    pub fn _score(&self) -> (u8, u8, u8, u8) {
-        let iface = self
-            .dev
-            .as_deref()
-            .map(|d| {
-                if d.starts_with("br") || d.starts_with("lan") || d.starts_with("eth") {
-                    2
-                } else if d.starts_with("wlan") || d.starts_with("wl") {
-                    1
-                } else {
-                    0
-                }
-            })
-            .unwrap_or(0);
-        (
-            self.state.rank(),
-            self.mac.is_some() as u8,
-            matches!(self.ip, IpAddr::V4(_)) as u8,
-            iface,
-        )
-    }
-}

src/compat.rs

@@ -0,0 +1,145 @@
+use serde::Serialize;
+use wakey_core::parse::mac;
+use wakey_core::{
+    DeviceFilters, DhcpLeaseWithState, NeighborEntry, Status, WakeResult, WakeTargetResult,
+};
+
+#[derive(Debug, Clone, Serialize)]
+pub struct LegacyStatusRow {
+    pub ip: std::net::IpAddr,
+    pub dev: Option<String>,
+    #[serde(with = "mac::option_mac")]
+    pub mac: Option<macaddr::MacAddr>,
+    pub state: wakey_core::NeighborState,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct LegacyStatusResponse {
+    pub name: Option<String>,
+    pub table: Vec<LegacyStatusRow>,
+    pub filters: DeviceFilters,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct LegacyLeaseRow {
+    pub expires_epoch: u64,
+    pub ip: std::net::IpAddr,
+    #[serde(with = "mac")]
+    pub mac: macaddr::MacAddr,
+    pub name: Option<String>,
+    pub nud_state: Option<wakey_core::NeighborState>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct LegacyWakeResult {
+    pub result: Vec<LegacyWakeResultRow>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize)]
+pub struct LegacyWakeResultRow {
+    #[serde(flatten)]
+    pub target: wakey_core::WakeTarget,
+    pub status: wakey_core::WakeStatus,
+}
+
+pub fn legacy_status_from_domain(status: Status<NeighborEntry>) -> LegacyStatusResponse {
+    LegacyStatusResponse {
+        name: status.name,
+        table: status.table.into_iter().map(legacy_status_row).collect(),
+        filters: status.filters,
+    }
+}
+
+pub fn legacy_status_row(row: NeighborEntry) -> LegacyStatusRow {
+    LegacyStatusRow {
+        ip: row.ip,
+        dev: row.dev,
+        mac: row.mac,
+        state: row.state,
+    }
+}
+
+pub fn legacy_leases_from_domain(leases: Vec<DhcpLeaseWithState>) -> Vec<LegacyLeaseRow> {
+    leases.into_iter().map(legacy_lease_row).collect()
+}
+
+pub fn legacy_lease_row(lease: DhcpLeaseWithState) -> LegacyLeaseRow {
+    LegacyLeaseRow {
+        expires_epoch: lease.lease_line.expires_epoch,
+        ip: lease.lease_line.ip,
+        mac: lease.lease_line.mac,
+        name: lease.lease_line.name,
+        nud_state: lease.nud_state,
+    }
+}
+
+pub fn legacy_wake_from_domain(result: WakeResult) -> LegacyWakeResult {
+    LegacyWakeResult {
+        result: result.result.into_iter().map(legacy_wake_row).collect(),
+    }
+}
+
+pub fn legacy_wake_row(row: WakeTargetResult) -> LegacyWakeResultRow {
+    LegacyWakeResultRow {
+        target: row.target,
+        status: row.status,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::net::{IpAddr, Ipv4Addr};
+    use wakey_core::{DhcpLease, NeighborState, WakeStatus, WakeTarget};
+
+    #[test]
+    fn maps_status_to_legacy_shape() {
+        let status = Status {
+            name: Some("pc".into()),
+            table: vec![NeighborEntry {
+                ip: IpAddr::V4(Ipv4Addr::new(192, 168, 1, 10)),
+                dev: Some("br-lan".into()),
+                mac: Some("aa:bb:cc:dd:ee:ff".parse().expect("mac")),
+                state: NeighborState::Reachable,
+            }],
+            filters: DeviceFilters::default(),
+        };
+        let legacy = legacy_status_from_domain(status);
+        assert_eq!(legacy.name.as_deref(), Some("pc"));
+        assert_eq!(legacy.table.len(), 1);
+        assert_eq!(legacy.table[0].state, NeighborState::Reachable);
+    }
+
+    #[test]
+    fn maps_leases_to_legacy_shape() {
+        let leases = vec![DhcpLeaseWithState {
+            lease_line: DhcpLease {
+                expires_epoch: 42,
+                ip: IpAddr::V4(Ipv4Addr::LOCALHOST),
+                mac: "aa:bb:cc:dd:ee:ff".parse().expect("mac"),
+                name: Some("pc".into()),
+            },
+            nud_state: Some(NeighborState::Reachable),
+        }];
+        let legacy = legacy_leases_from_domain(leases);
+        assert_eq!(legacy.len(), 1);
+        assert_eq!(legacy[0].name.as_deref(), Some("pc"));
+        assert_eq!(legacy[0].nud_state, Some(NeighborState::Reachable));
+    }
+
+    #[test]
+    fn maps_wake_to_legacy_shape() {
+        let result = WakeResult {
+            result: vec![WakeTargetResult {
+                target: WakeTarget {
+                    ip: Some(IpAddr::V4(Ipv4Addr::LOCALHOST)),
+                    mac: Some("aa:bb:cc:dd:ee:ff".parse().expect("mac")),
+                },
+                status: WakeStatus::Succeed,
+            }],
+        };
+        let legacy = legacy_wake_from_domain(result);
+        assert_eq!(legacy.result.len(), 1);
+        assert_eq!(legacy.result[0].status, WakeStatus::Succeed);
+    }
+}

src/dhcpparse.rs

@@ -1,84 +1 @@
-/// MAC->name cache location (ephemeral)
+pub use wakey_linux::dhcp::{load_mac_name_cache, read_dhcp_leases_with_names};
-const MAC_NAME_CACHE: &str = "/tmp/wakey_mac_names.json";
-
-/// Load MAC->name cache from disk
-pub(crate) async fn load_mac_name_cache() -> io::Result<std::collections::BTreeMap<String, String>>
-{
-    match tokio::fs::read_to_string(MAC_NAME_CACHE).await {
-        Ok(s) => serde_json::from_str(&s).map_err(io::Error::other),
-        Err(e) if e.kind() == ErrorKind::NotFound => Ok(Default::default()),
-        Err(e) => Err(e),
-    }
-}
-
-/// Save MAC->name cache to disk
-async fn save_mac_name_cache(map: &std::collections::BTreeMap<String, String>) -> io::Result<()> {
-    let s = serde_json::to_string(map).map_err(io::Error::other)?;
-    let _ = tokio::fs::write(MAC_NAME_CACHE, s).await;
-    Ok(())
-}
-
-/// Read all leases, filling names from MAC->name cache if missing
-pub async fn read_dhcp_leases_with_names() -> io::Result<Vec<DhcpLeaseLine>> {
-    let leases = read_dhcp_leases().await?;
-    let mut cache = load_mac_name_cache().await.unwrap_or_default();
-    let mut changed = false;
-    let mut leases_with_names = Vec::with_capacity(leases.len());
-    for mut l in leases {
-        let mac_s = l.mac.to_string();
-        if let Some(ref name) = l.name {
-            // if no name in cache file or it changed
-            if cache.get(&mac_s).map(|v| v != name).unwrap_or(true) {
-                cache.insert(mac_s, name.clone());
-                changed = true;
-            }
-        } else if let Some(prev) = cache.get(&mac_s) {
-            l.name = Some(prev.clone());
-        }
-        leases_with_names.push(l);
-    }
-    if changed {
-        let _ = save_mac_name_cache(&cache).await;
-    }
-    Ok(leases_with_names)
-}
-use crate::utils::parse::mac;
-use macaddr::MacAddr;
-use std::io::{self, ErrorKind};
-use std::net::IpAddr;
-
-/// A single line from /tmp/dhcp.leases
-#[derive(Debug, Clone, serde::Serialize)]
-pub struct DhcpLeaseLine {
-    /// Epoch seconds when the lease expires
-    pub expires_epoch: u64,
-    pub ip: IpAddr,
-    #[serde(with = "mac")]
-    pub mac: MacAddr,
-    pub name: Option<String>,
-}
-
-/// Parse one line of /tmp/dhcp.leases
-pub fn parse_dhcp_lease_line(line: &str) -> Option<DhcpLeaseLine> {
-    let mut c = line.split_whitespace();
-    let expires_epoch: u64 = c.next()?.parse().ok()?;
-    let mac = c.next()?.parse().ok()?;
-    let ip = c.next()?.parse().ok()?;
-    let name = c.next().filter(|c| *c != "*").map(str::to_string);
-    // ignore any remaining columns (e.g., client-id)
-    Some(DhcpLeaseLine {
-        expires_epoch,
-        ip,
-        mac,
-        name,
-    })
-}
-
-/// Read all leases from /tmp/dhcp.leases (simple and fast)
-pub async fn read_dhcp_leases() -> io::Result<Vec<DhcpLeaseLine>> {
-    match tokio::fs::read_to_string("/tmp/dhcp.leases").await {
-        Ok(file) => Ok(file.lines().filter_map(parse_dhcp_lease_line).collect()),
-        Err(e) if e.kind() == ErrorKind::NotFound => Ok(Vec::new()),
-        Err(e) => Err(e),
-    }
-}

src/lib.rs

@@ -0,0 +1,209 @@
+pub mod arpparse;
+pub mod compat;
+pub mod dhcpparse;
+pub mod route;
+pub mod utils;
+
+use std::{io, net::SocketAddr};
+
+use anyhow::{Context, Result};
+use axum::Router;
+use tokio::net::TcpListener;
+use tower_http::services::ServeDir;
+use wakey_core::{
+    DeviceFilters, DeviceQuery, DhcpLease, DhcpLeaseWithState, NeighborEntry, QueryInput, Status,
+    WakeResult, WakeTarget,
+};
+
+pub type StatusResponse = Status<NeighborEntry>;
+
+pub async fn resolve_query(input: impl Into<String>) -> Result<DeviceQuery> {
+    Ok(
+        match wakey_linux::devices::classify_query(input.into()).await {
+            QueryInput::Ip(ip_addr) => DeviceQuery {
+                filter: DeviceFilters {
+                    ips: vec![ip_addr],
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            QueryInput::Mac(mac_addr) => DeviceQuery {
+                filter: DeviceFilters {
+                    macs: vec![mac_addr],
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            QueryInput::Dev(dev) => DeviceQuery {
+                filter: DeviceFilters {
+                    devs: vec![dev],
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            QueryInput::Nud(state) => DeviceQuery {
+                filter: DeviceFilters {
+                    nuds: vec![state],
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            QueryInput::Name(name) => DeviceQuery {
+                name: Some(name),
+                ..Default::default()
+            },
+        },
+    )
+}
+
+pub async fn get_status(query: DeviceQuery) -> Result<StatusResponse> {
+    let table = wakey_linux::devices::query_status(&query).await?;
+    Ok(Status {
+        name: query.name,
+        table,
+        filters: query.filter,
+    })
+}
+
+pub async fn get_status_for_input(input: impl Into<String>) -> Result<StatusResponse> {
+    let query = resolve_query(input).await?;
+    get_status(query).await
+}
+
+pub async fn get_leases(include_state: bool) -> Result<Vec<DhcpLeaseWithState>> {
+    let leases = wakey_linux::dhcp::read_dhcp_leases_with_names()
+        .await
+        .context("failed to read DHCP leases")?;
+    if include_state {
+        Ok(wakey_linux::dhcp::enrich_leases_with_nud_state(leases).await)
+    } else {
+        Ok(leases
+            .into_iter()
+            .map(|lease_line| DhcpLeaseWithState {
+                lease_line,
+                nud_state: None,
+            })
+            .collect())
+    }
+}
+
+pub async fn wake_targets(targets: Vec<WakeTarget>) -> Result<WakeResult> {
+    let result = wakey_linux::wake::wake_many(targets)
+        .await
+        .context("failed to send wake packets")?;
+    Ok(WakeResult { result })
+}
+
+pub async fn wake_from_query(input: impl Into<String>) -> Result<WakeResult> {
+    let status = get_status_for_input(input).await?;
+    let targets = status
+        .table
+        .into_iter()
+        .map(|entry| WakeTarget {
+            ip: Some(entry.ip),
+            mac: entry.mac,
+        })
+        .collect();
+    wake_targets(targets).await
+}
+
+pub async fn list_interfaces() -> Result<Vec<String>> {
+    Ok(wakey_linux::devices::devs_sorted().await)
+}
+
+pub async fn get_ips(name: impl AsRef<str>) -> Result<Vec<std::net::IpAddr>> {
+    Ok(wakey_linux::devices::get_ips(name.as_ref())
+        .await?
+        .collect())
+}
+
+pub fn http_app(static_root: std::path::PathBuf) -> Router {
+    Router::new()
+        .nest("/api", route::api_router())
+        .fallback_service(axum::routing::get_service(
+            ServeDir::new(static_root)
+                .append_index_html_on_directories(true)
+                .precompressed_br()
+                .precompressed_deflate()
+                .precompressed_gzip()
+                .precompressed_zstd(),
+        ))
+}
+
+pub async fn serve_http(addr: SocketAddr, static_root: std::path::PathBuf) -> io::Result<()> {
+    let listener = TcpListener::bind(addr).await?;
+    axum::serve(listener, http_app(static_root).into_make_service()).await
+}
+
+pub async fn serve_http_from_current_exe(addr: SocketAddr) -> io::Result<()> {
+    let exe = std::env::current_exe()?;
+    let root = exe
+        .parent()
+        .ok_or_else(|| io::Error::other("no parent dir"))?;
+    serve_http(addr, root.join("static")).await
+}
+
+pub fn leases_without_state(leases: Vec<DhcpLease>) -> Vec<DhcpLeaseWithState> {
+    leases
+        .into_iter()
+        .map(|lease_line| DhcpLeaseWithState {
+            lease_line,
+            nud_state: None,
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::net::{IpAddr, Ipv4Addr};
+    use wakey_core::{NeighborState, WakeStatus};
+
+    #[tokio::test]
+    async fn resolve_query_parses_ip() {
+        let query = resolve_query("192.168.1.10").await.expect("resolve query");
+        assert_eq!(
+            query.filter.ips,
+            vec![IpAddr::V4(Ipv4Addr::new(192, 168, 1, 10))]
+        );
+    }
+
+    #[tokio::test]
+    async fn resolve_query_parses_mac() {
+        let query = resolve_query("aa:bb:cc:dd:ee:ff")
+            .await
+            .expect("resolve query");
+        assert_eq!(query.filter.macs.len(), 1);
+    }
+
+    #[tokio::test]
+    async fn resolve_query_parses_nud() {
+        let query = resolve_query("reachable").await.expect("resolve query");
+        assert_eq!(query.filter.nuds, vec![NeighborState::Reachable]);
+    }
+
+    #[test]
+    fn leases_without_state_clears_nud_state() {
+        let leases = vec![DhcpLease {
+            expires_epoch: 1,
+            ip: IpAddr::V4(Ipv4Addr::LOCALHOST),
+            mac: "aa:bb:cc:dd:ee:ff".parse().expect("mac"),
+            name: Some("pc".into()),
+        }];
+        let out = leases_without_state(leases);
+        assert_eq!(out.len(), 1);
+        assert!(out[0].nud_state.is_none());
+    }
+
+    #[tokio::test]
+    async fn wake_targets_marks_incomplete() {
+        let out = wake_targets(vec![WakeTarget {
+            ip: Some(IpAddr::V4(Ipv4Addr::LOCALHOST)),
+            mac: None,
+        }])
+        .await
+        .expect("wake");
+        assert_eq!(out.result.len(), 1);
+        assert_eq!(out.result[0].status, WakeStatus::Incomplete);
+    }
+}

src/main.rs

@@ -1,65 +1,126 @@
-//! braindead version v0.1.x
+use std::net::{IpAddr, SocketAddr};
-//!
-//! # whats next
-//!
-//! for version 2 i hope to have:
-//!
-//! 1. idk reworked frontend;
-//! 2. incorporate ip -j;
-//! 3. small 1-5 second caching;
 
-use axum::Router;
+use clap::{Args, Parser, Subcommand};
-use tokio::net::TcpListener;
+use wakey_core::{DeviceFilters, DeviceQuery};
-mod arpparse;
-mod dhcpparse;
-mod route;
-mod utils;
-use std::{env, io};
 
-#[cfg(target_os = "linux")]
+#[derive(Parser)]
-#[tokio::main]
+#[command(name = "wakey")]
-async fn entry() -> io::Result<()> {
+#[command(version, about = "Wakey service CLI and HTTP adapter")]
-    use crate::route::api_router;
+struct Cli {
-    use axum::routing::get_service;
+    #[command(subcommand)]
-    use tower_http::services::ServeDir;
+    command: Command,
-    let exe = env::current_exe()?;
+}
-    let root = exe
-        .parent()
-        .ok_or_else(|| io::Error::other("no parent dir"))?;
-    let static_dir = ServeDir::new(root.join("static"))
-        .append_index_html_on_directories(true)
-        .precompressed_br()
-        .precompressed_deflate()
-        .precompressed_gzip()
-        .precompressed_zstd();
-    let app = Router::new()
-        // .route("/home", get(home))
-        // .route("/", get(home_2))
-        // .merge(home_2_route())
-        // .route("/status", get(get_status_2))
-        .nest("/api", api_router())
-        .fallback_service(get_service(static_dir));
 
-    let port = TcpListener::bind("0.0.0.0:12012").await?;
+#[derive(Subcommand)]
-    axum::serve(port, app.into_make_service()).await?;
+enum Command {
-    Ok(())
+    Http(HttpArgs),
+    Status(StatusArgs),
+    Leases(LeasesArgs),
+    Wake(WakeArgs),
+    Devs,
+}
+
+#[derive(Args)]
+struct HttpArgs {
+    #[arg(long, default_value = "::")]
+    host: IpAddr,
+    #[arg(long, default_value_t = 12012)]
+    port: u16,
+}
+
+#[derive(Args)]
+struct LeasesArgs {
+    #[arg(long)]
+    include_state: bool,
+}
+
+#[derive(Args)]
+struct WakeArgs {
+    query: String,
+}
+
+#[derive(Args)]
+struct StatusArgs {
+    query: Option<String>,
+    #[arg(long)]
+    name: Option<String>,
+    #[arg(long = "ip")]
+    ips: Vec<std::net::IpAddr>,
+    #[arg(long = "dev")]
+    devs: Vec<String>,
+    #[arg(long = "nud")]
+    nuds: Vec<wakey_core::NeighborState>,
+    #[arg(long = "mac")]
+    macs: Vec<macaddr::MacAddr>,
+}
+
+fn status_args_to_query(args: StatusArgs) -> wakey_core::DeviceQuery {
+    if let Some(query) = args.query.as_ref()
+        && args.name.is_none()
+        && args.ips.is_empty()
+        && args.devs.is_empty()
+        && args.nuds.is_empty()
+        && args.macs.is_empty()
+    {
+        return DeviceQuery {
+            name: Some(query.clone()),
+            ..Default::default()
+        };
+    }
+
+    DeviceQuery {
+        name: args.name.or(args.query),
+        filter: DeviceFilters {
+            ips: args.ips,
+            devs: args.devs,
+            nuds: args.nuds,
+            macs: args.macs,
+        },
+    }
 }
 
 #[cfg(not(target_os = "linux"))]
-fn main() -> color_eyre::Result<()> {
+fn main() -> anyhow::Result<()> {
-    use std::net::ToSocketAddrs;
+    Err(anyhow::anyhow!(
-    color_eyre::install()?;
-    // use crate::arpparse::NUDState;
-    // println!("{}", NUDState::Reachable.to_string().to_lowercase());
-    println!("{:?}", "svuhuvshdv:331".to_socket_addrs());
-    // Err(Os { code: 11001, kind: Uncategorized, message: "No such host is known." })
-    Err(color_eyre::eyre::eyre!(
         "OS not supported! run this on your ahh router!"
     ))
 }
 
 #[cfg(target_os = "linux")]
-fn main() -> color_eyre::Result<()> {
+#[tokio::main]
-    color_eyre::install()?;
+async fn main() -> anyhow::Result<()> {
-    Ok(entry()?)
+    let cli = Cli::parse();
+    match cli.command {
+        Command::Http(args) => {
+            let addr = SocketAddr::new(args.host, args.port);
+            wakey::serve_http_from_current_exe(addr).await?;
+        }
+        Command::Status(args) => {
+            let query = status_args_to_query(args);
+            let status = if query.name.is_some()
+                && query.filter.ips.is_empty()
+                && query.filter.devs.is_empty()
+                && query.filter.nuds.is_empty()
+                && query.filter.macs.is_empty()
+            {
+                wakey::get_status_for_input(query.name.clone().unwrap_or_default()).await?
+            } else {
+                wakey::get_status(query).await?
+            };
+            println!("{}", serde_json::to_string_pretty(&status)?);
+        }
+        Command::Leases(args) => {
+            let leases = wakey::get_leases(args.include_state).await?;
+            println!("{}", serde_json::to_string_pretty(&leases)?);
+        }
+        Command::Wake(args) => {
+            let result = wakey::wake_from_query(args.query).await?;
+            println!("{}", serde_json::to_string_pretty(&result)?);
+        }
+        Command::Devs => {
+            let devs = wakey::list_interfaces().await?;
+            println!("{}", serde_json::to_string_pretty(&devs)?);
+        }
+    }
+    Ok(())
 }

src/route/api.rs

@@ -1,51 +1,24 @@
 use crate::route::error::ApiError;
-use crate::utils::query::parser::{QueryType, parse_query};
 use axum::Json;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::{extract::Path, response::Redirect};
+use wakey_core::DeviceQuery;
 
-use crate::route::status::{DeviceQuery, Filters, NamePath};
+use crate::route::status::NamePath;
-use crate::utils::query::get_ips;
 
 // Smart redirect: accept IP, MAC, dev, or NUD state and redirect to /api/status accordingly
 pub async fn status_smart_redirect(
     Path(q): Path<String>,
 ) -> axum::response::Result<Redirect, impl IntoResponse> {
-    // no less bullshit
+    let query: DeviceQuery = match crate::resolve_query(q).await {
-    let query = match parse_query(q).await {
+        Ok(query) => query,
-        QueryType::Ip(ip_addr) => DeviceQuery {
+        Err(e) => {
-            filter: Filters {
+            return Err(ApiError {
-                ips: vec![ip_addr],
+                error: e.to_string(),
-                ..Default::default()
+                code: StatusCode::BAD_GATEWAY,
-            },
+            });
-            ..Default::default()
+        }
-        },
-        QueryType::Mac(mac_addr) => DeviceQuery {
-            filter: Filters {
-                macs: vec![mac_addr],
-                ..Default::default()
-            },
-            ..Default::default()
-        },
-        QueryType::Dev(s) => DeviceQuery {
-            filter: Filters {
-                devs: vec![s],
-                ..Default::default()
-            },
-            ..Default::default()
-        },
-        QueryType::Nud(nudstate) => DeviceQuery {
-            filter: Filters {
-                nuds: vec![nudstate],
-                ..Default::default()
-            },
-            ..Default::default()
-        },
-        QueryType::Unknown(n) => DeviceQuery {
-            name: Some(n),
-            ..Default::default()
-        },
     };
     match serde_html_form::to_string(query) {
         Ok(e) => Ok(Redirect::to(&format!("/api/status?{e}"))),
@@ -64,8 +37,8 @@ pub async fn status_redirect(Path(NamePath { name }): Path<NamePath>) -> Redirec
 }
 
 pub async fn ip(Path(name): Path<String>) -> impl IntoResponse {
-    get_ips(&name).await.map_or_else(
+    crate::get_ips(&name).await.map_or_else(
         |e| ApiError::ise(e.to_string()).into_response(),
-        |ips| Json(ips.collect::<Vec<_>>()).into_response(),
+        |ips| Json(ips).into_response(),
     )
 }

src/route/devs.rs

@@ -1,7 +1,10 @@
-use crate::utils::query::dev;
+use crate::route::error::ApiError;
-use axum::Json;
+use axum::{Json, response::IntoResponse};
 
-pub async fn devs_router() -> Json<Vec<String>> {
+pub async fn devs_router() -> impl IntoResponse {
-    dev::devs_sorted().await.into()
+    match crate::list_interfaces().await {
+        Ok(devs) => Json(devs).into_response(),
+        Err(e) => ApiError::ise(e.to_string()).into_response(),
+    }
 }
 // Device listing endpoints

src/route/dhcp.rs

@@ -1,8 +1,4 @@
-use crate::{
+use crate::{route::error::ApiError, utils::parse::boolish_str};
-    dhcpparse::read_dhcp_leases_with_names,
-    route::error::ApiError,
-    utils::{parse::boolish_str, query::enrich_leases_with_nud_state},
-};
 use axum::{Json, extract::Query, http::StatusCode, response::IntoResponse};
 
 // DHCP lease endpoints
@@ -11,21 +7,17 @@ pub struct DhcpLeasesQueryRaw {
     include_state: Option<String>,
 }
 
-pub async fn get_dhcp_leases(Query(raw): Query<DhcpLeasesQueryRaw>) -> impl IntoResponse {
+pub async fn get_dhcp_leases(
-    let include_state = raw
+    Query(DhcpLeasesQueryRaw { include_state }): Query<DhcpLeasesQueryRaw>,
-        .include_state
+) -> impl IntoResponse {
-        .as_deref()
+    let include_state = include_state.as_deref().map(boolish_str).unwrap_or(false);
-        .map(boolish_str)
-        .unwrap_or(false);
 
-    match read_dhcp_leases_with_names().await {
+    match crate::get_leases(include_state).await {
-        Ok(leases_with_names) => {
+        Ok(leases) => (
-            if !include_state {
+            StatusCode::OK,
-                return (StatusCode::OK, Json(leases_with_names)).into_response();
+            Json(crate::compat::legacy_leases_from_domain(leases)),
-            }
+        )
-            let out = enrich_leases_with_nud_state(leases_with_names).await;
+            .into_response(),
-            (StatusCode::OK, Json(out)).into_response()
-        }
         Err(e) => ApiError {
             error: e.to_string(),
             code: StatusCode::BAD_GATEWAY,

src/route/error.rs

@@ -6,15 +6,15 @@ use axum::{
 use serde::Serialize;
 
 #[derive(Debug, Serialize)]
-pub struct ApiError {
+pub struct ApiError<T: Serialize> {
     #[serde(skip_serializing, skip_deserializing)]
     pub code: StatusCode,
-    pub error: String,
+    pub error: T,
 }
 
-impl ApiError {
+impl<T: Serialize> ApiError<T> {
     /// [StatusCode::INTERNAL_SERVER_ERROR] shortcut
-    pub const fn ise(error: String) -> Self {
+    pub const fn ise(error: T) -> Self {
         Self {
             code: StatusCode::INTERNAL_SERVER_ERROR,
             error,
@@ -22,7 +22,7 @@ impl ApiError {
     }
 }
 
-impl IntoResponse for ApiError {
+impl<T: Serialize> IntoResponse for ApiError<T> {
     fn into_response(self) -> Response {
         (self.code, Json(self)).into_response()
     }

src/route/mod.rs

@@ -12,6 +12,7 @@ use crate::route::api::status_redirect;
 use crate::route::api::status_smart_redirect;
 use crate::route::devs::devs_router;
 use crate::route::dhcp::get_dhcp_leases;
+use crate::route::error::ApiError;
 use crate::route::status::get_status_json;
 use crate::route::wake::wake_multi;
 
@@ -46,11 +47,9 @@ pub fn api_router() -> Router {
         .route("/ips/{name}", get(ip))
         .route(
             "/mac-cache",
-            get(|| async {
+            get(async || match load_mac_name_cache().await {
-                match load_mac_name_cache().await {
                 Ok(h) => Json(h).into_response(),
-                    Err(e) => e.to_string().into_response(),
+                Err(e) => ApiError::ise(e.to_string()).into_response(),
-                }
             }),
         )
         .layer(middleware::from_fn(add_performance_header))

src/route/status.rs

@@ -1,75 +1,13 @@
 use crate::route::error::ApiError;
 use axum::{Json, http::StatusCode, response::IntoResponse};
 use axum_extra::extract::Query;
-use macaddr::MacAddr;
+pub use wakey_core::{DeviceQuery, NamePath};
-use serde::{Deserialize, Serialize};
-use serde_with::skip_serializing_none;
-use serde_with::{DisplayFromStr, OneOrMany, serde_as};
-use std::net::IpAddr;
 
-use crate::arpparse::NUDState;
+pub async fn get_status_json(Query(query): Query<DeviceQuery>) -> impl IntoResponse {
-use crate::utils::query::get_macs;
+    match crate::get_status(query).await {
-
+        Ok(status) => (
-#[derive(Debug, Default, Clone, Hash, Deserialize, Serialize)]
-pub struct DeviceQuery {
-    pub name: Option<String>,
-    #[serde(flatten)]
-    pub filter: Filters,
-}
-
-#[derive(Debug, Default, Clone, Hash, Deserialize)]
-pub struct NamePath {
-    pub name: String,
-}
-
-#[skip_serializing_none]
-#[derive(Debug, Default, Serialize)]
-pub struct Status<T> {
-    pub name: Option<String>,
-    pub table: Vec<T>,
-    pub filters: Filters,
-}
-
-#[serde_as]
-#[derive(Debug, Default, Clone, Hash, Serialize, Deserialize)]
-pub struct Filters {
-    #[serde_as(as = "OneOrMany<_>")]
-    #[serde(default)]
-    pub ips: Vec<IpAddr>,
-    #[serde_as(as = "OneOrMany<_>")]
-    #[serde(default)]
-    pub devs: Vec<String>,
-    #[serde_as(as = "OneOrMany<_>")]
-    #[serde(default)]
-    pub nuds: Vec<NUDState>,
-    #[serde_as(as = "OneOrMany<DisplayFromStr>")]
-    #[serde(default)]
-    pub macs: Vec<MacAddr>,
-}
-
-pub async fn get_status_json(
-    Query(DeviceQuery {
-        name,
-        filter: filters,
-        ..
-    }): Query<DeviceQuery>,
-) -> impl IntoResponse {
-    match get_macs(
-        name.as_slice(),
-        &filters.ips,
-        &filters.devs,
-        &filters.nuds,
-        &filters.macs,
-    )
-    .await
-    {
-        Ok(table) => (
             StatusCode::OK,
-            Json(Status {
+            Json(crate::compat::legacy_status_from_domain(status)),
-                name,
-                table,
-                filters,
-            }),
         )
             .into_response(),
         Err(error) => ApiError {

src/route/wake.rs

@@ -1,112 +1,17 @@
-//! impls are at [`utils::wake::impl`](crate::utils::wake::r#impl) for some reason
+use crate::route::error::ApiError;
-use std::io;
-use std::net::IpAddr;
-
-/* use crate::arpparse::IpNeighLine;
-use crate::route::api::Status; */
-use crate::utils::parse::mac;
-use crate::utils::wake::wake_one;
 use axum::{extract::Json, http::StatusCode, response::IntoResponse};
-use futures::TryFutureExt;
+pub use wakey_core::WakeTarget;
-use macaddr::MacAddr;
-use serde::{Deserialize, Serialize};
-use serde_with::skip_serializing_none;
-use tokio::net::UdpSocket;
-
-#[skip_serializing_none]
-#[derive(Debug, Default, Serialize, Clone)]
-pub struct WakeResult {
-    pub success: bool,
-    pub result: Option<Vec<WakeTargetResult>>,
-    pub error: Option<String>,
-}
-#[skip_serializing_none]
-#[derive(Debug, Serialize, Clone, Copy)]
-pub struct WakeTargetResult {
-    #[serde(flatten)]
-    pub target: WakeTarget,
-    pub status: WakeTargetStatus,
-}
-
-#[derive(Debug, Serialize, Clone, Copy, Hash)]
-#[serde(rename_all = "snake_case")]
-pub enum WakeTargetStatus {
-    Succeed,
-    /// not a real address...
-    NonexistentAddress,
-    WrongSize,
-    /// input is not enough
-    Incomplete,
-}
-
-#[skip_serializing_none]
-#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
-pub struct WakeTarget {
-    #[serde(default)]
-    pub ip: Option<IpAddr>,
-    #[serde(default, with = "mac::option_mac")]
-    pub mac: Option<MacAddr>,
-}
 
 pub async fn wake_multi(Json(req): Json<Vec<WakeTarget>>) -> impl IntoResponse {
-    match wake_multi_split(req).await {
+    match crate::wake_targets(req).await {
-        Ok(results) => (
+        Ok(result) => (
             StatusCode::OK,
-            Json(WakeResult {
+            Json(crate::compat::legacy_wake_from_domain(result)),
-                success: true,
-                result: Some(results),
-                ..Default::default()
-            }),
-        ),
-        Err(error) => {
-            let error = Some(format!("Error: {}", error));
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(WakeResult {
-                    success: false,
-                    error,
-                    ..Default::default()
-                }),
         )
+            .into_response(),
+        Err(error) => {
+            let error = format!("Error: {}", error);
+            ApiError::ise(error).into_response()
         }
     }
 }
-
-/// this is so bad
-pub async fn wake_multi_split(
-    targets: impl IntoIterator<Item = WakeTarget>,
-) -> io::Result<Vec<WakeTargetResult>> {
-    let sock = UdpSocket::bind("[::]:0")
-        .or_else(|_| UdpSocket::bind(":0"))
-        .await?;
-    sock.set_broadcast(true)?;
-
-    let iter = targets.into_iter().map(async |c| {
-        if c.is_incomplete() {
-            c.to_incomplete()
-        } else {
-            let t = c.try_into().expect("complete struct failed to try_into");
-            wake_one(&sock, t).await.into()
-        }
-    });
-    Ok(futures::future::join_all(iter).await)
-}
-/* #[derive(Debug, Serialize)]
-pub struct WakeStatusLine {
-    #[serde(flatten)]
-    pub status: IpNeighLine, // most powerful find of the century
-    pub wake_status: WakeTargetStatus,
-}
-pub type WakeStatus = Status<WakeStatusLine>; */
-// /// return status BUT plus a indicator of i sent a wake.
-// pub async fn wake_status(
-//     Query(DeviceQuery {
-//         name,
-//         ip,
-//         dev,
-//         nud,
-//         mac,
-//         ..
-//     }): Query<DeviceQuery>,
-// ) -> impl IntoResponse {
-// }

src/utils/parse.rs

@@ -0,0 +1,41 @@
+/// key for yes: "1" | "true" | "yes" | "on" | "y"
+///
+/// frfr
+pub fn _de_boolish<'de, D>(des: D) -> Result<bool, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::Deserialize;
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum Boolish {
+        B(bool),
+        I(u8),
+        S(String),
+    }
+    Ok(match Boolish::deserialize(des)? {
+        Boolish::B(b) => b,
+        Boolish::I(i) => i != 0,
+        Boolish::S(s) => {
+            let t = s.trim().to_ascii_lowercase();
+            if t.is_empty() {
+                true // presence implies true
+            } else {
+                matches!(t.as_str(), "1" | "true" | "yes" | "on" | "y")
+            }
+        }
+    })
+}
+
+/// Parse a tolerant boolean value from a string.
+/// Accepts: "1", "true", "yes", "on", "y" as true; "0", "false", "no", "off", "n" as false.
+/// Empty string means true (presence-only query flag).
+pub fn boolish_str(s: &str) -> bool {
+    let t = s.trim().to_ascii_lowercase();
+    if t.is_empty() {
+        return true;
+    }
+    matches!(t.as_str(), "1" | "true" | "yes" | "on" | "y")
+        || (!matches!(t.as_str(), "0" | "false" | "no" | "off" | "n")
+            && t.parse::<u64>().map(|n| n != 0).unwrap_or(false))
+}

src/utils/parse/mac.rs

@@ -1,47 +0,0 @@
-use macaddr::MacAddr;
-use serde::{self, Deserialize, Deserializer, de::Error as DeError};
-use serde::{Serialize, Serializer, de};
-
-pub fn _serialize_macs<S>(macs: &[MacAddr], serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let strings: Vec<String> = macs.iter().map(|m| m.to_string()).collect();
-    serde::Serialize::serialize(&strings, serializer)
-}
-
-/// Serialize a MacAddr as a string
-pub fn serialize<S>(mac: &MacAddr, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    serializer.serialize_str(&mac.to_string())
-}
-
-/// Deserialize a MacAddr from a string
-pub fn _deserialize<'de, D>(deserializer: D) -> Result<MacAddr, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let s = <String as serde::Deserialize>::deserialize(deserializer)?;
-    s.parse::<MacAddr>().map_err(DeError::custom)
-}
-
-pub mod option_mac {
-    use super::*;
-    /// serialize an [`Option<MacAddr>`]
-    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>`]
-    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)
-    }
-}

src/utils/query/dev.rs

@@ -1,65 +0,0 @@
-use std::collections::HashSet;
-// /// 50ms
-// pub async fn get_dev() -> HashSet<String> {
-//     use lda_ipjs::subcommands::address::json as ipjs_json;
-//     let mut devs: HashSet<String> = HashSet::new();
-//     if let Ok(items) = ipjs_json::get(None).await {
-//         for item in items {
-//             if item.ifname != "lo" && !item.ifname.is_empty() {
-//                 devs.insert(item.ifname);
-//             }
-//         }
-//     }
-//     devs
-// }
-
-/// 3ms
-pub async fn get_dev() -> HashSet<String> {
-    use std::fs;
-    fn get_dev() -> HashSet<String> {
-        let mut devs: HashSet<String> = HashSet::new();
-        if let Ok(rd) = std::fs::read_dir("/sys/class/net") {
-            for e in rd.flatten() {
-                if e.file_type()
-                    .map(|ft| {
-                        if ft.is_symlink() {
-                            // true
-                            fs::metadata(e.path()).map(|m| m.is_dir()).unwrap_or(false)
-                        } else {
-                            ft.is_dir()
-                        }
-                    })
-                    .unwrap_or(false)
-                    && let Ok(name) = e.file_name().into_string()
-                    && name != "lo"
-                    && !name.is_empty()
-                {
-                    devs.insert(name);
-                }
-            }
-        } else if let Ok(txt) = std::fs::read_to_string("/proc/net/dev") {
-            for line in txt.lines().skip(2) {
-                if let Some((name, _rest)) = line.split_once(':') {
-                    let n = name.trim().to_string();
-                    if n != "lo" && !n.is_empty() {
-                        devs.insert(n);
-                    }
-                }
-            }
-        }
-        devs
-    }
-    tokio::task::spawn_blocking(get_dev)
-        .await
-        .unwrap_or_default()
-}
-
-pub async fn devs_sorted() -> Vec<String> {
-    let mut v: Vec<String> = get_dev().await.into_iter().collect();
-    v.sort();
-    v
-}
-
-pub async fn has_dev(name: &str) -> bool {
-    get_dev().await.contains(name)
-}

src/utils/query/leases.rs

@@ -1,43 +0,0 @@
-use crate::arpparse::NUDState;
-use crate::dhcpparse::DhcpLeaseLine;
-use crate::utils::query::get_macs;
-use serde_with::skip_serializing_none;
-use std::net::IpAddr;
-
-#[skip_serializing_none]
-#[derive(Debug, Clone, serde::Serialize)]
-pub struct DhcpLeaseOut {
-    #[serde(flatten)]
-    pub lease_line: DhcpLeaseLine,
-    pub nud_state: Option<NUDState>,
-}
-
-/// Enrich DHCP leases with NUD state and rank using get_macs
-pub async fn enrich_leases_with_nud_state(leases: Vec<DhcpLeaseLine>) -> Vec<DhcpLeaseOut> {
-    let ips: Vec<IpAddr> = leases.iter().map(|l| l.ip).collect();
-    let mut map: std::collections::HashMap<IpAddr, NUDState> = std::collections::HashMap::new();
-    if let Ok(rows) = get_macs(&[] as &[&str], &ips, &[] as &[&str], &[], &[]).await {
-        for row in rows {
-            let state = row.state;
-            let r = state.rank();
-            map.entry(row.ip)
-                .and_modify(|e| {
-                    let er = e.rank();
-                    if r > er {
-                        *e = state
-                    }
-                })
-                .or_insert(state);
-        }
-    }
-    leases
-        .into_iter()
-        .map(|lease_line| {
-            let nud_state = map.get(&lease_line.ip).copied();
-            DhcpLeaseOut {
-                lease_line,
-                nud_state,
-            }
-        })
-        .collect()
-}

src/utils/query/macs.rs

@@ -1,173 +1,28 @@
-use lda_ipjs::subcommands::neighbor;
+use anyhow::Result;
-use macaddr::MacAddr;
-
-use crate::arpparse::{self, IpNeighLine, NUDState};
-use anyhow::{Context, Result, bail};
-use std::collections::HashSet;
 use std::net::IpAddr;
 
+use crate::arpparse::{IpNeighLine, NUDState};
+
 pub async fn get_ips(machine_name: &str) -> Result<impl Iterator<Item = IpAddr>> {
-    Ok(tokio::net::lookup_host((machine_name, 0))
+    wakey_linux::devices::get_ips(machine_name).await
-        .await
-        .with_context(|| format!("DNS resolve failed for {machine_name}"))?
-        .map(|c| c.ip()))
 }
 
-// good now
-//
-// Current logic: When filtering by exactly 1 dev/mac, exclude entries missing that field.
-// This is because missing dev/mac usually means the entry is incomplete/transient.
-//
-// when there is only one MACs (getmac got some), the result will not have them fields.
-// so there are three cases:
-//
-// 1. dont got nothing: take all of them (macset.is_empty())
-// 2. exactly one: pre-filtered by ip, everything matches,
-// devset.len() != 1 returns false, but then it works????
-// OH THIS fuckass code i added it in the get_mac
-// 3. devset.len() > 1. if none then absolutely not match,
-// if some then check with the set; thats normal
 pub async fn get_macs(
     machine_names: &[impl AsRef<str>],
     ips: &[IpAddr],
     devs: &[impl AsRef<str>],
     state: &[NUDState],
-    macs: &[MacAddr],
+    macs: &[macaddr::MacAddr],
 ) -> Result<Vec<IpNeighLine>> {
-    let mut ip_set: HashSet<IpAddr> = ips.iter().map(|ip| ip.to_canonical()).collect();
+    wakey_linux::devices::get_neighbors(machine_names, ips, devs, state, macs).await
-    let ip_m: HashSet<IpAddr> = if !machine_names.is_empty() {
-        futures::future::try_join_all(machine_names.iter().map(|c| get_ips(c.as_ref())))
-            .await?
-            .into_iter()
-            .flatten()
-            .collect()
-    } else {
-        Default::default()
-    };
-    let ip_all = if ip_set.is_empty() && ip_m.is_empty() {
-        None
-    } else if ip_set.is_empty() {
-        Some(ip_m)
-    } else if ip_m.is_empty() {
-        Some(ip_set)
-    } else {
-        Some({
-            ip_set.retain(|c| ip_m.contains(c)); // inline AHHH
-            ip_set
-        })
-    };
-
-    let opt_dev = if devs.len() > 1 {
-        None
-    } else {
-        devs.iter().next().map(AsRef::as_ref)
-    };
-
-    let run_one = |to_ip: Option<IpAddr>| get_mac(to_ip, opt_dev, state);
-
-    let mut ip_filtered = if let Some(something) = ip_all {
-        if something.len() == 1 {
-            run_one(something.into_iter().next()).await?
-        } else {
-            run_one(None)
-                .await?
-                .into_iter()
-                .filter(|c| something.contains(&c.ip))
-                .collect()
-        }
-    } else {
-        run_one(None).await?
-    };
-
-    // Apply additional filters if any were provided
-    if !devs.is_empty() || !macs.is_empty() {
-        let devset: HashSet<_> = devs.iter().map(AsRef::as_ref).collect();
-        let macset: HashSet<_> = macs.iter().collect();
-
-        ip_filtered.retain(|entry| {
-            // Dev filter: if we're filtering by dev, entry must have a dev AND it must be in the set
-            let dev_ok =
-                devset.is_empty() || entry.dev.as_deref().is_some_and(|d| devset.contains(d));
-
-            // MAC filter: if we're filtering by MAC, entry must have a MAC AND it must be in the set
-            let mac_ok = macset.is_empty() || entry.mac.is_some_and(|m| macset.contains(&m));
-
-            dev_ok && mac_ok
-        })
-    };
-    Ok(ip_filtered)
 }
 
-// /// the atomic get_macs. handle ONE thing only.
-// // this one sucks shit
-// pub async fn get_mac(
-//     ip: Option<IpAddr>,
-//     dev: Option<&str>,
-//     state: &[NUDState],
-// ) -> Result<Vec<IpNeighLine>> {
-//     use lda_ipjs::subcommands::neighbor as ipjs_neigh;
-//     let ipjs_states: Vec<ipjs_neigh::NUDState> = state.iter().copied().map(Into::into).collect();
-
-//     let items = ipjs_neigh::json::get(ip, dev, &ipjs_states)
-//         .await
-//         .context("Calling ip -j neigh failed")?;
-
-//     let lines = items.into_iter().map(Into::into).collect();
-
-//     Ok(lines)
-// }
-
-/// the atomic get_macs. handle ONE thing only.
-// 17 - 25 ms full
-pub async fn _get_mac(
-    ip: Option<IpAddr>,
-    dev: Option<&str>,
-    state: &[NUDState],
-) -> Result<Vec<IpNeighLine>> {
-    let mut args: Vec<String> = vec!["neigh".into(), "show".into()];
-    if let Some(ip) = ip {
-        args.push("to".into());
-        args.push(ip.to_string());
-    }
-    if let Some(d) = dev {
-        args.push("dev".into());
-        args.push(d.to_string());
-    }
-    for nud in state {
-        args.push("nud".into());
-        args.push(nud.as_ip_neigh_arg().into());
-    }
-    let cmd = "ip";
-    let mut u = tokio::process::Command::new(cmd);
-    u.args(args);
-    let out = u.output().await?;
-
-    if !out.status.success() {
-        bail!(String::from_utf8_lossy(&out.stderr).into_owned());
-    }
-
-    let lines = String::from_utf8_lossy(&out.stdout);
-    let parsed = lines.lines().flat_map(arpparse::parse_ip_neigh_line);
-    let rows: Vec<IpNeighLine> = if let Some(d) = dev {
-        parsed.map(IpNeighLine::_with_dev(d)).collect()
-    } else {
-        parsed.collect()
-    };
-    Ok(rows)
-}
-
-// 15 - 20 ms full
 pub async fn get_mac(
     ip: Option<IpAddr>,
     dev: Option<&str>,
     state: &[NUDState],
 ) -> Result<Vec<IpNeighLine>> {
-    let state2: Vec<neighbor::NUDState> = state.iter().copied().map(Into::into).collect();
+    let ips: Vec<IpAddr> = ip.into_iter().collect();
-    Ok(neighbor::nl::get(ip, dev, &state2)
+    let devs: Vec<&str> = dev.into_iter().collect();
-        .await
+    get_macs(&[] as &[&str], &ips, &devs, state, &[]).await
-        .context("rtnetlink failed")?
-        .into_iter()
-        .map(Into::into)
-        .collect())
-    // how did i just do that
 }

src/utils/query/mod.rs

@@ -1,7 +1,17 @@
-pub mod dev;
+pub mod dev {
-pub mod leases;
+    pub use wakey_linux::devices::devs_sorted;
+}
+pub mod leases {
+    pub use wakey_linux::dhcp::enrich_leases_with_nud_state;
+}
 pub mod macs;
-pub mod parser;
+pub mod parser {
+    pub use wakey_core::QueryInput as QueryType;
+
+    pub async fn parse_query(q: String) -> QueryType {
+        wakey_linux::devices::classify_query(q).await
+    }
+}
 
 pub use leases::*;
 pub use macs::*;

src/utils/query/parser.rs

@@ -1,44 +0,0 @@
-use std::net::IpAddr;
-
-use macaddr::MacAddr;
-
-use crate::{arpparse::NUDState, utils::query::dev::has_dev};
-
-pub enum QueryType {
-    Ip(IpAddr),
-    Mac(MacAddr),
-    Dev(String),
-    Nud(NUDState),
-    Unknown(String),
-}
-
-pub async fn parse_query(q: String) -> QueryType {
-    let s = if cfg!(feature = "very-smart-parsing") {
-        crate::utils::parse::extract_host(&q)
-    } else {
-        q.trim()
-    };
-    // 1) IP
-    let ip = if cfg!(feature = "very-smart-parsing") {
-        crate::utils::parse::parse_numeric_ipv4(s).or_else(|| s.parse::<IpAddr>().ok())
-    } else {
-        s.parse::<IpAddr>().ok()
-    };
-    if let Some(ip) = ip {
-        return QueryType::Ip(ip);
-    }
-    // 2) MAC
-    if let Ok(mac) = s.parse::<MacAddr>() {
-        return QueryType::Mac(mac);
-    }
-    // 3) NUD state (reachable, stale, ...)
-    if let Ok(state) = s.parse::<NUDState>() {
-        return QueryType::Nud(state);
-    }
-    // 4) Known device? prefer dev first
-    if has_dev(s).await {
-        return QueryType::Dev(s.to_string());
-    }
-    // Default: name last // it will fail also
-    QueryType::Unknown(s.to_string())
-}

src/utils/wake.rs

@@ -0,0 +1,6 @@
+pub async fn wake_one(
+    sock: &tokio::net::UdpSocket,
+    t: wakey_linux::wake::CompleteWakeTarget,
+) -> wakey_core::WakeTargetResult {
+    wakey_linux::wake::wake_one(sock, t).await
+}

src/utils/wake/impls.rs

@@ -1,69 +0,0 @@
-use super::{WakeStatus, WakeTarget, WakeTargetResult};
-use crate::route::wake::{
-    WakeTarget as RouteWakeTarget, WakeTargetResult as RouteWakeResult,
-    WakeTargetStatus as RouteWakeStatus,
-};
-
-#[derive(Debug, Clone, Copy)]
-pub struct Incomplete;
-
-impl TryFrom<RouteWakeTarget> for WakeTarget {
-    type Error = Incomplete;
-    fn try_from(value: RouteWakeTarget) -> Result<Self, Self::Error> {
-        if let RouteWakeTarget {
-            ip: Some(ip),
-            mac: Some(mac),
-        } = value
-        {
-            Ok(Self { ip, mac })
-        } else {
-            Err(Incomplete)
-        }
-    }
-}
-
-impl From<WakeTarget> for RouteWakeTarget {
-    fn from(WakeTarget { ip, mac }: WakeTarget) -> Self {
-        Self {
-            ip: Some(ip),
-            mac: Some(mac),
-        }
-    }
-}
-
-impl From<WakeTargetResult> for RouteWakeResult {
-    fn from(WakeTargetResult { target, status }: WakeTargetResult) -> Self {
-        Self {
-            target: target.into(),
-            status: status.into(),
-        }
-    }
-}
-
-impl RouteWakeTarget {
-    pub const fn to_incomplete(self) -> RouteWakeResult {
-        RouteWakeResult {
-            target: self,
-            status: RouteWakeStatus::Incomplete,
-        }
-    }
-    pub const fn is_incomplete(&self) -> bool {
-        !matches!(
-            self,
-            Self {
-                ip: Some(_),
-                mac: Some(_)
-            }
-        )
-    }
-}
-
-impl From<WakeStatus> for RouteWakeStatus {
-    fn from(value: WakeStatus) -> Self {
-        match value {
-            WakeStatus::NonexistentAddress => Self::NonexistentAddress,
-            WakeStatus::Success => Self::Succeed,
-            WakeStatus::WrongSize => Self::WrongSize,
-        }
-    }
-}

src/utils/wake/mod.rs

@@ -1,75 +0,0 @@
-//! why did my Head Ass split these into two.
-
-pub mod impls;
-use std::{io, net::IpAddr};
-
-use futures::TryFutureExt;
-use macaddr::MacAddr;
-use tokio::net::UdpSocket;
-
-#[derive(Debug, Clone, Copy, Hash)]
-pub struct WakeTarget {
-    pub ip: IpAddr,
-    pub mac: MacAddr,
-}
-#[derive(Debug, Clone, Copy, Hash)]
-pub struct WakeTargetResult {
-    pub target: WakeTarget,
-    pub status: WakeStatus,
-}
-#[derive(Debug, Clone, Copy, Hash)]
-pub enum WakeStatus {
-    Success,
-    NonexistentAddress,
-    WrongSize,
-}
-impl WakeTarget {
-    const fn _new(ip: IpAddr, mac: MacAddr) -> Self {
-        Self { ip, mac }
-    }
-    const fn good(self) -> WakeTargetResult {
-        WakeTargetResult::new(self, WakeStatus::Success)
-    }
-    const fn bad(self) -> WakeTargetResult {
-        WakeTargetResult::new(self, WakeStatus::WrongSize)
-    }
-    const fn errored(self) -> WakeTargetResult {
-        WakeTargetResult::new(self, WakeStatus::NonexistentAddress)
-    }
-}
-impl WakeTargetResult {
-    const fn new(target: WakeTarget, status: WakeStatus) -> Self {
-        Self { target, status }
-    }
-}
-
-// its time. we have the ip; the macs. we dont need to send to the uh the broadcast anymore???
-pub async fn _wake_multi(
-    targets: impl IntoIterator<Item = WakeTarget>,
-) -> io::Result<Vec<WakeTargetResult>> {
-    let sock = UdpSocket::bind("[::]:0")
-        .or_else(|_| UdpSocket::bind(":0"))
-        .await?;
-    sock.set_broadcast(true)?;
-    let fs = targets.into_iter().map(|t| wake_one(&sock, t));
-    Ok(futures::future::join_all(fs).await)
-}
-
-pub async fn wake_one(sock: &UdpSocket, t: WakeTarget) -> WakeTargetResult {
-    let mac = t.mac;
-    let mb = mac.as_bytes();
-    let mut pac = [0; 6 + 6 * 16];
-    pac[..6].fill(0xff);
-    for i in 1..=16 {
-        pac[i * 6..(i + 1) * 6].copy_from_slice(mb);
-    }
-    let ip = t.ip;
-    let port = 9;
-    match sock.send_to(&pac, (ip, port)).await {
-        Ok(n) if n == pac.len() => t.good(),
-        Ok(_) => t.bad(),
-        Err(_) => t.errored(),
-    }
-}
-
-// pub async fn wake_query();

static/home_2/wake.js

@@ -33,7 +33,7 @@ export async function sendWake(name) {
 
     const j = await r.json();
 
-    if (!j.success) {
+    if (j.error) {
       elLog.textContent = `wake error: ${j.error}`;
       setPill("bad", "error");
       return;

wakey-core/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "wakey-core"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+macaddr = { version = "1", features = ["serde", "serde_std"] }
+serde = { version = "1", features = ["derive"] }
+serde_with = { version = "3", features = ["json"] }
+strum = { version = "0", features = ["derive", "strum_macros"] }
+thiserror = "2"

wakey-core/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod model;
+pub mod parse;
+
+pub use model::*;

wakey-core/src/model.rs

@@ -0,0 +1,244 @@
+use macaddr::MacAddr;
+use serde::{Deserialize, Serialize};
+use serde_with::skip_serializing_none;
+use serde_with::{DisplayFromStr, OneOrMany, serde_as};
+use std::{net::IpAddr, str::FromStr};
+use strum::{Display, EnumString};
+
+use crate::parse::mac;
+
+#[skip_serializing_none]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Serialize)]
+pub struct NeighborEntry {
+    pub ip: IpAddr,
+    pub dev: Option<String>,
+    #[serde(with = "mac::option_mac")]
+    pub mac: Option<MacAddr>,
+    pub state: NeighborState,
+}
+
+#[derive(
+    Debug, PartialEq, Eq, EnumString, Display, Clone, Copy, Hash, Serialize, Deserialize, Default,
+)]
+#[strum(serialize_all = "UPPERCASE", ascii_case_insensitive)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum NeighborState {
+    Permanent,
+    Noarp,
+    Reachable,
+    Stale,
+    Incomplete,
+    Delay,
+    Probe,
+    Failed,
+    #[serde(other)]
+    #[default]
+    None,
+}
+
+impl NeighborState {
+    pub const fn as_ip_neigh_arg(self) -> &'static str {
+        match self {
+            NeighborState::Permanent => "permanent",
+            NeighborState::Reachable => "reachable",
+            NeighborState::Stale => "stale",
+            NeighborState::Delay => "delay",
+            NeighborState::Probe => "probe",
+            NeighborState::Incomplete => "incomplete",
+            NeighborState::Noarp => "noarp",
+            NeighborState::None => "none",
+            NeighborState::Failed => "failed",
+        }
+    }
+
+    pub const fn rank(self) -> u8 {
+        match self {
+            NeighborState::Permanent | NeighborState::Reachable => 5,
+            NeighborState::Stale => 4,
+            NeighborState::Delay | NeighborState::Probe | NeighborState::Incomplete => 3,
+            NeighborState::Noarp => 2,
+            NeighborState::None => 1,
+            NeighborState::Failed => 0,
+        }
+    }
+}
+
+impl PartialOrd for NeighborState {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for NeighborState {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.rank().cmp(&other.rank())
+    }
+}
+
+#[derive(Debug, Default, Clone, Hash, Deserialize, Serialize)]
+pub struct DeviceQuery {
+    pub name: Option<String>,
+    #[serde(flatten)]
+    pub filter: DeviceFilters,
+}
+
+#[serde_as]
+#[derive(Debug, Default, Clone, Hash, Serialize, Deserialize)]
+pub struct DeviceFilters {
+    #[serde_as(as = "OneOrMany<_>")]
+    #[serde(default)]
+    pub ips: Vec<IpAddr>,
+    #[serde_as(as = "OneOrMany<_>")]
+    #[serde(default)]
+    pub devs: Vec<String>,
+    #[serde_as(as = "OneOrMany<_>")]
+    #[serde(default)]
+    pub nuds: Vec<NeighborState>,
+    #[serde_as(as = "OneOrMany<DisplayFromStr>")]
+    #[serde(default)]
+    pub macs: Vec<MacAddr>,
+}
+
+#[skip_serializing_none]
+#[derive(Debug, Default, Serialize)]
+pub struct Status<T> {
+    pub name: Option<String>,
+    pub table: Vec<T>,
+    pub filters: DeviceFilters,
+}
+
+#[derive(Debug, Default, Clone, Hash, Deserialize)]
+pub struct NamePath {
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct DhcpLease {
+    pub expires_epoch: u64,
+    pub ip: IpAddr,
+    #[serde(with = "mac")]
+    pub mac: MacAddr,
+    pub name: Option<String>,
+}
+
+#[skip_serializing_none]
+#[derive(Debug, Clone, Serialize)]
+pub struct DhcpLeaseWithState {
+    #[serde(flatten)]
+    pub lease_line: DhcpLease,
+    pub nud_state: Option<NeighborState>,
+}
+
+#[skip_serializing_none]
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, Hash, PartialEq, Eq)]
+pub struct WakeTarget {
+    #[serde(default)]
+    pub ip: Option<IpAddr>,
+    #[serde(default, with = "mac::option_mac")]
+    pub mac: Option<MacAddr>,
+}
+
+impl WakeTarget {
+    pub const fn is_complete(&self) -> bool {
+        matches!(
+            self,
+            Self {
+                ip: Some(_),
+                mac: Some(_)
+            }
+        )
+    }
+}
+
+#[derive(Debug, Serialize, Clone)]
+pub struct WakeResult {
+    pub result: Vec<WakeTargetResult>,
+}
+
+#[skip_serializing_none]
+#[derive(Debug, Serialize, Clone, Copy)]
+pub struct WakeTargetResult {
+    #[serde(flatten)]
+    pub target: WakeTarget,
+    pub status: WakeStatus,
+}
+
+#[derive(Debug, Serialize, Clone, Copy, Hash, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum WakeStatus {
+    Succeed,
+    NonexistentAddress,
+    WrongSize,
+    Incomplete,
+}
+
+impl WakeTargetResult {
+    pub const fn incomplete(target: WakeTarget) -> Self {
+        Self {
+            target,
+            status: WakeStatus::Incomplete,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum QueryInput {
+    Ip(IpAddr),
+    Mac(MacAddr),
+    Dev(String),
+    Nud(NeighborState),
+    Name(String),
+}
+
+#[derive(Debug, Display, thiserror::Error)]
+pub enum NeighborParseError {
+    IpWhere,
+    IpParseError(#[from] std::net::AddrParseError),
+    MacParseError(#[from] macaddr::ParseError),
+    StateWhere,
+    StateParseError(#[from] strum::ParseError),
+}
+
+pub fn parse_neighbor_line(s: &str) -> Result<NeighborEntry, NeighborParseError> {
+    let mut it = s.split_whitespace();
+    let ip: IpAddr = it.next().ok_or(NeighborParseError::IpWhere)?.parse()?;
+
+    let mut dev: Option<String> = None;
+    let mut mac: Option<MacAddr> = None;
+    let mut state: Option<NeighborState> = None;
+    let mut last_tok: Option<&str> = None;
+
+    while let Some(tok) = it.next() {
+        match tok {
+            "dev" => dev = it.next().map(str::to_string),
+            "lladdr" => {
+                mac = it.next().map(|m| m.parse()).transpose()?;
+            }
+            "nud" => {
+                state = it.next().map(|st| st.parse()).transpose()?;
+            }
+            other => last_tok = Some(other),
+        }
+    }
+
+    if state.is_none()
+        && let Some(st) = last_tok
+    {
+        state = Some(st.parse()?);
+    }
+
+    Ok(NeighborEntry {
+        ip,
+        dev,
+        mac,
+        state: state.ok_or(NeighborParseError::StateWhere)?,
+    })
+}
+
+impl FromStr for NeighborEntry {
+    type Err = NeighborParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        parse_neighbor_line(s)
+    }
+}

wakey-core/src/parse.rs

@@ -1,20 +1,16 @@
-/// Parses Chrome-style numeric IPv4 forms: hex (0x...), decimal, octal.
 pub fn parse_numeric_ipv4(s: &str) -> Option<std::net::IpAddr> {
     let s = s.trim();
-    // hex
     if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X"))
         && hex.chars().all(|c| c.is_ascii_hexdigit())
         && let Ok(n) = u32::from_str_radix(hex, 16)
     {
         return Some(std::net::IpAddr::V4(std::net::Ipv4Addr::from(n)));
     }
-    // decimal
     if s.chars().all(|c| c.is_ascii_digit())
         && let Ok(n) = s.parse::<u32>()
     {
         return Some(std::net::IpAddr::V4(std::net::Ipv4Addr::from(n)));
     }
-    // octal (leading 0, all octal digits)
     if s.len() > 1
         && s.as_bytes()[0] == b'0'
         && s.chars().all(|c| matches!(c, '0'..='7'))
@@ -24,30 +20,25 @@ pub fn parse_numeric_ipv4(s: &str) -> Option<std::net::IpAddr> {
     }
     None
 }
-/// Extracts the host portion from a URL-like string, for smart input parsing.
+
 pub fn extract_host(input: &str) -> &str {
     let mut s = input.trim();
-    // Strip scheme (e.g., http://, https://, ssh://) or network-path reference (//host)
     if let Some(idx) = s.find("://") {
         s = &s[idx + 3..];
     } else if let Some(rest) = s.strip_prefix("//") {
         s = rest;
     }
-    // Strip potential userinfo (user@host)
     if let Some((_, host)) = s.rsplit_once('@') {
         s = host;
     }
-    // If bracketed IPv6 like [::1]:8080/path -> extract inside brackets
     if let Some(host) = s.strip_prefix('[') {
         if let Some(end) = host.find(']') {
             s = &host[..end];
         }
     } else {
-        // Trim path suffix if any
         if let Some(pos) = s.find('/') {
             s = &s[..pos];
         }
-        // Drop trailing :port if present and numeric, but only if there's exactly one ':'
         if let Some((host, port)) = s.rsplit_once(':')
             && s.matches(':').count() == 1
             && port.chars().all(|c| c.is_ascii_digit())
@@ -58,38 +49,6 @@ pub fn extract_host(input: &str) -> &str {
     s.trim()
 }
 
-/// key for yes: "1" | "true" | "yes" | "on" | "y"
-///
-/// frfr
-pub fn _de_boolish<'de, D>(des: D) -> Result<bool, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    use serde::Deserialize;
-    #[derive(Deserialize)]
-    #[serde(untagged)]
-    enum Boolish {
-        B(bool),
-        I(u8),
-        S(String),
-    }
-    Ok(match Boolish::deserialize(des)? {
-        Boolish::B(b) => b,
-        Boolish::I(i) => i != 0,
-        Boolish::S(s) => {
-            let t = s.trim().to_ascii_lowercase();
-            if t.is_empty() {
-                true // presence implies true
-            } else {
-                matches!(t.as_str(), "1" | "true" | "yes" | "on" | "y")
-            }
-        }
-    })
-}
-
-/// Parse a tolerant boolean value from a string.
-/// Accepts: "1", "true", "yes", "on", "y" as true; "0", "false", "no", "off", "n" as false.
-/// Empty string means true (presence-only query flag).
 pub fn boolish_str(s: &str) -> bool {
     let t = s.trim().to_ascii_lowercase();
     if t.is_empty() {
@@ -100,4 +59,47 @@ pub fn boolish_str(s: &str) -> bool {
             && t.parse::<u64>().map(|n| n != 0).unwrap_or(false))
 }
 
-pub mod mac;
+pub mod mac {
+    use macaddr::MacAddr;
+    use serde::{Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<S>(m: &MacAddr, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&m.to_string())
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<MacAddr, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        s.parse().map_err(serde::de::Error::custom)
+    }
+
+    pub mod option_mac {
+        use macaddr::MacAddr;
+        use serde::{Deserialize, Deserializer, Serializer};
+
+        pub fn serialize<S>(m: &Option<MacAddr>, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            match m {
+                Some(mac) => serializer.serialize_some(&mac.to_string()),
+                None => serializer.serialize_none(),
+            }
+        }
+
+        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<MacAddr>, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            let s = Option::<String>::deserialize(deserializer)?;
+            s.map(|x| x.parse())
+                .transpose()
+                .map_err(serde::de::Error::custom)
+        }
+    }
+}

wakey-linux/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "wakey-linux"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1"
+futures = "0"
+macaddr = { version = "1", features = ["serde", "serde_std"] }
+serde_json = "1"
+tokio = { version = "1", features = ["fs", "net", "rt", "sync"] }
+wakey-core = { path = "../wakey-core" }
+
+[dependencies.lda-ipjs]
+path = "../ipjs"
+registry = "gitea"
+version = "*"
+features = ["experimental-nl"]

wakey-linux/src/devices.rs

@@ -0,0 +1,230 @@
+use anyhow::{Context, Result};
+use futures::future::try_join_all;
+use std::collections::HashSet;
+use std::net::IpAddr;
+use wakey_core::{DeviceQuery, NeighborEntry, NeighborState, QueryInput, parse};
+
+use lda_ipjs::subcommands::neighbor;
+
+pub async fn get_ips(machine_name: &str) -> Result<impl Iterator<Item = IpAddr>> {
+    Ok(tokio::net::lookup_host((machine_name, 0))
+        .await
+        .with_context(|| format!("DNS resolve failed for {machine_name}"))?
+        .map(|c| c.ip()))
+}
+
+pub async fn get_neighbors(
+    machine_names: &[impl AsRef<str>],
+    ips: &[IpAddr],
+    devs: &[impl AsRef<str>],
+    state: &[NeighborState],
+    macs: &[macaddr::MacAddr],
+) -> Result<Vec<NeighborEntry>> {
+    let resolved_ips: HashSet<IpAddr> = if !machine_names.is_empty() {
+        try_join_all(machine_names.iter().map(|n| get_ips(n.as_ref())))
+            .await?
+            .into_iter()
+            .flatten()
+            .collect()
+    } else {
+        HashSet::new()
+    };
+
+    let ip_filter: Vec<IpAddr> = if ips.is_empty() && resolved_ips.is_empty() {
+        vec![]
+    } else if ips.is_empty() {
+        resolved_ips.into_iter().collect()
+    } else if resolved_ips.is_empty() {
+        ips.iter().map(|ip| ip.to_canonical()).collect()
+    } else {
+        ips.iter()
+            .map(|ip| ip.to_canonical())
+            .filter(|ip| resolved_ips.contains(ip))
+            .collect()
+    };
+
+    let nud_filter: Vec<neighbor::NUDState> = state.iter().copied().map(to_ipjs_state).collect();
+    let dev_strs: Vec<&str> = devs.iter().map(AsRef::as_ref).collect();
+
+    #[cfg(unix)]
+    {
+        let results = neighbor::nl::get(&ip_filter, &dev_strs, &nud_filter, macs)
+            .await
+            .context("rtnetlink failed")?
+            .into_iter()
+            .map(map_neighbor_item)
+            .collect();
+        Ok(results)
+    }
+
+    #[cfg(not(unix))]
+    {
+        let mut results = Vec::new();
+        if ip_filter.is_empty() {
+            let dev = dev_strs.first().copied();
+            results = neighbor::get_with_backend(neighbor::Backend::Json, None, dev, &nud_filter)
+                .await
+                .context("ip -j neigh failed")?
+                .into_iter()
+                .map(map_neighbor_item)
+                .collect();
+        } else {
+            for ip in &ip_filter {
+                let dev = dev_strs.first().copied();
+                let mut rows = neighbor::get_with_backend(
+                    neighbor::Backend::Json,
+                    Some(*ip),
+                    dev,
+                    &nud_filter,
+                )
+                .await
+                .with_context(|| format!("ip -j neigh failed for {ip}"))?
+                .into_iter()
+                .map(map_neighbor_item)
+                .collect::<Vec<_>>();
+                results.append(&mut rows);
+            }
+        }
+
+        if !dev_strs.is_empty() {
+            results.retain(|row| row.dev.as_deref().is_some_and(|d| dev_strs.contains(&d)));
+        }
+        if !macs.is_empty() {
+            let mac_set: HashSet<macaddr::MacAddr> = macs.iter().copied().collect();
+            results.retain(|row| row.mac.is_some_and(|m| mac_set.contains(&m)));
+        }
+        if !ip_filter.is_empty() {
+            let ip_set: HashSet<IpAddr> = ip_filter.iter().copied().collect();
+            results.retain(|row| ip_set.contains(&row.ip));
+        }
+        Ok(results)
+    }
+}
+
+pub async fn query_status(query: &DeviceQuery) -> Result<Vec<NeighborEntry>> {
+    get_neighbors(
+        query.name.as_slice(),
+        &query.filter.ips,
+        &query.filter.devs,
+        &query.filter.nuds,
+        &query.filter.macs,
+    )
+    .await
+}
+
+pub async fn list_devs() -> HashSet<String> {
+    fn get_dev() -> HashSet<String> {
+        let mut devs: HashSet<String> = HashSet::new();
+        if let Ok(rd) = std::fs::read_dir("/sys/class/net") {
+            for e in rd.flatten() {
+                if e.file_type()
+                    .map(|ft| {
+                        if ft.is_symlink() {
+                            std::fs::metadata(e.path())
+                                .map(|m| m.is_dir())
+                                .unwrap_or(false)
+                        } else {
+                            ft.is_dir()
+                        }
+                    })
+                    .unwrap_or(false)
+                    && let Ok(name) = e.file_name().into_string()
+                    && name != "lo"
+                    && !name.is_empty()
+                {
+                    devs.insert(name);
+                }
+            }
+        } else if let Ok(txt) = std::fs::read_to_string("/proc/net/dev") {
+            for line in txt.lines().skip(2) {
+                if let Some((name, _rest)) = line.split_once(':') {
+                    let n = name.trim().to_string();
+                    if n != "lo" && !n.is_empty() {
+                        devs.insert(n);
+                    }
+                }
+            }
+        }
+        devs
+    }
+
+    tokio::task::spawn_blocking(get_dev)
+        .await
+        .unwrap_or_default()
+}
+
+pub async fn devs_sorted() -> Vec<String> {
+    let mut v: Vec<String> = list_devs().await.into_iter().collect();
+    v.sort();
+    v
+}
+
+pub async fn has_dev(name: &str) -> bool {
+    list_devs().await.contains(name)
+}
+
+pub async fn classify_query(q: String) -> QueryInput {
+    let s = parse::extract_host(&q);
+    if let Some(ip) = parse::parse_numeric_ipv4(s).or_else(|| s.parse::<IpAddr>().ok()) {
+        return QueryInput::Ip(ip);
+    }
+    if let Ok(mac) = s.parse::<macaddr::MacAddr>() {
+        return QueryInput::Mac(mac);
+    }
+    if let Ok(state) = s.parse::<NeighborState>() {
+        return QueryInput::Nud(state);
+    }
+    if has_dev(s).await {
+        return QueryInput::Dev(s.to_string());
+    }
+    QueryInput::Name(s.to_string())
+}
+
+fn to_ipjs_state(value: NeighborState) -> lda_ipjs::subcommands::neighbor::NUDState {
+    match value {
+        NeighborState::Permanent => lda_ipjs::subcommands::neighbor::NUDState::Permanent,
+        NeighborState::Noarp => lda_ipjs::subcommands::neighbor::NUDState::Noarp,
+        NeighborState::Reachable => lda_ipjs::subcommands::neighbor::NUDState::Reachable,
+        NeighborState::Stale => lda_ipjs::subcommands::neighbor::NUDState::Stale,
+        NeighborState::None => lda_ipjs::subcommands::neighbor::NUDState::None,
+        NeighborState::Incomplete => lda_ipjs::subcommands::neighbor::NUDState::Incomplete,
+        NeighborState::Delay => lda_ipjs::subcommands::neighbor::NUDState::Delay,
+        NeighborState::Probe => lda_ipjs::subcommands::neighbor::NUDState::Probe,
+        NeighborState::Failed => lda_ipjs::subcommands::neighbor::NUDState::Failed,
+    }
+}
+
+fn from_ipjs_state(value: lda_ipjs::subcommands::neighbor::NUDState) -> NeighborState {
+    match value {
+        lda_ipjs::subcommands::neighbor::NUDState::Permanent => NeighborState::Permanent,
+        lda_ipjs::subcommands::neighbor::NUDState::Noarp => NeighborState::Noarp,
+        lda_ipjs::subcommands::neighbor::NUDState::Reachable => NeighborState::Reachable,
+        lda_ipjs::subcommands::neighbor::NUDState::Stale => NeighborState::Stale,
+        lda_ipjs::subcommands::neighbor::NUDState::None => NeighborState::None,
+        lda_ipjs::subcommands::neighbor::NUDState::Incomplete => NeighborState::Incomplete,
+        lda_ipjs::subcommands::neighbor::NUDState::Delay => NeighborState::Delay,
+        lda_ipjs::subcommands::neighbor::NUDState::Probe => NeighborState::Probe,
+        lda_ipjs::subcommands::neighbor::NUDState::Failed => NeighborState::Failed,
+        lda_ipjs::subcommands::neighbor::NUDState::Other(_) => NeighborState::None,
+    }
+}
+
+fn map_neighbor_item(
+    lda_ipjs::subcommands::neighbor::NeighborItem {
+        ip,
+        dev,
+        mac,
+        state,
+    }: lda_ipjs::subcommands::neighbor::NeighborItem,
+) -> NeighborEntry {
+    NeighborEntry {
+        ip,
+        dev,
+        mac,
+        state: state
+            .into_iter()
+            .map(from_ipjs_state)
+            .max()
+            .unwrap_or(NeighborState::None),
+    }
+}

wakey-linux/src/dhcp.rs

@@ -0,0 +1,93 @@
+use std::io::{self, ErrorKind};
+use std::net::IpAddr;
+
+use wakey_core::{DhcpLease, DhcpLeaseWithState};
+
+const MAC_NAME_CACHE: &str = "/tmp/wakey_mac_names.json";
+
+pub async fn load_mac_name_cache() -> io::Result<std::collections::BTreeMap<String, String>> {
+    match tokio::fs::read_to_string(MAC_NAME_CACHE).await {
+        Ok(s) => serde_json::from_str(&s).map_err(io::Error::other),
+        Err(e) if e.kind() == ErrorKind::NotFound => Ok(Default::default()),
+        Err(e) => Err(e),
+    }
+}
+
+async fn save_mac_name_cache(map: &std::collections::BTreeMap<String, String>) -> io::Result<()> {
+    let s = serde_json::to_string(map).map_err(io::Error::other)?;
+    let _ = tokio::fs::write(MAC_NAME_CACHE, s).await;
+    Ok(())
+}
+
+pub fn parse_dhcp_lease_line(line: &str) -> Option<DhcpLease> {
+    let mut c = line.split_whitespace();
+    let expires_epoch: u64 = c.next()?.parse().ok()?;
+    let mac = c.next()?.parse().ok()?;
+    let ip = c.next()?.parse().ok()?;
+    let name = c.next().filter(|c| *c != "*").map(str::to_string);
+    Some(DhcpLease {
+        expires_epoch,
+        ip,
+        mac,
+        name,
+    })
+}
+
+pub async fn read_dhcp_leases() -> io::Result<Vec<DhcpLease>> {
+    match tokio::fs::read_to_string("/tmp/dhcp.leases").await {
+        Ok(file) => Ok(file.lines().filter_map(parse_dhcp_lease_line).collect()),
+        Err(e) if e.kind() == ErrorKind::NotFound => Ok(Vec::new()),
+        Err(e) => Err(e),
+    }
+}
+
+pub async fn read_dhcp_leases_with_names() -> io::Result<Vec<DhcpLease>> {
+    let leases = read_dhcp_leases().await?;
+    let mut cache = load_mac_name_cache().await.unwrap_or_default();
+    let mut changed = false;
+    let mut leases_with_names = Vec::with_capacity(leases.len());
+    for mut l in leases {
+        let mac_s = l.mac.to_string();
+        if let Some(ref name) = l.name {
+            if cache.get(&mac_s).map(|v| v != name).unwrap_or(true) {
+                cache.insert(mac_s, name.clone());
+                changed = true;
+            }
+        } else if let Some(prev) = cache.get(&mac_s) {
+            l.name = Some(prev.clone());
+        }
+        leases_with_names.push(l);
+    }
+    if changed {
+        let _ = save_mac_name_cache(&cache).await;
+    }
+    Ok(leases_with_names)
+}
+
+pub async fn enrich_leases_with_nud_state(leases: Vec<DhcpLease>) -> Vec<DhcpLeaseWithState> {
+    let ips: Vec<IpAddr> = leases.iter().map(|l| l.ip).collect();
+    let mut map: std::collections::HashMap<IpAddr, wakey_core::NeighborState> =
+        std::collections::HashMap::new();
+    if let Ok(rows) =
+        crate::devices::get_neighbors(&[] as &[&str], &ips, &[] as &[&str], &[], &[]).await
+    {
+        for row in rows {
+            let state = row.state;
+            let r = state.rank();
+            map.entry(row.ip)
+                .and_modify(|e| {
+                    if r > e.rank() {
+                        *e = state
+                    }
+                })
+                .or_insert(state);
+        }
+    }
+    leases
+        .into_iter()
+        .map(|lease_line| DhcpLeaseWithState {
+            nud_state: map.get(&lease_line.ip).copied(),
+            lease_line,
+        })
+        .collect()
+}

wakey-linux/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod devices;
+pub mod dhcp;
+pub mod wake;
+
+pub use devices::*;
+pub use dhcp::*;
+pub use wake::*;

wakey-linux/src/wake.rs

@@ -0,0 +1,78 @@
+use std::{io, net::IpAddr};
+
+use futures::TryFutureExt;
+use macaddr::MacAddr;
+use tokio::net::UdpSocket;
+use wakey_core::{WakeStatus, WakeTarget, WakeTargetResult};
+
+#[derive(Debug, Clone, Copy, Hash)]
+pub struct CompleteWakeTarget {
+    pub ip: IpAddr,
+    pub mac: MacAddr,
+}
+
+impl TryFrom<WakeTarget> for CompleteWakeTarget {
+    type Error = ();
+
+    fn try_from(value: WakeTarget) -> Result<Self, Self::Error> {
+        if let WakeTarget {
+            ip: Some(ip),
+            mac: Some(mac),
+        } = value
+        {
+            Ok(Self { ip, mac })
+        } else {
+            Err(())
+        }
+    }
+}
+
+pub async fn wake_one(sock: &UdpSocket, t: CompleteWakeTarget) -> WakeTargetResult {
+    let mac = t.mac;
+    let mb = mac.as_bytes();
+    let mut pac = [0; 6 + 6 * 16];
+    pac[..6].fill(0xff);
+    for i in 1..=16 {
+        pac[i * 6..(i + 1) * 6].copy_from_slice(mb);
+    }
+    match sock.send_to(&pac, (t.ip, 9)).await {
+        Ok(n) if n == pac.len() => WakeTargetResult {
+            target: WakeTarget {
+                ip: Some(t.ip),
+                mac: Some(t.mac),
+            },
+            status: WakeStatus::Succeed,
+        },
+        Ok(_) => WakeTargetResult {
+            target: WakeTarget {
+                ip: Some(t.ip),
+                mac: Some(t.mac),
+            },
+            status: WakeStatus::WrongSize,
+        },
+        Err(_) => WakeTargetResult {
+            target: WakeTarget {
+                ip: Some(t.ip),
+                mac: Some(t.mac),
+            },
+            status: WakeStatus::NonexistentAddress,
+        },
+    }
+}
+
+pub async fn wake_many(
+    targets: impl IntoIterator<Item = WakeTarget>,
+) -> io::Result<Vec<WakeTargetResult>> {
+    let sock = UdpSocket::bind("[::]:0")
+        .or_else(|_| UdpSocket::bind(":0"))
+        .await?;
+    sock.set_broadcast(true)?;
+
+    let iter = targets
+        .into_iter()
+        .map(async |target| match CompleteWakeTarget::try_from(target) {
+            Ok(target) => wake_one(&sock, target).await,
+            Err(()) => WakeTargetResult::incomplete(target),
+        });
+    Ok(futures::future::join_all(iter).await)
+}