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

+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()
}