Files
uu-remote-linux/src/desktop_control_tests.rs
T
Jeff Zhang f4f16aafe4 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
2026-11-02 11:17:55 +08:00

372 lines
21 KiB
Rust

//! Real local SCTP peers; no cloud, desktop consent, audio or power operations.
use super::*;
use crate::protocol::{decode_wire, WireValue};
use std::{collections::HashMap, time::Duration};
use tokio::sync::mpsc;
type Messages = mpsc::UnboundedReceiver<(String, Vec<u8>)>;
struct Viewer {
pc: Arc<RTCPeerConnection>,
channels: HashMap<String, Arc<RTCDataChannel>>,
messages: Messages,
router: Arc<Mutex<webrtc::util::vnet::router::Router>>,
}
async fn connect(input: Arc<InputInjector>, desktop: bool,
portal: Option<Arc<crate::desktop_session::PortalDesktop>>, labels: &[&str]) -> (WebRtcSession, Viewer) {
let (host_setting, viewer_setting, router) = crate::test_network::virtual_network().await;
let screen = Arc::new(ScreenCapture::unavailable("synthetic locked desktop".into()));
let host = WebRtcSession::new(screen, input, crate::signaling::SignalingClient::disconnected(),
desktop, crate::session_ice::SessionIce::virtual_net(host_setting), portal).await.unwrap();
let pc = Arc::new(APIBuilder::new().with_setting_engine(viewer_setting).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let (tx, messages) = mpsc::unbounded_channel();
let mut channels = HashMap::new();
for label in labels {
let channel = pc.create_data_channel(label, None).await.unwrap();
let (tx, name) = (tx.clone(), label.to_string());
channel.on_message(Box::new(move |message| {
let _ = tx.send((name.clone(), message.data.to_vec()));
Box::pin(async {})
}));
channels.insert(label.to_string(), channel);
}
let mut gathered = pc.gathering_complete_promise().await;
pc.set_local_description(pc.create_offer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
host.pc.set_remote_description(pc.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.pc.gathering_complete_promise().await;
host.pc.set_local_description(host.pc.create_answer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
pc.set_remote_description(host.pc.local_description().await.unwrap()).await.unwrap();
tokio::time::timeout(Duration::from_secs(8), async {
while channels.values().any(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) {
tokio::time::sleep(Duration::from_millis(20)).await;
}
}).await.expect("local SCTP channels did not open");
(host, Viewer { pc, channels, messages, router })
}
fn body(message: &[u8], number: u32) -> Option<&[u8]> {
decode_wire(message).ok()?.into_iter().find_map(|field| match (field.number, field.value) {
(n, WireValue::Bytes(bytes)) if n == number => Some(bytes), _ => None,
})
}
fn bytes(number: u32, value: &[u8]) -> Vec<u8> {
fn varint(mut value: usize, out: &mut Vec<u8>) {
while value >= 128 { out.push((value as u8 & 127) | 128); value >>= 7; }
out.push(value as u8);
}
let mut out = Vec::new();
varint(((number << 3) | 2) as usize, &mut out);
varint(value.len(), &mut out);
out.extend_from_slice(value);
out
}
async fn receive(messages: &mut Messages, label: &str, field: u32) -> Vec<u8> {
tokio::time::timeout(Duration::from_secs(5), async {
loop {
let (channel, message) = messages.recv().await.expect("peer stopped responding");
if channel == label && body(&message, field).is_some() { return message; }
}
}).await.expect("expected protocol response timed out")
}
async fn send(viewer: &Viewer, label: &str, message: Vec<u8>) {
viewer.channels[label].send(&message.into()).await.unwrap();
}
fn mapping(kind: u8, payload: &[u8]) -> Vec<u8> {
let mut frame = vec![8, 1, 16, 2, 24, 3, 32, kind];
frame.extend(bytes(5, payload));
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 {
let input = Arc::new(InputInjector::without_desktop());
let mut screen = ScreenCapture::unavailable("synthetic ready desktop".into());
screen.backend = crate::desktop_backend::DesktopBackend::Portal;
screen.init_error = None;
let (lock, locked) = tokio::sync::watch::channel(Some(true));
let portal = Arc::new(crate::desktop_session::PortalDesktop::with_lock_state(Arc::new(screen), locked));
let (host, mut viewer) = connect(input.clone(), true, Some(portal.clone()), &["CONTROL_DATA_CHANNEL"]).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
for (index, state) in [Some(true), None].into_iter().enumerate() {
lock.send(state).unwrap();
let before = input.portal_input_counts_for_test();
for message in [
br#"{"action":"kbd_press","key":65}"#.as_slice(),
br#"{"action":"kbd_release","key":65}"#.as_slice(),
br#"{"action":"mouse_press","button":1}"#.as_slice(),
br#"{"action":"mouse_release","button":1}"#.as_slice(),
] {
send(&viewer, "CONTROL_DATA_CHANNEL", message.to_vec()).await;
}
let sequence = 310 + index as u64;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(sequence, 0, 3, &[8, 0])).await;
loop {
let response = receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
let args: serde_json::Value = serde_json::from_slice(body(body(&response, 3).unwrap(), 2).unwrap()).unwrap();
if args["seq"] == sequence { break; }
}
let after = input.portal_input_counts_for_test();
assert_eq!(after[2] - before[2], 2, "keyboard dropped for lock state {state:?}");
assert_eq!(after[1] - before[1], 2, "mouse buttons dropped for lock state {state:?}");
}
let before = input.portal_input_counts_for_test();
let mut unavailable = ScreenCapture::unavailable("synthetic closed source".into());
unavailable.backend = crate::desktop_backend::DesktopBackend::Portal;
portal.publish_test_screen(Arc::new(unavailable));
send(&viewer, "CONTROL_DATA_CHANNEL", br#"{"action":"kbd_click","key":65}"#.to_vec()).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(320, 0, 3, &[8, 0])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
assert_eq!(input.portal_input_counts_for_test(), before, "unavailable source accepted input");
host.pc.close().await.unwrap();
viewer.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("locked CONTROL input regression exceeded deadline");
}
#[tokio::test]
async fn closing_unnegotiated_peers_releases_callback_state() {
for desktop in [false, true] {
let input = Arc::new(InputInjector::without_desktop());
let capture = Arc::new(ScreenCapture::unavailable("synthetic desktop".into()));
let peer = WebRtcSession::new(capture, input,
crate::signaling::SignalingClient::disconnected(), desktop,
crate::session_ice::SessionIce::local(), None).await.unwrap();
let weak = Arc::downgrade(&peer.pc);
peer.pc.close().await.unwrap();
drop(peer);
tokio::time::timeout(Duration::from_secs(4), async {
while weak.upgrade().is_some() {
tokio::time::sleep(Duration::from_millis(20)).await;
}
}).await.expect("closed peer retained by callbacks");
}
}
#[tokio::test]
async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
tokio::time::timeout(Duration::from_secs(35), async {
let input = Arc::new(InputInjector::without_desktop());
let (lock, locked) = tokio::sync::watch::channel(Some(true));
let portal = Arc::new(crate::desktop_session::PortalDesktop::with_lock_state(
Arc::new(ScreenCapture::unavailable("synthetic locked desktop".into())), locked));
let (desktop, mut viewer) = connect(input.clone(), true, Some(portal.clone()), &["CONTROL_DATA_CHANNEL"]).await;
// Official Android 4.43.0's unlock presenter requires CaptureChange
// (desktop/window) before it will use the secure state to send action15.
let selected = receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 8).await;
let selected = decode_wire(body(&selected, 8).unwrap()).unwrap();
let capture_type = selected.iter().find_map(|f| match (f.number, &f.value) {
(1, WireValue::Varint(value)) => Some(*value), _ => None,
}).unwrap_or(0);
assert_eq!(capture_type, 0);
let state = receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 15).await;
let secure = body(body(&state, 15).unwrap(), 1).unwrap();
assert!(decode_wire(secure).unwrap().iter().any(|f| f.number == 1 && f.value == WireValue::Varint(1)));
assert!(portal.snapshot().screen.init_error.is_some());
// A capture request waiting for unlock must not occupy CONTROL dispatch.
let mut capture = bytes(1, &[8, 31]);
capture.extend(bytes(2, &[16, 2, 144, 1, 60]));
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(10, 0, 21, &capture)).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(91, 0, 3, &[8, 0])).await;
let echo = receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
let echo: serde_json::Value = serde_json::from_slice(body(body(&echo, 3).unwrap(), 2).unwrap()).unwrap();
assert_eq!(echo["seq"], 91);
send(&viewer, "CONTROL_DATA_CHANNEL",
crate::initialization::envelope(92, 0, 16, &[8, 1])).await;
let state = receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 15).await;
assert!(body(body(&state, 15).unwrap(), 1).is_some());
// Missing password exercises the real AUTO_UNLOCK_SYSTEM failure route
// without invoking PAM or unlocking the local user's desktop.
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(1, 0, 3, &[8, 15])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 12).await;
let (terminal, mut terminal_viewer) = connect(input.clone(), false, None,
&["CONTROL_DATA_CHANNEL", "BINARY_DATA_CHANNEL"]).await;
send(&terminal_viewer, "BINARY_DATA_CHANNEL",
crate::terminal::encode(crate::terminal::LIST_REQ, 71, &[])).await;
let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); }
}
}).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 71));
let (files, mut file_viewer) = connect(input.clone(), false, None,
&["CONTROL_DATA_CHANNEL", "FILE_DATA_CHANNEL"]).await;
let directory = std::env::temp_dir().join(format!("uu-control-empty-{}-{}", std::process::id(), rand::random::<u64>()));
std::fs::create_dir(&directory).unwrap();
let mut read = bytes(1, &[8, 7]);
read.extend(bytes(2, directory.to_str().unwrap().as_bytes()));
let mut request = bytes(1, &[8, 99]);
request.extend(bytes(8, &bytes(10, &read)));
let query = crate::initialization::envelope(5, 0, 21, &request);
send(&file_viewer, "CONTROL_DATA_CHANNEL", query.clone()).await;
let response = receive(&mut file_viewer.messages, "FILE_DATA_CHANNEL", 22).await;
let listing = body(body(body(&response, 22).unwrap(), 4).unwrap(), 7).unwrap();
assert!(decode_wire(listing).unwrap().iter().any(|f| f.number == 4 && f.value == WireValue::Varint(1)));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let echo = tokio::spawn(async move {
let (socket, _) = listener.accept().await.unwrap();
let (mut read, mut write) = socket.into_split();
tokio::io::copy(&mut read, &mut write).await.unwrap();
});
let (ports, mut port_viewer) = connect(input, false, None,
&["CONTROL_DATA_CHANNEL", "FILE_DATA_CHANNEL"]).await;
let target = serde_json::json!({"version":1,"target_host":"127.0.0.1","target_port":port}).to_string();
send(&port_viewer, "FILE_DATA_CHANNEL", mapping(0, target.as_bytes())).await;
let ack = receive(&mut port_viewer.messages, "FILE_DATA_CHANNEL", 27).await;
let ack: serde_json::Value = serde_json::from_slice(body(body(&ack, 27).unwrap(), 5).unwrap()).unwrap();
assert_eq!(ack["ok"], true);
let mut sessions = HashMap::from([
("desktop".into(), desktop), ("terminal".into(), terminal), ("files".into(), files),
("ports".into(), ports),
]);
assert!(crate::superseded_peer_ids(&sessions, "another-tool", false).is_empty());
assert_eq!(crate::superseded_peer_ids(&sessions, "next-desktop", true), ["desktop"]);
for id in crate::superseded_peer_ids(&sessions, "next-desktop", true) {
sessions.remove(&id).unwrap().pc.close().await.unwrap();
}
assert_eq!(sessions["terminal"].pc.connection_state(), RTCPeerConnectionState::Connected);
assert_eq!(sessions["files"].pc.connection_state(), RTCPeerConnectionState::Connected);
// A desktop close must not cancel the independent file-transfer responder.
send(&file_viewer, "CONTROL_DATA_CHANNEL", query).await;
receive(&mut file_viewer.messages, "FILE_DATA_CHANNEL", 22).await;
send(&port_viewer, "FILE_DATA_CHANNEL", mapping(2, b"local echo")).await;
let echoed = receive(&mut port_viewer.messages, "FILE_DATA_CHANNEL", 27).await;
assert_eq!(body(body(&echoed, 27).unwrap(), 5), Some(b"local echo".as_slice()));
send(&terminal_viewer, "BINARY_DATA_CHANNEL",
crate::terminal::encode(crate::terminal::LIST_REQ, 72, &[])).await;
let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); }
}
}).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 72));
std::fs::remove_dir(directory).unwrap();
for (_, peer) in sessions { peer.pc.close().await.unwrap(); }
viewer.pc.close().await.unwrap();
terminal_viewer.pc.close().await.unwrap();
file_viewer.pc.close().await.unwrap();
port_viewer.pc.close().await.unwrap();
for router in [&viewer.router, &terminal_viewer.router, &file_viewer.router, &port_viewer.router] {
router.lock().await.stop().await.unwrap();
}
echo.abort();
drop(lock);
}).await.expect("locked bootstrap/tool regression exceeded deadline");
}
#[tokio::test]
async fn capture_desktop_on_a_port_mapping_peer_promotes_it_once() {
tokio::time::timeout(Duration::from_secs(25), async {
let input = Arc::new(InputInjector::without_desktop());
let (host, mut viewer) = connect(input.clone(), false, None, &["CONTROL_DATA_CHANNEL", "FILE_DATA_CHANNEL"]).await;
let (requests, mut requested) = mpsc::unbounded_channel();
host.on_desktop_request(move || { let _ = requests.send(()); });
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
assert!(!host.role.is_desktop() && host.role.input().is_none());
// The Mac viewer opens the desktop on its existing port-mapping peer (#99).
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(5, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop());
assert!(host.role.input().is_some_and(|session| session.is_current()));
// CONTROL repeats the desktop initialization for the same viewer.
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
// The port-mapping session on this peer still answers.
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"still mapped")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
// A repeated capture_desktop does not ask again, and a later promote is a no-op.
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(6, 0, 3, &[8, 4])).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(7, 0, 3, &[8, 0])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
assert!(requested.try_recv().is_err());
let lease = host.role.input().unwrap();
host.promote(None);
assert!(lease.is_current());
// Its video ended on its own (capture failed while locked, #114): capture_desktop restarts it
// on the same input lease.
let ended = tokio::spawn(async {});
*host.role.stream_task.lock().unwrap() = Some(ended.abort_handle());
ended.await.unwrap();
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(9, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop() && !host.role.stream_ended() && lease.is_current());
// A newer desktop demotes it; the port mapping stays, and capture_desktop promotes it again.
host.demote();
assert!(!host.role.is_desktop() && host.role.input().is_none());
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"after demotion")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(8, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop() && host.role.input().is_some_and(|session| session.is_current()));
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
host.pc.close().await.unwrap();
viewer.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("capture_desktop promotion exceeded deadline");
}