From 5949314e55d0ebe06e68621d378c0fc5415947f8 Mon Sep 17 00:00:00 2001 From: VallierDev <24893073+VallierDev@users.noreply.github.com> Date: Tue, 20 Oct 2026 12:43:13 +0800 Subject: [PATCH] Experimental WOL helper (UU_WOL_HELPER=1); doctor keeps logs quiet Mirrors the official Windows host (GameViewerServer reportLanInfo / PushMessageHandler::wakeOnLan / send_wol): report the LAN identity after sign-in and answer wake_on_lan pushes with a magic packet to the target's subnet broadcast. Field names come from the official log strings; off by default and unverified end to end. wake_on_lan push key names are always logged for evidence. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 1 + README.en.md | 1 + README.md | 1 + src/auth.rs | 10 ++++ src/doctor.rs | 2 + src/main.rs | 21 +++++++++ src/wol.rs | 123 ++++++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 159 insertions(+) create mode 100644 src/wol.rs diff --git a/AGENTS.md b/AGENTS.md index aef58b1..f4edc65 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -117,6 +117,7 @@ viewer does not reconnect them automatically. | `UU_AUDIO=0`, `UU_AUDIO_SOURCE` | disable sound / choose the Pulse source (default `@DEFAULT_MONITOR@`) | | `UU_LOGIN_WINDOW=0` | don't auto-open the login window | | `UU_ENGINE_DIR` | directory holding `libuu-wayland.so` / `libuu-portal.so` (`--features engine-plugins`, used by release packages: engines are dlopen'ed only on Wayland sessions; also searched next to the binary, `../lib/uu-remote-linux`, `~/.local/lib/uu-remote-linux`, `/usr/lib/uu-remote-linux`) | +| `UU_WOL_HELPER=1` | experimental: report LAN info (`api-ipv4…/api/v1/device/wake_on_lan/info` {mac, ip, subnet_mask}) after sign-in and answer `wake_on_lan` pushes (`target_device` {mac, ip, subnet_mask}) with a magic packet, like the official Windows host (field names from its log strings; not verified end to end). `wake_on_lan` push key names are always logged | | `UU_USE_PROXY=1` | honor HTTP/SOCKS proxy env vars; cloud API clients bypass env proxies by default | | `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors | diff --git a/README.en.md b/README.en.md index edf8f03..a4fb604 100644 --- a/README.en.md +++ b/README.en.md @@ -333,6 +333,7 @@ Common environment variables: | `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) | | `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing | | `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) | +| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (not verified end to end) | | `UU_USE_PROXY=1` | Honor HTTP/SOCKS proxy environment variables; by default proxies are ignored and NetEase servers are reached directly | Host settings such as "lock after remote session" and "mute host" are stored in diff --git a/README.md b/README.md index d9e1565..ee9b161 100644 --- a/README.md +++ b/README.md @@ -303,6 +303,7 @@ systemctl --user restart uuremote-native.service | `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) | | `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) | | `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) | +| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) | | `UU_USE_PROXY=1` | 使用环境变量里的 HTTP/SOCKS 代理;默认忽略代理、直连网易服务器 | 「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。 diff --git a/src/auth.rs b/src/auth.rs index 7bd8a90..ba9afff 100644 --- a/src/auth.rs +++ b/src/auth.rs @@ -251,6 +251,16 @@ impl UUAuthClient { Ok((status, value)) } + /// Signed JSON POST to another API host (the signature covers the path only). + pub async fn post_json_url(&self, base: &str, path: &str, body: &serde_json::Value) -> Result<(u16, serde_json::Value), String> { + let body_str = serde_json::to_string(body).map_err(|e| e.to_string())?; + let resp = self.http.post(format!("{base}{path}")) + .headers(self.build_headers("POST", path, &body_str)).body(body_str) + .send().await.map_err(|e| format!("HTTP post {path} failed: {}", transport_error(&e)))?; + let status = resp.status().as_u16(); + Ok((status, resp.json().await.unwrap_or(serde_json::Value::Null))) + } + /// Guest APIs use requestPlain for empty requests; sign the actual empty body. /// Errors intentionally exclude response text and URL (both can contain secrets). pub async fn assist_post(&self, path: &str, body: Option<&serde_json::Value>) -> Result<(u16, serde_json::Value), String> { diff --git a/src/doctor.rs b/src/doctor.rs index 0eefb2d..497c1a1 100644 --- a/src/doctor.rs +++ b/src/doctor.rs @@ -41,6 +41,8 @@ async fn command_output(program: &str, args: &[&str]) -> Option { pub async fn run() -> Result<(), String> { use crate::desktop_backend as backend; use crate::engine_plugin::{load, Engine}; + // Info logs (e.g. plugin paths under the home directory) would bypass the redaction below. + log::set_max_level(log::LevelFilter::Warn); println!("uu-remote-linux doctor (safe to paste: no ids, tokens, addresses or file contents)"); line("version", format!("v{} {}", env!("CARGO_PKG_VERSION"), std::env::consts::ARCH)); line("glibc", glibc()); diff --git a/src/main.rs b/src/main.rs index b7e8819..ad1d0ed 100644 --- a/src/main.rs +++ b/src/main.rs @@ -3,6 +3,7 @@ mod engine_plugin; mod doctor; +mod wol; mod desktop_backend; mod desktop_session; mod desktop_power; @@ -649,6 +650,11 @@ async fn serve(mut capture: Arc, input: Arc, shutd } SignalingEvent::Connected => { log::info!("Signaling handshake established."); + static WOL_REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); + if wol::enabled() && assist.as_ref().is_none_or(|s| s.is_account()) && !WOL_REPORTED.swap(true, std::sync::atomic::Ordering::AcqRel) { + let client = auth.clone(); + tokio::spawn(async move { wol::report(&client).await; }); + } } SignalingEvent::RoomInfoAck(_) => { log::info!("RoomInfo acknowledged by NetEase server"); } SignalingEvent::DeviceInfoChanged(val) => { @@ -658,6 +664,21 @@ async fn serve(mut capture: Arc, input: Arc, shutd log::debug!("Assist bmsg_push shape: type={:?} keys={:?} data_keys={:?}", val.get("type").and_then(serde_json::Value::as_str), keys(Some(&val)), keys(val.get("data"))); } + if val.get("type").and_then(serde_json::Value::as_str) == Some("wake_on_lan") { + // Key names only: the target carries a MAC and LAN address. + let data = val.get("data").unwrap_or(&val); + log::info!("wake_on_lan push received: keys={:?} target_keys={:?} helper_enabled={}", + data.as_object().map(|o| o.keys().cloned().collect::>()).unwrap_or_default(), + data.get("target_device").and_then(|t| t.as_object()).map(|o| o.keys().cloned().collect::>()).unwrap_or_default(), + wol::enabled()); + if wol::enabled() { + match wol::handle_push(data) { + Ok(sent) => log::info!("WOL helper: magic packet sent ({sent} datagrams)"), + Err(error) => log::warn!("WOL helper: {error}"), + } + } + continue; + } if val.get("type").and_then(serde_json::Value::as_str) == Some("get_control_mode") { if let Some(s) = assist.as_mut() { match s.control_mode(val.get("data").unwrap_or(&serde_json::Value::Null)).await { diff --git a/src/wol.rs b/src/wol.rs new file mode 100644 index 0000000..78c9886 --- /dev/null +++ b/src/wol.rs @@ -0,0 +1,123 @@ +//! Experimental Wake-on-LAN helper (`UU_WOL_HELPER=1`, off by default). +//! +//! The official Windows host (GameViewerServer: LoginManager::reportLanInfo, PushMessageHandler::wakeOnLan, +//! wake_on_lan.cpp host::send_wol) reports its LAN address to `api-ipv4…/api/v1/device/wake_on_lan/info` +//! after sign-in (logged as "mac / ip / subnet_mask", response carries `turn_on_wol`), and on a +//! `wake_on_lan` cloud push with a `target_device` {mac, ip, subnet_mask} it sends a magic packet to that +//! subnet's broadcast address, waking another PC of the account on the same LAN. The exact request and +//! push field names come from the official log strings only; nothing here is verified end to end yet. +//! Addresses are sent to NetEase only when the helper is enabled and are never logged. + +use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket}; + +pub fn enabled() -> bool { std::env::var("UU_WOL_HELPER").is_ok_and(|v| v == "1") } + +/// `aa:bb:cc:dd:ee:ff` / `aa-bb-…` / `aabbcc…` → 6 bytes. +pub fn parse_mac(text: &str) -> Option<[u8; 6]> { + let hex: String = text.chars().filter(|c| c.is_ascii_hexdigit()).collect(); + if hex.len() != 12 || text.chars().any(|c| !(c.is_ascii_hexdigit() || matches!(c, ':' | '-' | '.'))) { return None; } + let mut mac = [0u8; 6]; + for (i, byte) in mac.iter_mut().enumerate() { *byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).ok()?; } + (mac != [0; 6] && mac != [0xff; 6]).then_some(mac) +} + +/// Six 0xFF bytes followed by the MAC sixteen times. +pub fn magic_packet(mac: [u8; 6]) -> Vec { + let mut packet = vec![0xff; 6]; + for _ in 0..16 { packet.extend_from_slice(&mac); } + packet +} + +/// Directed broadcast of `ip`/`mask`, or None when either is missing or invalid. +pub fn subnet_broadcast(ip: &str, mask: &str) -> Option { + let (ip, mask): (Ipv4Addr, Ipv4Addr) = (ip.parse().ok()?, mask.parse().ok()?); + let mask = u32::from(mask); + if mask == 0 || mask.leading_ones() + mask.trailing_zeros() != 32 { return None; } + Some(Ipv4Addr::from(u32::from(ip) | !mask)) +} + +/// Handles a `wake_on_lan` push payload; returns how many datagrams were sent. +pub fn handle_push(data: &serde_json::Value) -> Result { + let target = data.get("target_device").or_else(|| data.get("data").and_then(|d| d.get("target_device"))) + .ok_or("wake_on_lan push without target_device")?; + let text = |key: &str| target.get(key).and_then(serde_json::Value::as_str).unwrap_or(""); + let mac = parse_mac(text("mac")).ok_or("wake_on_lan target has no valid mac")?; + let packet = magic_packet(mac); + let socket = UdpSocket::bind("0.0.0.0:0").map_err(|e| format!("WOL socket: {}", e.kind()))?; + socket.set_broadcast(true).map_err(|e| format!("WOL broadcast: {}", e.kind()))?; + let mut targets = vec![Ipv4Addr::BROADCAST]; + if let Some(directed) = subnet_broadcast(text("ip"), text("subnet_mask")) { targets.insert(0, directed); } + let mut sent = 0; + for address in targets { for port in [9, 7] { + if socket.send_to(&packet, SocketAddrV4::new(address, port)).is_ok() { sent += 1; } + } } + if sent == 0 { return Err("WOL packet could not be sent".into()); } + Ok(sent) +} + +/// This host's LAN identity on the default IPv4 route: (mac, ip, subnet mask). +#[cfg(target_os = "linux")] +pub fn lan_info() -> Option<(String, String, String)> { + let routes = std::fs::read_to_string("/proc/net/route").ok()?; + let iface = routes.lines().skip(1).map(|l| l.split_whitespace().collect::>()) + .find(|f| f.len() > 2 && f[1] == "00000000")?.first()?.to_string(); + let mac = std::fs::read_to_string(format!("/sys/class/net/{iface}/address")).ok()?.trim().to_owned(); + parse_mac(&mac)?; + let mut addrs: *mut libc::ifaddrs = std::ptr::null_mut(); + if unsafe { libc::getifaddrs(&mut addrs) } != 0 { return None; } + let mut result = None; + let mut cursor = addrs; + while !cursor.is_null() { + let entry = unsafe { &*cursor }; + cursor = entry.ifa_next; + if entry.ifa_addr.is_null() || entry.ifa_netmask.is_null() { continue; } + let name = unsafe { std::ffi::CStr::from_ptr(entry.ifa_name) }.to_string_lossy(); + if name != iface.as_str() || i32::from(unsafe { (*entry.ifa_addr).sa_family }) != libc::AF_INET { continue; } + let v4 = |p: *mut libc::sockaddr| Ipv4Addr::from(u32::from_be(unsafe { (*(p as *const libc::sockaddr_in)).sin_addr.s_addr })); + result = Some((mac.clone(), v4(entry.ifa_addr).to_string(), v4(entry.ifa_netmask).to_string())); + break; + } + unsafe { libc::freeifaddrs(addrs) }; + result +} +#[cfg(not(target_os = "linux"))] +pub fn lan_info() -> Option<(String, String, String)> { None } + +/// Report this host's LAN identity like the official host after sign-in. +pub async fn report(auth: &crate::auth::UUAuthClient) { + let Some((mac, ip, subnet_mask)) = lan_info() else { log::warn!("WOL helper: no IPv4 default-route interface"); return; }; + let body = serde_json::json!({ "mac": mac, "ip": ip, "subnet_mask": subnet_mask }); + match auth.post_json_url("https://api-ipv4.nrd.nie.163.com", "/api/v1/device/wake_on_lan/info", &body).await { + Ok((status, value)) => log::info!("WOL helper: LAN info reported: status={status} code={:?} turn_on_wol={:?}", + value.get("code").and_then(serde_json::Value::as_i64), + value.get("data").and_then(|d| d.get("turn_on_wol")).or_else(|| value.get("turn_on_wol"))), + Err(error) => log::warn!("WOL helper: LAN info report failed: {error}"), + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn mac_parsing_and_packet() { + assert_eq!(parse_mac("AA:bb:cc:dd:ee:01"), Some([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 1])); + assert_eq!(parse_mac("aa-bb-cc-dd-ee-01"), parse_mac("aabbccddee01")); + assert!(parse_mac("aa:bb:cc").is_none() && parse_mac("zz:bb:cc:dd:ee:01").is_none() && parse_mac("00:00:00:00:00:00").is_none()); + let packet = magic_packet([1, 2, 3, 4, 5, 6]); + assert_eq!(packet.len(), 102); + assert_eq!(&packet[..6], &[0xff; 6]); + assert_eq!(&packet[96..], &[1, 2, 3, 4, 5, 6]); + } + #[test] + fn directed_broadcast() { + assert_eq!(subnet_broadcast("192.168.2.29", "255.255.255.0"), Some(Ipv4Addr::new(192, 168, 2, 255))); + assert_eq!(subnet_broadcast("10.1.2.3", "255.255.0.0"), Some(Ipv4Addr::new(10, 1, 255, 255))); + assert_eq!(subnet_broadcast("10.1.2.3", "255.0.255.0"), None); + assert_eq!(subnet_broadcast("", "255.255.255.0"), None); + } + #[test] + fn push_without_target_is_rejected() { + assert!(handle_push(&serde_json::json!({})).is_err()); + assert!(handle_push(&serde_json::json!({"target_device": {"mac": "nope"}})).is_err()); + } +}