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
This commit is contained in:
Jeff Zhang authored and GitHub committed 2026-11-02 11:17:55 +08:00
1 parent cb6f5b6617
commit f4f16aafe4
9 files changed
+296 -42

No files matched your search

+1 -1
View File
@@ -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 |
+1 -1
View File
@@ -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 账号**现在可以通过「远程协助」使用 |
+44 -3
View File
@@ -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
+54
View File
@@ -79,6 +79,60 @@ fn mapping(kind: u8, payload: &[u8]) -> Vec<u8> {
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 {
+2 -5
View File
@@ -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<u8> {
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<u8>, 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> {
+2 -2
View File
@@ -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<String>,
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option<String>,
/// 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<u8>,
}
@@ -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),
})
}
}
+35 -16
View File
@@ -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<u8> }
pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec<u8> {
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<_>>(), 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));
}
}
}
+92
View File
@@ -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<Vec<u8>>,
metrics: watch::Sender<Option<Vec<u8>>>,
overflow_reported: Arc<AtomicBool>,
}
pub(super) struct Receiver {
replies: mpsc::Receiver<Vec<u8>>,
metrics: watch::Receiver<Option<Vec<u8>>>,
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<u8>) -> Result<(), mpsc::error::SendError<Vec<u8>>> {
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<u8>) {
let _ = self.metrics.send(Some(message));
}
}
impl Receiver {
pub(super) async fn recv(&mut self) -> Option<Vec<u8>> {
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::<Vec<_>>());
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]);
}
}
+65 -14
View File
@@ -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<std::sync::Mutex<Option<Arc<RTCDataChannel>>>> = Arc::new(std::sync::Mutex::new(None));
let (file_tx, mut file_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
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<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx)));
let mut open_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + 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::<Vec<u8>>();
(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<Box<dyn std::future::Future<Output = ()> + 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::<Vec<u8>>(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<Vec<u8>>),
}
impl Outbound {
fn send(&self, message: Vec<u8>) -> Result<(), tokio::sync::mpsc::error::SendError<Vec<u8>>> {
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<Vec<u8>>),
}
impl OutboundReceiver {
async fn recv(&mut self) -> Option<Vec<u8>> {
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<T>(slot: &tokio::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<T>>>) -> Option<tokio::sync::mpsc::UnboundedReceiver<T>> {
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<T>>) -> Option<T> {
slot.lock().await.take()
}