mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
fix(portal): establish desktop CONTROL while GNOME is locked and auto unlock cold connections (#30)
* fix(portal): establish locked desktop control before capture * test(portal): preserve v4 pixel inventory after deferred capture settings * fix(control): refresh lock state after viewer Echo handshake * fix(portal): announce desktop target before locked capture wait * ci: run the desktop_power native test under ASan/UBSan Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * input: skip the Portal release sweep while no session is bound The first locked connection creates its peer before any Portal exists; the sweep then logged two failed injections and a 'reset incomplete' warning for nothing. Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * docs: describe locked cold connections, auto unlock limits and iPhone status Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * fix(portal): treat a cached screen with a closed Portal session as not ready begin() now marks the state as waiting when the cached session is dead, and permission/video/clipboard consumers honor it instead of reporting Allow and starting the stale video path before maintain() has rebuilt capture. Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * fix(portal): gate input on a ready desktop and share recovery backoff Input dispatch kept only the cached screen and dropped State.waiting, so a closed Portal passed the gate once the screen unlocked. The supervisor's recover() and the encoder's stream-loss recovery now share failure backoff and a terminal-denial flag, so a denied consent is not re-prompted by the other path. Co-Authored-By: Claude Sonnet 5.5 <[email protected]> * fix(control): keep unknown lock state unlocked, stop waits on Closing, never drop capture settings - QuerySystemState with no logind lock state (Xvfb/linger) reports unlocked as before. - The Portal wait loop also exits while the channel is Closing. - Capture-setting requests back-pressure instead of try_send dropping the latest setting. Co-Authored-By: Claude Opus 5.5 <[email protected]> --------- Co-authored-by: Claude Sonnet 5.5 <[email protected]> Co-authored-by: VallierDev <[email protected]>
This commit is contained in:
23 files changed
+2292
-207
No files matched your search
+10
-5
@@ -66,6 +66,12 @@ pub struct ScreenCapture {
|
||||
}
|
||||
|
||||
impl ScreenCapture {
|
||||
pub fn open_portal(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, crate::portal::PortalError> {
|
||||
let session = std::sync::Arc::new(crate::portal::PortalSession::open_cancellable(cancelled)?);
|
||||
Ok(Self { backend: crate::desktop_backend::DesktopBackend::Portal, init_error: None,
|
||||
display: "wayland:portal".into(), width: session.width, height: session.height,
|
||||
portal: Some(session), kms: None, buffer: Mutex::new(Vec::new()) })
|
||||
}
|
||||
pub fn new() -> Result<Self, String> {
|
||||
let backend=crate::desktop_backend::detect()?;
|
||||
if backend == crate::desktop_backend::DesktopBackend::Kms {
|
||||
@@ -75,10 +81,7 @@ impl ScreenCapture {
|
||||
buffer:Mutex::new(Vec::new()),kms:Some(kms) });
|
||||
}
|
||||
if backend == crate::desktop_backend::DesktopBackend::Portal {
|
||||
let session=std::sync::Arc::new(crate::portal::PortalSession::open()?);
|
||||
let (width,height)=(session.width,session.height);
|
||||
return Ok(Self { backend,init_error:None,portal:Some(session),kms:None,display:"wayland:portal".into(),width,height,
|
||||
buffer:Mutex::new(Vec::new()) });
|
||||
return Self::open_portal(&std::sync::atomic::AtomicBool::new(false)).map_err(|error| error.to_string());
|
||||
}
|
||||
if backend == crate::desktop_backend::DesktopBackend::Wayland {
|
||||
let (width,height)=crate::wayland::init()?;
|
||||
@@ -156,7 +159,9 @@ impl Drop for ScreenCapture {
|
||||
/// Keep the display visible only while a peer is streaming; never unlock it.
|
||||
pub fn keep_display_awake() -> Result<(), String> {
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Kms { return Ok(()); }
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Portal { return Ok(()); }
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Portal {
|
||||
return crate::desktop_power::wake();
|
||||
}
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Wayland {
|
||||
return crate::wayland::wake();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,212 @@
|
||||
//! 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,
|
||||
}
|
||||
|
||||
async fn connect(input: Arc<InputInjector>, desktop: bool,
|
||||
portal: Option<Arc<crate::desktop_session::PortalDesktop>>, labels: &[&str]) -> (WebRtcSession, Viewer) {
|
||||
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::local(), portal).await.unwrap();
|
||||
let pc = Arc::new(APIBuilder::new().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 })
|
||||
}
|
||||
|
||||
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 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();
|
||||
echo.abort();
|
||||
drop(lock);
|
||||
}).await.expect("locked bootstrap/tool regression exceeded deadline");
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
//! Small GNOME-only display wake and idle-inhibition bridge.
|
||||
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
mod native {
|
||||
use std::{ffi::c_void, ptr::NonNull};
|
||||
|
||||
extern "C" {
|
||||
fn uu_desktop_power_wake() -> i32;
|
||||
fn uu_desktop_idle_inhibitor_acquire(error: *mut i32) -> *mut c_void;
|
||||
fn uu_desktop_idle_inhibitor_release(inhibitor: *mut c_void);
|
||||
}
|
||||
|
||||
pub struct Handle(NonNull<c_void>);
|
||||
|
||||
// GDBusConnection is thread-safe; the C handle is only used by its single Drop call.
|
||||
unsafe impl Send for Handle {}
|
||||
|
||||
impl Handle {
|
||||
pub fn acquire() -> Result<Self, String> {
|
||||
let mut error = 0;
|
||||
let pointer = unsafe { uu_desktop_idle_inhibitor_acquire(&mut error) };
|
||||
NonNull::new(pointer).map(Self).ok_or_else(|| super::error("idle inhibition", error))
|
||||
}
|
||||
|
||||
pub fn wake() -> Result<(), String> {
|
||||
super::check("display wake", unsafe { uu_desktop_power_wake() })
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Handle {
|
||||
fn drop(&mut self) {
|
||||
unsafe { uu_desktop_idle_inhibitor_release(self.0.as_ptr()) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Set GNOME's display power-save mode to on. This does not unlock the session or change
|
||||
/// lock-screen policy. Session-bus setup and each method call are bounded to three seconds.
|
||||
pub fn wake() -> Result<(), String> {
|
||||
if !gnome_portal_active() {
|
||||
return Ok(());
|
||||
}
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
{
|
||||
native::Handle::wake()
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal")))]
|
||||
{
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Holds a GNOME SessionManager idle-only inhibitor until dropped.
|
||||
///
|
||||
/// Acquire and drop perform blocking D-Bus work. Session-bus setup and each method call are
|
||||
/// bounded to three seconds. Callers on an async runtime should move both operations to a
|
||||
/// blocking worker.
|
||||
pub struct IdleInhibitor {
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
_handle: Option<native::Handle>,
|
||||
}
|
||||
|
||||
impl IdleInhibitor {
|
||||
pub fn acquire() -> Result<Self, String> {
|
||||
if !gnome_portal_active() {
|
||||
return Ok(Self {
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
_handle: None,
|
||||
});
|
||||
}
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
{
|
||||
native::Handle::acquire().map(|handle| Self { _handle: Some(handle) })
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal")))]
|
||||
{
|
||||
Ok(Self {})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn gnome_portal_active() -> bool {
|
||||
let gnome = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().split(':')
|
||||
.any(|desktop| desktop.eq_ignore_ascii_case("gnome"));
|
||||
gnome && crate::desktop_backend::detect().is_ok_and(|backend| backend == crate::desktop_backend::DesktopBackend::Portal)
|
||||
}
|
||||
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
fn check(operation: &str, code: i32) -> Result<(), String> {
|
||||
if code == 0 { Ok(()) } else { Err(error(operation, code)) }
|
||||
}
|
||||
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
fn error(operation: &str, code: i32) -> String {
|
||||
let reason = match code {
|
||||
1 => "session D-Bus unavailable",
|
||||
2 => "GNOME D-Bus operation failed",
|
||||
_ => "GNOME D-Bus operation failed",
|
||||
};
|
||||
format!("{operation}: {reason} (code {code})")
|
||||
}
|
||||
@@ -0,0 +1,567 @@
|
||||
//! Portal availability is independent of the authenticated CONTROL transport.
|
||||
use std::future::Future;
|
||||
use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
|
||||
use std::time::Instant;
|
||||
use tokio::sync::{watch, Mutex};
|
||||
use crate::{capture::ScreenCapture, input::DesktopInputSession};
|
||||
use crate::portal::PortalError;
|
||||
use webrtc::{data_channel::{RTCDataChannel, data_channel_state::RTCDataChannelState},
|
||||
peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState}};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct State {
|
||||
pub screen: Arc<ScreenCapture>,
|
||||
pub waiting: bool,
|
||||
}
|
||||
impl State {
|
||||
pub fn permission(&self, desktop: bool) -> crate::system_metrics::Permission {
|
||||
use crate::system_metrics::Permission;
|
||||
if !desktop { Permission::Allow }
|
||||
else if self.waiting { Permission::Unknown }
|
||||
else if self.screen.init_error.is_none() { Permission::Allow }
|
||||
else { Permission::Reject }
|
||||
}
|
||||
/// Capture exists and is not waiting for a replacement of a closed Portal session.
|
||||
pub fn ready(&self) -> bool { self.screen.init_error.is_none() && !self.waiting }
|
||||
}
|
||||
|
||||
pub struct PortalDesktop {
|
||||
state: watch::Sender<State>,
|
||||
opening: Arc<Mutex<()>>,
|
||||
locked: watch::Receiver<Option<bool>>,
|
||||
}
|
||||
|
||||
struct CancelOnDrop(Arc<AtomicBool>);
|
||||
impl Drop for CancelOnDrop {
|
||||
fn drop(&mut self) { self.0.store(true, Ordering::Release); }
|
||||
}
|
||||
|
||||
enum Inhibitor {
|
||||
Real(crate::desktop_power::IdleInhibitor),
|
||||
#[cfg(test)]
|
||||
Fake(DropSignal),
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
struct DropSignal(Arc<std::sync::atomic::AtomicUsize>);
|
||||
#[cfg(test)]
|
||||
impl Drop for DropSignal {
|
||||
fn drop(&mut self) { self.0.fetch_add(1, Ordering::Relaxed); }
|
||||
}
|
||||
|
||||
struct AttemptPrep {
|
||||
wake: Result<(), String>,
|
||||
inhibitor: IdleGuard,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct IdleGuard(Option<Inhibitor>);
|
||||
impl Drop for IdleGuard {
|
||||
fn drop(&mut self) {
|
||||
match self.0.take() {
|
||||
Some(Inhibitor::Real(guard)) => { tokio::task::spawn_blocking(move || drop(guard)); }
|
||||
#[cfg(test)]
|
||||
Some(Inhibitor::Fake(signal)) => drop(signal),
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum AttemptOutcome {
|
||||
Ready(Arc<ScreenCapture>),
|
||||
Retry(String),
|
||||
Terminal(String),
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
fn classify(result: Result<Arc<ScreenCapture>, PortalError>) -> AttemptOutcome {
|
||||
match result {
|
||||
Ok(screen) => AttemptOutcome::Ready(screen),
|
||||
Err(error) if error.code == 13 => AttemptOutcome::Cancelled,
|
||||
// 4/5/14 are fatal session/geometry states; 6/8 are unsupported
|
||||
// consent/format shapes which must not loop prompts forever.
|
||||
Err(error) if matches!(error.code, 4 | 5 | 6 | 8 | 14) => AttemptOutcome::Terminal(error.to_string()),
|
||||
Err(error) => AttemptOutcome::Retry(error.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
fn should_prepare_power(healthy: bool, force_wake: bool) -> bool {
|
||||
!healthy || force_wake
|
||||
}
|
||||
|
||||
fn prepare_attempt<W, I>(
|
||||
cancelled: &AtomicBool,
|
||||
owner: &DesktopInputSession,
|
||||
locked: &watch::Receiver<Option<bool>>,
|
||||
wake: W,
|
||||
inhibit: I,
|
||||
) -> Option<AttemptPrep>
|
||||
where
|
||||
W: FnOnce() -> Result<(), String>,
|
||||
I: FnOnce() -> IdleGuard,
|
||||
{
|
||||
let current = || !cancelled.load(Ordering::Acquire)
|
||||
&& owner.is_current()
|
||||
&& *locked.borrow() == Some(false);
|
||||
if !current() { return None; }
|
||||
let wake = wake();
|
||||
if !current() { return None; }
|
||||
let inhibitor = inhibit();
|
||||
if !current() { return None; }
|
||||
Some(AttemptPrep { wake, inhibitor })
|
||||
}
|
||||
|
||||
impl PortalDesktop {
|
||||
pub fn new(screen: Arc<ScreenCapture>) -> Self {
|
||||
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
|
||||
opening: Arc::new(Mutex::new(())), locked: crate::session_lock::watch_locked() }
|
||||
}
|
||||
pub fn begin(&self) {
|
||||
// GNOME closes the Portal session on lock; a cached screen with a dead session
|
||||
// is not ready (no Allow, no stale video path) until maintain() rebuilds it.
|
||||
self.state.send_modify(|state| state.waiting = state.screen.init_error.is_some()
|
||||
|| state.screen.portal.as_ref().is_some_and(|portal| !portal.is_alive()));
|
||||
}
|
||||
pub fn snapshot(&self) -> State { self.state.borrow().clone() }
|
||||
pub fn subscribe(&self) -> watch::Receiver<State> { self.state.subscribe() }
|
||||
pub fn lock_state(&self) -> watch::Receiver<Option<bool>> { self.locked.clone() }
|
||||
#[cfg(test)]
|
||||
pub fn with_lock_state(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>) -> Self {
|
||||
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
|
||||
opening: Arc::new(Mutex::new(())), locked }
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub fn publish_test_screen(&self, screen: Arc<ScreenCapture>) {
|
||||
self.state.send_replace(State { screen, waiting: false });
|
||||
}
|
||||
|
||||
fn publish(&self, owner: &DesktopInputSession, screen: Arc<ScreenCapture>) {
|
||||
owner.with_current(|| {
|
||||
if screen.init_error.is_some() { owner.release_input(); }
|
||||
owner.bind_portal(screen.portal.clone());
|
||||
self.state.send_replace(State { screen, waiting: false });
|
||||
});
|
||||
}
|
||||
|
||||
fn pause(&self, owner: &DesktopInputSession) {
|
||||
let screen = self.snapshot().screen;
|
||||
owner.with_current(|| {
|
||||
owner.release_input();
|
||||
if let Some(portal) = &screen.portal { portal.pause(); }
|
||||
});
|
||||
}
|
||||
|
||||
pub async fn run(self: Arc<Self>, pc: Arc<RTCPeerConnection>, channel: Arc<RTCDataChannel>,
|
||||
owner: Arc<DesktopInputSession>) {
|
||||
self.run_until(owner, closed(&pc, &channel)).await;
|
||||
}
|
||||
|
||||
pub async fn run_until<F>(self: Arc<Self>, owner: Arc<DesktopInputSession>, wait_closed: F)
|
||||
where F: Future<Output = ()> {
|
||||
tokio::select! {
|
||||
result = self.maintain(owner.clone()) => {
|
||||
if let Err(error) = result {
|
||||
log::warn!("Portal desktop unavailable: {error}");
|
||||
self.publish(&owner, Arc::new(ScreenCapture::unavailable(error)));
|
||||
}
|
||||
},
|
||||
_ = wait_closed => {},
|
||||
}
|
||||
}
|
||||
|
||||
async fn maintain(&self, owner: Arc<DesktopInputSession>) -> Result<(), String> {
|
||||
self.maintain_with(owner,
|
||||
crate::desktop_power::wake,
|
||||
|| match crate::desktop_power::IdleInhibitor::acquire() {
|
||||
Ok(guard) => IdleGuard(Some(Inhibitor::Real(guard))),
|
||||
Err(error) => { log::warn!("Desktop idle inhibition unavailable: {error}"); IdleGuard::default() }
|
||||
},
|
||||
|screen, cancel| {
|
||||
if let Some(portal) = &screen.portal {
|
||||
portal.recover(&cancel)?;
|
||||
Ok(screen)
|
||||
} else {
|
||||
ScreenCapture::open_portal(&cancel).map(Arc::new)
|
||||
}
|
||||
}).await
|
||||
}
|
||||
|
||||
async fn maintain_with<W, I, O>(&self, owner: Arc<DesktopInputSession>, wake: W, inhibit: I, open: O) -> Result<(), String>
|
||||
where
|
||||
W: Fn() -> Result<(), String> + Send + Sync + 'static,
|
||||
I: Fn() -> IdleGuard + Send + Sync + 'static,
|
||||
O: Fn(Arc<ScreenCapture>, Arc<AtomicBool>) -> Result<Arc<ScreenCapture>, PortalError> + Send + Sync + 'static,
|
||||
{
|
||||
let wake = Arc::new(wake);
|
||||
let inhibit = Arc::new(inhibit);
|
||||
let open = Arc::new(open);
|
||||
let mut locked = self.locked.clone();
|
||||
let mut previous = None;
|
||||
let mut retry_at = Instant::now();
|
||||
loop {
|
||||
if !owner.is_current() { return Ok(()); }
|
||||
let state = *locked.borrow_and_update();
|
||||
if state != Some(false) {
|
||||
if previous == Some(false) { self.pause(&owner); }
|
||||
} else {
|
||||
// A fresh unlocked transition gets an immediate wake/recovery attempt.
|
||||
let force_wake = previous != Some(false);
|
||||
if force_wake { retry_at = Instant::now(); }
|
||||
let mut attempt_locked = locked.clone();
|
||||
let outcome = tokio::select! {
|
||||
biased;
|
||||
_ = wait_for_lock(&mut locked) => AttemptOutcome::Cancelled,
|
||||
outcome = self.portal_attempt(&owner, &mut attempt_locked, retry_at, force_wake, wake.clone(), inhibit.clone(), open.clone()) => outcome,
|
||||
};
|
||||
match outcome {
|
||||
AttemptOutcome::Ready(screen) => self.publish(&owner, screen),
|
||||
AttemptOutcome::Terminal(error) => return Err(error),
|
||||
AttemptOutcome::Retry(error) => {
|
||||
log::warn!("Portal desktop recovery deferred: {error}");
|
||||
retry_at = Instant::now() + std::time::Duration::from_secs(5);
|
||||
}
|
||||
AttemptOutcome::Cancelled => {}
|
||||
}
|
||||
if *locked.borrow_and_update() != Some(false) { self.pause(&owner); }
|
||||
}
|
||||
previous = *locked.borrow_and_update();
|
||||
tokio::select! {
|
||||
_ = locked.changed() => {},
|
||||
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn portal_attempt<W, I, O>(&self, owner: &Arc<DesktopInputSession>,
|
||||
locked: &mut watch::Receiver<Option<bool>>, retry_at: Instant, force_wake: bool,
|
||||
wake: Arc<W>, inhibit: Arc<I>, open: Arc<O>) -> AttemptOutcome
|
||||
where
|
||||
W: Fn() -> Result<(), String> + Send + Sync + 'static,
|
||||
I: Fn() -> IdleGuard + Send + Sync + 'static,
|
||||
O: Fn(Arc<ScreenCapture>, Arc<AtomicBool>) -> Result<Arc<ScreenCapture>, PortalError> + Send + Sync + 'static,
|
||||
{
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) || Instant::now() < retry_at {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
let gate = self.opening.clone().lock_owned().await;
|
||||
// The state can change while this attempt waits for an earlier worker
|
||||
// to finish rotating the Portal permission token.
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
let screen = self.snapshot().screen;
|
||||
let healthy = screen.portal.as_ref().is_some_and(|portal| portal.is_alive());
|
||||
if !should_prepare_power(healthy, force_wake) {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let _cancel = CancelOnDrop(cancel.clone());
|
||||
let prep_cancel = cancel.clone();
|
||||
let prep_owner = owner.clone();
|
||||
let prep_locked = locked.clone();
|
||||
let prep = match tokio::task::spawn_blocking(move || prepare_attempt(
|
||||
&prep_cancel,
|
||||
&prep_owner,
|
||||
&prep_locked,
|
||||
|| (*wake)(),
|
||||
|| (*inhibit)(),
|
||||
)).await {
|
||||
Ok(Some(prep)) => prep,
|
||||
Ok(None) => return AttemptOutcome::Cancelled,
|
||||
Err(_) => return AttemptOutcome::Terminal("Desktop power worker failed".into()),
|
||||
};
|
||||
if let Err(error) = prep.wake { log::warn!("Portal screen wake failed: {error}"); }
|
||||
// Held by the cancellable async helper, not the blocking worker, so a
|
||||
// lock transition releases it while worker cleanup may still be running.
|
||||
let _inhibitor = prep.inhibitor;
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
// A new controller can arrive while the cached Portal handle is alive
|
||||
// but the display has gone to sleep without a lock transition.
|
||||
if healthy { return AttemptOutcome::Ready(screen); }
|
||||
let worker_cancel = cancel.clone();
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
// The worker owns the gate until its real cleanup completes; a
|
||||
// cancelled helper only signals it and cannot start an overlap.
|
||||
let _gate = gate;
|
||||
if worker_cancel.load(Ordering::Acquire) {
|
||||
return Err(PortalError { code: 13 });
|
||||
}
|
||||
open(screen, worker_cancel)
|
||||
}).await;
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
match result {
|
||||
Ok(result) => classify(result),
|
||||
Err(_) => AttemptOutcome::Terminal("Portal initialization worker failed".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn wait_for_lock(locked: &mut watch::Receiver<Option<bool>>) {
|
||||
while locked.changed().await.is_ok() {
|
||||
if *locked.borrow_and_update() != Some(false) { return; }
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn closed(pc: &RTCPeerConnection, channel: &RTCDataChannel) {
|
||||
while !matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed)
|
||||
&& channel.ready_state() == RTCDataChannelState::Open {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn wait_ready(state: &mut watch::Receiver<State>, channel: &RTCDataChannel) -> Option<Arc<ScreenCapture>> {
|
||||
loop {
|
||||
let current = state.borrow_and_update().clone();
|
||||
if current.ready() { return Some(current.screen); }
|
||||
if !current.waiting || channel.ready_state() != RTCDataChannelState::Open { return None; }
|
||||
tokio::select! {
|
||||
changed = state.changed() => if changed.is_err() { return None; },
|
||||
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::sync::atomic::AtomicUsize;
|
||||
fn host() -> PortalDesktop {
|
||||
let (_, locked) = watch::channel(Some(true));
|
||||
PortalDesktop::with_lock_state(Arc::new(ScreenCapture::unavailable("pending".into())), locked)
|
||||
}
|
||||
fn ready_screen() -> Arc<ScreenCapture> {
|
||||
let mut screen = ScreenCapture::unavailable("synthetic".into());
|
||||
screen.backend = crate::desktop_backend::DesktopBackend::Portal;
|
||||
screen.init_error = None;
|
||||
screen.width = 1920;
|
||||
screen.height = 1080;
|
||||
Arc::new(screen)
|
||||
}
|
||||
#[test]
|
||||
fn cached_screen_waiting_for_a_closed_portal_is_not_ready_or_allowed() {
|
||||
use crate::system_metrics::Permission;
|
||||
let live = State { screen: ready_screen(), waiting: false };
|
||||
assert!(live.ready() && live.permission(true) == Permission::Allow);
|
||||
let stale = State { screen: ready_screen(), waiting: true };
|
||||
assert!(!stale.ready());
|
||||
assert!(stale.permission(true) == Permission::Unknown);
|
||||
assert!(stale.permission(false) == Permission::Allow);
|
||||
}
|
||||
#[test]
|
||||
fn recovered_screen_is_retained_across_transient_disconnect() {
|
||||
let host = host();
|
||||
let mut updates = host.subscribe();
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let owner = input.desktop_session();
|
||||
owner.connected();owner.disconnected();
|
||||
let screen = ready_screen();
|
||||
host.publish(&owner, screen.clone());
|
||||
assert!(updates.has_changed().unwrap());
|
||||
assert!(!updates.borrow_and_update().waiting);
|
||||
assert!(Arc::ptr_eq(&host.snapshot().screen, &screen));
|
||||
assert!(!host.snapshot().waiting);
|
||||
assert_eq!(host.snapshot().permission(true), crate::system_metrics::Permission::Allow);
|
||||
owner.with_input(|| panic!("publication must not reactivate input"));
|
||||
owner.connected();
|
||||
assert!(Arc::ptr_eq(&host.snapshot().screen, &screen));
|
||||
}
|
||||
#[test]
|
||||
fn terminal_failure_publishes_rejection_while_disconnected() {
|
||||
let host = host();
|
||||
let mut updates = host.subscribe();
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let owner = input.desktop_session();
|
||||
owner.connected();owner.disconnected();
|
||||
host.publish(&owner, Arc::new(ScreenCapture::unavailable("consent rejected".into())));
|
||||
assert!(updates.has_changed().unwrap());
|
||||
assert!(!updates.borrow_and_update().waiting);
|
||||
assert!(!host.snapshot().waiting);
|
||||
assert_eq!(host.snapshot().permission(true), crate::system_metrics::Permission::Reject);
|
||||
owner.connected();
|
||||
assert!(!host.snapshot().waiting);
|
||||
assert_eq!(host.snapshot().screen.init_error.as_deref(), Some("consent rejected"));
|
||||
}
|
||||
#[test]
|
||||
fn replaced_peer_cannot_publish_success_or_failure() {
|
||||
let host = host();
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let old = input.desktop_session();
|
||||
let current = input.desktop_session();
|
||||
let screen = ready_screen();
|
||||
host.publish(¤t, screen.clone());
|
||||
host.publish(&old, Arc::new(ScreenCapture::unavailable("late failure".into())));
|
||||
host.publish(&old, ready_screen());
|
||||
assert!(Arc::ptr_eq(&host.snapshot().screen, &screen));
|
||||
assert!(!host.snapshot().waiting);
|
||||
}
|
||||
#[test]
|
||||
fn unavailable_desktop_does_not_reject_independent_tools() {
|
||||
let host = PortalDesktop::new(Arc::new(ScreenCapture::unavailable("not authorized".into())));
|
||||
assert_eq!(host.snapshot().permission(true), crate::system_metrics::Permission::Unknown);
|
||||
assert_eq!(host.snapshot().permission(false), crate::system_metrics::Permission::Allow);
|
||||
host.state.send_modify(|state| state.waiting = false);
|
||||
assert_eq!(host.snapshot().permission(true), crate::system_metrics::Permission::Reject);
|
||||
assert_eq!(host.snapshot().permission(false), crate::system_metrics::Permission::Allow);
|
||||
host.begin();
|
||||
assert!(host.snapshot().waiting);
|
||||
}
|
||||
#[test]
|
||||
fn unsupported_portal_shapes_are_terminal_while_transient_codes_retry() {
|
||||
for code in [4, 5, 6, 8, 14] {
|
||||
assert!(matches!(classify(Err(PortalError { code })), AttemptOutcome::Terminal(_)), "code {code}");
|
||||
}
|
||||
for code in [1, 3, 7, 9, 10] {
|
||||
assert!(matches!(classify(Err(PortalError { code })), AttemptOutcome::Retry(_)), "code {code}");
|
||||
}
|
||||
assert!(matches!(classify(Err(PortalError { code: 13 })), AttemptOutcome::Cancelled));
|
||||
}
|
||||
#[test]
|
||||
fn fresh_unlock_wakes_even_when_cached_portal_is_healthy() {
|
||||
assert!(should_prepare_power(true, true));
|
||||
assert!(should_prepare_power(false, false));
|
||||
assert!(!should_prepare_power(true, false));
|
||||
}
|
||||
#[test]
|
||||
fn queued_power_prep_checks_cancel_lock_and_current_owner_before_wake() {
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let owner = input.desktop_session();
|
||||
let (lock, locked) = watch::channel(Some(false));
|
||||
let wakes = AtomicUsize::new(0);
|
||||
let inhibitors = AtomicUsize::new(0);
|
||||
let cancelled = AtomicBool::new(true);
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 0);
|
||||
cancelled.store(false, Ordering::Release);
|
||||
lock.send(Some(true)).unwrap();
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 0);
|
||||
lock.send(Some(false)).unwrap();
|
||||
let locked_during_wake = lock.clone();
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
|| {
|
||||
wakes.fetch_add(1, Ordering::Relaxed);
|
||||
locked_during_wake.send(Some(true)).unwrap();
|
||||
Ok(())
|
||||
},
|
||||
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 1);
|
||||
assert_eq!(inhibitors.load(Ordering::Relaxed), 0);
|
||||
lock.send(Some(false)).unwrap();
|
||||
let replacement = input.desktop_session();
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 1);
|
||||
assert!(replacement.is_current());
|
||||
assert_eq!(inhibitors.load(Ordering::Relaxed), 0);
|
||||
}
|
||||
#[test]
|
||||
fn cancelling_a_peer_signals_its_blocking_permission_worker() {
|
||||
let flag = Arc::new(AtomicBool::new(false));
|
||||
let guard = CancelOnDrop(flag.clone());
|
||||
assert!(!flag.load(Ordering::Acquire));
|
||||
drop(guard);
|
||||
assert!(flag.load(Ordering::Acquire));
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn lock_transition_cancels_blocked_attempt_and_releases_inhibitor() {
|
||||
let (lock, locked) = watch::channel(Some(false));
|
||||
let host = Arc::new(PortalDesktop::with_lock_state(
|
||||
Arc::new(ScreenCapture::unavailable("pending".into())), locked));
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let owner = input.desktop_session();
|
||||
let releases = Arc::new(AtomicUsize::new(0));
|
||||
let wakes = Arc::new(AtomicUsize::new(0));
|
||||
let (started, mut started_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let task = tokio::spawn({
|
||||
let host = host.clone();
|
||||
let owner = owner.clone();
|
||||
let releases = releases.clone();
|
||||
let wakes = wakes.clone();
|
||||
async move {
|
||||
host.maintain_with(owner,
|
||||
move || {
|
||||
wakes.fetch_add(1, Ordering::Relaxed);
|
||||
Ok(())
|
||||
},
|
||||
move || IdleGuard(Some(Inhibitor::Fake(DropSignal(releases.clone())))),
|
||||
move |_screen, cancel| {
|
||||
let _ = started.send(());
|
||||
while !cancel.load(Ordering::Acquire) {
|
||||
std::thread::sleep(std::time::Duration::from_millis(1));
|
||||
}
|
||||
Err(PortalError { code: 13 })
|
||||
}).await
|
||||
}
|
||||
});
|
||||
started_rx.recv().await.unwrap();
|
||||
lock.send(Some(true)).unwrap();
|
||||
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
|
||||
while releases.load(Ordering::Relaxed) == 0 {
|
||||
assert!(tokio::time::Instant::now() < deadline, "cancelled attempt did not release inhibitor");
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 1);
|
||||
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
|
||||
while host.opening.try_lock().is_err() {
|
||||
assert!(tokio::time::Instant::now() < deadline, "cancelled worker did not finish");
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
task.abort();
|
||||
let _ = task.await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn inhibitor_release_does_not_wait_for_blocked_worker_cleanup() {
|
||||
let (lock, locked) = watch::channel(Some(false));
|
||||
let host = Arc::new(PortalDesktop::with_lock_state(
|
||||
Arc::new(ScreenCapture::unavailable("pending".into())), locked));
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let owner = input.desktop_session();
|
||||
let releases = Arc::new(AtomicUsize::new(0));
|
||||
let worker_release = Arc::new(AtomicBool::new(false));
|
||||
let (started, mut started_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let task = tokio::spawn({
|
||||
let host = host.clone();
|
||||
let owner = owner.clone();
|
||||
let releases = releases.clone();
|
||||
let worker_release = worker_release.clone();
|
||||
async move {
|
||||
host.maintain_with(owner,
|
||||
|| Ok(()),
|
||||
move || IdleGuard(Some(Inhibitor::Fake(DropSignal(releases.clone())))),
|
||||
move |screen, _cancel| {
|
||||
let _ = started.send(());
|
||||
while !worker_release.load(Ordering::Acquire) {
|
||||
std::thread::sleep(std::time::Duration::from_millis(1));
|
||||
}
|
||||
Ok(screen)
|
||||
}).await
|
||||
}
|
||||
});
|
||||
started_rx.recv().await.unwrap();
|
||||
lock.send(Some(true)).unwrap();
|
||||
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
|
||||
while releases.load(Ordering::Relaxed) == 0 {
|
||||
assert!(tokio::time::Instant::now() < deadline, "cancelled attempt did not release inhibitor");
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
assert!(host.opening.try_lock().is_err(), "worker cleanup must still own the gate");
|
||||
worker_release.store(true, Ordering::Release);
|
||||
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
|
||||
loop {
|
||||
if host.opening.try_lock().is_ok() { break; }
|
||||
assert!(tokio::time::Instant::now() < deadline, "worker cleanup did not release the gate");
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
task.abort();
|
||||
let _ = task.await;
|
||||
}
|
||||
}
|
||||
@@ -128,7 +128,8 @@ pub fn encode_screen_sources(seq: u64, timestamp: u64, screens: &[Screen<'_>], c
|
||||
}
|
||||
|
||||
/// Message.which field 8 CaptureChange. Enum: desktop=0, window=1,
|
||||
/// MuMu=2, hook=3, none=99. Caller confirms the active capture before emitting.
|
||||
/// MuMu=2, hook=3, none=99. Declares the selected target, not frame readiness:
|
||||
/// Android's unlock presenter requires desktop/window here even while locked.
|
||||
pub fn encode_capture_change(seq: u64, timestamp: u64, capture_type: i32, type_value: i32, description: &str) -> Result<Vec<u8>, String> {
|
||||
if !matches!(capture_type, 0 | 1 | 2 | 3 | 99) {
|
||||
return Err("Unknown CaptureChange type".into());
|
||||
|
||||
@@ -265,6 +265,8 @@ impl InputInjector {
|
||||
unsafe {x11_release_all();}
|
||||
} else if self.backend==crate::desktop_backend::DesktopBackend::Wayland && self.portal.lock().unwrap().is_none() {
|
||||
crate::wayland::release_all();
|
||||
} else if self.backend==crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_none() {
|
||||
// Nothing is bound yet (e.g. the first locked connection): no input can be held.
|
||||
} else {
|
||||
// Portal/Wayland cannot query global state. Sweep every key/button
|
||||
// that this host can emit through the currently bound session.
|
||||
@@ -445,6 +447,15 @@ impl InputInjector {
|
||||
}
|
||||
}
|
||||
impl DesktopInputSession {
|
||||
pub fn is_current(&self) -> bool {
|
||||
let owner = self.input.owner.lock().unwrap();
|
||||
owner.owns(self.id)
|
||||
}
|
||||
/// Call only inside with_current or with_input, so a superseded peer cannot change bindings.
|
||||
pub fn bind_portal(&self, portal: Option<std::sync::Arc<crate::portal::PortalSession>>) {
|
||||
self.input.bind_portal(portal);
|
||||
}
|
||||
pub fn release_input(&self) { self.input.release_held(); }
|
||||
pub fn connected(&self) {
|
||||
let mut owner=self.input.owner.lock().unwrap();
|
||||
if owner.owns(self.id) && !owner.active {self.input.release_held();owner.active=true;}
|
||||
@@ -453,6 +464,11 @@ impl DesktopInputSession {
|
||||
let mut owner=self.input.owner.lock().unwrap();
|
||||
if owner.owns(self.id) && owner.active {owner.active=false;self.input.release_held();}
|
||||
}
|
||||
/// Lifecycle updates survive a transient disconnect, but serialize with replacement and shutdown.
|
||||
pub fn with_current(&self, action:impl FnOnce()) {
|
||||
let owner=self.input.owner.lock().unwrap();
|
||||
if owner.owns(self.id) {action();}
|
||||
}
|
||||
pub fn with_input(&self, action:impl FnOnce()) {
|
||||
let owner=self.input.owner.lock().unwrap();
|
||||
if owner.owns(self.id) && owner.active {action();}
|
||||
@@ -460,11 +476,62 @@ impl DesktopInputSession {
|
||||
}
|
||||
impl Drop for DesktopInputSession {fn drop(&mut self) {self.disconnected();}}
|
||||
|
||||
#[cfg(test)]
|
||||
impl InputInjector {
|
||||
pub fn without_desktop() -> Self {
|
||||
Self { mac_controller:std::sync::atomic::AtomicBool::new(false),
|
||||
cmd:std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()),
|
||||
owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts:std::sync::Mutex::new(Shortcuts::default()),
|
||||
uinput:None, screen:std::sync::Mutex::new((0,0)), portal_failures:std::sync::atomic::AtomicUsize::new(0),
|
||||
portal_outcomes:std::array::from_fn(|_|std::sync::atomic::AtomicUsize::new(0)),
|
||||
portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::DesktopBackend::Portal,
|
||||
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod lifecycle_tests {
|
||||
use super::*;
|
||||
use std::sync::{Arc,atomic::{AtomicUsize,Ordering}};
|
||||
#[test]
|
||||
fn current_owner_can_publish_while_disconnected_but_cannot_inject() {
|
||||
let input=Arc::new(InputInjector::without_desktop());
|
||||
let session=input.desktop_session();
|
||||
session.connected();session.disconnected();
|
||||
let publications=AtomicUsize::new(0);
|
||||
session.with_current(||{publications.fetch_add(1,Ordering::Relaxed);});
|
||||
session.with_input(||panic!("disconnected owner must not inject"));
|
||||
assert_eq!(publications.load(Ordering::Relaxed),1);
|
||||
session.connected();
|
||||
session.with_input(||{publications.fetch_add(1,Ordering::Relaxed);});
|
||||
let next=input.desktop_session();
|
||||
session.with_current(||panic!("replaced owner must not publish"));
|
||||
next.with_current(||{publications.fetch_add(1,Ordering::Relaxed);});
|
||||
input.shutdown();
|
||||
next.with_current(||panic!("shutdown must reject lifecycle updates"));
|
||||
assert_eq!(publications.load(Ordering::Relaxed),3);
|
||||
}
|
||||
#[test]
|
||||
fn current_owner_gate_holds_ownership_through_publication() {
|
||||
let input=Arc::new(InputInjector::without_desktop());
|
||||
let session=input.desktop_session();
|
||||
let (started,ready)=std::sync::mpsc::channel();
|
||||
let (finish,resume)=std::sync::mpsc::channel();
|
||||
let worker=session.clone();
|
||||
let publication=std::thread::spawn(move ||worker.with_current(|| {
|
||||
started.send(()).unwrap();resume.recv().unwrap();
|
||||
}));
|
||||
ready.recv_timeout(std::time::Duration::from_secs(2)).unwrap();
|
||||
assert!(input.owner.try_lock().is_err());
|
||||
let replacing=input.clone();
|
||||
let replacement=std::thread::spawn(move ||replacing.desktop_session());
|
||||
finish.send(()).unwrap();
|
||||
publication.join().unwrap();
|
||||
let next=replacement.join().unwrap();
|
||||
assert!(next.is_current());
|
||||
session.with_current(||panic!("late publication after replacement"));
|
||||
}
|
||||
#[test]
|
||||
fn cleanup_discards_motion_shortcuts_and_untracked_input_ledger() {
|
||||
let input=Arc::new(InputInjector::new());
|
||||
input.held.lock().unwrap().keys.insert(0xffe1);
|
||||
|
||||
+66
-32
@@ -2,6 +2,8 @@
|
||||
//! Zero-Wine, Zero-Python, Single-Binary, 5 Native Tools Integrated
|
||||
|
||||
mod desktop_backend;
|
||||
mod desktop_session;
|
||||
mod desktop_power;
|
||||
mod portal;
|
||||
mod network_diagnostics;
|
||||
mod session_ice;
|
||||
@@ -60,6 +62,52 @@ use webrtc::WebRtcSession;
|
||||
|
||||
/// Set before a normal return when the host must come back in the other mode (signed in / out).
|
||||
static RESTART: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
|
||||
fn superseded_peer_ids(sessions: &HashMap<String, WebRtcSession>, ice: &str, desktop: bool) -> Vec<String> {
|
||||
sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop))
|
||||
.map(|(id, _)| id.clone()).collect()
|
||||
}
|
||||
fn released_peer_ids<T>(sessions: &HashMap<String, T>, ice: Option<&serde_json::Value>) -> Vec<String> {
|
||||
let ice = ice.map(|id| id.as_str().map(str::to_owned).unwrap_or_else(|| id.to_string()));
|
||||
sessions.keys().filter(|id| ice.as_deref().map_or(true, |ice| id.as_str() == ice)).cloned().collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod peer_release_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn explicit_releases_leave_independent_and_replacement_peers_alive() {
|
||||
let mut peers = HashMap::from([
|
||||
("old-desktop".to_owned(), ()), ("files".to_owned(), ()),
|
||||
("terminal".to_owned(), ()), ("port-mapping".to_owned(), ()),
|
||||
]);
|
||||
let targets = released_peer_ids(&peers, Some(&serde_json::json!("old-desktop")));
|
||||
assert_eq!(targets, ["old-desktop"]);
|
||||
for id in targets { peers.remove(&id); }
|
||||
peers.insert("new-desktop".to_owned(), ());
|
||||
assert!(released_peer_ids(&peers, Some(&serde_json::json!("old-desktop"))).is_empty());
|
||||
assert!(released_peer_ids(&peers, Some(&serde_json::json!("unknown"))).is_empty());
|
||||
for id in ["files", "terminal", "port-mapping", "new-desktop"] {
|
||||
assert_eq!(released_peer_ids(&peers, Some(&serde_json::json!(id))), [id]);
|
||||
}
|
||||
assert_eq!(peers.len(), 4);
|
||||
}
|
||||
#[test]
|
||||
fn release_without_an_ice_id_retains_room_wide_cleanup() {
|
||||
let peers = HashMap::from([("desktop".to_owned(), ()), ("files".to_owned(), ())]);
|
||||
let mut targets = released_peer_ids(&peers, None);
|
||||
targets.sort();
|
||||
assert_eq!(targets, ["desktop", "files"]);
|
||||
}
|
||||
#[test]
|
||||
fn explicit_non_string_ice_ids_never_become_room_wide_releases() {
|
||||
let peers = HashMap::from([("123".to_owned(), ()), ("files".to_owned(), ())]);
|
||||
for id in [serde_json::json!(999), serde_json::Value::Null, serde_json::json!(false), serde_json::json!({})] {
|
||||
assert!(released_peer_ids(&peers, Some(&id)).is_empty());
|
||||
}
|
||||
assert_eq!(released_peer_ids(&peers, Some(&serde_json::json!(123))), ["123"]);
|
||||
}
|
||||
}
|
||||
/// Re-executes this host; the new instance opens its window so the user sees the result.
|
||||
fn restart_host() -> ! {
|
||||
use std::os::unix::process::CommandExt;
|
||||
@@ -234,6 +282,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let mut frame = vec![0; screen.width as usize * screen.height as usize * 4];
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
|
||||
loop {
|
||||
if *locked.borrow() == Some(false) {
|
||||
session.recover(&std::sync::atomic::AtomicBool::new(false)).map_err(|error| error.to_string())?;
|
||||
}
|
||||
session.capture(&mut frame)?;
|
||||
if *locked.borrow() == Some(false) && session.is_alive() { break; }
|
||||
if std::time::Instant::now() >= deadline { return Err("Test VM portal did not recover".into()); }
|
||||
@@ -356,9 +407,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
|
||||
let capture = Arc::new((if desktop_backend::headless() {
|
||||
Err("headless mode (UU_DESKTOP_BACKEND=none)".to_owned())
|
||||
} else if desktop_backend::detect()?==desktop_backend::DesktopBackend::Portal
|
||||
&& std::env::var("UU_PORTAL_PREAUTHORIZE").ok().as_deref()!=Some("1") {
|
||||
Err("Portal screen access requires a desktop connection and local consent".to_owned())
|
||||
} else if desktop_backend::detect()?==desktop_backend::DesktopBackend::Portal {
|
||||
Err("Portal capture waits for a desktop CONTROL connection".to_owned())
|
||||
} else { ScreenCapture::new() }).unwrap_or_else(|error| {
|
||||
log::warn!("Desktop unavailable; terminal and file tools remain available: {error}");
|
||||
ScreenCapture::unavailable(error)
|
||||
@@ -424,6 +474,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
|
||||
async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutdown: &mut tokio::sync::watch::Receiver<bool>,
|
||||
assist: &mut Option<assist::Assist>, commands: &mut mpsc::Receiver<assist::Command>, webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>>) -> Result<(), Box<dyn std::error::Error>> {
|
||||
let portal_desktop = (capture.backend == desktop_backend::DesktopBackend::Portal && !desktop_backend::headless())
|
||||
.then(|| Arc::new(desktop_session::PortalDesktop::new(capture.clone())));
|
||||
let mut auth = if let Some(session) = assist.as_ref() { session.client.clone() } else {
|
||||
let creds = match config::file().and_then(Credentials::load) {
|
||||
Ok(creds) => creds,
|
||||
@@ -655,22 +707,10 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac);
|
||||
if desktop { input.set_mac_controller(controller_mac); }
|
||||
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
|
||||
if let Some(old) = sessions.remove(&ice) { let _ = old.pc.close().await; }
|
||||
if desktop {
|
||||
// One desktop stream at a time: a new desktop offer replaces stale ones.
|
||||
let stale: Vec<String> = sessions.iter().filter(|(_, s)| s.desktop).map(|(k, _)| k.clone()).collect();
|
||||
for k in stale { if let Some(old) = sessions.remove(&k) { let _ = old.pc.close().await; } }
|
||||
// Replace only this ICE id or a previous desktop, never tool peers.
|
||||
for id in superseded_peer_ids(&sessions, &ice, desktop) {
|
||||
if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; }
|
||||
}
|
||||
let stale_portal=if desktop {
|
||||
if let Some(session)=capture.portal.clone() {
|
||||
// A failed check must not end the host loop; treat it as not stale.
|
||||
match tokio::task::spawn_blocking(move || session.retire_if_closed()).await {
|
||||
Ok(Ok(stale)) => stale,
|
||||
Ok(Err(error)) => { log::warn!("Portal staleness check failed: {error}"); false }
|
||||
Err(_) => { log::warn!("Portal staleness check panicked"); false }
|
||||
}
|
||||
} else { false }
|
||||
} else { false };
|
||||
if desktop && desktop_backend::headless() {
|
||||
log::info!("Desktop connection ignored: headless mode (terminal, file transfer and port mapping remain available)");
|
||||
continue;
|
||||
@@ -678,11 +718,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
let resized=desktop && capture.init_error.is_none() && capture.backend==desktop_backend::DesktopBackend::X11
|
||||
&& tokio::task::spawn_blocking(crate::capture::x11_resized).await.unwrap_or(false);
|
||||
if resized { log::info!("Desktop geometry changed since startup; reinitializing capture"); }
|
||||
let session_capture=if desktop && (capture.init_error.is_some() || stale_portal || resized) {
|
||||
if stale_portal {
|
||||
input.release_held();input.bind_portal(None);
|
||||
capture=Arc::new(ScreenCapture::unavailable("Portal authorization expired".into()));
|
||||
}
|
||||
let session_capture=if desktop && portal_desktop.is_none() && (capture.init_error.is_some() || resized) {
|
||||
match tokio::task::spawn_blocking(ScreenCapture::new).await {
|
||||
Ok(Ok(screen))=>{ capture=Arc::new(screen);capture.clone() },
|
||||
Ok(Err(error))=>{ log::warn!("Desktop connection unavailable: {error}"); continue; },
|
||||
@@ -691,8 +727,10 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
} else { capture.clone() };
|
||||
// Independent file/terminal peers must not detach the
|
||||
// current desktop's authorized Portal input session.
|
||||
if desktop { input.bind_portal(session_capture.portal.clone()); }
|
||||
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport).await {
|
||||
if desktop && portal_desktop.is_none() { input.bind_portal(session_capture.portal.clone()); }
|
||||
if desktop { if let Some(portal) = &portal_desktop { portal.begin(); } }
|
||||
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport,
|
||||
if desktop { portal_desktop.clone() } else { None }).await {
|
||||
Ok(sess) => {
|
||||
// Register before awaiting SDP: shutdown can always close
|
||||
// a peer whose answer may already be queued to the viewer.
|
||||
@@ -730,15 +768,11 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
}
|
||||
}
|
||||
SignalingEvent::Released(val) | SignalingEvent::Left(val) => {
|
||||
let ice = ["ice_id", "iceId"].iter().find_map(|k| val.get(*k).or_else(|| val.get("data").and_then(|d| d.get(*k))))
|
||||
.and_then(|v| v.as_str()).map(str::to_owned);
|
||||
let ice = ["ice_id", "iceId"].iter().find_map(|k| val.get(*k).or_else(|| val.get("data").and_then(|d| d.get(*k))));
|
||||
let keys: Vec<String> = val.as_object().map(|o| o.keys().take(16).cloned().collect()).unwrap_or_default();
|
||||
let mut sessions = webrtc_sessions.lock().await;
|
||||
let targets: Vec<String> = match &ice {
|
||||
Some(id) if sessions.contains_key(id) => vec![id.clone()],
|
||||
_ => sessions.keys().cloned().collect(),
|
||||
};
|
||||
log::info!("Remote controller disconnected: keys={:?} ice_matched={} closing={}", keys, ice.as_ref().is_some_and(|i| sessions.contains_key(i)), targets.len());
|
||||
let targets = released_peer_ids(&sessions, ice);
|
||||
log::info!("Remote controller disconnected: keys={:?} ice_matched={} closing={}", keys, ice.is_some() && !targets.is_empty(), targets.len());
|
||||
let mut desktop_ended = false;
|
||||
for k in targets {
|
||||
if let Some(old) = sessions.remove(&k) {
|
||||
|
||||
+188
-93
@@ -1,6 +1,18 @@
|
||||
//! GNOME/KDE portal session. Capture and input must share this Arc; do not
|
||||
//! recreate it in an encoder subprocess (that would request consent again).
|
||||
use std::sync::Arc;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct PortalError { pub code: i32 }
|
||||
|
||||
impl std::fmt::Display for PortalError {
|
||||
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(formatter, "{}", error(self.code))
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for PortalError {}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
pub struct FrameVersion(usize, u64);
|
||||
#[cfg(unix)]
|
||||
@@ -12,6 +24,7 @@ mod native {
|
||||
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}};
|
||||
extern "C" {
|
||||
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_ready(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_set(portal: *mut c_void, text: *const u8, length: usize) -> i32;
|
||||
@@ -47,27 +60,29 @@ mod native {
|
||||
Ok(true)
|
||||
}
|
||||
#[derive(Default)]
|
||||
struct Recovery { retry_at: Option<std::time::Instant>, retired: bool }
|
||||
struct Recovery { retry_at: Option<std::time::Instant>, failed_until: Option<std::time::Instant>, denied: bool }
|
||||
impl Recovery {
|
||||
// Shared by the encoder's stream-loss recovery and the desktop supervisor: a failed open
|
||||
// backs both off, and a terminal consent/format failure stops the encoder from prompting again.
|
||||
fn failed(&mut self, now: std::time::Instant, code: i32) {
|
||||
let until = now + std::time::Duration::from_secs(5);
|
||||
self.failed_until = Some(until);
|
||||
self.retry_at = Some(until);
|
||||
if matches!(code, 4 | 5 | 6 | 8 | 14) { self.denied = true; }
|
||||
}
|
||||
fn succeeded(&mut self) { *self = Self::default(); }
|
||||
fn ready(&mut self, now: std::time::Instant, unlocked: impl FnOnce() -> bool) -> bool {
|
||||
if self.retired { return false; }
|
||||
if self.denied { return false; }
|
||||
let deadline = self.retry_at.get_or_insert(now + std::time::Duration::from_secs(1));
|
||||
if now < *deadline { return false; }
|
||||
*deadline = now + std::time::Duration::from_secs(1);
|
||||
unlocked()
|
||||
}
|
||||
}
|
||||
fn retire_if_closed<T>(current: &Mutex<T>, recovery: &Mutex<Recovery>, alive: impl FnOnce(&T) -> bool, unlocked: impl FnOnce() -> bool) -> Result<bool, String> {
|
||||
// Wait outside the input mutex. Inspect the published replacement if recovery
|
||||
// won; otherwise prevent the old encoder from opening after reconnect takes over.
|
||||
let mut recovery = recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
let alive = {
|
||||
let handle = current.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
alive(&handle)
|
||||
};
|
||||
if alive || !unlocked() { return Ok(false); }
|
||||
recovery.retired = true;
|
||||
Ok(true)
|
||||
fn clear_pause_for_unlocked_replacement(was_locked: &std::sync::atomic::AtomicBool, state: Option<bool>) {
|
||||
if state == Some(false) {
|
||||
was_locked.store(false, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
}
|
||||
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, pub width: u32, pub height: u32 }
|
||||
impl Session {
|
||||
@@ -81,11 +96,11 @@ mod native {
|
||||
};
|
||||
Ok(self.was_locked.swap(false, std::sync::atomic::Ordering::AcqRel))
|
||||
}
|
||||
fn check_geometry(&self, replacement: &Self) -> Result<(), String> {
|
||||
fn check_geometry(&self, replacement: &Self) -> Result<(), super::PortalError> {
|
||||
// Encoder buffers use frame pixels. Logical geometry and EIS regions
|
||||
// belong to the replacement handle and may change with scaling (#25).
|
||||
if (self.width, self.height) != (replacement.width, replacement.height) {
|
||||
Err("Portal dimensions changed; reconnect required".into())
|
||||
Err(super::PortalError { code: 14 })
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
@@ -93,11 +108,14 @@ mod native {
|
||||
pub fn is_alive(&self) -> bool {
|
||||
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
|
||||
}
|
||||
pub fn retire_if_closed(&self) -> Result<bool, String> {
|
||||
retire_if_closed(&self.handle, &self.recovery, |handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 },
|
||||
|| crate::session_lock::locked_now() == Some(false))
|
||||
}
|
||||
pub fn open() -> Result<Self, String> {
|
||||
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>) -> Result<Self, super::PortalError> {
|
||||
extern "C" fn is_cancelled(data: *mut c_void) -> i32 {
|
||||
let cancelled = unsafe { &*(data as *const std::sync::atomic::AtomicBool) };
|
||||
i32::from(cancelled.load(std::sync::atomic::Ordering::Acquire))
|
||||
}
|
||||
if cancelled.is_some_and(|value| value.load(std::sync::atomic::Ordering::Acquire)) {
|
||||
return Err(super::PortalError { code: 13 });
|
||||
}
|
||||
let (mut error, mut width, mut height) = (0, 0, 0);
|
||||
let directory = super::permissions::directory();
|
||||
let key = super::permissions::desktop_key();
|
||||
@@ -114,13 +132,79 @@ mod native {
|
||||
});
|
||||
if result.is_err() { log::warn!("Portal permission cache callback failed"); }
|
||||
}
|
||||
let pointer = unsafe { uu_portal_open_persist(token.as_ref().map_or(std::ptr::null(), |v| v.as_ptr()), save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height) };
|
||||
let handle = NonNull::new(pointer).ok_or_else(|| super::error(error))?;
|
||||
let restore = token.as_ref().map_or(std::ptr::null(), |value| value.as_ptr());
|
||||
let pointer = unsafe {
|
||||
if let Some(cancelled) = cancelled {
|
||||
uu_portal_open_persist_cancellable(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void,
|
||||
is_cancelled, cancelled as *const _ as *mut c_void,
|
||||
&mut error, &mut width, &mut height,
|
||||
)
|
||||
} else {
|
||||
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
}
|
||||
};
|
||||
let handle = NonNull::new(pointer).ok_or(super::PortalError { code: error })?;
|
||||
// A freshly opened session holds no lock-screen frame: only an observed lock (or a
|
||||
// closed stream) must discard the cached frame. Starting "locked" cleared the first
|
||||
// valid frame, and a static desktop sends no new one, so the viewer stayed black (#2).
|
||||
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), width, height })
|
||||
}
|
||||
pub fn open() -> Result<Self, String> {
|
||||
Self::open_inner(None).map_err(|error| error.to_string())
|
||||
}
|
||||
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
|
||||
Self::open_inner(Some(cancelled))
|
||||
}
|
||||
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, super::PortalError> {
|
||||
use std::sync::atomic::Ordering;
|
||||
if cancelled.load(Ordering::Acquire) { return Err(super::PortalError { code: 13 }); }
|
||||
// Serialize with the encoder's stream-loss recovery: two openers would ask for consent twice.
|
||||
let mut recovery = loop {
|
||||
match self.recovery.try_lock() {
|
||||
Ok(recovery) => break recovery,
|
||||
Err(TryLockError::WouldBlock) => {
|
||||
if cancelled.load(Ordering::Acquire) { return Err(super::PortalError { code: 13 }); }
|
||||
std::thread::sleep(std::time::Duration::from_millis(20));
|
||||
}
|
||||
Err(TryLockError::Poisoned(_)) => return Err(super::PortalError { code: 3 }),
|
||||
}
|
||||
};
|
||||
if recovery.failed_until.is_some_and(|until| std::time::Instant::now() < until) {
|
||||
return Err(super::PortalError { code: 3 });
|
||||
}
|
||||
let alive = {
|
||||
let handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 && uu_portal_capture_alive(handle.0.as_ptr()) != 0 }
|
||||
};
|
||||
if alive { return Ok(false); }
|
||||
|
||||
let result = super::open_then_install(cancelled, || Self::open_cancellable(cancelled), |replacement| {
|
||||
self.check_geometry(&replacement)?;
|
||||
let replacement_handle = replacement.handle.into_inner().map_err(|_| super::PortalError { code: 3 })?;
|
||||
let mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
if cancelled.load(Ordering::Acquire) { return Err(super::PortalError { code: 13 }); }
|
||||
*handle = replacement_handle;
|
||||
clear_pause_for_unlocked_replacement(&self.was_locked, *self.locked.borrow());
|
||||
log::info!("Portal capture session restored after closure");
|
||||
Ok(())
|
||||
});
|
||||
match result {
|
||||
Ok(()) => { recovery.succeeded(); Ok(true) }
|
||||
Err(error) => {
|
||||
if error.code != 13 { recovery.failed(std::time::Instant::now(), error.code); }
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn pause(&self) {
|
||||
if let Ok(handle) = self.handle.lock() {
|
||||
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
} else {
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
}
|
||||
pub fn capture(&self, frame: &mut [u8]) -> Result<(), String> {
|
||||
self.capture_changed(frame, &mut None).map(|_| ())
|
||||
}
|
||||
@@ -134,8 +218,8 @@ mod native {
|
||||
if state != Some(false) {
|
||||
// Unknown state (watcher not reported yet): show nothing but keep the cached frame.
|
||||
if state == Some(true) {
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
return Ok(blank_changed(frame, version));
|
||||
}
|
||||
@@ -166,16 +250,16 @@ mod native {
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
false
|
||||
}) { return Ok(None); }
|
||||
let replacement = match Self::open() {
|
||||
let replacement = match Self::open_inner(None) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
log::warn!("Portal capture recovery deferred: {error}");
|
||||
recovery.retry_at = Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
|
||||
recovery.failed(std::time::Instant::now(), error.code);
|
||||
return Ok(None);
|
||||
}
|
||||
};
|
||||
recovery.retry_at = None;
|
||||
self.check_geometry(&replacement)?;
|
||||
recovery.succeeded();
|
||||
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
|
||||
// Consent can outlive the unlocked state checked above.
|
||||
if *self.locked.borrow() != Some(false) || self.was_locked.load(std::sync::atomic::Ordering::Acquire) {
|
||||
return Ok(None);
|
||||
@@ -384,70 +468,17 @@ mod native {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reconnect_waits_for_recovery_and_rechecks_the_published_handle() {
|
||||
use std::{sync::mpsc::channel, time::Duration};
|
||||
for succeeds in [false, true] {
|
||||
let current = Arc::new(Mutex::new(false));
|
||||
let recovery = Arc::new(Mutex::new(Recovery::default()));
|
||||
let (opening, opened) = channel();
|
||||
let (resume, wait) = channel();
|
||||
let (checked, observed) = channel();
|
||||
let (starting, started) = channel();
|
||||
let worker = {
|
||||
let current = current.clone();
|
||||
let recovery = recovery.clone();
|
||||
std::thread::spawn(move || {
|
||||
let handle = current.lock().unwrap();
|
||||
let _owner = recovery.lock().unwrap();
|
||||
replace_handle(¤t, handle, || {
|
||||
opening.send(()).unwrap();
|
||||
wait.recv_timeout(Duration::from_secs(10)).unwrap();
|
||||
if succeeds { Ok(Some(true)) } else { Ok(None) }
|
||||
}).unwrap()
|
||||
})
|
||||
};
|
||||
let ready = opened.recv_timeout(Duration::from_secs(3));
|
||||
let reconnect = {
|
||||
let current = current.clone();
|
||||
let recovery = recovery.clone();
|
||||
std::thread::spawn(move || {
|
||||
starting.send(()).unwrap();
|
||||
retire_if_closed(¤t, &recovery, |alive| {
|
||||
checked.send(*alive).unwrap();
|
||||
*alive
|
||||
}, || {
|
||||
assert!(current.try_lock().is_ok());
|
||||
true
|
||||
}).unwrap()
|
||||
})
|
||||
};
|
||||
let started = started.recv_timeout(Duration::from_secs(3));
|
||||
// A reconnect waiting on recovery must leave input's mutex available.
|
||||
let input_available = current.try_lock().is_ok();
|
||||
let premature_check = observed.recv_timeout(Duration::from_millis(100));
|
||||
let _ = resume.send(());
|
||||
let recovered = worker.join().unwrap();
|
||||
let stale = reconnect.join().unwrap();
|
||||
assert!(ready.is_ok() && started.is_ok() && input_available);
|
||||
assert!(matches!(premature_check, Err(std::sync::mpsc::RecvTimeoutError::Timeout)));
|
||||
assert_eq!(observed.recv_timeout(Duration::from_secs(3)).unwrap(), succeeds);
|
||||
assert_eq!(recovered, succeeds);
|
||||
assert_eq!(stale, !succeeds);
|
||||
assert_eq!(recovery.lock().unwrap().retired, !succeeds);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reconnect_retirement_prevents_a_late_encoder_recovery() {
|
||||
let current = Mutex::new(false);
|
||||
let recovery = Mutex::new(Recovery::default());
|
||||
// Locked or unknown sessions must not be retired by a reconnect.
|
||||
assert!(!retire_if_closed(¤t, &recovery, |alive| *alive, || false).unwrap());
|
||||
assert!(!recovery.lock().unwrap().retired);
|
||||
assert!(retire_if_closed(¤t, &recovery, |alive| *alive, || true).unwrap());
|
||||
let mut recovery = recovery.lock().unwrap();
|
||||
recovery.retry_at = Some(std::time::Instant::now());
|
||||
assert!(!recovery.ready(std::time::Instant::now(), || panic!("retired encoder probed logind")));
|
||||
fn terminal_failure_stops_encoder_recovery_until_the_supervisor_succeeds() {
|
||||
let now = std::time::Instant::now();
|
||||
let later = now + std::time::Duration::from_secs(60);
|
||||
let mut recovery = Recovery::default();
|
||||
recovery.failed(now, 3);
|
||||
assert!(!recovery.denied && recovery.failed_until.is_some());
|
||||
recovery.failed(now, 4);
|
||||
assert!(recovery.denied);
|
||||
assert!(!recovery.ready(later, || panic!("denied consent must not be probed again")));
|
||||
recovery.succeeded();
|
||||
assert!(!recovery.denied && recovery.failed_until.is_none() && recovery.retry_at.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -514,18 +545,46 @@ mod native {
|
||||
assert!(session.take_lock_observation().unwrap());
|
||||
assert!(!session.was_locked.load(std::sync::atomic::Ordering::Acquire));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelled_recovery_does_not_touch_the_handle() {
|
||||
let session = Fixture::new((1920, 1080));
|
||||
let cancelled = std::sync::atomic::AtomicBool::new(true);
|
||||
assert_eq!(session.session().recover(&cancelled).unwrap_err().code, 13);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unlocked_replacement_keeps_its_first_static_frame() {
|
||||
let was_locked = std::sync::atomic::AtomicBool::new(true);
|
||||
clear_pause_for_unlocked_replacement(&was_locked, Some(false));
|
||||
assert!(!was_locked.load(std::sync::atomic::Ordering::Acquire));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn blank(frame: &mut [u8]) { for pixel in frame.chunks_exact_mut(4) { pixel.copy_from_slice(&[0, 0, 0, 255]); } }
|
||||
|
||||
fn open_then_install<T>(
|
||||
cancelled: &std::sync::atomic::AtomicBool,
|
||||
open: impl FnOnce() -> Result<T, PortalError>,
|
||||
install: impl FnOnce(T) -> Result<(), PortalError>,
|
||||
) -> Result<(), PortalError> {
|
||||
use std::sync::atomic::Ordering;
|
||||
if cancelled.load(Ordering::Acquire) { return Err(PortalError { code: 13 }); }
|
||||
let replacement = open()?;
|
||||
if cancelled.load(Ordering::Acquire) { return Err(PortalError { code: 13 }); }
|
||||
install(replacement)
|
||||
}
|
||||
|
||||
fn error(code: i32) -> String {
|
||||
let reason = match code {
|
||||
1 => "session bus unavailable", 2 => "RemoteDesktop/ScreenCast portal unavailable",
|
||||
3 => "request failed", 4 => "permission cancelled or denied", 5 => "permission request timed out",
|
||||
6 => "single monitor and keyboard/pointer permission required", 7 => "PipeWire connection failed",
|
||||
8 => "unsupported frame format or size", 9 => "session closed or stream lost",
|
||||
10 => "frame unavailable", 11 => "invalid input or frame buffer", _ => "operation failed",
|
||||
10 => "frame unavailable", 11 => "invalid input or frame buffer",
|
||||
13 => "operation cancelled", 14 => "dimensions changed; reconnect required",
|
||||
_ => "operation failed",
|
||||
};
|
||||
format!("Portal {reason} (code {code})")
|
||||
}
|
||||
@@ -542,8 +601,16 @@ impl PortalSession {
|
||||
pub fn clipboard_set(&self, _: &str) -> Result<(), String> { Err(error(2)) }
|
||||
pub fn clipboard_poll(&self) -> Option<String> { None }
|
||||
pub fn is_alive(&self) -> bool { false }
|
||||
pub fn retire_if_closed(&self) -> Result<bool, String> { Ok(false) }
|
||||
pub fn open() -> Result<Self, String> { Err("Portal backend requires Linux and --features portal".into()) }
|
||||
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, PortalError> {
|
||||
if cancelled.load(std::sync::atomic::Ordering::Acquire) { Err(PortalError { code: 13 }) }
|
||||
else { Err(PortalError { code: 2 }) }
|
||||
}
|
||||
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, PortalError> {
|
||||
if cancelled.load(std::sync::atomic::Ordering::Acquire) { Err(PortalError { code: 13 }) }
|
||||
else { Err(PortalError { code: 2 }) }
|
||||
}
|
||||
pub fn pause(&self) {}
|
||||
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(2)) }
|
||||
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(2)) }
|
||||
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(2)) }
|
||||
@@ -575,4 +642,32 @@ mod tests {
|
||||
assert!(super::check(4).unwrap_err().contains("cancelled or denied"));
|
||||
assert!(super::check(9).unwrap_err().contains("closed or stream lost"));
|
||||
}
|
||||
#[test]
|
||||
fn portal_error_display_is_fixed_and_sanitized() {
|
||||
assert_eq!(super::PortalError { code: 13 }.to_string(), "Portal operation cancelled (code 13)");
|
||||
assert_eq!(super::PortalError { code: 14 }.to_string(), "Portal dimensions changed; reconnect required (code 14)");
|
||||
assert_eq!(super::PortalError { code: 123 }.to_string(), "Portal operation failed (code 123)");
|
||||
}
|
||||
#[test]
|
||||
fn opening_with_pre_cancelled_flag_returns_cancellation_code() {
|
||||
let cancelled = std::sync::atomic::AtomicBool::new(true);
|
||||
let code = match super::PortalSession::open_cancellable(&cancelled) {
|
||||
Err(error) => error.code,
|
||||
Ok(_) => panic!("pre-cancelled portal open unexpectedly succeeded"),
|
||||
};
|
||||
assert_eq!(code, 13);
|
||||
}
|
||||
#[test]
|
||||
fn replacement_opens_before_installing_under_the_handle_lock() {
|
||||
let handle = std::sync::Mutex::new(7);
|
||||
let cancelled = std::sync::atomic::AtomicBool::new(false);
|
||||
super::open_then_install(&cancelled, || {
|
||||
assert_eq!(*handle.try_lock().unwrap(), 7);
|
||||
Ok(11)
|
||||
}, |replacement| {
|
||||
*handle.lock().unwrap() = replacement;
|
||||
Ok(())
|
||||
}).unwrap();
|
||||
assert_eq!(*handle.lock().unwrap(), 11);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,12 @@ pub struct SessionIce {
|
||||
}
|
||||
|
||||
impl SessionIce {
|
||||
#[cfg(test)]
|
||||
pub fn local() -> Self {
|
||||
// A supplied empty URL list disables the public STUN defaults in local peer tests.
|
||||
Self { servers: vec![RTCIceServer::default()], relay_only: false }
|
||||
}
|
||||
|
||||
pub fn from_header(header:&Value)->Self {
|
||||
let data=header.get("data").unwrap_or(header);
|
||||
let field=|name:&str|header.get(name).or_else(||data.get(name));
|
||||
|
||||
+13
-8
@@ -119,7 +119,9 @@ fn unlock_with(password: &str) -> UnlockResult {
|
||||
if Command::new("loginctl").args(["unlock-session", &session]).status().map(|s| !s.success()).unwrap_or(true) {
|
||||
return UnlockResult::NoPermission;
|
||||
}
|
||||
let _ = crate::capture::keep_display_awake(); // a blanked monitor would keep the stream black
|
||||
if let Err(error) = crate::capture::keep_display_awake() {
|
||||
log::warn!("Display wake after auto unlock failed: {error}");
|
||||
}
|
||||
// Post-unlock confirmation like the official host: the lock screen must actually go away.
|
||||
for _ in 0..100 { // GNOME takes ~3 s to drop the shield after logind's Unlock
|
||||
if session_locked(&session) == Some(false) { return UnlockResult::Success; }
|
||||
@@ -134,23 +136,26 @@ type Sequence = std::sync::Arc<std::sync::atomic::AtomicU64>;
|
||||
fn now() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs() }
|
||||
|
||||
/// Message 15 SystemStateChange { 1: SecureDesktopState } on CONTROL.
|
||||
pub async fn send_state(channel: &Channel, sequence: &Sequence, locked: bool) {
|
||||
pub async fn send_state(channel: &Channel, sequence: &Sequence, locked: bool) -> bool {
|
||||
let seq = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let message = crate::initialization::encode_secure_desktop(seq, now(), locked, false, supported());
|
||||
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await { log::warn!("Secure desktop state send failed: {e}"); }
|
||||
match channel.send(&bytes::Bytes::from(message)).await {
|
||||
Ok(_) => {
|
||||
log::info!("Secure desktop state sent: locked={} auto_unlock={}", locked, supported());
|
||||
true
|
||||
}
|
||||
Err(e) => { log::warn!("Secure desktop state send failed: {e}"); false }
|
||||
}
|
||||
}
|
||||
|
||||
/// Reports the lock state to one desktop viewer: now, then on every change, until it closes.
|
||||
pub async fn report_states(channel: Channel, sequence: Sequence) {
|
||||
pub async fn report_states(channel: Channel, sequence: Sequence, mut state: watch::Receiver<Option<bool>>) {
|
||||
use webrtc::data_channel::data_channel_state::RTCDataChannelState;
|
||||
let mut state = watch_locked();
|
||||
let mut sent = None;
|
||||
loop {
|
||||
let locked = *state.borrow_and_update();
|
||||
if let Some(locked) = locked.filter(|l| sent != Some(*l)) {
|
||||
send_state(&channel, &sequence, locked).await;
|
||||
log::info!("Secure desktop state sent: locked={} auto_unlock={}", locked, supported());
|
||||
sent = Some(locked);
|
||||
if send_state(&channel, &sequence, locked).await { sent = Some(locked); }
|
||||
}
|
||||
tokio::select! {
|
||||
changed = state.changed() => if changed.is_err() { return; },
|
||||
|
||||
@@ -54,6 +54,13 @@ pub struct SignalingClient {
|
||||
_reconnect_key: Arc<std::sync::Mutex<Option<String>>>,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
impl SignalingClient {
|
||||
pub fn disconnected() -> Arc<Self> {
|
||||
Arc::new(Self { tx_outgoing: mpsc::channel(1).0, _reconnect_key: Arc::new(std::sync::Mutex::new(None)) })
|
||||
}
|
||||
}
|
||||
|
||||
fn refreshed_key(ack:&Value)->Option<String> {
|
||||
let values=ack.as_array()?;
|
||||
if values.first()?.as_str()? != "success" { return None; }
|
||||
|
||||
+5
-2
@@ -805,7 +805,10 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
&& pc.sctp().state() == webrtc::sctp_transport::sctp_transport_state::RTCSctpTransportState::Connected { break; }
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
crate::capture::keep_display_awake()?;
|
||||
// Portal power/idle policy belongs to its CONTROL-scoped supervisor,
|
||||
// including when video has no frames or the user locks manually.
|
||||
if portal.is_none() { crate::capture::keep_display_awake()?; }
|
||||
let portal_stream = portal.is_some();
|
||||
let (latest, mut receiver) = mpsc::channel(4);
|
||||
let budget=Arc::new(Semaphore::new(4));
|
||||
let sequence = Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
@@ -892,7 +895,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
max_send_ms=max_send_ms.max(send_started.elapsed().as_millis());
|
||||
frames += 1;
|
||||
if stats.elapsed() >= Duration::from_secs(30) {
|
||||
crate::capture::keep_display_awake()?;
|
||||
if !portal_stream { crate::capture::keep_display_awake()?; }
|
||||
log::info!("Desktop latest-frame stats: sent={} skipped={} latest_seq={} window_s={} window_sent={} window_skipped={} max_slot_age_ms={} max_send_ms={}",
|
||||
frames, skipped, frame.sequence, stats.elapsed().as_secs(), frames - window_frames, skipped - window_skipped, max_age_ms, max_send_ms);
|
||||
(window_frames, window_skipped) = (frames, skipped);
|
||||
|
||||
+303
-42
@@ -25,6 +25,15 @@ use webrtc::dtls_transport::dtls_role::DTLSRole;
|
||||
use webrtc::track::track_local::track_local_static_sample::TrackLocalStaticSample;
|
||||
use webrtc::track::track_local::TrackLocalWriter;
|
||||
|
||||
fn is_capture_setting_message(data: &[u8]) -> bool {
|
||||
use crate::protocol::WireValue;
|
||||
let Ok(fields) = crate::protocol::decode_wire(data) else { return false; };
|
||||
fields.iter().find_map(|field| match (field.number, &field.value) {
|
||||
(21, WireValue::Bytes(rpc)) => crate::protocol::decode_wire(rpc).ok(),
|
||||
_ => None,
|
||||
}).is_some_and(|rpc| rpc.iter().any(|field| matches!(field.number, 2 | 3 | 4 | 6)))
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone)]
|
||||
pub struct SessionContext {
|
||||
pub client_id: Option<String>,
|
||||
@@ -48,6 +57,7 @@ impl WebRtcSession {
|
||||
signaling_client: Arc<crate::signaling::SignalingClient>,
|
||||
desktop: bool,
|
||||
transport:crate::session_ice::SessionIce,
|
||||
portal_desktop: Option<Arc<crate::desktop_session::PortalDesktop>>,
|
||||
) -> Result<Self, String> {
|
||||
let mut m = MediaEngine::default();
|
||||
m.register_default_codecs()
|
||||
@@ -222,7 +232,7 @@ impl WebRtcSession {
|
||||
});
|
||||
|
||||
// Desktop sound on the viewer's audio m-line (it always offers Opus).
|
||||
if desktop && crate::audio::enabled() {
|
||||
if desktop && crate::audio::enabled() && !cfg!(test) {
|
||||
let audio_track = Arc::new(TrackLocalStaticSample::new(
|
||||
RTCRtpCodecCapability { mime_type: "audio/opus".to_owned(), clock_rate: 48000, channels: 2, ..Default::default() },
|
||||
"audio_0".to_owned(), "audio_0".to_owned(),
|
||||
@@ -247,7 +257,7 @@ impl WebRtcSession {
|
||||
// Per-connection mute / lock-after-session settings (安全 menu).
|
||||
let peer_actions = Arc::new(crate::system_actions::PeerActions::default());
|
||||
let desktop_sound = desktop && crate::audio::enabled();
|
||||
if desktop {
|
||||
if desktop && !cfg!(test) {
|
||||
let (end_pc, actions) = (pc.clone(), peer_actions.clone());
|
||||
tokio::spawn(async move {
|
||||
{
|
||||
@@ -269,12 +279,29 @@ impl WebRtcSession {
|
||||
});
|
||||
}
|
||||
let portal=capture.portal.clone();
|
||||
let stream_desktop = portal_desktop.clone();
|
||||
// File/terminal/port-mapping connections carry no desktop video.
|
||||
let control_video_track = video_track.clone();
|
||||
let stream_settings = video_settings.clone();
|
||||
if desktop {
|
||||
if desktop && !cfg!(test) {
|
||||
let state_pc = streaming_pc.clone();
|
||||
tokio::spawn(async move {
|
||||
let screen = if let Some(desktop) = stream_desktop {
|
||||
let mut updates = desktop.subscribe();
|
||||
loop {
|
||||
let state = updates.borrow_and_update().clone();
|
||||
if state.ready() { break Some(state.screen); }
|
||||
if !state.waiting { return; }
|
||||
if matches!(streaming_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) { return; }
|
||||
tokio::select! {
|
||||
changed = updates.changed() => if changed.is_err() { return; },
|
||||
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
|
||||
}
|
||||
}
|
||||
} else { None };
|
||||
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
|
||||
(capture_size, capture_display, portal),
|
||||
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
|
||||
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request).await {
|
||||
// A send racing the viewer's close fails with a misleading track error.
|
||||
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
|
||||
@@ -289,12 +316,25 @@ impl WebRtcSession {
|
||||
}
|
||||
let input_clone = input.clone();
|
||||
let control_capture = capture.clone();
|
||||
let desktop_pc = Arc::downgrade(&pc);
|
||||
let control_sequence = Arc::new(std::sync::atomic::AtomicU64::new(1));
|
||||
// Capability belongs to the granted session, including while GNOME is
|
||||
// locked. Echo can precede TEXT readiness and CONTROL auto-unlock;
|
||||
// advertising false here would disable clipboard for the entire peer.
|
||||
let portal_clipboard_supported = desktop && capture.portal.as_ref().is_some_and(|session| session.clipboard_supported());
|
||||
let portal_clipboard_supported = desktop && portal_desktop.as_ref().map_or_else(
|
||||
|| capture.portal.as_ref().is_some_and(|session| session.clipboard_supported()),
|
||||
|manager| {
|
||||
let state = manager.snapshot();
|
||||
state.ready()
|
||||
&& state.screen.portal.as_ref().is_some_and(|session| session.clipboard_supported())
|
||||
});
|
||||
let text_clipboard_ready = Arc::new(std::sync::atomic::AtomicBool::new(portal_clipboard_supported));
|
||||
let last_echo_request = Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
let echo_seen = Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
// Same watcher the desktop session uses: the manager's when Portal owns the
|
||||
// session, otherwise the global lock watcher. Unknown state fails closed below.
|
||||
let channel_lock_state = portal_desktop.as_ref().map_or_else(
|
||||
crate::session_lock::watch_locked, |manager| manager.lock_state());
|
||||
// One file-transfer session per peer. The viewer may send FileTransferFtp RPCs on CONTROL,
|
||||
// but it receives file traffic only through streamerDidReceiveFileData, so every reply and
|
||||
// host-initiated request goes out on FILE_DATA_CHANNEL.
|
||||
@@ -337,8 +377,13 @@ impl WebRtcSession {
|
||||
let input_inst = input_clone.clone();
|
||||
let channel_input_session=input_session.clone();
|
||||
let screen = control_capture.clone();
|
||||
let portal_desktop = portal_desktop.clone();
|
||||
let desktop_pc = desktop_pc.clone();
|
||||
let out_sequence = control_sequence.clone();
|
||||
let shared_clipboard_ready = text_clipboard_ready.clone();
|
||||
let last_echo_request = last_echo_request.clone();
|
||||
let echo_seen = echo_seen.clone();
|
||||
let channel_lock_state = channel_lock_state.clone();
|
||||
let peer_files = peer_files.clone();
|
||||
let peer_port_mapping = port_mapping.clone();
|
||||
let peer_video_settings = video_settings.clone();
|
||||
@@ -350,7 +395,6 @@ impl WebRtcSession {
|
||||
let lbl = label.clone();
|
||||
let inp = input_inst.clone();
|
||||
let d_reply = d.clone();
|
||||
let input_size = (screen.width, screen.height);
|
||||
let reply_sequence = out_sequence.clone();
|
||||
let channel_video_settings = peer_video_settings.clone();
|
||||
let channel_actions = peer_actions.clone();
|
||||
@@ -378,6 +422,88 @@ impl WebRtcSession {
|
||||
}
|
||||
});
|
||||
}
|
||||
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
|
||||
if label == "CONTROL_DATA_CHANNEL" {
|
||||
let settings = channel_video_settings.clone();
|
||||
let track = peer_video_track.clone();
|
||||
let response_tx = outbound.clone();
|
||||
let sequence = reply_sequence.clone();
|
||||
let manager = portal_desktop.clone();
|
||||
let channel = Arc::downgrade(&d);
|
||||
let initial_screen = screen.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut health = tokio::time::interval(std::time::Duration::from_millis(100));
|
||||
loop {
|
||||
let request = tokio::select! {
|
||||
request = capture_rx.recv() => match request { Some(request) => request, None => break },
|
||||
_ = health.tick() => {
|
||||
if channel.upgrade().is_none_or(|channel| matches!(
|
||||
channel.ready_state(),
|
||||
webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
|
||||
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed
|
||||
)) { break; }
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let active_screen = if desktop {
|
||||
if let Some(manager) = &manager {
|
||||
loop {
|
||||
let state = manager.snapshot();
|
||||
if !state.waiting && state.screen.init_error.is_some() {
|
||||
log::warn!("Capture setting request dropped: Portal desktop unavailable");
|
||||
break None;
|
||||
}
|
||||
let live = state.screen.init_error.is_none()
|
||||
&& (cfg!(test) || state.screen.portal.as_ref().is_some_and(|portal| portal.is_alive()))
|
||||
&& *manager.lock_state().borrow() == Some(false);
|
||||
if live { break Some(state.screen); }
|
||||
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||
if channel.upgrade().is_none_or(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) { return; }
|
||||
}
|
||||
} else {
|
||||
Some(initial_screen.clone())
|
||||
}
|
||||
} else {
|
||||
Some(initial_screen.clone())
|
||||
};
|
||||
let Some(active_screen) = active_screen else { continue; };
|
||||
let input_size = if active_screen.init_error.is_none() {
|
||||
(active_screen.width, active_screen.height)
|
||||
} else { (1920, 1080) };
|
||||
let Ok(fields) = crate::protocol::decode_wire(&request) else { continue; };
|
||||
use crate::protocol::WireValue;
|
||||
let Some(rpc) = fields.iter().find_map(|f| match (f.number, &f.value) {
|
||||
(21, WireValue::Bytes(rpc)) => Some(*rpc), _ => None,
|
||||
}) else { continue; };
|
||||
let Ok(rpc_fields) = crate::protocol::decode_wire(rpc) else { continue; };
|
||||
let before = *settings.borrow();
|
||||
let output_before = before.output;
|
||||
let revision = track.revision();
|
||||
let Some(response) = crate::capture_setting::handle_rpc_with_codecs(
|
||||
&rpc_fields, &settings, input_size,
|
||||
track.supports(crate::capture_setting::VideoCodec::H264),
|
||||
track.supports(crate::capture_setting::VideoCodec::H265)) else { continue; };
|
||||
let codec_changed = settings.borrow().codec != before.codec;
|
||||
if desktop && codec_changed && !track.wait_for_applied(revision, &settings).await {
|
||||
log::warn!("Codec switch did not produce a transmitted frame; success reply withheld");
|
||||
continue;
|
||||
}
|
||||
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap_or_default().as_secs();
|
||||
let next = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let _ = response_tx.send(crate::initialization::envelope(next(), timestamp, 22, &response));
|
||||
let current = *settings.borrow();
|
||||
if current.output != output_before {
|
||||
match crate::capture_setting::screen_sources(next(), timestamp, input_size, current.output, "Linux desktop") {
|
||||
Ok(screens) => { let _ = response_tx.send(screens); }
|
||||
Err(error) => log::warn!("Screen sources update failed: {}", error),
|
||||
}
|
||||
}
|
||||
let sync = crate::capture_setting::sync_payload(¤t, input_size);
|
||||
let _ = response_tx.send(crate::initialization::envelope(next(), timestamp, 25, &sync));
|
||||
}
|
||||
});
|
||||
}
|
||||
// The viewer sends FileTransferFtp RPCs (Message 21/22) on CONTROL; accept them on TEXT/FILE too.
|
||||
let file_session = if matches!(label.as_str(), "CONTROL_DATA_CHANNEL" | "TEXT_DATA_CHANNEL" | "FILE_DATA_CHANNEL") {
|
||||
Some(peer_files.clone())
|
||||
@@ -391,23 +517,59 @@ impl WebRtcSession {
|
||||
let initial_sequence = out_sequence.clone();
|
||||
let clipboard_sink = clipboard_input.clone();
|
||||
let clipboard_ready = clipboard_enabled.clone();
|
||||
let last_echo_request = last_echo_request.clone();
|
||||
let echo_seen = echo_seen.clone();
|
||||
let rich_outgoing=rich_state.clone();
|
||||
let open_actions = channel_actions.clone();
|
||||
let open_video = channel_video_settings.clone();
|
||||
let open_track = peer_video_track.clone();
|
||||
let open_desktop = portal_desktop.clone();
|
||||
let open_owner = channel_input_session.clone();
|
||||
let open_screen = screen.clone();
|
||||
d.on_open(Box::new(move || {
|
||||
let init_actions = open_actions.clone();
|
||||
let init_video = open_video.clone();
|
||||
let init_track = open_track.clone();
|
||||
let channel = channel.clone();
|
||||
let sequence = initial_sequence.clone();
|
||||
let screen = screen.clone();
|
||||
let screen = open_screen.clone();
|
||||
let clipboard_sink = clipboard_sink.clone();
|
||||
let clipboard_ready = clipboard_ready.clone();
|
||||
let rich_outgoing=rich_outgoing.clone();
|
||||
let portal_desktop = open_desktop.clone();
|
||||
let owner = open_owner.clone();
|
||||
let pc = desktop_pc.upgrade();
|
||||
Box::pin(async move {
|
||||
// Permission dialogs and first-frame waits must not occupy the
|
||||
// channel-open callback or delay CONTROL message dispatch.
|
||||
tokio::spawn(async move {
|
||||
if channel.label() == "TEXT_DATA_CHANNEL" {
|
||||
if !desktop { return; }
|
||||
let screen = if let Some(desktop) = &portal_desktop {
|
||||
let mut updates = desktop.subscribe();
|
||||
let Some(_) = crate::desktop_session::wait_ready(&mut updates, &channel).await else { return; };
|
||||
let mut locked = desktop.lock_state();
|
||||
loop {
|
||||
let state = desktop.snapshot();
|
||||
if !state.waiting && state.screen.init_error.is_some() { return; }
|
||||
if let Some(session) = state.screen.portal.as_ref() {
|
||||
if session.is_alive() && *locked.borrow() == Some(false) {
|
||||
break state.screen;
|
||||
}
|
||||
}
|
||||
tokio::select! {
|
||||
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
|
||||
changed = locked.changed() => if changed.is_err() { return; },
|
||||
_ = async {
|
||||
loop {
|
||||
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
|
||||
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return; }
|
||||
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||
}
|
||||
} => return,
|
||||
}
|
||||
}
|
||||
} else { screen };
|
||||
let bridge = if let Some(session)=screen.portal.clone() { crate::clipboard::start_portal(session) } else { crate::clipboard::start(screen.display.clone()) };
|
||||
*clipboard_sink.lock().unwrap() = Some(bridge.incoming);
|
||||
let clipboard_channel = channel.clone();
|
||||
@@ -452,6 +614,92 @@ impl WebRtcSession {
|
||||
});
|
||||
return;
|
||||
}
|
||||
let early_desktop_selection = desktop && portal_desktop.is_some();
|
||||
if early_desktop_selection {
|
||||
// Android 4.43.0's unlock presenter requires CaptureChange
|
||||
// CT_DESKTOP/CT_WINDOW as well as SecureDesktopState before
|
||||
// sending UnlockRemoteSystem, even with no video frames.
|
||||
let timestamp = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let message = crate::initialization::encode_capture_change(
|
||||
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
|
||||
timestamp, 0, 0, "Linux desktop").expect("desktop capture type");
|
||||
if let Err(error) = channel.send(&bytes::Bytes::from(message)).await {
|
||||
log::error!("CONTROL desktop selection failed: {error}");
|
||||
return;
|
||||
}
|
||||
log::info!("CONTROL initialization field 8 sent (desktop selection before capture)");
|
||||
}
|
||||
if desktop {
|
||||
// Report secure-desktop state before waiting for capture,
|
||||
// so AUTO_UNLOCK_SYSTEM can arrive on this same CONTROL.
|
||||
let state = portal_desktop.as_ref().map_or_else(
|
||||
crate::session_lock::watch_locked, |desktop| desktop.lock_state());
|
||||
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), state));
|
||||
}
|
||||
if let Some(manager) = &portal_desktop {
|
||||
let mut updates = manager.subscribe();
|
||||
let channel = channel.clone();
|
||||
let sequence = sequence.clone();
|
||||
let echo_request = last_echo_request.clone();
|
||||
let clipboard_ready = clipboard_ready.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut health = tokio::time::interval(std::time::Duration::from_millis(100));
|
||||
loop {
|
||||
tokio::select! {
|
||||
changed = updates.changed() => if changed.is_err() { break; },
|
||||
_ = health.tick() => {
|
||||
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; }
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let state = updates.borrow_and_update().clone();
|
||||
let supported = state.ready()
|
||||
&& state.screen.portal.as_ref().is_some_and(|portal| portal.clipboard_supported());
|
||||
clipboard_ready.store(supported, std::sync::atomic::Ordering::Release);
|
||||
// echo_seen is published after the request seq, so reading it
|
||||
// first guarantees a non-stale sequence for the replay.
|
||||
if supported && echo_seen.load(std::sync::atomic::Ordering::Acquire) {
|
||||
let request_seq = echo_request.load(std::sync::atomic::Ordering::Acquire);
|
||||
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let response = crate::control_protocol::encode_echo_response_with_clipboard(
|
||||
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
|
||||
timestamp, request_seq, true);
|
||||
let _ = channel.send(&bytes::Bytes::from(response)).await;
|
||||
}
|
||||
if !state.waiting && state.screen.init_error.is_some() { break; }
|
||||
}
|
||||
});
|
||||
}
|
||||
let screen = if let Some(portal) = &portal_desktop {
|
||||
if !cfg!(test) {
|
||||
if let (Some(owner), Some(pc)) = (owner, pc) {
|
||||
tokio::spawn(portal.clone().run(pc, channel.clone(), owner));
|
||||
}
|
||||
}
|
||||
let snapshot = portal.snapshot();
|
||||
if !snapshot.ready() {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
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)));
|
||||
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 {
|
||||
Some(screen) => screen,
|
||||
None => {
|
||||
if channel.ready_state() == webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
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));
|
||||
let _ = channel.send(&bytes::Bytes::from(message)).await;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else { snapshot.screen }
|
||||
} else { screen };
|
||||
let timestamp = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let next_seq = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
@@ -480,6 +728,7 @@ impl WebRtcSession {
|
||||
log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false });
|
||||
}
|
||||
for (field, message) in messages {
|
||||
if early_desktop_selection && field == 8 { continue; }
|
||||
if (!desktop || screen.init_error.is_some()) && field == 18 { continue; }
|
||||
if desktop && screen.init_error.is_some() && matches!(field,7|8) { continue; }
|
||||
let message = match message {
|
||||
@@ -494,7 +743,6 @@ impl WebRtcSession {
|
||||
}
|
||||
// Mirror the Linux pointer shape; the video itself carries no pointer.
|
||||
if !desktop { return; }
|
||||
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone()));
|
||||
let mut shapes = crate::cursor::monitor(&screen.display);
|
||||
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
|
||||
let mut sent = 0usize;
|
||||
@@ -518,12 +766,19 @@ impl WebRtcSession {
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
})
|
||||
}));
|
||||
}
|
||||
|
||||
|
||||
d.on_message(Box::new(move |msg: DataChannelMessage| {
|
||||
// Keep the whole state: a cached screen waiting for a closed Portal is not ready for input.
|
||||
let (screen, desktop_ready) = portal_desktop.as_ref().map_or_else(|| (screen.clone(), true), |desktop| {
|
||||
let state = desktop.snapshot();
|
||||
let ready = state.ready();
|
||||
(state.screen, ready)
|
||||
});
|
||||
let channel_name = lbl.clone();
|
||||
let input_worker = inp.clone();
|
||||
let message_input_session=channel_input_session.clone();
|
||||
@@ -537,43 +792,29 @@ impl WebRtcSession {
|
||||
let rich_incoming=rich_state.clone();
|
||||
let file_worker = file_session.clone();
|
||||
let mapping = peer_port_mapping.clone();
|
||||
let video_settings = channel_video_settings.clone();
|
||||
let negotiated_track = peer_video_track.clone();
|
||||
let actions = channel_actions.clone();
|
||||
let portal_for_message = portal_desktop.clone();
|
||||
let lock_for_message = channel_lock_state.clone();
|
||||
let echo_for_message = last_echo_request.clone();
|
||||
let echo_seen_for_message = echo_seen.clone();
|
||||
let capture_requests = capture_tx.clone();
|
||||
|
||||
Box::pin(async move {
|
||||
let input_size = (screen.width, screen.height);
|
||||
if let Some(term) = &terminal_worker {
|
||||
if crate::terminal::is_frame(&msg.data) { term.handle(&msg.data); return; }
|
||||
}
|
||||
if channel_name == "CONTROL_DATA_CHANNEL" && is_capture_setting_message(&msg.data) {
|
||||
// Back-pressure like the old inline handler instead of dropping the latest setting.
|
||||
if capture_requests.send(msg.data.to_vec()).await.is_err() {
|
||||
log::warn!("Capture setting queue closed; request dropped");
|
||||
}
|
||||
return;
|
||||
}
|
||||
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
|
||||
use crate::protocol::WireValue;
|
||||
let rpc = fields.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None });
|
||||
let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok());
|
||||
let before = *video_settings.borrow();
|
||||
let output_before = before.output;
|
||||
let revision = negotiated_track.revision();
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::capture_setting::handle_rpc_with_codecs(r, &video_settings, input_size, negotiated_track.supports(crate::capture_setting::VideoCodec::H264), negotiated_track.supports(crate::capture_setting::VideoCodec::H265))) {
|
||||
let codec_changed = video_settings.borrow().codec != before.codec;
|
||||
if codec_changed && !negotiated_track.wait_for_applied(revision, &video_settings).await {
|
||||
// Official host replies after startVideoCaptureAndSendRpcResponse.
|
||||
// Do not fabricate a codec error number or acknowledge an encoder that never started.
|
||||
log::warn!("Codec switch did not produce a transmitted frame; success reply withheld");
|
||||
return;
|
||||
}
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let next = || out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let _ = rpc_out.send(crate::initialization::envelope(next(), ts, 22, &response));
|
||||
let current = *video_settings.borrow();
|
||||
if current.output != output_before {
|
||||
match crate::capture_setting::screen_sources(next(), ts, input_size, current.output, "Linux desktop") {
|
||||
Ok(screens) => { let _ = rpc_out.send(screens); },
|
||||
Err(e) => log::warn!("Screen sources update failed: {}", e),
|
||||
}
|
||||
}
|
||||
let sync = crate::capture_setting::sync_payload(¤t, input_size);
|
||||
let _ = rpc_out.send(crate::initialization::envelope(next(), ts, 25, &sync));
|
||||
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));
|
||||
@@ -722,10 +963,17 @@ impl WebRtcSession {
|
||||
// QuerySystemState { 1: SS_ID_SECURE_DESKTOP_STATE = 1 } asks for the lock state now.
|
||||
let query = fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 16) => Some(*v), _ => None });
|
||||
if let Some(query) = query {
|
||||
let id = crate::protocol::decode_wire(query).ok().and_then(|q| q.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Varint(v), 1) => Some(*v), _ => None }));
|
||||
let query_fields = crate::protocol::decode_wire(query).ok();
|
||||
let id = query_fields.as_ref().and_then(|q| q.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Varint(v), 1) => Some(*v), _ => None }));
|
||||
let shape = query_fields.as_ref().map(|fields| fields.iter().map(|field| match &field.value {
|
||||
WireValue::Bytes(bytes) => (field.number, "bytes", bytes.len()),
|
||||
_ => (field.number, "number", 0),
|
||||
}).collect::<Vec<_>>());
|
||||
log::info!("CONTROL system-state query: fields={:?} secure_desktop={}", shape, id == Some(1));
|
||||
if id == Some(1) {
|
||||
let locked = *crate::session_lock::watch_locked().borrow();
|
||||
crate::session_lock::send_state(&reply_chan, &out_sequence, locked.unwrap_or(false)).await;
|
||||
let locked = *lock_for_message.borrow();
|
||||
// Unknown (no logind session, e.g. Xvfb) stays unlocked, as before.
|
||||
crate::session_lock::send_state(&reply_chan, &out_sequence, locked == Some(true)).await;
|
||||
}
|
||||
}
|
||||
if let Some(simple) = simple {
|
||||
@@ -747,6 +995,7 @@ impl WebRtcSession {
|
||||
log::info!("SimpleAction {} ({}) received: value={:?} args={}", action,
|
||||
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();
|
||||
tokio::spawn(async move {
|
||||
let worker = actions.clone();
|
||||
let report = tokio::task::spawn_blocking(move || worker.handle(action, value, &args, || {
|
||||
@@ -756,7 +1005,10 @@ impl WebRtcSession {
|
||||
})).await.unwrap_or(false);
|
||||
if report {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let message = crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &actions.metrics_payload(desktop_sound, crate::system_metrics::Permission::Allow));
|
||||
let permission = settings_portal.as_ref().map_or(
|
||||
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));
|
||||
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
|
||||
}
|
||||
});
|
||||
@@ -765,6 +1017,8 @@ impl WebRtcSession {
|
||||
log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));
|
||||
}
|
||||
if action == 0 {
|
||||
echo_for_message.store(seq, std::sync::atomic::Ordering::Release);
|
||||
echo_seen_for_message.store(true, std::sync::atomic::Ordering::Release);
|
||||
let response = crate::control_protocol::encode_echo_response_with_clipboard(
|
||||
out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(), seq,
|
||||
@@ -772,10 +1026,7 @@ impl WebRtcSession {
|
||||
if let Err(e) = reply_chan.send(&bytes::Bytes::from(response)).await {
|
||||
log::error!("CONTROL echo response failed: {}", e);
|
||||
} else {
|
||||
static RESPONSES: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
if RESPONSES.fetch_add(1, std::sync::atomic::Ordering::Relaxed) == 0 {
|
||||
log::info!("CONTROL protobuf echo request answered");
|
||||
}
|
||||
log::info!("CONTROL protobuf echo request answered");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -788,6 +1039,8 @@ impl WebRtcSession {
|
||||
if channel_name.contains("CONTROL") {
|
||||
match crate::control_protocol::decode_control(&msg.data) {
|
||||
Ok(crate::control_protocol::ControlMessage::Input(event)) => {
|
||||
if screen.backend == crate::desktop_backend::DesktopBackend::Portal
|
||||
&& (screen.init_error.is_some() || !desktop_ready || *lock_for_message.borrow() != Some(false)) { return; }
|
||||
use crate::control_protocol::ControlInput;
|
||||
// Separate receipt budgets keep motion floods from hiding clicks.
|
||||
static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
|
||||
@@ -1049,6 +1302,14 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "desktop_control_tests.rs"]
|
||||
mod desktop_control_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "webrtc_lifecycle_tests.rs"]
|
||||
mod webrtc_lifecycle_tests;
|
||||
|
||||
/// Virtual/overlay interfaces never carry the UU video path (ZeroTier, containers).
|
||||
fn ice_interface_allowed(name: &str) -> bool {
|
||||
!["zt", "docker", "br-", "veth", "virbr", "lo"].iter().any(|prefix| name.starts_with(prefix))
|
||||
|
||||
@@ -0,0 +1,224 @@
|
||||
//! CONTROL lifecycle regressions: an early Echo must be answered while the Portal
|
||||
//! session is still pending, capture settings must be deferred (never dropped, never
|
||||
//! blocking Echo/unlock) until the desktop is ready, and tool peers must apply
|
||||
//! settings against the nominal screen without waiting for a desktop at all.
|
||||
//! Local SCTP peers only; 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,
|
||||
}
|
||||
|
||||
async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>)
|
||||
-> (WebRtcSession, Viewer) {
|
||||
let input = Arc::new(InputInjector::without_desktop());
|
||||
let screen = Arc::new(ScreenCapture::unavailable("synthetic pending desktop".into()));
|
||||
let host = WebRtcSession::new(screen, input, crate::signaling::SignalingClient::disconnected(),
|
||||
desktop, crate::session_ice::SessionIce::local(), portal).await.unwrap();
|
||||
let pc = Arc::new(APIBuilder::new().build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
let (tx, messages) = mpsc::unbounded_channel();
|
||||
let mut channels = HashMap::new();
|
||||
for label in ["CONTROL_DATA_CHANNEL"] {
|
||||
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 })
|
||||
}
|
||||
|
||||
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 varint_of(message: &[u8], number: u32) -> Option<u64> {
|
||||
decode_wire(message).ok()?.into_iter().find_map(|field| match (field.number, field.value) {
|
||||
(n, WireValue::Varint(value)) if n == number => Some(value), _ => None,
|
||||
})
|
||||
}
|
||||
fn put_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);
|
||||
}
|
||||
fn field_bytes(number: u32, value: &[u8]) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_varint(((number << 3) | 2) as usize, &mut out);
|
||||
put_varint(value.len(), &mut out);
|
||||
out.extend_from_slice(value);
|
||||
out
|
||||
}
|
||||
fn field_varint(number: u32, value: u64, out: &mut Vec<u8>) {
|
||||
put_varint((number << 3) as usize, out);
|
||||
put_varint(value as usize, out);
|
||||
}
|
||||
/// Message 21 RpcRequest {1 header{1 request_id}, <case>}, the verified viewer shape.
|
||||
fn capture_rpc(request_id: u64, case: u32, setting: &[u8]) -> Vec<u8> {
|
||||
let mut header = Vec::new();
|
||||
field_varint(1, request_id, &mut header);
|
||||
let mut rpc = field_bytes(1, &header);
|
||||
rpc.extend(field_bytes(case, setting));
|
||||
crate::initialization::envelope(11, 0, 21, &rpc)
|
||||
}
|
||||
/// Message 3 SimpleAction action 0: the viewer's FeatureFlag Echo request.
|
||||
fn echo_request(seq: u64) -> Vec<u8> {
|
||||
crate::initialization::envelope(seq, 0, 3, &[8, 0])
|
||||
}
|
||||
async fn receive(messages: &mut Messages, field: u32, within: Duration) -> Option<Vec<u8>> {
|
||||
tokio::time::timeout(within, async {
|
||||
loop {
|
||||
let (channel, message) = messages.recv().await?;
|
||||
if channel == "CONTROL_DATA_CHANNEL" && body(&message, field).is_some() { return Some(message); }
|
||||
}
|
||||
}).await.unwrap_or(None)
|
||||
}
|
||||
/// The Echo response advertises ff_clipboard (FeatureFlag field 8) only when true.
|
||||
fn echo_advertises_clipboard(message: &[u8]) -> bool {
|
||||
body(message, 3).and_then(|action| decode_wire(action).ok()).is_some_and(|action| {
|
||||
action.iter().any(|field| match (field.number, &field.value) {
|
||||
(4, WireValue::Bytes(flags)) => decode_wire(flags).ok().is_some_and(|flags| {
|
||||
flags.iter().any(|flag| flag.number == 8)
|
||||
}),
|
||||
_ => false,
|
||||
})
|
||||
})
|
||||
}
|
||||
fn ready_screen() -> Arc<ScreenCapture> {
|
||||
let mut screen = ScreenCapture::unavailable("synthetic ready desktop".into());
|
||||
screen.backend = crate::desktop_backend::DesktopBackend::Portal;
|
||||
screen.init_error = None;
|
||||
screen.display = "wayland:test".into();
|
||||
screen.width = 1920;
|
||||
screen.height = 1080;
|
||||
Arc::new(screen)
|
||||
}
|
||||
|
||||
/// A Portal screen whose session reports clipboard support, for the refresh path.
|
||||
/// `PortalSession` is a real native handle type, so this uses the manager's own
|
||||
/// test publish hook with a session-less screen and asserts the negative path:
|
||||
/// a ready screen without a Portal session must not advertise ff_clipboard.
|
||||
#[tokio::test]
|
||||
async fn ready_without_portal_session_does_not_advertise_clipboard() {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
let (_, locked) = tokio::sync::watch::channel(Some(false));
|
||||
let portal = Arc::new(crate::desktop_session::PortalDesktop::with_lock_state(
|
||||
Arc::new(ScreenCapture::unavailable("synthetic pending desktop".into())), locked));
|
||||
let (host, mut viewer) = connect(true, Some(portal.clone())).await;
|
||||
// Establish the early Echo while the desktop is still pending: no clipboard claim.
|
||||
viewer.channels["CONTROL_DATA_CHANNEL"].send(&echo_request(3).into()).await.unwrap();
|
||||
let echo = receive(&mut viewer.messages, 3, Duration::from_secs(3)).await.expect("early Echo");
|
||||
assert!(!echo_advertises_clipboard(&echo));
|
||||
// Readiness with no Portal session keeps the capability false and must not
|
||||
// manufacture an unsolicited Echo response from a timer tick.
|
||||
portal.publish_test_screen(ready_screen());
|
||||
assert!(receive(&mut viewer.messages, 3, Duration::from_millis(800)).await.is_none(),
|
||||
"Echo was re-sent without an established clipboard capability");
|
||||
viewer.pc.close().await.unwrap();
|
||||
host.pc.close().await.unwrap();
|
||||
}).await.expect("clipboard capability regression exceeded deadline");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pending_portal_answers_echo_immediately_and_defers_capture_settings() {
|
||||
tokio::time::timeout(Duration::from_secs(30), async {
|
||||
let (_, locked) = tokio::sync::watch::channel(Some(false));
|
||||
let portal = Arc::new(crate::desktop_session::PortalDesktop::with_lock_state(
|
||||
Arc::new(ScreenCapture::unavailable("synthetic pending desktop".into())), locked));
|
||||
let (host, mut viewer) = connect(true, Some(portal.clone())).await;
|
||||
|
||||
// Echo must be answered while the placeholder screen is still pending, and it
|
||||
// must not claim a clipboard bridge that is not established yet.
|
||||
viewer.channels["CONTROL_DATA_CHANNEL"].send(&echo_request(7).into()).await.unwrap();
|
||||
let echo = receive(&mut viewer.messages, 3, Duration::from_secs(3)).await.expect("early Echo was not answered while Portal was pending");
|
||||
assert!(!echo_advertises_clipboard(&echo));
|
||||
let args = body(&echo, 3).and_then(|action| decode_wire(action).ok())
|
||||
.and_then(|action| action.into_iter().find_map(|field| match (field.number, field.value) {
|
||||
(2, WireValue::Bytes(bytes)) => Some(bytes), _ => None,
|
||||
}));
|
||||
assert_eq!(args, Some(br#"{"seq":7}"#.as_slice()));
|
||||
|
||||
// A capture setting arriving during the same pending window is queued, not dropped.
|
||||
let mut setting = Vec::new();
|
||||
field_varint(2, 2, &mut setting); // quality = General (高清 2M)
|
||||
field_varint(18, 30, &mut setting); // fpsCount = 30
|
||||
field_varint(5, 1920, &mut setting);
|
||||
field_varint(6, 1080, &mut setting);
|
||||
viewer.channels["CONTROL_DATA_CHANNEL"].send(&capture_rpc(77, 2, &setting).into()).await.unwrap();
|
||||
assert!(receive(&mut viewer.messages, 22, Duration::from_millis(700)).await.is_none(),
|
||||
"capture setting answered before the desktop was ready");
|
||||
|
||||
// Readiness publishes the real geometry; the queued request is applied and answered.
|
||||
let mut screen = ready_screen();
|
||||
let native = Arc::get_mut(&mut screen).unwrap();
|
||||
native.width = 3840;
|
||||
native.height = 2160;
|
||||
portal.publish_test_screen(screen);
|
||||
let response = receive(&mut viewer.messages, 22, Duration::from_secs(5)).await.expect("deferred capture setting was never answered");
|
||||
let header = body(&response, 22).and_then(|r| body(r, 1)).expect("RpcResponse header");
|
||||
assert_eq!(varint_of(header, 1), Some(77), "deferred reply lost the request id");
|
||||
let inventory = receive(&mut viewer.messages, 7, Duration::from_secs(5)).await.expect("updated ScreenSources");
|
||||
let display = body(&inventory, 7).and_then(|sources| body(sources, 1)).expect("display");
|
||||
// v4 advertises pixels even when the recovered desktop's native size differs.
|
||||
for (field, size) in [(4, (1920, 1080)), (6, (3840, 2160))] {
|
||||
let rect = body(display, field).expect("display rectangle");
|
||||
assert_eq!((varint_of(rect, 3), varint_of(rect, 4)), (Some(size.0), Some(size.1)));
|
||||
assert_eq!((varint_of(rect, 5), varint_of(rect, 6)), (Some(size.0), Some(size.1)));
|
||||
}
|
||||
assert!(decode_wire(display).unwrap().iter().any(|field|
|
||||
field.number == 8 && field.value == WireValue::Fixed64(1.0f64.to_le_bytes())));
|
||||
let sync = receive(&mut viewer.messages, 25, Duration::from_secs(5)).await.expect("CaptureSettingSync");
|
||||
let sync = body(&sync, 25).expect("CaptureSettingSync payload");
|
||||
assert_eq!(varint_of(sync, 1), Some(30));
|
||||
assert_eq!((varint_of(sync, 5), varint_of(sync, 6)), (Some(1920), Some(1080)));
|
||||
|
||||
// CONTROL still serves Echo after readiness, and no timer-driven flood appears.
|
||||
viewer.channels["CONTROL_DATA_CHANNEL"].send(&echo_request(9).into()).await.unwrap();
|
||||
assert!(receive(&mut viewer.messages, 3, Duration::from_secs(3)).await.is_some());
|
||||
assert!(receive(&mut viewer.messages, 3, Duration::from_millis(700)).await.is_none(),
|
||||
"Echo was re-sent without a capability change");
|
||||
|
||||
viewer.pc.close().await.unwrap();
|
||||
host.pc.close().await.unwrap();
|
||||
}).await.expect("pending-Portal lifecycle regression exceeded deadline");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn tool_peer_applies_capture_settings_without_a_desktop() {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
let (host, mut viewer) = connect(false, None).await;
|
||||
let mut setting = Vec::new();
|
||||
field_varint(1, 1280, &mut setting);
|
||||
field_varint(2, 720, &mut setting);
|
||||
viewer.channels["CONTROL_DATA_CHANNEL"].send(&capture_rpc(5, 6, &setting).into()).await.unwrap();
|
||||
let response = receive(&mut viewer.messages, 22, Duration::from_secs(3)).await.expect("tool capture setting was not answered");
|
||||
let header = body(&response, 22).and_then(|r| body(r, 1)).expect("RpcResponse header");
|
||||
assert_eq!(varint_of(header, 1), Some(5));
|
||||
let sync = receive(&mut viewer.messages, 25, Duration::from_secs(3)).await.expect("CaptureSettingSync");
|
||||
let sync = body(&sync, 25).expect("CaptureSettingSync payload");
|
||||
assert_eq!((varint_of(sync, 5), varint_of(sync, 6)), (Some(1280), Some(720)));
|
||||
viewer.pc.close().await.unwrap();
|
||||
host.pc.close().await.unwrap();
|
||||
}).await.expect("tool capture-setting regression exceeded deadline");
|
||||
}
|
||||
Reference in new issue
Block a user