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:
authored and GitHub committed 2026-10-17 10:48:43 +08:00
1 parent 369b493e47
commit bb95774ecb
23 files changed
+2292 -207

No files matched your search

+10 -5
View File
@@ -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();
}
+212
View File
@@ -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");
}
+101
View File
@@ -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})")
}
+567
View File
@@ -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(&current, 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;
}
}
+2 -1
View File
@@ -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());
+67
View File
@@ -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
View File
@@ -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
View File
@@ -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(&current, 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(&current, &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(&current, &recovery, |alive| *alive, || false).unwrap());
assert!(!recovery.lock().unwrap().retired);
assert!(retire_if_closed(&current, &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);
}
}
+6
View File
@@ -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
View File
@@ -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; },
+7
View File
@@ -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
View File
@@ -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
View File
@@ -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(&current, 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(&current, 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))
+224
View File
@@ -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");
}