From 4c86c7f78218fa2bab4b8098c468275111d50334 Mon Sep 17 00:00:00 2001 From: "Mr. Error" Date: Tue, 3 Nov 2026 16:33:41 +0800 Subject: [PATCH] Privacy: auto-enable on desktop connect (UU_PRIVACY_AUTO) (#161) * feat(privacy): auto-enable the privacy screen on desktop connect `UU_PRIVACY_AUTO=picture` / `screen-off` (or 2 / 3) enables the privacy screen when the first desktop controller connects. Off by default. The switch waits for the portal capture session and retries while it is missing; the viewer's own RPC 7 cancels a pending auto-enable for that session. The privacy state poller that pushes SystemMetrics and SystemStateChange now starts for desktop peers too (it only ran for a tool peer promoted to desktop), and it pushes once on its first tick. A mode the viewer did not request, such as an auto-enable, therefore reaches its menu, and the state message also goes to TEXT, which viewers read for privacy replies. Verified on KDE Plasma Wayland with an iOS viewer: auto picture and auto screen-off both engage, the menu reflects the mode after the push, and a disconnect restores the physical outputs. `cargo test --features wayland,portal`: 320 passed, 10 ignored. * fix(privacy): let a viewer request win against auto-enable races Two paths could still override an explicit choice: - the override was checked before acquiring STATE, so an RPC 7 applied in that window could disable privacy and the auto thread could turn it back on; the check now happens inside the same lock that enters the mode - `session_started` captured the override counter as its baseline, so a request that arrived after CONTROL opened but before the session counter started was treated as unrelated and auto-enable ran anyway; the counter is now a flag set by any RPC 7 and cleared only when the last desktop session ends docs/privacy-screen.md now says remote-assistance (guest) sessions are covered too, and that supported hosts push the current privacy state once on every desktop connect. --- README.en.md | 2 +- README.md | 2 +- docs/privacy-screen.md | 14 +++++++ src/portal.rs | 4 ++ src/privacy_screen/mod.rs | 87 +++++++++++++++++++++++++++++++++++++-- src/webrtc.rs | 16 ++++++- 6 files changed, 118 insertions(+), 7 deletions(-) diff --git a/README.en.md b/README.en.md index fe16a35..4363eb7 100644 --- a/README.en.md +++ b/README.en.md @@ -159,7 +159,7 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18 | True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; `inproc-av` native NVENC encodes H.264 High 4:4:4 / HEVC FRExt; VAAPI stays 4:2:0 and reports that to the client | | HDR | Not implemented | | Super screen / virtual display | Not implemented | -| Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; see [docs/privacy-screen.md](docs/privacy-screen.md) | +| Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; `UU_PRIVACY_AUTO=picture` / `screen-off` enables it automatically on desktop connect; see [docs/privacy-screen.md](docs/privacy-screen.md) | | Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) | | Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist | | Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance | diff --git a/README.md b/README.md index a960ac2..2d95370 100644 --- a/README.md +++ b/README.md @@ -140,7 +140,7 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通 | 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;`inproc-av` 原生 NVENC 输出 H.264 High 4:4:4 / HEVC FRExt;VAAPI 管线仍为 4:2:0,并如实回报给客户端 | | HDR | 未实现 | | 超级屏 / 虚拟显示器 | 未实现 | -| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显,见 [docs/privacy-screen.md](docs/privacy-screen.md) | +| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) | | 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) | | 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 | | Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 | diff --git a/docs/privacy-screen.md b/docs/privacy-screen.md index 2ffb337..a40dcc4 100644 --- a/docs/privacy-screen.md +++ b/docs/privacy-screen.md @@ -44,6 +44,20 @@ is aimed at the virtual output's region. Needs GTK3. `UU_PRIVACY_BLOCK_INPUT=0` to keep local input. KWin saves the device flag, so a `privacy-guard` child restores devices and outputs from the record whenever the host ends, including SIGKILL; the next start retries too. Devices plugged in during privacy are not blocked. +- 自动开启:`UU_PRIVACY_AUTO=picture`(或 `2`)在第一个桌面控制端连上后自动启用隐私屏保, + `UU_PRIVACY_AUTO=screen-off`(或 `3`)自动关屏;默认关闭。远程协助(访客)的桌面会话同样适用。 + 控制端自己的请求优先:一次会话里只要客户端发过隐私请求(包括连接刚建立、会话计数还没开始的 + 那一刻),待执行的自动开启就不再触发;断开后照常恢复。主机不支持或依赖缺失时只记日志,不影响连接。 + 自动开启后主机会向控制端推送一次 SystemMetrics 和 SystemStateChange,控制端菜单随之更新。支持的主机上, + 每次桌面连接也会先推送一次当前状态(关闭时为关闭),这是新增的主动上报。 + Auto: `UU_PRIVACY_AUTO=picture` (or `2`) enables picture mode when the first desktop controller + connects; `screen-off` (or `3`) turns the physical screens off. Off by default. Remote-assistance + (guest) desktop sessions are covered too. The viewer's own request wins for that session, including + one that arrives right after the connection opens and before the session counter starts: a pending + auto-enable then does not run, and a disconnect restores as usual. Unsupported hosts or missing + tools only log; the connection is unaffected. After an auto-enable the host pushes SystemMetrics + and SystemStateChange once, so the viewer's menu follows; on supported hosts every desktop + connection also pushes the current state first (off when it is off), which is new outbound traffic. - 这是尽力而为的遮挡,不是保密边界。/ This is best-effort obscuring, not a confidentiality boundary. - 恢复记录保存在配置文件旁的 `privacy-power.json`(0600);崩溃后下次启动重新启用记录的物理屏。 若主机无法启动,可在本机终端执行 `kscreen-doctor output..enable`。 diff --git a/src/portal.rs b/src/portal.rs index 1e7b37c..0e99813 100644 --- a/src/portal.rs +++ b/src/portal.rs @@ -883,6 +883,10 @@ pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connect pub fn register(session: &Arc) { *ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session)); } +/// Whether a desktop capture session is registered for monitor/virtual switching. +pub fn available() -> bool { + ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade).is_some() +} /// Privacy screen: see `Session::set_virtual`. Restoring without a live session is a no-op; /// failures switching a live session must reach the controller so its recovery record survives. pub fn set_virtual_active(on: bool) -> Result<(), String> { diff --git a/src/privacy_screen/mod.rs b/src/privacy_screen/mod.rs index 43a53fd..b34b021 100644 --- a/src/privacy_screen/mod.rs +++ b/src/privacy_screen/mod.rs @@ -21,6 +21,10 @@ static STATE: Mutex = Mutex::new(State { sessions: 0, active: None }); static ACTIVE: AtomicBool = AtomicBool::new(false); static PICTURE: AtomicBool = AtomicBool::new(false); static POINTER: Mutex> = Mutex::new(None); +/// Set by any viewer RPC 7 during the current desktop sessions and cleared when the last one +/// ends. An auto-enable never overrides it, including an RPC that arrives after the connection +/// opens but before `session_started` bumps the counter. +static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false); pub fn supported() -> bool { backend::detect().is_some() } pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) } @@ -80,7 +84,9 @@ fn save_preference(mode: Mode) { if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_type = Some(mode.wire_type())) { log::warn!("Privacy mode not saved: {e}"); } } /// RPC 7: `mode` is None for an unknown privacy_type. -fn set(enable: bool, mode: Option) -> Result<(), String> { +fn set(enable: bool, mode: Option) -> Result<(), String> { set_inner(enable, mode, true) } +/// `save` records the viewer's preference; the auto-enable path must not overwrite it. +fn set_inner(enable: bool, mode: Option, save: bool) -> Result<(), String> { let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?; if !enable { return leave(&mut state); } let mode = mode.ok_or("unsupported privacy type")?; @@ -89,7 +95,7 @@ fn set(enable: bool, mode: Option) -> Result<(), String> { // A failed rollback keeps the record and the guard: the next request, exit or start retries. if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } } drop(state); - if result.is_ok() { save_preference(mode); } + if result.is_ok() && save { save_preference(mode); } result } /// Why RPC 7 cannot be served at all; checked before answering. @@ -119,21 +125,83 @@ pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec, Option pub const REPORT_ERROR: i32 = -7; impl Accepted { pub fn apply(self) -> Result<(), String> { + VIEWER_OVERRIDE.store(true, Ordering::Relaxed); let result = set(self.enable, self.mode); if let Err(e) = &result { log::warn!("Privacy request failed: enable={} mode={:?}: {e}", self.enable, self.mode); } result } } -pub fn session_started() { if let Ok(mut s) = STATE.lock() { s.sessions += 1; } } +/// `UU_PRIVACY_AUTO` accepts `picture`/`2` and `screen-off`/`3`; anything else leaves the viewer +/// in charge (and so does the viewer's own RPC 7, which cancels a pending auto-enable). +fn parse_auto(value: &str) -> Option { + match value.trim().to_ascii_lowercase().as_str() { + "2" | "picture" => Some(Mode::Picture), + "3" | "screen-off" | "screen_off" => Some(Mode::ScreenOff), + _ => None, + } +} +fn auto_mode() -> Option { std::env::var("UU_PRIVACY_AUTO").ok().as_deref().and_then(parse_auto) } +/// Enter the auto mode with the viewer-override check inside the STATE lock, so a request that +/// lands between the caller's check and this lock still wins. Ok(false): the viewer overrode it. +fn auto_set(mode: Mode) -> Result { + let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?; + if VIEWER_OVERRIDE.load(Ordering::Relaxed) { return Ok(false); } + if state.sessions == 0 { return Err("no active desktop session".into()); } + let result = enter(&mut state, mode); + if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } } + result.map(|_| true) +} +/// The capture session and the viewer's CONTROL state need a moment after the peer connects; +/// retry while the portal session is still missing, and let the viewer's RPC 7 win if it arrives. +fn auto_enable(mode: Mode) { + for attempt in 1..=5 { + if VIEWER_OVERRIDE.load(Ordering::Relaxed) { + log::info!("Privacy auto: skipped, the viewer already chose a mode"); + return; + } + // Not a failure yet: the desktop capture opens its portal session a moment after the peer + // connects, and entering without it would roll back and log a restore for nothing. + if !crate::portal::available() { + log::info!("Privacy auto: waiting for the desktop capture (attempt {attempt})"); + std::thread::sleep(std::time::Duration::from_secs(1)); + continue; + } + match auto_set(mode) { + Ok(true) => { log::info!("Privacy auto: enabled mode={mode:?} on attempt {attempt}"); return; } + Ok(false) => { log::info!("Privacy auto: skipped, the viewer already chose a mode"); return; } + Err(e) if e.contains("no active desktop session") => return, + Err(e) if e.contains("Portal desktop unavailable") => { + log::info!("Privacy auto: desktop capture not ready (attempt {attempt})"); + std::thread::sleep(std::time::Duration::from_secs(1)); + } + Err(e) => { log::warn!("Privacy auto failed: {e}"); return; } + } + } + log::warn!("Privacy auto: giving up; the viewer can still enable the privacy screen"); +} +pub fn session_started() { + let auto = auto_mode(); + let first = STATE.lock().ok().is_some_and(|mut s| { s.sessions += 1; s.sessions == 1 }); + let Some(mode) = auto else { return }; + if !first { return; } + std::thread::spawn(move || { + std::thread::sleep(std::time::Duration::from_millis(1500)); + auto_enable(mode); + }); +} pub fn session_ended() { if let Ok(mut s) = STATE.lock() { s.sessions = s.sessions.saturating_sub(1); - if s.sessions == 0 { if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); } } + if s.sessions == 0 { + VIEWER_OVERRIDE.store(false, Ordering::Relaxed); + if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); } + } } } pub fn shutdown() { if let Ok(mut s) = STATE.lock() { s.sessions = 0; + VIEWER_OVERRIDE.store(false, Ordering::Relaxed); if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); } } } @@ -167,6 +235,17 @@ pub fn cover_main(args: &[String]) -> i32 { cover::main(args) } #[cfg(test)] mod tests { + #[test] + fn parses_auto_privacy_modes() { + use super::{parse_auto, Mode}; + assert_eq!(parse_auto("picture"), Some(Mode::Picture)); + assert_eq!(parse_auto("2"), Some(Mode::Picture)); + assert_eq!(parse_auto(" screen-off "), Some(Mode::ScreenOff)); + assert_eq!(parse_auto("3"), Some(Mode::ScreenOff)); + assert_eq!(parse_auto("0"), None); + assert_eq!(parse_auto("off"), None); + assert_eq!(parse_auto(""), None); + } #[test] fn enabling_without_a_backend_is_refused_and_reports_off() { let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3]; diff --git a/src/webrtc.rs b/src/webrtc.rs index 0300d26..23437a2 100644 --- a/src/webrtc.rs +++ b/src/webrtc.rs @@ -1002,6 +1002,7 @@ impl WebRtcSession { // Default file-transfer folder: the desktop user's home directory. let home = std::env::var("HOME").unwrap_or_else(|_| "/".into()); let (mut desktop, mut promoted, mut lock_reported) = (desktop, false, desktop); + let mut privacy_reported = false; let mut screen = screen; loop { loop { @@ -1056,11 +1057,20 @@ impl WebRtcSession { if !lock_reported { lock_reported = true; tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked())); + } + // The viewer's menu only learns about a mode it did not ask for (an + // auto-enable) from this push, so desktop peers need it too, not only a + // tool peer promoted to desktop. + if !privacy_reported && crate::privacy_screen::supported() { + privacy_reported = true; let (channel, sequence, actions) = (channel.clone(), sequence.clone(), init_actions.clone()); let portal = portal_desktop.clone(); let text_out = text_out.clone(); tokio::spawn(async move { - let mut previous = crate::privacy_screen::current_type(); + // 0 is not a wire type: the first tick must push the effective state. + // An auto-enable can land before this task starts, and the viewer + // never sent an RPC to learn the mode from a response. + let mut previous = 0u8; let mut tick = tokio::time::interval(std::time::Duration::from_secs(1)); loop { tick.tick().await; @@ -1068,6 +1078,7 @@ impl WebRtcSession { let current = crate::privacy_screen::current_type(); if current == previous { continue; } previous = current; + log::info!("Privacy state change pushed: type={current}"); let permission = portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(true)); let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); let payload = actions.metrics_payload(desktop_sound, permission); @@ -1075,6 +1086,9 @@ impl WebRtcSession { text_out.metrics(message.clone()); if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; } let state = crate::privacy_screen::state_message(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts); + // Android 4.43.0 handles privacy replies on TEXT; CONTROL stays for + // viewers that only read the desktop channel. + let _ = text_out.send(state.clone()); if channel.send(&bytes::Bytes::from(state)).await.is_err() { return; } } });