From f4f16aafe482d8423c65461c969f86d7b9d48321 Mon Sep 17 00:00:00 2001 From: Jeff Zhang Date: Mon, 2 Nov 2026 11:17:55 +0800 Subject: [PATCH] fix(privacy): synchronize Mac viewer privacy status over TEXT (#148) * fix(privacy): synchronize Mac viewer privacy status over TEXT * fix(webrtc): bound pending TEXT replies and coalesce metrics --- README.en.md | 2 +- README.md | 2 +- docs/privacy-screen.md | 47 ++++++++++++++++-- src/desktop_control_tests.rs | 54 +++++++++++++++++++++ src/privacy_screen/mod.rs | 7 +-- src/system_actions.rs | 4 +- src/system_metrics.rs | 51 +++++++++++++------- src/text_outbox.rs | 92 ++++++++++++++++++++++++++++++++++++ src/webrtc.rs | 79 +++++++++++++++++++++++++------ 9 files changed, 296 insertions(+), 42 deletions(-) create mode 100644 src/text_outbox.rs diff --git a/README.en.md b/README.en.md index ecd9a3b..a1ef3f7 100644 --- a/README.en.md +++ b/README.en.md @@ -151,7 +151,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; 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; 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 e9ab2a5..3e67e65 100644 --- a/README.md +++ b/README.md @@ -136,7 +136,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),见 [docs/privacy-screen.md](docs/privacy-screen.md) | +| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显,见 [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 dd5f4d3..2ffb337 100644 --- a/docs/privacy-screen.md +++ b/docs/privacy-screen.md @@ -63,13 +63,54 @@ is aimed at the virtual output's region. Needs GTK3. `{1 error_code, 2 req_privacy_type, 3 cur_privacy_type}`;PrivateScreenType 2 隐私/picture, 3 关屏/screen off。 主机先应答再切换(客户端约数秒超时,报 9998);切换失败发 ReportError -7。 The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7. + 成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。 + Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success. - RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。 Sent before picture mode; answered empty (success), the host keeps its own wallpaper. - FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type` - (最近一次开启的模式,存于 host_settings.json `privacy_type`);SystemStateChange 5 `PrivateScreenState` 在状态变化时推送。 + 上报当前实际模式(1 关闭、2 屏保、3 关屏),不使用 host_settings.json 中的历史选项;SystemStateChange 5 + `PrivateScreenState` 在状态变化时推送。 + SettingMetric 4/7 report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference; + SystemStateChange 5 is sent after a switch. -已知限制:官方 Mac 客户端的防窥菜单在切换后仍回显"不启用",实际模式正确;客户端未回读上述状态。 -Known limitation: the official Mac viewer's menu still shows "off" after switching although the mode applies. +Mac 4.43.0 从 CONTROL 发送请求,但只在 TEXT 接收分支处理上述 RPC 应答与 SystemMetrics。 +防窥与屏保应答走 TEXT;SystemMetrics 同步发送到 TEXT,并保留 CONTROL 上报以兼容其他客户端。 +每个 peer 独立排队,TEXT 打开后才发送;待发 SystemMetrics 只保留最新一条,其他应答最多 64 条, +按入队顺序发送。满队列时丢弃新增应答并记录一次警告,不阻塞 CONTROL 请求处理。 +SystemMetrics 优先读取非零的 field 7,仅在其为 0 时回退 +到 field 4。SystemMetrics field 1 `metrics` 必须列出本次报告的类型(general=1、setting=2), +否则客户端直接忽略消息内容。已用原签名 Mac 4.43.0 客户端验证三种模式的安全浮层回显, +关屏后断开恢复物理屏与输入设备,再次连接回显“不启用”。 +Mac 4.43.0 sends requests on CONTROL, but handles these RPC responses and SystemMetrics only on TEXT. +Privacy/screensaver replies use TEXT; SystemMetrics are also sent on TEXT, retaining CONTROL for other +viewers. Each peer queues messages until its TEXT channel opens, retaining only the latest pending +SystemMetrics and up to 64 other replies in FIFO order. Excess replies are dropped with one warning +per peer, without blocking CONTROL request handling. Nonzero field 7 takes precedence over +field 4. SystemMetrics field 1 `metrics` must list the reported sections (general=1, setting=2), or the +viewer ignores the payload. The original signed Mac 4.43.0 viewer was verified for all three labels, +physical-screen/input restoration on disconnect, and an off label after reconnecting. + +官方主机侧依据:原签名 Mac `UURemoteServer` 4.43.0(626),arm64 UUID +`7E10CB24-F516-3728-8375-BA5EC124A2C5`。`SystemMetricsHandler.handleSystemMetrics`(`0x10000a96c`) +按请求填充各节,general 分支在 `0x10000abe8` 追加 `1`,setting helper(`0x10000a230`) +在 `0x10000a64c` 追加 `2`;`GvPb_SystemMetrics.traverse`(`0x100423840`)将列表按 packed enum +写入 field 1。发送链 `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` 使用 TEXT。 +这是静态主机代码依据:请求 general 和 setting 时得到 `[1,2]`,不是抓包,也不表示每条响应都固定 +包含两节或证明官方 CONTROL 报文。本实现总是报告两节,因此列出 `[1,2]`。 +Official host evidence: the original signed Mac `UURemoteServer` 4.43.0 (626), arm64 UUID +`7E10CB24-F516-3728-8375-BA5EC124A2C5`. `SystemMetricsHandler.handleSystemMetrics` (`0x10000a96c`) +fills the requested sections, appending GENERAL=1 at `0x10000abe8` and SETTING=2 at `0x10000a64c` +in helper `0x10000a230`. `GvPb_SystemMetrics.traverse` (`0x100423840`) encodes that list as packed +field 1. The send chain `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` uses TEXT. +This is static host-code evidence: requesting both sections produces `[1,2]`; it is not a packet +capture or proof that every response includes both sections or that the official host sends it on +CONTROL. Our payload always reports both sections, so it lists `[1,2]`. + +Android 4.43.0 已确认打开 TEXT;主机日志和手机端人工验收确认,关屏、隐私屏保、取消三种操作的 +实际模式与菜单选中状态均正确。Windows/iOS 未在本轮验收。 +Android 4.43.0 opens TEXT; host logs and manual phone-side acceptance confirmed that screen-off, +picture and off operations update both the effective mode and the selected menu item. +Windows/iOS were not tested in this round. ## 本机诊断 / Local diagnostic diff --git a/src/desktop_control_tests.rs b/src/desktop_control_tests.rs index c42acd5..4344ae2 100644 --- a/src/desktop_control_tests.rs +++ b/src/desktop_control_tests.rs @@ -79,6 +79,60 @@ fn mapping(kind: u8, payload: &[u8]) -> Vec { crate::initialization::envelope(1, 0, 27, &frame) } +#[tokio::test] +async fn privacy_replies_wait_for_each_peers_text_channel() { + tokio::time::timeout(Duration::from_secs(25), async { + let mut peers = Vec::new(); + for request_id in [41, 51] { + let (host, mut viewer) = connect(Arc::new(InputInjector::without_desktop()), false, None, + &["CONTROL_DATA_CHANNEL"]).await; + receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await; + for (id, case, payload) in [(request_id, 25, &[][..]), (request_id + 1, 7, &[8, 1, 16, 3][..])] { + let mut rpc = bytes(1, &[8, id]); + rpc.extend(bytes(case, payload)); + send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(1, 0, 21, &rpc)).await; + } + // A synthetic host rejects privacy without touching a physical desktop. + // Echo is a dispatch barrier: both replies are queued before TEXT exists. + send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(2, 0, 3, &[8, 0])).await; + receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await; + peers.push((request_id, host, viewer)); + } + for (request_id, host, mut viewer) in peers { + let text = viewer.pc.create_data_channel("TEXT_DATA_CHANNEL", None).await.unwrap(); + let (tx, messages) = mpsc::unbounded_channel(); + text.on_message(Box::new(move |message| { + let _ = tx.send(("TEXT_DATA_CHANNEL".into(), message.data.to_vec())); + Box::pin(async {}) + })); + viewer.messages = messages; + let mut replies = Vec::new(); + let mut metrics_seen = false; + while replies.len() < 2 || !metrics_seen { + let (channel, message) = tokio::time::timeout(Duration::from_secs(5), viewer.messages.recv()).await + .expect("late TEXT delivery timed out").expect("peer stopped responding"); + assert_eq!(channel, "TEXT_DATA_CHANNEL"); + if let Some(metrics) = body(&message, 13) { + assert_eq!(body(metrics, 1), Some([1, 2].as_slice())); + metrics_seen = true; + } + if body(&message, 22).is_some() { replies.push(message); } + } + for ((id, case), message) in [(request_id, 21), (request_id + 1, 3)].into_iter().zip(replies) { + let rpc = body(&message, 22).unwrap(); + assert_eq!(body(rpc, 1), Some([8, id].as_slice())); + let response = body(rpc, case).expect("wrong RPC response case"); + if case == 3 { + assert!(decode_wire(response).unwrap().iter().any(|f| f.number == 1 && f.value == WireValue::Varint(1))); + } + } + host.pc.close().await.unwrap(); + viewer.pc.close().await.unwrap(); + viewer.router.lock().await.stop().await.unwrap(); + } + }).await.expect("privacy TEXT routing regression exceeded deadline"); +} + #[tokio::test] async fn ready_portal_control_input_is_forwarded_while_locked() { tokio::time::timeout(Duration::from_secs(20), async { diff --git a/src/privacy_screen/mod.rs b/src/privacy_screen/mod.rs index f6c3507..43a53fd 100644 --- a/src/privacy_screen/mod.rs +++ b/src/privacy_screen/mod.rs @@ -28,10 +28,6 @@ pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) } pub fn current_type() -> u8 { if !active() { mode::TYPE_OFF } else if PICTURE.load(Ordering::Relaxed) { Mode::Picture.wire_type() } else { Mode::ScreenOff.wire_type() } } -/// The mode last enabled (kept in host_settings.json), 1 (PS_NOT_SET) before any. -pub fn preferred_type() -> u8 { - crate::system_actions::load_settings().privacy_type.filter(|t| matches!(t, 2 | 3)).unwrap_or(mode::TYPE_OFF) -} /// Message 15 SystemStateChange { 5 PrivateScreenState } for the state now in effect. pub fn state_message(seq: u64, timestamp: u64) -> Vec { crate::initialization::envelope(seq, timestamp, 15, &protocol::state_change(current_type())) @@ -118,7 +114,8 @@ pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec, Option let expected = if request.enable { request.mode.map_or(mode::TYPE_OFF, Mode::wire_type) } else { mode::TYPE_OFF }; Some((protocol::response(&header, &request, false, expected), Some(Accepted { enable: request.enable, mode: request.mode }))) } -/// ReportError.error_code the Mac viewer treats as a privacy-screen failure (handleForReportError). +/// Mac 4.43.0 handleForReportError: -7 resets privacy to off; -9 reports an RDP session change, +/// not privacy success. Success is carried by RpcResponse 3 and SystemMetrics.setting 7. pub const REPORT_ERROR: i32 = -7; impl Accepted { pub fn apply(self) -> Result<(), String> { diff --git a/src/system_actions.rs b/src/system_actions.rs index a5d992d..ab9ec30 100644 --- a/src/system_actions.rs +++ b/src/system_actions.rs @@ -36,7 +36,7 @@ pub(crate) struct Settings { /// video field cannot drop auto_lock / mute when the document is loaded. #[serde(default, deserialize_with = "lenient_string")] pub(crate) video_encoder: Option, #[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option, - /// Last privacy_type the viewer enabled (2 picture, 3 screen off), reported as SettingMetric 7. + /// Last privacy_type the viewer enabled (2 picture, 3 screen off), not the current live state. #[serde(default)] pub(crate) privacy_type: Option, } @@ -291,7 +291,7 @@ impl PeerActions { let current = state().lock().unwrap().settings.clone(); payload_with_settings(desktop, desktop, desktop, &home, &crate::system_metrics::Settings { sound, keep_mute: current.keep_mute, mute_permanent: current.mute_permanent, auto_lock: current.auto_lock, - private_screen: crate::privacy_screen::supported().then(|| (crate::privacy_screen::active(), crate::privacy_screen::preferred_type())), + private_screen: crate::privacy_screen::supported().then(crate::privacy_screen::current_type), }) } } diff --git a/src/system_metrics.rs b/src/system_metrics.rs index c954840..168fd28 100644 --- a/src/system_metrics.rs +++ b/src/system_metrics.rs @@ -27,14 +27,14 @@ pub fn payload_with_location(capture: Permission, operation: Permission, control /// Optional host settings the viewer shows in 声音 / 安全 (SettingMetric 1 keep_mute, /// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support). #[derive(Debug, Default, Clone, Copy)] -pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool, pub private_screen: Option<(bool, u8)> } +pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool, pub private_screen: Option } pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec { let mut setting = Vec::new(); - // Mac UURemote name map: SettingMetric 4 private_screen (on), 7 private_screen_type - // (PrivateScreenType 2 normal/picture, 3 enhanced/screen off): the chosen mode, also while off. - if let Some((on, kind)) = settings.private_screen { - setting.extend([4 << 3, u8::from(on), 7 << 3, kind]); + // Mac 4.43.0 callBackSystemMetrics reads field 7 first, falling back to field 4 only when 7=0. + // Report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference. + if let Some(kind) = settings.private_screen { + setting.extend([4 << 3, u8::from(kind != 1), 7 << 3, kind]); } for (field, on) in [(1u8, settings.keep_mute), (2, settings.mute_permanent), (3, settings.auto_lock)] { if on { setting.push(field << 3); setting.push(1); } @@ -52,7 +52,13 @@ pub fn payload_with_settings(capture: Permission, operation: Permission, control } // SystemMetrics.general: system_sound_support = SS_SUPPORT (2) when desktop audio is streamed // (GvPb_SystemSoundSupport: 0 unknown, 1 nonsupport, 2 support). - let mut out = if settings.sound { vec![26, 2, 16, 2] } else { vec![26, 0] }; + // Official Mac host 4.43.0 (626), arm64: SystemMetricsHandler (0x10000a96c) + // appends GENERAL=1 (0x10000abe8) and SETTING=2 (helper 0x10000a230, write + // 0x10000a64c) as it fills those sections; traverse (0x100423840) packs field 1. + // We always report both sections. The Mac viewer ignores an empty list + // (callBackSystemMetrics, 0x1003b4584). Host evidence: docs/privacy-screen.md. + let mut out = vec![10, 2, 1, 2]; + out.extend(if settings.sound { &[26, 2, 16, 2][..] } else { &[26, 0][..] }); // No support_touch, sound capability, win_os_ver, private-screen, virtual // mouse, auto-lock, file path or optional feature claims are fabricated. out.push(34); // SystemMetrics.setting field 4 @@ -86,27 +92,29 @@ mod tests { fn measured_allow_capabilities_use_official_enum_values() { let p = payload(Permission::Allow, Permission::Allow, Permission::Allow); let fields = decode_wire(&p).unwrap(); - assert_eq!(fields.len(), 2); - assert_eq!(fields[0].number, 3); - assert_eq!(fields[0].value, WireValue::Bytes(&[])); - let WireValue::Bytes(setting) = fields[1].value else { panic!("setting not a message") }; - assert_eq!(fields[1].number, 4); + assert_eq!(fields.len(), 3); + assert_eq!(fields[0].number, 1); + assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2])); + assert_eq!(fields[1].number, 3); + assert_eq!(fields[1].value, WireValue::Bytes(&[])); + let WireValue::Bytes(setting) = fields[2].value else { panic!("setting not a message") }; + assert_eq!(fields[2].number, 4); let s = decode_wire(setting).unwrap(); assert_eq!(s.iter().map(|f| f.number).collect::>(), vec![8, 9, 10]); assert!(s.iter().all(|f| f.value == WireValue::Varint(2))); } #[test] fn rejected_and_unknown_observations_are_not_promoted_to_allow() { - assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![26, 0, 34, 0]); - assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![26, 0, 34, 6, 64, 2, 72, 1, 80, 1]); + assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![10, 2, 1, 2, 26, 0, 34, 0]); + assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![10, 2, 1, 2, 26, 0, 34, 6, 64, 2, 72, 1, 80, 1]); } #[test] fn emits_no_audio_touch_windows_or_auto_unlock_capability() { let p = payload(Permission::Allow, Permission::Allow, Permission::Allow); let fields = decode_wire(&p).unwrap(); - let WireValue::Bytes(general) = fields[0].value else { panic!() }; + let WireValue::Bytes(general) = fields[1].value else { panic!() }; assert!(general.is_empty()); - let WireValue::Bytes(setting) = fields[1].value else { panic!() }; + let WireValue::Bytes(setting) = fields[2].value else { panic!() }; assert!(decode_wire(setting).unwrap().iter().all(|f| (8..=10).contains(&f.number))); } #[test] @@ -114,10 +122,21 @@ mod tests { let home = "/home/user/".repeat(12); let p = payload_with_location(Permission::Allow, Permission::Allow, Permission::Allow, &home); let fields = decode_wire(&p).unwrap(); - let WireValue::Bytes(setting) = fields[1].value else { panic!() }; + let WireValue::Bytes(setting) = fields[2].value else { panic!() }; let s = decode_wire(setting).unwrap(); assert_eq!(s[0].number, 5); assert_eq!(s[0].value, WireValue::Bytes(home.as_bytes())); assert_eq!(decode_wire(&remote_download_path("/home/x")).unwrap()[0].value, WireValue::Bytes(b"/home/x")); } + #[test] + fn privacy_modes_report_matching_flag_and_current_type() { + for (kind, expected) in [(1, [32, 0, 56, 1]), (2, [32, 1, 56, 2]), (3, [32, 1, 56, 3])] { + let settings = Settings { private_screen: Some(kind), ..Settings::default() }; + let p = payload_with_settings(Permission::Unknown, Permission::Unknown, Permission::Unknown, "", &settings); + let fields = decode_wire(&p).unwrap(); + assert_eq!(fields[0].number, 1); + assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2])); + assert_eq!(fields.iter().find(|f| f.number == 4).unwrap().value, WireValue::Bytes(&expected)); + } + } } diff --git a/src/text_outbox.rs b/src/text_outbox.rs new file mode 100644 index 0000000..a9d5bd6 --- /dev/null +++ b/src/text_outbox.rs @@ -0,0 +1,92 @@ +//! Per-peer TEXT backlog: one current metrics snapshot and bounded ordered replies. +use std::sync::{Arc, atomic::{AtomicBool, Ordering}}; +use tokio::sync::{mpsc, watch}; + +const REPLY_CAPACITY: usize = 64; + +#[derive(Clone)] +pub(super) struct Sender { + replies: mpsc::Sender>, + metrics: watch::Sender>>, + overflow_reported: Arc, +} +pub(super) struct Receiver { + replies: mpsc::Receiver>, + metrics: watch::Receiver>>, + metrics_open: bool, + replies_open: bool, +} +pub(super) fn channel() -> (Sender, Receiver) { + let (replies, rx) = mpsc::channel(REPLY_CAPACITY); + let (metrics, latest) = watch::channel(None); + (Sender { replies, metrics, overflow_reported: Arc::new(AtomicBool::new(false)) }, + Receiver { replies: rx, metrics: latest, metrics_open: true, replies_open: true }) +} +impl Sender { + pub(super) fn send(&self, message: Vec) -> Result<(), mpsc::error::SendError>> { + self.replies.try_send(message).map_err(|error| { + // Never wait for TEXT inside CONTROL's request handler: some viewers never open it. + if matches!(error, mpsc::error::TrySendError::Full(_)) + && !self.overflow_reported.swap(true, Ordering::Relaxed) { + log::warn!("TEXT reply queue full; dropping excess replies"); + } + mpsc::error::SendError(error.into_inner()) + }) + } + pub(super) fn metrics(&self, message: Vec) { + let _ = self.metrics.send(Some(message)); + } +} +impl Receiver { + pub(super) async fn recv(&mut self) -> Option> { + loop { + if !self.metrics_open && !self.replies_open { return None; } + tokio::select! { + changed = self.metrics.changed(), if self.metrics_open => { + if changed.is_err() { self.metrics_open = false; continue; } + if let Some(message) = self.metrics.borrow_and_update().clone() { return Some(message); } + } + message = self.replies.recv(), if self.replies_open => match message { + Some(message) => return Some(message), + None => self.replies_open = false, + }, + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn unopened_text_keeps_latest_metrics_and_bounded_fifo_replies() { + let (tx, mut rx) = channel(); + for i in 0..10_000u32 { tx.metrics(i.to_le_bytes().to_vec()); } + for i in 0..REPLY_CAPACITY { tx.send(vec![i as u8]).unwrap(); } + assert_eq!(tx.send(vec![255]).unwrap_err().0, vec![255]); + let mut replies = Vec::new(); + let mut metrics = Vec::new(); + for _ in 0..REPLY_CAPACITY + 1 { + let message = rx.recv().await.unwrap(); + if message.len() == 4 { metrics.push(message); } else { replies.push(message[0]); } + } + assert_eq!(metrics, vec![9_999u32.to_le_bytes().to_vec()]); + assert_eq!(replies, (0..REPLY_CAPACITY as u8).collect::>()); + assert!(tokio::time::timeout(std::time::Duration::from_millis(20), rx.recv()).await.is_err()); + tx.send(vec![100]).unwrap(); + assert_eq!(rx.recv().await, Some(vec![100])); + drop(tx); + assert_eq!(rx.recv().await, None); + } + + #[tokio::test] + async fn closed_text_rejects_replies() { + let (tx, rx) = channel(); + tx.metrics(vec![13]); + tx.send(vec![22]).unwrap(); + drop(rx); + assert!(tx.send(vec![23]).is_err()); + tx.metrics(vec![14]); + } +} diff --git a/src/webrtc.rs b/src/webrtc.rs index 659f3f6..0300d26 100644 --- a/src/webrtc.rs +++ b/src/webrtc.rs @@ -4,6 +4,9 @@ use crate::capture::ScreenCapture; use crate::input::InputInjector; use crate::signaling::SoacMessage; +#[path = "text_outbox.rs"] +mod text_outbox; + use base64::Engine; use flate2::read::GzDecoder; use std::io::Read; @@ -489,6 +492,11 @@ impl WebRtcSession { let file_channel: Arc>>> = Arc::new(std::sync::Mutex::new(None)); let (file_tx, mut file_rx) = tokio::sync::mpsc::unbounded_channel::>(); let peer_files = crate::file_trans::FileSession::new(file_tx, control_sequence.clone()); + // Mac 4.43: streamerDidReceiveTextData (0x1001f56b4, arm64) reaches + // the metrics/RPC dispatcher at 0x1003a8560; CONTROL does not. + // Keep CONTROL metrics for other viewers; privacy replies use TEXT. + let (text_tx, text_rx) = text_outbox::channel(); + let text_rx = Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Text(text_rx)))); // 端口映射 frames (Message 27) also travel on FILE_DATA_CHANNEL; one session per peer. let port_mapping = crate::port_mapping::Session::new(file_channel.clone(), control_sequence.clone()); { @@ -537,6 +545,8 @@ impl WebRtcSession { let echo_seen = echo_seen.clone(); let channel_lock_state = channel_lock_state.clone(); let peer_files = peer_files.clone(); + let text_out = text_tx.clone(); + let text_rx = text_rx.clone(); let peer_port_mapping = port_mapping.clone(); let peer_video_settings = video_settings.clone(); let peer_video_track = control_video_track.clone(); @@ -565,12 +575,16 @@ impl WebRtcSession { } // Ordered outbound queue for protocol replies produced outside this callback. // webrtc-rs announces the channel before handle_open (ready_state Connecting); - // send() returns ErrClosedPipe until Open. Draining CONTROL here would drop - // Message 25 and every later reply. Start CONTROL from the on_open below + // send() returns ErrClosedPipe until Open. Draining CONTROL/TEXT here would + // drop initial state and replies. Start them from the on_open below // (one handler; a second on_open replaces it). Receiver taken once. - let mut control_drain: Option std::pin::Pin + Send>>) + Send + Sync>> = None; - let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::>(); - let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx))); + let mut open_drain: Option std::pin::Pin + Send>>) + Send + Sync>> = None; + let (outbound, outbound_rx) = if label == "TEXT_DATA_CHANNEL" { + (Outbound::Text(text_out.clone()), text_rx) + } else { + let (tx, rx) = tokio::sync::mpsc::unbounded_channel::>(); + (Outbound::Other(tx), Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Other(rx))))) + }; if label == "CONTROL_DATA_CHANNEL" { if let Some(mut chroma_sync_rx) = chroma_sync_rx.lock().unwrap().take() { let sync_out = outbound.clone(); @@ -603,8 +617,8 @@ impl WebRtcSession { }); }) as std::pin::Pin + Send>> }; - if label != "CONTROL_DATA_CHANNEL" { tokio::spawn(start_drain()); } - else { control_drain = Some(Box::new(start_drain)); } + if !matches!(label.as_str(), "CONTROL_DATA_CHANNEL" | "TEXT_DATA_CHANNEL") { tokio::spawn(start_drain()); } + else { open_drain = Some(Box::new(start_drain)); } } let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::>(16); if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") { @@ -776,9 +790,10 @@ impl WebRtcSession { Some(peer_files.clone()) } else { None }; // CT_TERMINAL: TERM frames and terminal RPCs (check_env/rename) on BINARY. - let terminal_conn = if label == "BINARY_DATA_CHANNEL" { - Some(Arc::new(crate::terminal::TerminalConn::new(outbound.clone()))) - } else { None }; + let terminal_conn = match (&outbound, label.as_str()) { + (Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))), + _ => None, + }; if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" { let channel = d.clone(); let initial_sequence = out_sequence.clone(); @@ -795,8 +810,9 @@ impl WebRtcSession { let open_role = channel_role.clone(); let open_screen = screen.clone(); let open_selection = peer_selection; + let open_text_out = text_out.clone(); d.on_open(Box::new(move || { - if let Some(start_drain) = control_drain { tokio::spawn(start_drain()); } + if let Some(start_drain) = open_drain { tokio::spawn(start_drain()); } let init_actions = open_actions.clone(); let init_video = open_video.clone(); let init_track = open_track.clone(); @@ -810,6 +826,7 @@ impl WebRtcSession { let owner = open_owner.clone(); let role = open_role.clone(); let pc = desktop_pc.upgrade(); + let text_out = open_text_out.clone(); Box::pin(async move { // Permission dialogs and first-frame waits must not occupy the // channel-open callback or delay CONTROL message dispatch. @@ -962,6 +979,7 @@ impl WebRtcSession { let message = crate::initialization::envelope( sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &init_actions.metrics_payload(desktop_sound, snapshot.permission(true))); + text_out.metrics(message.clone()); if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; } let mut updates = portal.subscribe(); match crate::desktop_session::wait_ready(&mut updates, &channel).await { @@ -972,6 +990,7 @@ impl WebRtcSession { let message = crate::initialization::envelope( sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &init_actions.metrics_payload(desktop_sound, crate::system_metrics::Permission::Reject)); + text_out.metrics(message.clone()); let _ = channel.send(&bytes::Bytes::from(message)).await; } return; @@ -1019,6 +1038,7 @@ impl WebRtcSession { Ok(message) => message, Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; } }; + if field == 13 { text_out.metrics(message.clone()); } if let Err(e) = channel.send(&bytes::Bytes::from(message)).await { log::error!("CONTROL initialization field {} failed: {}", field, e); return; @@ -1038,6 +1058,7 @@ impl WebRtcSession { tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked())); 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(); let mut tick = tokio::time::interval(std::time::Duration::from_secs(1)); @@ -1051,6 +1072,7 @@ impl WebRtcSession { 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); let message = crate::initialization::envelope(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &payload); + 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); if channel.send(&bytes::Bytes::from(state)).await.is_err() { return; } @@ -1107,6 +1129,7 @@ impl WebRtcSession { let message_role=channel_role.clone(); let terminal_worker = terminal_conn.clone(); let rpc_out = outbound.clone(); + let text_out = text_out.clone(); let reply_chan = d_reply.clone(); let out_sequence = reply_sequence.clone(); let clipboard_sink = clipboard_input.clone(); @@ -1145,7 +1168,7 @@ impl WebRtcSession { if let Some(request) = rpc.filter(|_| rpc_fields.as_ref().is_some_and(|r| r.iter().any(|f| f.number == 7))) { let Some((response, accepted)) = rpc_fields.as_deref().and_then(crate::privacy_screen::rpc_accept) else { return }; let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); - let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response)); + let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response)); let Some(accepted) = accepted else { return }; let failed = tokio::task::spawn_blocking(move || accepted.apply().is_err()).await.unwrap_or(true); let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); @@ -1156,13 +1179,19 @@ impl WebRtcSession { } let permission = portal_for_message.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(desktop)); let metrics = actions.metrics_payload(desktop_sound, permission); + text_out.metrics(crate::initialization::envelope(next(), ts, 13, &metrics)); let _ = reply_chan.send(&bytes::Bytes::from(crate::initialization::envelope(next(), ts, 13, &metrics))).await; let state = crate::privacy_screen::state_message(next(), ts); let _ = reply_chan.send(&bytes::Bytes::from(state)).await; log::info!("Privacy switch done: failed={failed} type={}", crate::privacy_screen::current_type()); return; } - if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::privacy_screen::screensaver_response(r).or_else(|| crate::system_actions::plugin_response(r)).or_else(|| crate::system_actions::session_rpc_response(r))) { + if let Some(response) = rpc_fields.as_deref().and_then(crate::privacy_screen::screensaver_response) { + let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); + let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response)); + return; + } + if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) { let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response)); return; @@ -1343,6 +1372,7 @@ impl WebRtcSession { crate::control_protocol::simple_action_name(action).unwrap_or("?"), value, sa::args_shape(&args)); let (actions, input, chan, seq_out) = (actions.clone(), input_worker.clone(), reply_chan.clone(), out_sequence.clone()); let settings_portal = portal_for_message.clone(); + let text_out = text_out.clone(); tokio::spawn(async move { let worker = actions.clone(); let report = tokio::task::spawn_blocking(move || worker.handle(action, value, &args, || { @@ -1356,6 +1386,7 @@ impl WebRtcSession { crate::system_metrics::Permission::Allow, |manager| manager.snapshot().permission(desktop)); let message = crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &actions.metrics_payload(desktop_sound, permission)); + text_out.metrics(message.clone()); if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); } } }); @@ -1710,8 +1741,28 @@ fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> { None } +#[derive(Clone)] +enum Outbound { + Text(text_outbox::Sender), + Other(tokio::sync::mpsc::UnboundedSender>), +} +impl Outbound { + fn send(&self, message: Vec) -> Result<(), tokio::sync::mpsc::error::SendError>> { + match self { Self::Text(tx) => tx.send(message), Self::Other(tx) => tx.send(message) } + } +} +enum OutboundReceiver { + Text(text_outbox::Receiver), + Other(tokio::sync::mpsc::UnboundedReceiver>), +} +impl OutboundReceiver { + async fn recv(&mut self) -> Option> { + match self { Self::Text(rx) => rx.recv().await, Self::Other(rx) => rx.recv().await } + } +} + /// First drain owns the outbound receiver; a later open must not start another. -async fn take_outbound_once(slot: &tokio::sync::Mutex>>) -> Option> { +async fn take_outbound_once(slot: &tokio::sync::Mutex>) -> Option { slot.lock().await.take() }