Initial import of uu-remote-linux

Unofficial Linux host for NetEase UU Remote: X11 (production-tested on
GNOME/Ubuntu 24.04), experimental Wayland (Hyprland) and portal
(GNOME/KDE) backends; video, input, clipboard, file transfer, terminal,
sound, quality/fps/resolution settings, lock/unlock and system actions.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
VallierDevandClaude Opus 5.5 committed 2026-10-14 23:53:16 +08:00
commit 502635b156
176 files changed
+30257

No files matched your search

+92
View File
@@ -0,0 +1,92 @@
//! Desktop sound for the viewer's 声音 menu: the default output's monitor (PulseAudio or
//! PipeWire-pulse) is encoded to Opus by FFmpeg and sent on the negotiated audio m-line.
//! PipeWire monitors ignore the sink's mute by default, so 被控端静音运行 keeps the stream audible.
//! `UU_AUDIO=0` disables it; `UU_AUDIO_SOURCE` picks another Pulse source.
use std::io::Read;
use std::process::{Child, Command, Stdio};
use std::sync::Arc;
use std::time::Duration;
use webrtc::media::io::ogg_reader::OggReader;
use webrtc::media::Sample;
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
use webrtc::peer_connection::RTCPeerConnection;
use webrtc::track::track_local::track_local_static_sample::TrackLocalStaticSample;
/// One Opus packet per Ogg page (FFmpeg -page_duration), 20 ms each.
const FRAME: Duration = Duration::from_millis(20);
pub fn enabled() -> bool { std::env::var("UU_AUDIO").map_or(true, |v| v != "0") }
struct Encoder(Child);
impl Drop for Encoder { fn drop(&mut self) { let _ = self.0.kill(); let _ = self.0.wait(); } }
fn spawn_encoder() -> Result<Encoder, String> {
let source = std::env::var("UU_AUDIO_SOURCE").unwrap_or_else(|_| "@DEFAULT_MONITOR@".into());
let mut command = match crate::config::ffmpeg_root() {
Some(root) => { let mut c = Command::new(root.join("bin/ffmpeg")); c.env("LD_LIBRARY_PATH", root.join("lib/x86_64-linux-gnu")); c }
None => Command::new("ffmpeg"),
};
command.args(["-hide_banner", "-loglevel", "error", "-nostdin",
"-f", "pulse", "-fragment_size", "1920", "-i", &source, "-vn",
"-c:a", "libopus", "-ar", "48000", "-ac", "2", "-b:a", "128k", "-application", "lowdelay",
"-frame_duration", "20", "-page_duration", "20000", "-flush_packets", "1", "-f", "ogg", "pipe:1"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::inherit());
command.spawn().map(Encoder).map_err(|e| format!("Start audio encoder: {e}"))
}
/// Reads Opus packets until the encoder ends or `tx` closes. Blocking.
fn read_packets(stdout: impl Read, tx: &tokio::sync::mpsc::Sender<bytes::Bytes>) -> Result<(), String> {
let (mut reader, _) = OggReader::new(stdout, false).map_err(|e| format!("Audio Ogg header: {e}"))?;
loop {
let (payload, _) = reader.parse_next_page().map_err(|e| format!("Audio Ogg page: {e}"))?;
if payload.starts_with(b"OpusTags") { continue; }
if tx.blocking_send(payload.freeze()).is_err() { return Ok(()); }
}
}
fn closed(pc: &RTCPeerConnection) -> bool {
matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed)
}
/// Streams desktop sound to one viewer until its connection closes; restarts a failed encoder.
pub async fn stream_audio(pc: Arc<RTCPeerConnection>, track: Arc<TrackLocalStaticSample>) {
while pc.connection_state() != RTCPeerConnectionState::Connected {
if closed(&pc) { return; }
tokio::time::sleep(Duration::from_millis(100)).await;
}
let mut failures = 0u32;
while !closed(&pc) {
let mut encoder = match spawn_encoder() {
Ok(encoder) => encoder,
Err(e) => { log::warn!("{e}"); return; }
};
let Some(stdout) = encoder.0.stdout.take() else { return };
let (tx, mut rx) = tokio::sync::mpsc::channel::<bytes::Bytes>(25);
let reader = tokio::task::spawn_blocking(move || read_packets(stdout, &tx));
log::info!("Desktop audio started: opus 48k stereo");
let mut packets = 0u64;
let mut health = tokio::time::interval(Duration::from_millis(500));
loop {
tokio::select! {
packet = rx.recv() => {
let Some(data) = packet else { break };
if let Err(e) = track.write_sample(&Sample { data, duration: FRAME, ..Default::default() }).await {
log::warn!("Audio send: {e}"); break;
}
packets += 1;
},
_ = health.tick() => if closed(&pc) { break },
}
}
drop(rx);
drop(encoder); // kills FFmpeg, which ends the blocking reader
let result = reader.await.unwrap_or_else(|e| Err(e.to_string()));
if closed(&pc) { break; }
log::warn!("Desktop audio stopped after {packets} packets: {:?}", result.err());
failures = if packets > 250 { 0 } else { failures + 1 };
if failures >= 5 { log::warn!("Desktop audio disabled for this connection"); return; }
tokio::time::sleep(Duration::from_secs(2)).await;
}
log::info!("Desktop audio ended");
}
+205
View File
@@ -0,0 +1,205 @@
//! UU Remote Official Authentication & REST Client
use hmac::{Hmac, Mac};
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use serde::{Deserialize, Serialize};
use sha2::Sha256;
use std::collections::BTreeMap;
use std::time::{SystemTime, UNIX_EPOCH};
type HmacSha256 = Hmac<Sha256>;
/// Request-signing key built into the official UU PC client (x-param-plat=1); the same for
/// every user. Config "sign_key" / UU_SIGN_KEY override it if NetEase rotates the key.
pub const DEFAULT_SIGN_KEY: &str = "alWiSzXZTLu3WfFnw13uBru3";
/// API code for an invalid or expired login token ("Token无效或已过期", HTTP 422).
pub const TOKEN_INVALID: i64 = 1120;
#[derive(Debug)]
pub enum RoomError { LoginExpired, Other(String) }
impl std::fmt::Display for RoomError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { RoomError::LoginExpired => f.write_str("login token invalid or expired"), RoomError::Other(e) => f.write_str(e) }
}
}
pub const BASE_URL: &str = "https://api.nrd.nie.163.com";
/// Account binding and request-signing key. Never committed: loaded at startup from
/// a private config file or environment variables (see config.example.json).
#[derive(Clone, Serialize, Deserialize, Default)]
pub struct Credentials {
pub user_id: String,
pub device_id: String,
pub client_id: String,
pub system_id: String,
pub token: String,
pub csrf: String,
/// HMAC-SHA256 key for x-param-sign.
pub sign_key: String,
}
impl std::fmt::Debug for Credentials {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("Credentials { .. }")
}
}
impl Credentials {
/// Environment variables win over the file (UU_USER_ID, UU_DEVICE_ID, UU_CLIENT_ID,
/// UU_SYSTEM_ID, UU_TOKEN, UU_CSRF, UU_SIGN_KEY).
pub fn load(file: Option<&serde_json::Value>) -> Result<Self, String> {
let get = |key: &str| -> String {
std::env::var(format!("UU_{}", key.to_uppercase())).ok().filter(|v| !v.is_empty())
.or_else(|| file.and_then(|f| f.get(key)).and_then(|v| v.as_str()).map(str::to_owned))
.unwrap_or_default()
};
let creds = Self {
user_id: get("user_id"), device_id: get("device_id"), client_id: get("client_id"),
system_id: get("system_id"), token: get("token"), csrf: get("csrf"),
sign_key: Some(get("sign_key")).filter(|k| !k.is_empty()).unwrap_or_else(|| DEFAULT_SIGN_KEY.into()),
};
let missing: Vec<&str> = [("user_id", &creds.user_id), ("device_id", &creds.device_id), ("client_id", &creds.client_id),
("system_id", &creds.system_id), ("token", &creds.token), ("csrf", &creds.csrf), ("sign_key", &creds.sign_key)]
.iter().filter(|(_, v)| v.is_empty()).map(|(k, _)| *k).collect();
if missing.is_empty() { Ok(creds) } else { Err(format!("missing credential settings: {}", missing.join(", "))) }
}
}
#[derive(Debug, Deserialize)]
pub struct ApiResponse<T> {
pub code: i32,
pub msg: String,
pub data: Option<T>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct RoomData {
pub signaling_server: String,
pub token: String,
pub signaling_list: Option<Vec<String>>,
pub ws_connect_timeout_ms: Option<u64>,
}
pub struct UUAuthClient {
pub creds: Credentials,
http: reqwest::Client,
}
impl UUAuthClient {
pub fn new(creds: Credentials) -> Self {
let http = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(12))
.build()
.unwrap();
Self { creds, http }
}
/// 计算网易 NRD HMAC-SHA256 签名
pub fn sign_request(
&self,
method: &str,
path: &str,
headers: &BTreeMap<String, String>,
body_str: &str,
) -> String {
let mut filtered: BTreeMap<String, String> = BTreeMap::new();
for (k, v) in headers {
let kl = k.to_lowercase();
if kl.starts_with("x-param-") && kl != "x-param-sign" {
filtered.insert(kl, v.clone());
}
}
let params_str = filtered
.iter()
.map(|(k, v)| format!("{}={}", k, v))
.collect::<Vec<_>>()
.join("&");
let string_to_sign = format!("{}{}{}{}", method.to_uppercase(), path, params_str, body_str);
let mut mac = HmacSha256::new_from_slice(self.creds.sign_key.as_bytes()).expect("HMAC can take key");
mac.update(string_to_sign.as_bytes());
hex::encode(mac.finalize().into_bytes())
}
pub fn build_headers(
&self,
method: &str,
path: &str,
body_str: &str,
) -> HeaderMap {
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs();
let ts = now.to_string();
let mut param_map = BTreeMap::new();
param_map.insert("x-param-plat".into(), "1".into());
param_map.insert("x-param-vn".into(), "4.42.0.2770".into());
param_map.insert("x-param-vc".into(), "2770".into());
param_map.insert("x-param-pkgn".into(), "com.netease.gameviewer".into());
param_map.insert("x-param-chn".into(), "gwqd".into());
param_map.insert("x-param-lang".into(), "zh-CN".into());
param_map.insert("x-param-cnt".into(), "CN".into());
// Before login some identifiers do not exist yet; absent ones are not sent or signed.
for (key, value) in [("x-param-client-id", &self.creds.client_id), ("x-param-device-id", &self.creds.device_id),
("x-param-system-id", &self.creds.system_id), ("x-param-user-id", &self.creds.user_id)] {
if !value.is_empty() { param_map.insert(key.into(), value.clone()); }
}
param_map.insert("x-param-ts".into(), ts);
let sign = self.sign_request(method, path, &param_map, body_str);
let mut headers = HeaderMap::new();
headers.insert("Content-Type", HeaderValue::from_static("application/json"));
headers.insert("Accept", HeaderValue::from_static("application/json"));
headers.insert(
"User-Agent",
HeaderValue::from_static("UURemote/4.42.0 (Windows NT 10.0; Win64; x64)"),
);
if !self.creds.token.is_empty() {
if let Ok(v) = HeaderValue::from_str(&format!("Bearer {}", self.creds.token)) { headers.insert("Authorization", v); }
if let Ok(v) = HeaderValue::from_str(&format!("nrd_access_token={}; nrd_csrf_access_token={}", self.creds.token, self.creds.csrf)) {
headers.insert("Cookie", v);
}
if let Ok(v) = HeaderValue::from_str(&self.creds.csrf) { headers.insert("X-CSRF-TOKEN", v); }
}
for (k, v) in param_map {
if let Ok(name) = HeaderName::from_bytes(k.as_bytes()) {
if let Ok(val) = HeaderValue::from_str(&v) {
headers.insert(name, val);
}
}
}
headers.insert("X-Param-SIGN", HeaderValue::from_str(&sign).unwrap());
headers
}
/// Signed JSON POST; returns (HTTP status, decoded body).
pub async fn post_json(&self, path: &str, body: &serde_json::Value) -> Result<(u16, serde_json::Value), String> {
let body_str = serde_json::to_string(body).map_err(|e| e.to_string())?;
let resp = self.http.post(format!("{}{}", BASE_URL, path))
.headers(self.build_headers("POST", path, &body_str)).body(body_str)
.send().await.map_err(|e| format!("HTTP post {path} failed: {e}"))?;
let status = resp.status().as_u16();
let value = resp.json().await.unwrap_or(serde_json::Value::Null);
Ok((status, value))
}
/// 向网易服务器请求创建房间,获取最新的信令服务器与鉴权 Token
pub async fn create_room(&self) -> Result<RoomData, RoomError> {
let (status, body) = self.post_json("/api/v1/room/create", &serde_json::json!({})).await.map_err(RoomError::Other)?;
let code = body.get("code").and_then(|c| c.as_i64()).unwrap_or(-1);
if code == TOKEN_INVALID { return Err(RoomError::LoginExpired); }
if status == 200 && code == 0 {
if let Some(data) = body.get("data") {
return serde_json::from_value(data.clone()).map_err(|e| RoomError::Other(format!("room data decode failed: {e}")));
}
}
Err(RoomError::Other(format!("create_room error http {status} code {code}: {}",
body.get("msg").and_then(|m| m.as_str()).unwrap_or(""))))
}
}
+75
View File
@@ -0,0 +1,75 @@
//! Wire payloads reconstructed from the official libstreamer ARM64 serializers.
//! See analysis/protocol-fix-20261013/datachannel for address-bound evidence.
//! These payloads do not claim server acceptance or invent missing handshake steps.
use serde_json::{json, Value};
pub const ICE_FINISHED_EVENT: &str = "ice_finished_log";
pub const FORWARD_SETTING_EVENT: &str = "forward_setting";
pub const VIDEO_CODEC_H264: i32 = 1;
pub const CODEC_IMPL_NVENC: i32 = 0;
/// Official serializer emits exactly two string fields (0x107190).
/// The event is telemetry emitted for official pc::State 6; it is not an ACK.
pub fn ice_finished(ice_id: &str, app_control_id: &str) -> Value {
json!({"ice_id": ice_id, "app_control_id": app_control_id})
}
/// Supply the stable id of a display that this host can actually capture.
/// Official Mac display construction uses type 0 and HDR disabled value 0.
/// `codec_impl` is caller-selected: the observed names are 0 NVENC, 1 AMD AMF,
/// 2 Intel QSV, 3 VideoToolbox, 4 MediaCodec; values >=5 log as SoftWare.
/// Using 5 as software is an inference and must be runtime-validated by caller.
pub fn h264_device_capability(
client_id: &str,
ice_id: &str,
display_id: i32,
fps: i32,
codec_impl: i32,
) -> Value {
json!({
"client_id": client_id,
"type": "device_capability",
"data": {
"display_info": [{"id": display_id, "fps": fps, "type": 0, "hdr": 0}],
"video_codec_capability": [{
"video_codec": VIDEO_CODEC_H264,
"chroma_sampling": 1,
"codec_impl": codec_impl,
"bit_depth": 8
}],
"ice_id": ice_id
}
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ice_finished_keeps_string_identifiers_and_exact_fields() {
let payload = ice_finished("ice-example", "control-example");
assert_eq!(payload.as_object().unwrap().len(), 2);
assert!(payload["ice_id"].is_string());
assert_eq!(payload["app_control_id"], "control-example");
assert_eq!(ICE_FINISHED_EVENT, "ice_finished_log");
}
#[test]
fn device_capability_uses_object_data_and_string_ice_id() {
let payload = h264_device_capability("client-example", "ice-example", 11, 60, 0);
assert_eq!(payload["type"], "device_capability");
assert!(payload["data"].is_object());
assert_eq!(payload["data"]["ice_id"], "ice-example");
let display = &payload["data"]["display_info"][0];
assert_eq!(display.as_object().unwrap().len(), 4);
assert_eq!(display["id"], 11);
assert_eq!(display["fps"], 60);
let codec = &payload["data"]["video_codec_capability"][0];
assert_eq!(codec.as_object().unwrap().len(), 4);
assert_eq!(codec["video_codec"], 1);
assert_eq!(codec["codec_impl"], 0);
assert_eq!(codec["bit_depth"], 8);
}
}
+142
View File
@@ -0,0 +1,142 @@
//! Native Linux X11 Capture Engine via XShm
use std::sync::Mutex;
#[cfg(target_os = "linux")]
extern "C" {
fn x11_init(display_name: *const libc::c_char) -> libc::c_int;
fn x11_get_dimensions(out_w: *mut libc::c_int, out_h: *mut libc::c_int) -> libc::c_int;
fn x11_capture_frame(
out_buffer: *mut libc::c_uchar,
out_w: *mut libc::c_int,
out_h: *mut libc::c_int,
) -> libc::c_int;
fn x11_close();
fn x11_wake_display() -> libc::c_int;
fn x11_display_name() -> *const libc::c_char;
}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_init(_: *const libc::c_char) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_get_dimensions(out_w: *mut libc::c_int, out_h: *mut libc::c_int) -> libc::c_int {
*out_w = 1920;
*out_h = 1080;
0
}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_capture_frame(
out_buffer: *mut libc::c_uchar,
out_w: *mut libc::c_int,
out_h: *mut libc::c_int,
) -> libc::c_int {
*out_w = 1920;
*out_h = 1080;
std::ptr::write_bytes(out_buffer, 0, (1920 * 1080 * 4) as usize);
0
}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_close() {}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_display_name() -> *const libc::c_char { b":0\0".as_ptr().cast() }
pub struct ScreenCapture {
pub backend: crate::desktop_backend::DesktopBackend,
pub init_error: Option<String>,
pub portal: Option<std::sync::Arc<crate::portal::PortalSession>>,
pub display: String,
pub width: u32,
pub height: u32,
buffer: Mutex<Vec<u8>>,
}
impl ScreenCapture {
pub fn new() -> Result<Self, String> {
let backend=crate::desktop_backend::detect()?;
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),display:"wayland:portal".into(),width,height,
buffer:Mutex::new(vec![0;(width as usize)*(height as usize)*4]) });
}
if backend == crate::desktop_backend::DesktopBackend::Wayland {
let (width,height)=crate::wayland::init()?;
return Ok(Self { backend, init_error:None, portal:None, display:"wayland:native".into(), width,height,
buffer:Mutex::new(vec![0;(width as usize)*(height as usize)*4]) });
}
let ret = unsafe { x11_init(std::ptr::null()) };
if ret != 0 {
return Err(format!("x11_init failed with code {}", ret));
}
let mut w: libc::c_int = 0;
let mut h: libc::c_int = 0;
unsafe { x11_get_dimensions(&mut w, &mut h) };
if w <= 0 || h <= 0 {
return Err(format!("Invalid screen dimensions: {}x{}", w, h));
}
let buf_size = (w * h * 4) as usize;
let buffer = Mutex::new(vec![0u8; buf_size]);
log::info!("ScreenCapture initialized: {}x{}", w, h);
let display_ptr = unsafe { x11_display_name() };
if display_ptr.is_null() { return Err("Capture display name unavailable".into()); }
let display = unsafe { std::ffi::CStr::from_ptr(display_ptr) }.to_string_lossy().into_owned();
log::info!("Selected capture display: {}", display);
Ok(Self {
backend,
init_error:None,
portal:None,
display,
width: w as u32,
height: h as u32,
buffer,
})
}
/// Metadata for non-desktop tools. Never advertise a usable fake screen.
pub fn unavailable(error:String)->Self {
Self { backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11),
init_error:Some(error), portal:None, display:String::new(), width:0,height:0,buffer:Mutex::new(Vec::new()) }
}
/// 截取一帧 BGRA 图像
pub fn capture_frame(&self) -> Result<Vec<u8>, String> {
if let Some(error)=&self.init_error { return Err(error.clone()); }
let mut buf = self.buffer.lock().unwrap();
if let Some(session)=&self.portal { session.capture(&mut buf)?; return Ok(buf.clone()); }
if self.backend == crate::desktop_backend::DesktopBackend::Wayland {
crate::wayland::capture(&mut buf)?;
return Ok(buf.clone());
}
let mut w: libc::c_int = self.width as libc::c_int;
let mut h: libc::c_int = self.height as libc::c_int;
let ret = unsafe { x11_capture_frame(buf.as_mut_ptr(), &mut w, &mut h) };
if ret != 0 {
return Err(format!("x11_capture_frame failed with code {}", ret));
}
Ok(buf.clone())
}
}
impl Drop for ScreenCapture {
fn drop(&mut self) {
if self.init_error.is_none() && self.backend==crate::desktop_backend::DesktopBackend::X11 { unsafe { x11_close() }; }
}
}
/// 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::Portal { return Ok(()); }
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Wayland {
return crate::wayland::wake();
}
#[cfg(target_os = "linux")]
if unsafe { x11_wake_display() } != 0 { return Err("X11 display wake failed".into()); }
Ok(())
}
+237
View File
@@ -0,0 +1,237 @@
//! Viewer quality/frame-rate settings (画质 / 帧率) for the desktop stream.
//!
//! The viewer only sends settings to a host whose echo FeatureFlag declares ff_capture_setting
//! (field 1); our echo declares FF_CAPTURE_SETTING_CUSTOM_BITRATE = 4. Requests arrive as
//! Message 21 RpcRequest { 1 RequestHeader, 2 CaptureSettingRequest | 3 FpsSettingRequest |
//! 4 VideoQualitySettingReqeust } and are answered with Message 22 RpcResponse { 1 ResponseHeader
//! (same request_id), 2 CaptureSettingResponse { 1 errors (none = applied) } }. The applied values
//! are then reported with Message 25 CaptureSettingSync. Field maps: server-field-maps.json.
use crate::protocol::{decode_wire, WireField, WireValue};
use tokio::sync::watch;
/// Official GvPb_VideoQuality values.
pub const QUALITY_FAST: u64 = 1;
pub const QUALITY_GENERAL: u64 = 2;
pub const QUALITY_HD: u64 = 3;
pub const QUALITY_BLURAY: u64 = 4;
pub const QUALITY_AUTO: u64 = 5;
pub const QUALITY_CUSTOM: u64 = 6;
/// FeatureFlag.ff_capture_setting we declare: fps, preset quality and custom bitrate.
/// (Chroma 4:4:4, DPI scaling and HDR are higher versions and are not implemented.)
pub const FEATURE_VERSION: u64 = 4;
const MIN_FPS: u32 = 5;
const MAX_FPS: u32 = 144;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct VideoSettings {
pub fps: u32,
pub quality: u64,
/// Viewer max_custom_bitrate (only used for QUALITY_CUSTOM): Mbit/s, or kbit/s above 1000.
pub custom_mbps: u32,
/// Scaled stream size (其他分辨率); None streams the native desktop size.
pub output: Option<(u32, u32)>,
}
impl Default for VideoSettings {
fn default() -> Self { Self { fps: 60, quality: QUALITY_AUTO, custom_mbps: 0, output: None } }
}
/// Selectable smaller stream sizes with the desktop's aspect ratio (even dimensions).
/// The host display itself is never reconfigured; the encoder scales.
pub fn scaled_sizes(native: (u32, u32)) -> Vec<(u32, u32)> {
[5u32, 4, 3, 2].iter().map(|sixths| (native.0 * sixths / 6 & !1, native.1 * sixths / 6 & !1))
.filter(|(w, h)| *w >= 640 && *h >= 360).collect()
}
/// Requested size clamped to the desktop: None (native) when at least as large.
fn clamp_output(native: (u32, u32), width: u64, height: u64) -> Option<(u32, u32)> {
if width == 0 || height == 0 { return None; }
if width >= u64::from(native.0) || height >= u64::from(native.1) { return None; }
Some(((width as u32).max(320) & !1, (height as u32).max(180) & !1))
}
impl VideoSettings {
/// Constant-quality level: presets must look different even on a mostly static desktop,
/// where a bitrate cap alone never binds (measured ~2.7 Mbit/s at CQ18).
pub fn cq(&self) -> u32 {
match self.quality { QUALITY_BLURAY => 17, QUALITY_HD => 21, QUALITY_GENERAL => 26, QUALITY_FAST => 30, _ => 18 }
}
/// Encoder bitrate cap in kbit/s; None keeps the constant-quality default (自动).
/// Preset caps follow the viewer menu labels: 高清 2M, 超清 8M, 原画 20M.
pub fn max_kbps(&self) -> Option<u32> {
match self.quality {
QUALITY_FAST => Some(1_000),
QUALITY_GENERAL => Some(2_000),
QUALITY_HD => Some(8_000),
QUALITY_BLURAY => Some(20_000),
QUALITY_CUSTOM if self.custom_mbps > 0 =>
Some(if self.custom_mbps > 1_000 { self.custom_mbps } else { self.custom_mbps * 1_000 }.min(100_000)),
_ => None,
}
}
}
fn varint(mut v: u64, out: &mut Vec<u8>) { while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; } out.push(v as u8); }
fn put_varint(field: u64, v: u64, out: &mut Vec<u8>) { varint(field << 3, out); varint(v, out); }
fn put_bytes(field: u64, v: &[u8], out: &mut Vec<u8>) { varint(field << 3 | 2, out); varint(v.len() as u64, out); out.extend_from_slice(v); }
fn number(fields: &[WireField], n: u32) -> Option<u64> {
fields.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Varint(v)) if x == n => Some(*v), _ => None })
}
fn message<'a>(fields: &[WireField<'a>], n: u32) -> Option<&'a [u8]> {
fields.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Bytes(b)) if x == n => Some(*b), _ => None })
}
/// Frame rate from a value that is either an fps option index (observed 1 = 30, 2 = 60;
/// 3/4 assumed 90/144 from the menu order) or already frames per second.
fn fps_from_option(value: u64) -> Option<u64> {
match value { 0 => None, 1 => Some(30), 2 => Some(60), 3 => Some(90), 4 => Some(144), v => Some(v) }
}
/// Applies a capture-setting RPC to `settings` and returns the RpcResponse payload (Message 22),
/// or None when the RPC is not a capture/fps/quality setting.
pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32)) -> Option<Vec<u8>> {
let header = message(rpc, 1).unwrap_or(&[]);
let mut next = *settings.borrow();
if let Some(request) = message(rpc, 2) {
let fields = decode_wire(request).ok()?;
// Numbers only: fps, quality, bitrate, resolution and flags carry no user content.
log::info!("Capture setting request: {:?}", fields.iter().filter_map(|f| match f.value {
WireValue::Varint(v) => Some((f.number, v)), _ => None }).collect::<Vec<_>>());
// Field 1 is the viewer's fps option index (1 = 30, 2 = 60, ...); 18 fpsCount is the frame rate.
if let Some(fps) = number(&fields, 18).filter(|v| *v > 0).or_else(|| number(&fields, 1).and_then(fps_from_option)) { next.fps = fps as u32; }
if let Some(quality) = number(&fields, 2).filter(|v| *v > 0) { next.quality = quality; }
if let Some(bitrate) = number(&fields, 8).filter(|v| *v > 0) { next.custom_mbps = bitrate as u32; }
// ChooseResolutionType 3 = follow remote (native); otherwise pixel size, else logical size.
if number(&fields, 10) == Some(3) { next.output = None; }
else if let Some((w, h)) = number(&fields, 16).zip(number(&fields, 17)).or_else(|| number(&fields, 5).zip(number(&fields, 6))) {
next.output = clamp_output(native, w, h);
}
} else if let Some(request) = message(rpc, 6) {
let fields = decode_wire(request).ok()?;
let (w, h) = (number(&fields, 1).unwrap_or(0), number(&fields, 2).unwrap_or(0));
log::info!("Resolution setting request: {}x{}", w, h);
next.output = clamp_output(native, w, h);
} else if let Some(request) = message(rpc, 3) {
let fields = decode_wire(request).ok()?;
log::info!("Fps setting request: fps={:?}", number(&fields, 1));
if let Some(fps) = number(&fields, 1).and_then(fps_from_option) { next.fps = fps as u32; }
} else if let Some(request) = message(rpc, 4) {
let fields = decode_wire(request).ok()?;
log::info!("Video quality setting request: quality={:?}", number(&fields, 1));
if let Some(quality) = number(&fields, 1).filter(|v| *v > 0) { next.quality = quality; }
} else {
return None;
}
next.fps = next.fps.clamp(MIN_FPS, MAX_FPS);
settings.send_if_modified(|current| if *current != next {
log::info!("Desktop video settings: fps={} quality={} max_kbps={:?} output={:?}", next.fps, next.quality, next.max_kbps(), next.output);
*current = next; true
} else { false });
let mut out = Vec::new();
put_bytes(1, header, &mut out);
put_bytes(2, &[], &mut out); // CaptureSettingResponse without errors: applied
Some(out)
}
/// Message 7 ScreenSources for the single desktop: native size, scaled choices, current size.
pub fn screen_sources(seq: u64, timestamp: u64, native: (u32, u32), output: Option<(u32, u32)>, name: &str) -> Result<Vec<u8>, String> {
use crate::initialization::{Screen, WinRect};
let (w, h) = (native.0 as i32, native.1 as i32);
let scaled: Vec<(i32, i32)> = scaled_sizes(native).into_iter().map(|(w, h)| (w as i32, h as i32)).collect();
let resolution = WinRect { left: 0, top: 0, width: w, height: h, pixel_width: w, pixel_height: h };
let screens = [Screen { id: 0, fps: crate::video::FPS as i32, resolution, primary: true, dpr: 1.0,
display_name: name, video_track_index: 0, screen_type: 0, builtin_screen_type: 0,
scaled: &scaled, current: output.map(|(w, h)| (w as i32, h as i32)) }];
crate::initialization::encode_screen_sources(seq, timestamp, &screens, 0)
}
/// Message 25 CaptureSettingSync payload reporting what the host now encodes.
pub fn sync_payload(settings: &VideoSettings, native: (u32, u32)) -> Vec<u8> {
let size = settings.output.unwrap_or(native);
let mut out = Vec::new();
put_varint(1, u64::from(settings.fps), &mut out);
put_varint(2, settings.quality, &mut out);
put_varint(3, 1, &mut out); // ChromaFormat_420
if settings.custom_mbps > 0 { put_varint(4, u64::from(settings.custom_mbps), &mut out); }
put_varint(5, u64::from(size.0), &mut out);
put_varint(6, u64::from(size.1), &mut out);
put_varint(9, u64::from(size.0), &mut out);
put_varint(10, u64::from(size.1), &mut out);
out
}
#[cfg(test)]
mod tests {
use super::*;
fn rpc(request_id: u64, field: u64, body: &[u8]) -> Vec<u8> {
let mut header = Vec::new();
put_varint(1, request_id, &mut header);
let mut out = Vec::new();
put_bytes(1, &header, &mut out);
put_bytes(field, body, &mut out);
out
}
#[test]
fn capture_setting_request_updates_fps_and_quality_and_echoes_request_id() {
let (tx, rx) = watch::channel(VideoSettings::default());
let mut body = Vec::new();
put_varint(1, 1, &mut body); // option index, not fps
put_varint(2, QUALITY_GENERAL, &mut body);
put_varint(18, 30, &mut body);
let request = rpc(77, 2, &body);
let response = handle_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(*rx.borrow(), VideoSettings { fps: 30, quality: QUALITY_GENERAL, custom_mbps: 0, output: None });
assert_eq!(rx.borrow().max_kbps(), Some(2_000));
let fields = decode_wire(&response).unwrap();
assert_eq!(message(&fields, 1), Some(&[8u8, 77][..]));
assert_eq!(message(&fields, 2), Some(&[][..]));
}
#[test]
fn separate_fps_and_quality_requests_and_limits() {
let (tx, rx) = watch::channel(VideoSettings::default());
handle_rpc(&decode_wire(&rpc(1, 3, &[8, 200, 1])).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().fps, MAX_FPS);
// Observed viewer request: option 2 with fpsCount 60 must stream 60 fps, not 2.
let observed = [8, 2, 16, 4, 40, 128, 15, 48, 184, 8, 144, 1, 60];
handle_rpc(&decode_wire(&rpc(4, 2, &observed)).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().fps, 60);
handle_rpc(&decode_wire(&rpc(2, 4, &[8, QUALITY_BLURAY as u8])).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().max_kbps(), Some(20_000));
assert!(handle_rpc(&decode_wire(&rpc(3, 9, &[])).unwrap(), &tx, (1920, 1080)).is_none());
}
#[test]
fn resolution_requests_scale_below_native_only() {
let (tx, rx) = watch::channel(VideoSettings::default());
handle_rpc(&decode_wire(&rpc(1, 6, &[8, 128, 10, 16, 208, 5])).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().output, Some((1280, 720)));
handle_rpc(&decode_wire(&rpc(2, 6, &[8, 160, 32, 16, 160, 20])).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().output, None);
assert_eq!(scaled_sizes((1920, 1080)), vec![(1600, 900), (1280, 720), (960, 540), (640, 360)]);
}
#[test]
fn auto_quality_keeps_constant_quality_encoding() {
assert_eq!(VideoSettings::default().max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_mbps: 0, ..Default::default() }.max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_mbps: 12, ..Default::default() }.max_kbps(), Some(12_000));
}
#[test]
fn sync_reports_fps_quality_and_resolution() {
let payload = sync_payload(&VideoSettings::default(), (1920, 1080));
let fields = decode_wire(&payload).unwrap();
assert_eq!(number(&fields, 1), Some(60));
assert_eq!(number(&fields, 2), Some(QUALITY_AUTO));
assert_eq!(number(&fields, 5), Some(1920));
assert_eq!(number(&fields, 10), Some(1080));
}
}
+193
View File
@@ -0,0 +1,193 @@
//! Session-scoped native X11 text selection worker. No content is logged.
use tokio::sync::watch;
// Keep worst-case UTF-16 plus protobuf framing below webrtc0.10's65535-byte reader.
pub const MAX_TEXT: usize = 30 * 1024;
pub struct ClipboardBridge {
pub incoming: watch::Sender<Option<String>>,
pub outgoing: watch::Receiver<Option<String>>,
pub ready: tokio::sync::oneshot::Receiver<bool>,
}
#[cfg(target_os = "linux")]
extern "C" {
fn clipboard_open(display: *const libc::c_char) -> *mut libc::c_void;
fn clipboard_set(handle: *mut libc::c_void, text: *const u8, length: usize) -> libc::c_int;
fn clipboard_poll(handle: *mut libc::c_void, out: *mut u8, capacity: usize) -> libc::c_int;
fn clipboard_close(handle: *mut libc::c_void);
}
pub fn start(display: String) -> ClipboardBridge {
if display == "wayland:native" { return start_wayland(); }
if display == "wayland:portal" {
let (incoming,_)=watch::channel(None);let (_,outgoing)=watch::channel(None);
let (sender,ready)=tokio::sync::oneshot::channel();let _=sender.send(false);
return ClipboardBridge {incoming,outgoing,ready};
}
let (incoming, mut input) = watch::channel::<Option<String>>(None);
let (output, outgoing) = watch::channel(None);
let (ready_tx, ready) = tokio::sync::oneshot::channel();
#[cfg(target_os = "linux")]
tokio::task::spawn_blocking(move || {
let Ok(display) = std::ffi::CString::new(display) else {
let _ = ready_tx.send(false); return;
};
let handle = unsafe { clipboard_open(display.as_ptr()) };
if handle.is_null() { let _ = ready_tx.send(false); return; }
let _ = ready_tx.send(true);
let mut buffer = vec![0; MAX_TEXT];
while !output.is_closed() && input.has_changed().is_ok() {
if input.has_changed().unwrap_or(false) {
let text = input.borrow_and_update().clone();
if let Some(text) = text {
if text.len() <= MAX_TEXT {
let result = unsafe { clipboard_set(handle, text.as_ptr(), text.len()) };
if result != 0 { log::warn!("Native clipboard ownership failed"); }
}
}
}
let length = unsafe { clipboard_poll(handle, buffer.as_mut_ptr(), buffer.len()) };
if length >= 0 {
if let Ok(text) = std::str::from_utf8(&buffer[..length as usize]) {
output.send_replace(Some(text.to_owned()));
}
}
std::thread::sleep(std::time::Duration::from_millis(10));
}
unsafe { clipboard_close(handle) };
});
#[cfg(not(target_os = "linux"))]
{
let _ = (display, input, output);
let _ = ready_tx.send(false);
}
ClipboardBridge { incoming, outgoing, ready }
}
fn start_wayland() -> ClipboardBridge {
use tokio::io::{AsyncReadExt,AsyncWriteExt};
use std::process::Stdio;
let (incoming,mut input)=watch::channel::<Option<String>>(None);
let (output,outgoing)=watch::channel(None);
let (ready_tx,ready)=tokio::sync::oneshot::channel();
tokio::spawn(async move {
for program in ["wl-copy","wl-paste"] {
let result=tokio::time::timeout(std::time::Duration::from_secs(2),
tokio::process::Command::new(program).arg("--version").kill_on_drop(true)
.stdout(Stdio::null()).stderr(Stdio::null()).status()).await;
if !matches!(result,Ok(Ok(status)) if status.success()) { let _=ready_tx.send(false); return; }
}
let _=ready_tx.send(true);
let mut owner:Option<tokio::process::Child>=None;
let mut last=None;
let mut tick=tokio::time::interval(std::time::Duration::from_millis(250));
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
tokio::select! {
_=output.closed()=>break,
changed=input.changed()=>{
if changed.is_err() { break; }
let text=input.borrow_and_update().clone();
if let Some(text)=text.filter(|s|s.len()<=MAX_TEXT) {
if let Some(mut child)=owner.take() { let _=child.kill().await; }
if let Ok(mut child)=tokio::process::Command::new("wl-copy")
.args(["--foreground","--type","text/plain;charset=utf-8"])
.stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::null()).kill_on_drop(true).spawn() {
if let Some(mut stdin)=child.stdin.take() {
let written=tokio::time::timeout(std::time::Duration::from_secs(2),stdin.write_all(text.as_bytes())).await;
if matches!(written,Ok(Ok(()))) { last=Some(text); }
}
owner=Some(child);
}
}
},
_=tick.tick()=>{
// Bound both content and duration; never log clipboard text.
let read=async {
let mut child=tokio::process::Command::new("wl-paste").args(["--no-newline","--type","text"])
.stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().ok()?;
let mut bytes=Vec::new();
child.stdout.take()?.take((MAX_TEXT+1) as u64).read_to_end(&mut bytes).await.ok()?;
if bytes.len()>MAX_TEXT { return None; }
if !child.wait().await.ok()?.success() { return None; }
String::from_utf8(bytes).ok()
};
if let Ok(Some(text))=tokio::time::timeout(std::time::Duration::from_secs(2),read).await {
if last.as_ref()!=Some(&text) { last=Some(text.clone()); output.send_replace(Some(text)); }
}
},
}
}
if let Some(mut child)=owner { let _=child.kill().await; }
});
ClipboardBridge { incoming,outgoing,ready }
}
#[cfg(all(test,target_os="linux",feature="wayland"))]
mod wayland_acceptance {
use super::*;
use tokio::io::AsyncWriteExt;
use std::process::Stdio;
#[tokio::test]
#[ignore = "requires the isolated uu-hyprland-test desktop"]
async fn native_clipboard_roundtrip() {
assert!(std::fs::read_to_string("/proc/sys/kernel/hostname").unwrap().trim()=="uu-hyprland-test",
"Refusing to alter clipboard outside the isolated test VM");
assert!(std::env::var_os("WAYLAND_DISPLAY").is_some());
let mut bridge=start("wayland:native".into());
assert!(tokio::time::timeout(std::time::Duration::from_secs(3),&mut bridge.ready).await.unwrap().unwrap());
let incoming="UU Wayland test\n中文 ✓";
bridge.incoming.send_replace(Some(incoming.into()));
let received=tokio::time::timeout(std::time::Duration::from_secs(3),async {
loop {
use tokio::io::AsyncReadExt;
let mut child=tokio::process::Command::new("wl-paste").args(["--no-newline","--type","text"])
.kill_on_drop(true).stdout(Stdio::piped()).stderr(Stdio::null()).spawn().unwrap();
let mut bytes=Vec::new();
child.stdout.take().unwrap().take((MAX_TEXT+1) as u64).read_to_end(&mut bytes).await.unwrap();
if bytes.len()<=MAX_TEXT && child.wait().await.unwrap().success() && bytes==incoming.as_bytes() { break; }
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
}
}).await;
assert!(received.is_ok(),"Native clipboard did not receive inbound text");
let mut owner=tokio::process::Command::new("wl-copy").args(["--foreground","--type","text/plain;charset=utf-8"])
.stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let external="UU native outbound test";
let mut pipe=owner.stdin.take().unwrap(); pipe.write_all(external.as_bytes()).await.unwrap(); drop(pipe);
let changed=tokio::time::timeout(std::time::Duration::from_secs(3),async {
loop {
bridge.outgoing.changed().await.unwrap();
if bridge.outgoing.borrow_and_update().as_deref()==Some(external) { break; }
}
}).await;
assert!(changed.is_ok(),"Bridge did not report native outbound text");
drop(bridge);
owner.kill().await.unwrap();
}
}
/// Portal Clipboard shares the authorized video/input Arc and survives native handle renewal.
pub fn start_portal(session: std::sync::Arc<crate::portal::PortalSession>) -> ClipboardBridge {
let (incoming,mut input)=watch::channel::<Option<String>>(None);
let (output,outgoing)=watch::channel(None);
let (ready_tx,ready)=tokio::sync::oneshot::channel();
tokio::task::spawn_blocking(move || {
let available=session.clipboard_ready(); let _=ready_tx.send(available);
if !available { return; }
let mut last=None; let mut pending=None;
while !output.is_closed() && input.has_changed().is_ok() {
if input.has_changed().unwrap_or(false) {
pending=input.borrow_and_update().clone().filter(|text|text.len()<=MAX_TEXT);
}
if let Some(text)=pending.as_ref() {
if session.clipboard_set(text).is_ok() { last=pending.take(); }
}
if let Some(text)=session.clipboard_poll() {
if last.as_ref()!=Some(&text) { last=Some(text.clone()); output.send_replace(Some(text)); }
}
std::thread::sleep(std::time::Duration::from_millis(100));
}
});
ClipboardBridge {incoming,outgoing,ready}
}
+68
View File
@@ -0,0 +1,68 @@
//! Synthetic clipboard acceptance; never prints clipboard data.
use std::{io::{BufRead,BufReader,Write},process::{Command,Stdio},sync::Arc,time::{Duration,Instant}};
pub fn run() -> Result<(),String> {
if std::fs::read_to_string("/proc/sys/kernel/hostname").unwrap_or_default().trim()!="uu-hyprland-test" {
return Err("Clipboard acceptance is restricted to the isolated VM".into());
}
let session=Arc::new(crate::portal::PortalSession::open()?);
let bridge=crate::clipboard::start_portal(session.clone());
if !bridge.ready.blocking_recv().unwrap_or(false) { return Err("Portal clipboard permission not granted".into()); }
let mut child=Command::new("python3").arg("/home/uuremote/clipboard-acceptance.py")
.env("GDK_BACKEND","wayland").env("GSK_RENDERER","cairo")
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).spawn().map_err(|_|"Start GTK clipboard fixture")?;
let result=(|| {
let mut writer=child.stdin.take().ok_or("Clipboard fixture stdin missing")?;
let mut reader=BufReader::new(child.stdout.take().ok_or("Clipboard fixture stdout missing")?);
let mut line=String::new(); reader.read_line(&mut line).map_err(|_|"Clipboard fixture not ready")?;
let ready:serde_json::Value=serde_json::from_str(&line).map_err(|_|"Invalid clipboard fixture readiness")?;
if ready["ready"]!=true || ready["native_wayland"]!=true { return Err("Clipboard fixture is not native Wayland".into()); }
std::thread::sleep(Duration::from_secs(2));
let mut outgoing=bridge.outgoing;
let mut check=|op:&str,text:&str|->Result<bool,String> {
writeln!(writer,"{}",serde_json::json!({"op":op,"text":text})).map_err(|_|"Clipboard fixture write failed")?;
writer.flush().map_err(|_|"Clipboard fixture write failed")?;
let mut line=String::new();reader.read_line(&mut line).map_err(|_|"Clipboard fixture read failed")?;
let result:serde_json::Value=serde_json::from_str(&line).map_err(|_|"Invalid clipboard fixture result")?;
Ok(result["ok"]==true)
};
for (name,text) in [("unicode", "UU incoming 中文🙂\nsecond line".to_owned()),("empty",String::new()),("maximum_utf8","中".repeat(crate::clipboard::MAX_TEXT/3))] {
bridge.incoming.send_replace(Some(text.clone()));
let deadline=Instant::now()+Duration::from_secs(6);let mut matched=false;
while Instant::now()<deadline { if check("read",&text)? {matched=true;break;} std::thread::sleep(Duration::from_millis(100)); }
if !matched { return Err(format!("Portal clipboard incoming {name} mismatch")); }
std::thread::sleep(Duration::from_millis(300));
if outgoing.has_changed().unwrap_or(false) { return Err("Portal clipboard echoed its own selection".into()); }
println!("Portal clipboard incoming {name}: passed; no echo");
}
session.move_pointer(f64::from(session.width)/2.0,f64::from(session.height)/2.0,false)?;
session.button(1,true)?; session.button(1,false)?;
std::thread::sleep(Duration::from_millis(300));
let external="UU outgoing 中文🚀\nsecond line";
if !check("set",external)? { return Err("GTK clipboard ownership failed".into()); }
let deadline=Instant::now()+Duration::from_secs(6);let mut matched=false;
while Instant::now()<deadline {
if outgoing.has_changed().unwrap_or(false) && outgoing.borrow_and_update().as_deref()==Some(external) {matched=true;break;}
std::thread::sleep(Duration::from_millis(100));
}
if !matched { return Err("Portal clipboard outgoing Unicode mismatch".into()); }
println!("Portal clipboard outgoing unicode: passed");
bridge.incoming.send_replace(Some("x".repeat(crate::clipboard::MAX_TEXT+1)));
std::thread::sleep(Duration::from_millis(400));
if !check("read",external)? { return Err("Oversized text altered native clipboard".into()); }
println!("Portal clipboard incoming oversized rejection: passed");
if !check("set",&"y".repeat(crate::clipboard::MAX_TEXT+1))? { return Err("GTK oversized fixture setup failed".into()); }
std::thread::sleep(Duration::from_secs(3));
if outgoing.has_changed().unwrap_or(false) { return Err("Portal clipboard published oversized native text".into()); }
println!("Portal clipboard outgoing oversized rejection: passed");
if !check("set","")? { return Err("GTK empty fixture setup failed".into()); }
let deadline=Instant::now()+Duration::from_secs(6);let mut matched=false;
while Instant::now()<deadline {
if outgoing.has_changed().unwrap_or(false) && outgoing.borrow_and_update().as_deref()==Some("") {matched=true;break;}
std::thread::sleep(Duration::from_millis(100));
}
if !matched { return Err("Portal clipboard outgoing empty text mismatch".into()); }
println!("Portal clipboard outgoing empty: passed");
drop(writer); Ok(())
})();
let _=child.kill();let _=child.wait();result
}
+145
View File
@@ -0,0 +1,145 @@
//! Official GvPb_Message field 17 / ClipboardChange (UInt32, String, Bool).
//! Source-bound field/type evidence is retained in control/CLIPBOARD.md.
use crate::protocol::{decode_wire, WireValue};
use crate::clipboard::MAX_TEXT;
use std::time::{Duration, Instant};
#[derive(Default)]
pub struct Assembly {
pending: Option<(u32, String, Instant)>,
}
impl Assembly {
pub fn accept(&mut self, message: &[u8]) -> Result<Option<String>, &'static str> {
let result = self.decode(message);
if result.is_err() { self.pending = None; }
result
}
fn decode(&mut self, message: &[u8]) -> Result<Option<String>, &'static str> {
if message.len() > MAX_TEXT + 256 { return Err("clipboard message exceeds limit"); }
let fields = decode_wire(message).map_err(|_| "invalid clipboard wire")?;
let mut id = 0;
let mut text = "";
let mut more = false;
let mut seen = [false; 3];
for field in fields {
if !(1..=3).contains(&field.number) { continue; }
let index = field.number as usize - 1;
if seen[index] { return Err("duplicate clipboard field"); }
seen[index] = true;
match (field.number, field.value) {
(1, WireValue::Varint(value)) => id = u32::try_from(value).map_err(|_| "invalid clipboard content id")?,
(2, WireValue::Bytes(value)) => text = std::str::from_utf8(value).map_err(|_| "invalid clipboard UTF-8")?,
(3, WireValue::Varint(value @ 0..=1)) => more = value != 0,
_ => return Err("invalid clipboard field type"),
}
}
let now = Instant::now();
let mut combined = match self.pending.take() {
Some((previous, text, started)) if previous == id && now.duration_since(started) < Duration::from_secs(5) => (text, started),
_ => (String::new(), now),
};
if combined.0.len() + text.len() > MAX_TEXT { return Err("clipboard text exceeds limit"); }
combined.0.push_str(text);
if more { self.pending = Some((id, combined.0, combined.1)); Ok(None) }
else { Ok(Some(combined.0)) }
}
}
pub(crate) fn varint(mut value: u64, out: &mut Vec<u8>) {
while value >= 128 { out.push(value as u8 & 127 | 128); value >>= 7; }
out.push(value as u8);
}
pub(crate) fn nested(field: u32, payload: &[u8], out: &mut Vec<u8>) {
varint(u64::from(field) << 3 | 2, out);
varint(payload.len() as u64, out); out.extend_from_slice(payload);
}
pub fn text_request(request_id: u64, text: &str) -> Vec<u8> {
let mut header=vec![8];varint(request_id,&mut header);
// Official ClipboardMobileManager uses format_id=1 for text.
let data=encode(1,text,false);
let mut request=Vec::new();nested(1,&header,&mut request);nested(10,&data,&mut request);request
}
pub fn read_text_request(request: &[u8]) -> Result<Option<(Vec<u8>,String)>, &'static str> {
if request.len()>MAX_TEXT+256 {return Err("clipboard RPC exceeds limit");}
let fields=decode_wire(request).map_err(|_|"invalid clipboard RPC")?;
let data=fields.iter().find(|f|f.number==10);
let Some(data)=data else {return Ok(None);};
let header=fields.iter().find(|f|f.number==1).ok_or("missing clipboard RPC header")?;
let WireValue::Bytes(header)=header.value else {return Err("invalid clipboard RPC header");};
if header.len()>32 {return Err("invalid clipboard RPC header length");}
let header_fields=decode_wire(header).map_err(|_|"invalid clipboard RPC request id")?;
if header_fields.iter().any(|f|f.number!=1 || !matches!(f.value,WireValue::Varint(_))) {return Err("invalid clipboard RPC request id");}
let WireValue::Bytes(data)=data.value else {return Err("invalid clipboard RPC text");};
let parts=decode_wire(data).map_err(|_|"invalid clipboard RPC text")?;
if !parts.iter().any(|f|f.number==1 && f.value==WireValue::Varint(1)) || parts.iter().any(|f|f.number==1 && f.value!=WireValue::Varint(1)) {return Err("unsupported clipboard RPC format");}
let text=Assembly::default().accept(data)?.ok_or("incomplete clipboard RPC text")?;
Ok(Some((header.to_vec(),text)))
}
pub fn text_response(header: &[u8]) -> Vec<u8> {
let mut response=Vec::new();nested(1,header,&mut response);
nested(6,&[8,1],&mut response); // TextChangeResponse.err=CB_SUCCEEDED
response
}
pub fn encode(id: u32, text: &str, more: bool) -> Vec<u8> {
let mut out = vec![8]; varint(u64::from(id), &mut out);
out.push(18); varint(text.len() as u64, &mut out); out.extend_from_slice(text.as_bytes());
if more { out.extend_from_slice(&[24, 1]); }
out
}
pub fn chunks(text: &str) -> Result<Vec<&str>, &'static str> {
if text.len() > MAX_TEXT { return Err("clipboard text exceeds limit"); }
if text.is_empty() { return Ok(vec![""]); }
let mut chunks = Vec::new();
let mut remaining = text;
while !remaining.is_empty() {
let mut end = remaining.len().min(8192);
while !remaining.is_char_boundary(end) { end -= 1; }
chunks.push(&remaining[..end]); remaining = &remaining[end..];
}
Ok(chunks)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rpc_text_roundtrip_preserves_request_id_and_returns_official_success() {
let text="UU-test-中文🙂\n";
let request=text_request(0x12345678,text);
let (header,received)=read_text_request(&request).unwrap().unwrap();
assert_eq!(received,text);
assert_eq!(header,vec![8,0xf8,0xac,0xd1,0x91,1]);
let response=text_response(&header);
assert_eq!(&response[response.len()-4..],&[50,2,8,1]);
assert_eq!(&response[2..2+header.len()],header.as_slice());
assert!(read_text_request(&[10,1,255,82,0]).is_err());
assert!(read_text_request(&[10,0,82,2,8,2]).is_err());
assert!(read_text_request(&[10,0,74,0]).unwrap().is_none());
}
#[test]
fn unicode_chunk_roundtrip_and_empty_copy() {
let text = "中文🙂\n".repeat(1600);
let parts = chunks(&text).unwrap(); assert!(parts.len() > 1);
let mut assembly = Assembly::default();
for (i, part) in parts.iter().enumerate() {
let result = assembly.accept(&encode(u32::MAX, part, i + 1 < parts.len())).unwrap();
if i + 1 == parts.len() { assert_eq!(result.as_deref(), Some(text.as_str())); }
else { assert!(result.is_none()); }
}
assert_eq!(assembly.accept(&encode(0,"",false)).unwrap(),Some(String::new()));
}
#[test]
fn resets_for_new_id_and_rejects_malformed_and_oversized_text() {
let mut assembly = Assembly::default();
assembly.accept(&encode(1,"stale",true)).unwrap();
assert_eq!(assembly.accept(&encode(2,"new",false)).unwrap(),Some("new".into()));
assert!(assembly.accept(&[18,1,255]).is_err());
assert!(assembly.accept(&[8,1,8,2]).is_err());
assert!(assembly.accept(&[24,2]).is_err());
assert!(chunks(&"a".repeat(MAX_TEXT+1)).is_err());
assembly.accept(&encode(1,&"a".repeat(MAX_TEXT),true)).unwrap();
assert!(assembly.accept(&encode(1,"b",false)).is_err());
assert_eq!(assembly.accept(&encode(1,"fresh",false)).unwrap(),Some("fresh".into()));
}
}
+186
View File
@@ -0,0 +1,186 @@
//! Text-only desktop clipboard format negotiation. No file formats are offered.
use crate::clipboard::MAX_TEXT;
use crate::clipboard_protocol::{nested,varint};
use crate::protocol::{decode_wire,WireValue};
use std::collections::BTreeMap;
const UNICODE_TEXT:u64=13;
const BLOCK_BYTES:usize=0x20000;
const MAX_BYTES:usize=MAX_TEXT*2+2;
pub struct ResultMessages {pub messages:Vec<(u32,Vec<u8>)>,pub text:Option<String>}
impl Default for ResultMessages {fn default()->Self{Self{messages:Vec::new(),text:None}}}
struct Pending {key:String, count:Option<usize>, blocks:BTreeMap<usize,Vec<u8>>}
#[derive(Default)]
pub struct State {local:Option<String>, pending:Option<Pending>}
pub fn format_ids(rpc:&[u8])->Vec<u64>{
let Ok(Some(clip))=bytes(rpc,9) else{return Vec::new();};
let Ok(Some(list))=bytes(clip,1) else{return Vec::new();};
let Ok(fields)=decode_wire(list) else{return Vec::new();};
fields.iter().filter(|f|f.number==1).filter_map(|f|match f.value{WireValue::Bytes(format)=>number(format,1).ok(),_=>None}).take(32).collect()
}
fn int(field:u32,value:u64,out:&mut Vec<u8>){varint(u64::from(field)<<3,out);varint(value,out);}
fn string(field:u32,value:&str,out:&mut Vec<u8>){nested(field,value.as_bytes(),out);}
fn number(data:&[u8],field:u32)->Result<u64,&'static str>{
let fields=decode_wire(data).map_err(|_|"invalid clipboard message")?;
match fields.iter().find(|f|f.number==field).map(|f|&f.value){
Some(WireValue::Varint(v))=>Ok(*v),None=>Ok(0),_=>Err("invalid clipboard integer"),
}
}
fn bytes(data:&[u8],field:u32)->Result<Option<&[u8]>,&'static str>{
let fields=decode_wire(data).map_err(|_|"invalid clipboard message")?;
match fields.iter().find(|f|f.number==field).map(|f|&f.value){
Some(WireValue::Bytes(v))=>Ok(Some(*v)),None=>Ok(None),_=>Err("invalid clipboard bytes"),
}
}
fn text_field(data:&[u8],field:u32)->Result<&str,&'static str>{
std::str::from_utf8(bytes(data,field)?.unwrap_or(&[])).map_err(|_|"invalid clipboard string")
}
fn header(data:&[u8])->Result<&[u8],&'static str>{
let h=bytes(data,1)?.ok_or("missing clipboard request header")?;
if h.len()>32{return Err("clipboard header exceeds limit");}
number(h,1)?;Ok(h)
}
fn request(id:u64,kind:u32,body:&[u8])->Vec<u8>{
let mut h=Vec::new();int(1,id,&mut h);
let mut clip=Vec::new();nested(kind,body,&mut clip);
let mut rpc=Vec::new();nested(1,&h,&mut rpc);nested(9,&clip,&mut rpc);rpc
}
fn response(h:&[u8],kind:u32,body:&[u8])->Vec<u8>{
let mut clip=Vec::new();nested(kind,body,&mut clip);
let mut rpc=Vec::new();nested(1,h,&mut rpc);nested(5,&clip,&mut rpc);rpc
}
fn encode_windows(text:&str)->Vec<u8>{
text.replace("\r\n","\n").replace('\n',"\r\n").encode_utf16().chain(std::iter::once(0)).flat_map(u16::to_le_bytes).collect()
}
fn decode_windows(data:&[u8])->Result<String,&'static str>{
if data.len()>MAX_BYTES||data.len()%2!=0{return Err("invalid Unicode clipboard length");}
let mut chars:Vec<u16>=data.chunks_exact(2).map(|v|u16::from_le_bytes([v[0],v[1]])).collect();
if chars.last()==Some(&0){chars.pop();}
if chars.contains(&0){return Err("embedded NUL in clipboard text");}
let text=String::from_utf16(&chars).map_err(|_|"invalid Unicode clipboard text")?.replace("\r\n","\n");
if text.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}Ok(text)
}
impl State{
pub fn offer(&mut self,id:u64,text:String)->Result<Vec<u8>,&'static str>{
if text.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}
if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");}
self.local=Some(text);
let mut format=Vec::new();int(1,UNICODE_TEXT,&mut format);string(2,"CF_UNICODETEXT",&mut format);
let mut list=Vec::new();nested(1,&format,&mut list);
Ok(request(id,1,&list))
}
pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{
if rpc.len()>MAX_BYTES+512{return Err("clipboard RPC exceeds limit");}
let Some(clip)=bytes(rpc,9)? else{return Ok(ResultMessages::default());};
let h=header(rpc)?;
let mut out=ResultMessages::default();
if let Some(list)=bytes(clip,1)?{
out.messages.push((22,response(h,1,&[])));
let fields=decode_wire(list).map_err(|_|"invalid clipboard format list")?;
let supports_text=fields.iter().filter(|f|f.number==1).any(|f|match f.value{WireValue::Bytes(format)=>number(format,1)==Ok(UNICODE_TEXT),_=>false});
self.pending=None;
if supports_text{
let id=next();
let epoch=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs() as u32;
let key=format!("{epoch:08x}-0000-4000-8000-{:012x}",id & 0xffffffffffff);
let mut ask=Vec::new();int(1,UNICODE_TEXT,&mut ask);string(2,&key,&mut ask);string(3,"CF_UNICODETEXT",&mut ask);
self.pending=Some(Pending{key,count:None,blocks:BTreeMap::new()});
out.messages.push((21,request(id,2,&ask)));
}
}else if let Some(ask)=bytes(clip,2)?{
let key=text_field(ask,2)?;
if key.len()>256||key.is_empty(){return Err("invalid clipboard block key");}
let available=number(ask,1)?==UNICODE_TEXT&&self.local.is_some();
let mut confirm=Vec::new();int(1,if available{1}else{2},&mut confirm);string(2,key,&mut confirm);
let data=if available{Some(encode_windows(self.local.as_ref().unwrap()))}else{None};
if let Some(data)=&data{int(3,data.chunks(BLOCK_BYTES).len() as u64,&mut confirm);}
out.messages.push((22,response(h,2,&confirm)));
if let Some(data)=data{
for (index,part) in data.chunks(BLOCK_BYTES).enumerate(){
let mut block=Vec::new();string(1,key,&mut block);int(2,index as u64,&mut block);nested(3,part,&mut block);
out.messages.push((21,request(next(),3,&block)));
}
}
}else if let Some(block)=bytes(clip,3)?{
let key=text_field(block,1)?;
let index=usize::try_from(number(block,2)?).map_err(|_|"invalid clipboard block index")?;
let data=bytes(block,3)?.unwrap_or(&[]);
log::info!("Clipboard incoming block metadata: index={} bytes={}",index,data.len());
if index>MAX_BYTES/BLOCK_BYTES+1||data.len()>MAX_BYTES{return Err("clipboard block exceeds limit");}
let pending=self.pending.as_mut().ok_or("unsolicited clipboard block")?;
if key!=pending.key{return Err("unexpected clipboard block key");}
if let Some(existing)=pending.blocks.get(&index){
if existing!=data{return Err("conflicting clipboard block");}
}else{
if pending.blocks.values().map(Vec::len).sum::<usize>()+data.len()>MAX_BYTES{return Err("clipboard transfer exceeds limit");}
pending.blocks.insert(index,data.to_vec());
}
let mut confirm=Vec::new();string(1,key,&mut confirm);int(2,index as u64,&mut confirm);int(3,1,&mut confirm);
out.messages.push((22,response(h,3,&confirm)));
out.text=self.complete()?;
}
Ok(out)
}
pub fn response(&mut self,rpc:&[u8])->Result<Option<String>,&'static str>{
let Some(clip)=bytes(rpc,5)? else{return Ok(None);};
let Some(confirm)=bytes(clip,2)? else{return Ok(None);};
let Some(pending)=self.pending.as_mut() else{return Ok(None);};
if text_field(confirm,2)?!=pending.key{return Ok(None);}
let status=number(confirm,1)?;
log::info!("Clipboard data confirmation metadata: status={} block_count={}",status,number(confirm,3)?);
if status!=1{self.pending=None;return Ok(None);}
let count=usize::try_from(number(confirm,3)?).map_err(|_|"invalid clipboard block count")?;
if count==0||count>MAX_BYTES/BLOCK_BYTES+2{self.pending=None;return Err("invalid clipboard block count");}
pending.count=Some(count);self.complete()
}
fn complete(&mut self)->Result<Option<String>,&'static str>{
let Some(pending)=&self.pending else{return Ok(None);};
let Some(count)=pending.count else{return Ok(None);};
// Native providers may number wire blocks from one while their internal
// buffer slicing uses a zero-based index. Accept a complete contiguous
// set in either convention; never complete from a missing middle block.
let first=if (0..count).all(|i|pending.blocks.contains_key(&i)){0}
else if (1..=count).all(|i|pending.blocks.contains_key(&i)){1}
else{return Ok(None);};
let data:Vec<u8>=(first..first+count).flat_map(|i|pending.blocks[&i].iter().copied()).collect();
self.pending=None;decode_windows(&data).map(Some)
}
}
#[cfg(test)]
mod tests{
use super::*;
#[test]
fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){
let text="UU-test-中文🙂\n".repeat(900);
let mut provider=State::default();let mut receiver=State::default();let mut id=10;let mut next=||{id+=1;id};
let offer=provider.offer(1,text.clone()).unwrap();
let result=receiver.request(&offer,&mut next).unwrap();assert_eq!(result.messages.len(),2);
let send=provider.request(&result.messages[1].1,&mut next).unwrap();assert_eq!(send.messages.len(),2);
// Blocks may arrive before DataConfirm; completion waits for both.
for (_,block) in send.messages.iter().skip(1).rev(){assert!(receiver.request(block,&mut next).unwrap().text.is_none());}
assert_eq!(receiver.response(&send.messages[0].1).unwrap(),Some(text));
}
#[test]
fn rejects_invalid_unicode_unsolicited_blocks_and_unknown_formats(){
assert!(decode_windows(&[0,0xd8,0,0]).is_err());
assert!(decode_windows(&[1]).is_err());
let mut s=State::default();let mut block=Vec::new();string(1,"unknown",&mut block);nested(3,&[0,0],&mut block);
assert!(s.request(&request(1,3,&block),&mut||2).is_err());
let mut format=Vec::new();int(1,15,&mut format);let mut list=Vec::new();nested(1,&format,&mut list);
let out=s.request(&request(1,1,&list),&mut||2).unwrap();assert_eq!(out.messages.len(),1);assert!(s.pending.is_none());
}
#[test]
fn accepts_one_based_wire_blocks_without_breaking_zero_based_provider(){
let mut source=State::default();let mut target=State::default();let mut id=10;let mut next=||{id+=1;id};
let offer=source.offer(1,"中文🙂".into()).unwrap();
let offered=target.request(&offer,&mut next).unwrap();
let sent=source.request(&offered.messages[1].1,&mut next).unwrap();
assert!(target.response(&sent.messages[0].1).unwrap().is_none());
let clip=bytes(&sent.messages[1].1,9).unwrap().unwrap();
let original=bytes(clip,3).unwrap().unwrap();
let mut block=Vec::new();string(1,text_field(original,1).unwrap(),&mut block);int(2,1,&mut block);nested(3,bytes(original,3).unwrap().unwrap(),&mut block);
assert_eq!(target.request(&request(99,3,&block),&mut next).unwrap().text,Some("中文🙂".into()));
}
}
+43
View File
@@ -0,0 +1,43 @@
//! Runtime configuration. Nothing machine- or account-specific is compiled in.
//! File: $UU_CONFIG, else $XDG_CONFIG_HOME/uuremote/config.json, else ~/.config/uuremote/config.json.
//! Environment variables override file values. Keep the file private (chmod 600).
use std::path::PathBuf;
use std::sync::OnceLock;
pub fn path() -> PathBuf {
if let Some(p) = std::env::var_os("UU_CONFIG") { return PathBuf::from(p); }
let base = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from)
.or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))
.unwrap_or_else(|| PathBuf::from("."));
base.join("uuremote/config.json")
}
/// Re-reads the config file (used after `login` rewrites it while the server runs).
pub fn read_fresh() -> Result<Option<serde_json::Value>, String> {
let p = path();
match std::fs::read(&p) {
Ok(bytes) => serde_json::from_slice(&bytes).map(Some).map_err(|e| format!("invalid config {}: {e}", p.display())),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
Err(e) => Err(format!("cannot read config {}: {e}", p.display())),
}
}
/// Parsed config file, or None when absent. A malformed file is an error, not silently ignored.
pub fn file() -> Result<Option<&'static serde_json::Value>, String> {
static FILE: OnceLock<Result<Option<serde_json::Value>, String>> = OnceLock::new();
FILE.get_or_init(|| {
let p = path();
match std::fs::read(&p) {
Ok(bytes) => serde_json::from_slice(&bytes).map(Some).map_err(|e| format!("invalid config {}: {e}", p.display())),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
Err(e) => Err(format!("cannot read config {}: {e}", p.display())),
}
}).as_ref().map(|v| v.as_ref()).map_err(Clone::clone)
}
/// Optional bundled FFmpeg prefix: UU_FFMPEG_ROOT or config "ffmpeg_root".
pub fn ffmpeg_root() -> Option<PathBuf> {
std::env::var_os("UU_FFMPEG_ROOT").filter(|v| !v.is_empty()).map(PathBuf::from)
.or_else(|| file().ok().flatten().and_then(|f| f.get("ffmpeg_root")).and_then(|v| v.as_str()).map(PathBuf::from))
}
+207
View File
@@ -0,0 +1,207 @@
//! Mac UU CONTROL JSON messages recovered from the shipped ARM64 client.
//! Wire parsing accepts UTF-8 JSON carried by binary SCTP messages as well as text.
//! Coordinates and key/button identifiers remain wire values; Linux translation
//! belongs to the input engine. Only the verified protobuf echo-response shape
//! is encoded; other protobuf messages remain opaque.
use serde_json::Value;
#[derive(Debug, Clone, PartialEq)]
pub enum ControlInput {
Keyboard { key: i32, pressed: bool },
KeyboardClick { key: i32 },
MouseButton { button: i32, pressed: bool },
MouseClick { button: i32 },
MouseAbsolute { x: f64, y: f64 },
MouseRelative { dx: i32, dy: i32 },
MouseScroll { dx: i32, dy: i32 },
}
#[derive(Debug, Clone, PartialEq)]
pub enum ControlMessage {
KeyboardHeartbeat,
Input(ControlInput),
Unsupported(Value),
}
fn integer(v: &Value, name: &str) -> Result<i32, String> {
v.get(name)
.and_then(Value::as_i64)
.and_then(|n| i32::try_from(n).ok())
.ok_or_else(|| format!("CONTROL field {name} must be an i32 integer"))
}
fn coordinate(v: &Value, name: &str) -> Result<f64, String> {
v.get(name).and_then(Value::as_f64).filter(|n| n.is_finite())
.ok_or_else(|| format!("CONTROL field {name} must be a finite number"))
}
pub fn decode_control(data: &[u8]) -> Result<ControlMessage, String> {
let v: Value = serde_json::from_slice(data)
.map_err(|_| "CONTROL payload is not valid JSON".to_owned())?;
if v.get("heartbeat").and_then(Value::as_str) == Some("kbd_heartbeat") {
return Ok(ControlMessage::KeyboardHeartbeat);
}
let Some(action) = v.get("action").and_then(Value::as_str) else {
return Ok(ControlMessage::Unsupported(v));
};
let event = match action {
"kbd_press" => ControlInput::Keyboard { key: integer(&v, "key")?, pressed: true },
"kbd_release" => ControlInput::Keyboard { key: integer(&v, "key")?, pressed: false },
"kbd_click" => ControlInput::KeyboardClick { key: integer(&v, "key")? },
"mouse_press" => ControlInput::MouseButton { button: integer(&v, "button")?, pressed: true },
"mouse_release" => ControlInput::MouseButton { button: integer(&v, "button")?, pressed: false },
"mouse_click" => ControlInput::MouseClick { button: integer(&v, "button")? },
"mouse_move_absolute" => ControlInput::MouseAbsolute {
x: coordinate(&v, "abs_x")?, y: coordinate(&v, "abs_y")?,
},
"mouse_move_relative" => ControlInput::MouseRelative {
dx: integer(&v, "delta_x")?, dy: integer(&v, "delta_y")?,
},
"mouse_scroll" => ControlInput::MouseScroll {
dx: integer(&v, "delta_x")?, dy: integer(&v, "delta_y")?,
},
_ => return Ok(ControlMessage::Unsupported(v)),
};
Ok(ControlMessage::Input(event))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn recognizes_binary_carried_keyboard_heartbeat() {
let bytes = br#"{"heartbeat":"kbd_heartbeat"}"#;
assert_eq!(bytes.len(), 29);
assert_eq!(decode_control(bytes).unwrap(), ControlMessage::KeyboardHeartbeat);
}
#[test]
fn decodes_mac_absolute_and_relative_wire_keys() {
assert_eq!(decode_control(br#"{"action":"mouse_move_absolute","abs_x":12,"abs_y":34}"#).unwrap(),
ControlMessage::Input(ControlInput::MouseAbsolute { x: 12.0, y: 34.0 }));
assert_eq!(decode_control(br#"{"action":"mouse_move_relative","delta_x":-4,"delta_y":5}"#).unwrap(),
ControlMessage::Input(ControlInput::MouseRelative { dx: -4, dy: 5 }));
}
#[test]
fn preserves_wire_key_and_button_identifiers() {
assert_eq!(decode_control(br#"{"action":"kbd_release","key":65}"#).unwrap(),
ControlMessage::Input(ControlInput::Keyboard { key: 65, pressed: false }));
assert_eq!(decode_control(br#"{"action":"mouse_press","button":2}"#).unwrap(),
ControlMessage::Input(ControlInput::MouseButton { button: 2, pressed: true }));
}
#[test]
fn rejects_missing_or_unrepresentable_input_fields() {
assert!(decode_control(br#"{"action":"kbd_press"}"#).is_err());
assert!(decode_control(br#"{"action":"kbd_press","key":2147483648}"#).is_err());
assert!(decode_control(br#"{"action":"kbd_press","key":1.5}"#).is_err());
assert!(decode_control(&[0xff, 0x08]).is_err());
}
#[test]
fn encodes_echo_response_without_advertising_unverified_features() {
let reply = encode_echo_response_for(1, 2, 200);
assert_eq!(&reply[..4], &[8, 1, 16, 2]);
assert!(reply.windows(11).any(|b| b == br#"{"seq":200}"#));
assert!(reply.ends_with(&[34, 8, 8, 4, 16, 2, 24, 2, 48, 2]));
assert!(reply.windows(2).any(|b| b == [8, 1]));
}
#[test]
fn advertises_verified_text_rpc_clipboard_when_backend_ready() {
use crate::protocol::{decode_wire,WireValue};
let response = encode_echo_response_with_clipboard(1,2,200,true);
let outer=decode_wire(&response).unwrap();
let action=outer.iter().find(|f|f.number==3).unwrap();
let WireValue::Bytes(action)=action.value else {panic!("action type")};
let fields=decode_wire(action).unwrap();
let flag=fields.iter().find(|f|f.number==4).unwrap();
let WireValue::Bytes(flag)=flag.value else {panic!("flag type")};
let features=decode_wire(flag).unwrap();
let numbers:Vec<(u32,u64)>=features.iter().map(|f|match f.value {WireValue::Varint(v)=>(f.number,v),_=>panic!("flag type")}).collect();
assert_eq!(numbers,vec![(1,4),(2,2),(3,2),(6,2),(8,3)]);
}
#[test]
fn names_only_official_simple_action_values() {
assert_eq!(simple_action_name(4), Some("capture_desktop"));
assert_eq!(simple_action_name(22), Some("acquire_system_info"));
assert_eq!(simple_action_name(27), Some("need_restart_userapp"));
assert_eq!(simple_action_name(28), None);
assert_eq!(simple_action_name(u64::MAX), None);
}
#[test]
fn does_not_invent_actions_for_unknown_json() {
assert!(matches!(decode_control(br#"{"action":"unverified"}"#).unwrap(), ControlMessage::Unsupported(_)));
}
}
/// Generate the verified protobuf SimpleAction echoResponse envelope.
/// The caller chooses sequence/timestamp policy; no peer feature flags are copied.
pub fn encode_echo_response(seq: u64, timestamp: u64) -> Vec<u8> {
encode_echo_response_for(seq, timestamp, seq)
}
/// Correlate the response using the official args JSON request-sequence field.
/// An explicit empty FeatureFlag advertises no unimplemented feature versions.
pub fn encode_echo_response_for(seq: u64, timestamp: u64, request_seq: u64) -> Vec<u8> {
encode_echo_response_with_clipboard(seq, timestamp, request_seq, false)
}
/// Advertise only the verified legacy text bridge when the native backend is ready.
/// FeatureFlag.ff_clipboard field 8: SUPPORT_TEXT_CHANGE=3; no file-transfer claim.
pub fn encode_echo_response_with_clipboard(seq: u64, timestamp: u64, request_seq: u64, clipboard: bool) -> Vec<u8> {
fn put_varint(mut v: u64, out: &mut Vec<u8>) {
while v >= 128 {
out.push((v as u8 & 127) | 128);
v >>= 7;
}
out.push(v as u8);
}
let args = format!(r#"{{"seq":{request_seq}}}"#);
let mut action = vec![8, 1, 18];
put_varint(args.len() as u64, &mut action);
action.extend_from_slice(args.as_bytes());
// FeatureFlag: 1 ff_capture_setting = CUSTOM_BITRATE (fps/quality/bitrate RPCs),
// 2 ff_simple_action = AUTO_LOCK (mute + lock after session), 3 ff_system_metrics = SETTING_AUTO_LOCK,
// 6 ff_file_transfer_ftp = LIST_COMPRESS (zlib dir_data), 8 ff_clipboard = SUPPORT_TEXT_CHANGE.
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8,
16, crate::system_actions::FF_SIMPLE_ACTION, 24, crate::system_actions::FF_SYSTEM_METRICS, 48, 2];
if clipboard { flags.extend_from_slice(&[64, 3]); }
action.push(34);
action.push(flags.len() as u8);
action.extend_from_slice(&flags);
let mut out = Vec::new();
if seq != 0 {
out.push(8);
put_varint(seq, &mut out);
}
if timestamp != 0 {
out.push(16);
put_varint(timestamp, &mut out);
}
out.push(26); // Message.simpleAction
put_varint(action.len() as u64, &mut out);
out.extend_from_slice(&action);
out
}
/// Official ActionType map recovered from _ProtoNameProviding's 28-entry table.
/// This describes messages; it does not authorize or execute system actions.
pub fn simple_action_name(action: u64) -> Option<&'static str> {
const NAMES: [&str; 28] = [
"echo_request", "echo_response", "show_desktop", "show_windows",
"capture_desktop", "capture_window", "capture_mumu", "stop_capture",
"restart_capture", "reboot_system", "lock_system", "key_toggle",
"shutdown_system", "show_taskmgr", "mute_system", "auto_unlock_system",
"mute_restore", "mute_permanent", "mute_temporary", "set_auto_lock",
"stop_acquire_update", "quit_capture", "acquire_system_info",
"microphone_opened", "microphone_closed", "speaker_opened",
"speaker_closed", "need_restart_userapp",
];
usize::try_from(action).ok().and_then(|n| NAMES.get(n).copied())
}
+189
View File
@@ -0,0 +1,189 @@
//! Pointer shape mirroring. The video no longer contains the pointer (x11grab
//! -draw_mouse 0), so the viewer draws its local pointer; this tells it which shape.
//! Wire layout recovered from the official Mac host sendCursorShape (UURemoteServer
//! arm64 0x1000065ac..0x100006d3c): Message.which=15 SystemStateChange, field 2
//! CursorShape { 1 pos_x, 2 pos_y = hotspot, 3 width, 4 height, 5 byte_value = PNG
//! (representationUsingType 4), 6 cursor_type = 0 with image, 7/8 coordinate x/y
//! scale = video pixels per screen point (double), 9 screen_id }.
use std::sync::{Arc, OnceLock};
use tokio::sync::watch;
#[cfg(target_os = "linux")]
extern "C" {
fn x11_cursor_open(display_name: *const libc::c_char) -> libc::c_int;
fn x11_cursor_wait(timeout_ms: libc::c_int) -> libc::c_int;
fn x11_cursor_poll(pixels: *mut u32, max_pixels: libc::c_int, width: *mut libc::c_int, height: *mut libc::c_int,
hot_x: *mut libc::c_int, hot_y: *mut libc::c_int, force: libc::c_int) -> libc::c_int;
}
#[cfg(target_os = "linux")]
const MAX_EDGE: usize = 256;
/// Upper bound between checks; cursor-change events wake the monitor immediately.
#[cfg(target_os = "linux")]
const WAIT_MS: libc::c_int = 250;
#[derive(Debug, PartialEq)]
pub struct CursorImage { pub width: u32, pub height: u32, pub hot_x: i32, pub hot_y: i32, pub png: Vec<u8> }
/// XFixes delivers premultiplied ARGB32; PNG needs straight-alpha RGBA.
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn argb_premultiplied_to_rgba(pixels: &[u32]) -> Vec<u8> {
let mut rgba = Vec::with_capacity(pixels.len() * 4);
for &pixel in pixels {
let a = pixel >> 24;
let straight = |shift: u32| -> u8 {
let c = (pixel >> shift) & 0xff;
if a == 0 { 0 } else { ((c * 255 + a / 2) / a).min(255) as u8 }
};
rgba.extend_from_slice(&[straight(16), straight(8), straight(0), a as u8]);
}
rgba
}
/// Minimal 8-bit RGBA PNG (filter 0) using the existing flate2 dependency.
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) fn encode_png(width: u32, height: u32, rgba: &[u8]) -> Vec<u8> {
use std::io::Write;
fn chunk(out: &mut Vec<u8>, kind: &[u8; 4], data: &[u8]) {
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
let mut crc = flate2::Crc::new();
crc.update(kind);
crc.update(data);
out.extend_from_slice(kind);
out.extend_from_slice(data);
out.extend_from_slice(&crc.sum().to_be_bytes());
}
let mut header = Vec::with_capacity(13);
header.extend_from_slice(&width.to_be_bytes());
header.extend_from_slice(&height.to_be_bytes());
header.extend_from_slice(&[8, 6, 0, 0, 0]); // 8-bit, RGBA, deflate, filter 0, no interlace
let mut scanlines = Vec::with_capacity(rgba.len() + height as usize);
for row in rgba.chunks(width as usize * 4) {
scanlines.push(0);
scanlines.extend_from_slice(row);
}
let mut encoder = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
encoder.write_all(&scanlines).expect("in-memory zlib");
let compressed = encoder.finish().expect("in-memory zlib");
let mut png = b"\x89PNG\r\n\x1a\n".to_vec();
chunk(&mut png, b"IHDR", &header);
chunk(&mut png, b"IDAT", &compressed);
chunk(&mut png, b"IEND", &[]);
png
}
fn varint(mut value: u64, out: &mut Vec<u8>) {
while value >= 128 { out.push((value as u8 & 127) | 128); value >>= 7; }
out.push(value as u8);
}
/// Message.which=15 SystemStateChange { 2: CursorShape } for an unscaled source screen 0.
pub fn encode_cursor_shape(seq: u64, timestamp: u64, cursor: &CursorImage) -> Vec<u8> {
let mut shape = Vec::new();
for (field, value) in [(1, cursor.hot_x), (2, cursor.hot_y), (3, cursor.width as i32), (4, cursor.height as i32)] {
if value != 0 { varint(field << 3, &mut shape); varint(value as i64 as u64, &mut shape); }
}
varint(5 << 3 | 2, &mut shape);
varint(cursor.png.len() as u64, &mut shape);
shape.extend_from_slice(&cursor.png);
// cursor_type 0 (image present) and screen_id 0 are protobuf defaults and omitted.
for field in [7u64, 8] {
varint(field << 3 | 1, &mut shape);
shape.extend_from_slice(&1.0f64.to_le_bytes());
}
let mut change = Vec::new();
varint(2 << 3 | 2, &mut change);
varint(shape.len() as u64, &mut change);
change.extend_from_slice(&shape);
crate::initialization::envelope(seq, timestamp, 15, &change)
}
/// One process-wide monitor thread; every session subscribes to the latest shape.
pub fn monitor(display: &str) -> watch::Receiver<Option<Arc<CursorImage>>> {
if display.starts_with("wayland:") {
// XFixes cannot observe native Wayland cursors; no false XWayland monitor.
let (_,receiver)=watch::channel(None); return receiver;
}
static LATEST: OnceLock<watch::Sender<Option<Arc<CursorImage>>>> = OnceLock::new();
LATEST.get_or_init(|| {
let (tx, _) = watch::channel(None);
start_thread(display.to_owned(), tx.clone());
tx
}).subscribe()
}
#[cfg(target_os = "linux")]
fn start_thread(display: String, tx: watch::Sender<Option<Arc<CursorImage>>>) {
let spawned = std::thread::Builder::new().name("cursor-shape".into()).spawn(move || {
let Ok(name) = std::ffi::CString::new(display) else { return };
let opened = unsafe { x11_cursor_open(name.as_ptr()) };
if opened != 0 { log::warn!("Cursor shape monitor unavailable: {}", opened); return; }
let mut pixels = vec![0u32; MAX_EDGE * MAX_EDGE];
let mut force = 1;
loop {
let (mut w, mut h, mut x, mut y) = (0, 0, 0, 0);
let result = unsafe { x11_cursor_poll(pixels.as_mut_ptr(), pixels.len() as i32, &mut w, &mut h, &mut x, &mut y, force) };
if result == 1 {
let (width, height) = (w as u32, h as u32);
let rgba = argb_premultiplied_to_rgba(&pixels[..(width * height) as usize]);
tx.send_replace(Some(Arc::new(CursorImage { width, height, hot_x: x, hot_y: y, png: encode_png(width, height, &rgba) })));
force = 0;
} else if result < 0 {
log::warn!("Cursor shape poll failed: {}", result);
std::thread::sleep(std::time::Duration::from_secs(1));
}
unsafe { x11_cursor_wait(WAIT_MS) };
}
});
if let Err(e) = spawned { log::warn!("Cursor shape thread failed: {}", e); }
}
#[cfg(not(target_os = "linux"))]
fn start_thread(_: String, _: watch::Sender<Option<Arc<CursorImage>>>) {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn unpremultiplies_alpha_for_png() {
// Opaque white, half-transparent premultiplied red (0x80,0x80,0,0), fully transparent.
assert_eq!(argb_premultiplied_to_rgba(&[0xffffffff, 0x80800000, 0x00000000]),
vec![255,255,255,255, 255,0,0,128, 0,0,0,0]);
}
#[test]
fn png_has_valid_structure_and_decodes_back() {
let rgba: Vec<u8> = (0..2*3*4).map(|i| i as u8 * 10).collect();
let png = encode_png(2, 3, &rgba);
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"));
assert_eq!(&png[12..16], b"IHDR");
assert_eq!(u32::from_be_bytes(png[16..20].try_into().unwrap()), 2);
assert_eq!(u32::from_be_bytes(png[20..24].try_into().unwrap()), 3);
assert!(png.ends_with(&[0,0,0,0, b'I',b'E',b'N',b'D', 0xae,0x42,0x60,0x82]));
// IDAT inflates to filtered scanlines: each row = filter byte 0 + 8 pixels bytes.
let idat_len = u32::from_be_bytes(png[33..37].try_into().unwrap()) as usize;
assert_eq!(&png[37..41], b"IDAT");
let mut raw = Vec::new();
std::io::Read::read_to_end(&mut flate2::read::ZlibDecoder::new(&png[41..41+idat_len]), &mut raw).unwrap();
assert_eq!(raw.len(), 3 * (1 + 8));
assert_eq!(&raw[1..9], &rgba[0..8]);
assert_eq!(raw[9], 0);
}
#[test]
fn cursor_shape_matches_official_field_layout() {
let cursor = CursorImage { width: 24, height: 24, hot_x: 4, hot_y: 2, png: vec![1, 2, 3] };
let message = encode_cursor_shape(7, 9, &cursor);
// Message: seq 7, timestamp 9, field 15 (tag 0x7a) SystemStateChange.
assert_eq!(&message[..4], &[8, 7, 16, 9]);
assert_eq!(message[4], 0x7a);
let change = &message[6..];
assert_eq!(change[0], 0x12); // SystemStateChange.field2 cursor_shape
let shape = &change[2..];
assert_eq!(&shape[..8], &[8, 4, 16, 2, 24, 24, 32, 24]); // hotspot, width, height
assert_eq!(&shape[8..13], &[0x2a, 3, 1, 2, 3]); // byte_value PNG
assert_eq!(shape[13], 0x39); // field 7 double
assert_eq!(&shape[14..22], &1.0f64.to_le_bytes());
assert_eq!(shape[22], 0x41); // field 8 double
assert_eq!(shape.len(), 31);
}
}
+39
View File
@@ -0,0 +1,39 @@
//! Select the host desktop, not the presence of an XWayland DISPLAY socket.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DesktopBackend { X11, Wayland, Portal }
pub fn detect() -> Result<DesktopBackend, String> {
let backend=select(std::env::var("UU_DESKTOP_BACKEND").ok().as_deref(),
std::env::var("XDG_SESSION_TYPE").ok().as_deref(),
std::env::var("WAYLAND_DISPLAY").ok().as_deref())?;
let explicit=std::env::var("UU_DESKTOP_BACKEND").unwrap_or_else(|_|"auto".into());
let desktop=std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default();
Ok(if explicit=="auto" && backend==DesktopBackend::Wayland && desktop.split(':').any(|s|s.eq_ignore_ascii_case("gnome")||s.eq_ignore_ascii_case("kde")) { DesktopBackend::Portal } else { backend })
}
fn select(explicit: Option<&str>, session: Option<&str>, socket: Option<&str>) -> Result<DesktopBackend, String> {
match explicit {
Some("x11") => Ok(DesktopBackend::X11),
Some("wayland") => Ok(DesktopBackend::Wayland),
Some("portal") => Ok(DesktopBackend::Portal),
None | Some("auto") => {
if session == Some("wayland") || socket.is_some_and(|s| !s.is_empty()) {
Ok(DesktopBackend::Wayland)
} else { Ok(DesktopBackend::X11) }
},
Some(_) => Err("UU_DESKTOP_BACKEND must be auto, x11, wayland or portal".into()),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn xwayland_does_not_override_wayland_session() {
assert_eq!(select(None,Some("wayland"),Some("wayland-0")),Ok(DesktopBackend::Wayland));
assert_eq!(select(None,None,Some("wayland-1")),Ok(DesktopBackend::Wayland));
assert_eq!(select(None,Some("x11"),None),Ok(DesktopBackend::X11));
assert_eq!(select(Some("x11"),Some("wayland"),Some("wayland-0")),Ok(DesktopBackend::X11));
assert!(select(Some("typo"),None,None).is_err());
}
}
+741
View File
@@ -0,0 +1,741 @@
//! UU file-transfer RPC (FILE_DATA_CHANNEL) for the Linux desktop.
//! Wire shapes come from the official Mac host's SwiftProtobuf name maps and field
//! descriptors: analysis/tools-fix-20261013/server-field-maps.json and server-fieldmd.json.
//! Message 21 RpcRequest{1 header{1 request_id}, 8 FileTransferFtpRequest};
//! Message 22 RpcResponse{1 header, 4 FileTransferFtpResponse}.
//! Logs carry counts and sizes only, never file names, paths or contents.
use crate::protocol::{decode_wire, WireField, WireValue};
use std::collections::HashMap;
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use tokio::sync::{mpsc, oneshot};
// FileTransferError
pub const FT_SUCCEEDED: u64 = 1;
const FT_UNEXPECTED: u64 = 2;
const FT_PROTOCOL: u64 = 3;
const FT_PERMISSION: u64 = 4;
const FT_DISK: u64 = 5;
const FT_IO: u64 = 6;
const FT_CANCELED: u64 = 7;
const FT_NOT_FOUND: u64 = 9;
// FileType
const FT_DIR: u64 = 0;
const FT_DIR_DRIVE: u64 = 3;
const FT_FILE: u64 = 4;
// FileOperationStrategy
const FOS_DUPLICATE: u64 = 2;
const FOS_SKIP: u64 = 3;
const FOS_RESUME: u64 = 4;
const DOWNLOAD_BLOCK: usize = 32 * 1024;
const DOWNLOAD_WINDOW: usize = 16;
// ---------- protobuf helpers ----------
fn varint(mut v: u64, out: &mut Vec<u8>) {
while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; }
out.push(v as u8);
}
#[derive(Default)]
struct Enc(Vec<u8>);
impl Enc {
fn uint(mut self, field: u32, v: u64) -> Self {
if v != 0 { varint(u64::from(field) << 3, &mut self.0); varint(v, &mut self.0); }
self
}
fn boolean(self, field: u32, v: bool) -> Self { self.uint(field, v as u64) }
fn bytes(mut self, field: u32, v: &[u8]) -> Self {
varint((u64::from(field) << 3) | 2, &mut self.0); varint(v.len() as u64, &mut self.0);
self.0.extend_from_slice(v); self
}
fn text(self, field: u32, v: &str) -> Self { if v.is_empty() { self } else { self.bytes(field, v.as_bytes()) } }
fn msg(self, field: u32, v: Enc) -> Self { self.bytes(field, &v.0) }
}
fn get_uint(fields: &[WireField], n: u32) -> u64 {
fields.iter().rev().find_map(|f| match (f.number == n, &f.value) { (true, WireValue::Varint(v)) => Some(*v), _ => None }).unwrap_or(0)
}
fn get_bytes<'a>(fields: &[WireField<'a>], n: u32) -> Option<&'a [u8]> {
fields.iter().rev().find_map(|f| match (f.number == n, &f.value) { (true, WireValue::Bytes(v)) => Some(*v), _ => None })
}
fn get_all<'a>(fields: &[WireField<'a>], n: u32) -> Vec<&'a [u8]> {
fields.iter().filter_map(|f| match (f.number == n, &f.value) { (true, WireValue::Bytes(v)) => Some(*v), _ => None }).collect()
}
fn get_text(fields: &[WireField], n: u32) -> String {
get_bytes(fields, n).map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default()
}
/// GvPb_TaskId {1 task_id, 2 file_index}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub struct TaskId { pub task: u64, pub index: u64 }
impl TaskId {
fn parse(fields: &[WireField]) -> Self {
get_bytes(fields, 1).and_then(|b| decode_wire(b).ok())
.map(|f| TaskId { task: get_uint(&f, 1), index: get_uint(&f, 2) }).unwrap_or_default()
}
fn enc(self) -> Enc { Enc::default().uint(1, self.task).uint(2, self.index) }
}
/// GvPb_FileInfo {1 rel_path, 2 size, 3 modified_time}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FileInfo { pub rel_path: String, pub size: u64, pub modified: u64 }
impl FileInfo {
fn parse(b: &[u8]) -> Option<Self> {
let f = decode_wire(b).ok()?;
Some(Self { rel_path: get_text(&f, 1), size: get_uint(&f, 2), modified: get_uint(&f, 3) })
}
fn enc(&self) -> Enc { Enc::default().text(1, &self.rel_path).uint(2, self.size).uint(3, self.modified) }
}
/// Files may arrive inline (repeated field) or as list_data: a FileList {1 files}, compressed
/// when FF_FILE_TRANSFER_FTP_LIST_COMPRESS is negotiated (zlib; gzip/raw deflate tolerated).
fn parse_files(inline: Vec<&[u8]>, list_data: Option<&[u8]>) -> Vec<FileInfo> {
let mut out: Vec<FileInfo> = inline.into_iter().filter_map(FileInfo::parse).collect();
if out.is_empty() {
if let Some(data) = list_data.filter(|d| !d.is_empty()) {
let mut candidates = Vec::new();
let mut buf = Vec::new();
if flate2::read::ZlibDecoder::new(data).read_to_end(&mut buf).is_ok() { candidates.push(std::mem::take(&mut buf)); }
if flate2::read::GzDecoder::new(data).read_to_end(&mut buf).is_ok() { candidates.push(std::mem::take(&mut buf)); }
if flate2::read::DeflateDecoder::new(data).read_to_end(&mut buf).is_ok() { candidates.push(std::mem::take(&mut buf)); }
candidates.push(data.to_vec());
for c in candidates {
if let Ok(f) = decode_wire(&c) {
let files: Vec<FileInfo> = get_all(&f, 1).into_iter().filter_map(FileInfo::parse).collect();
if !files.is_empty() { out = files; break; }
}
}
if out.is_empty() {
log::warn!("File transfer list_data not decoded: bytes={} magic={:02x?}", data.len(), &data[..data.len().min(2)]);
}
}
}
out
}
/// zlib(FileList{1 files}) for list_data.
fn list_data(files: &[FileInfo]) -> Vec<u8> {
let mut list = Enc::default();
for f in files { list = list.msg(1, f.enc()); }
zlib(&list.0)
}
fn zlib(data: &[u8]) -> Vec<u8> {
let mut enc = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
let _ = enc.write_all(data);
enc.finish().unwrap_or_default()
}
fn unix_secs(t: std::io::Result<std::time::SystemTime>) -> u64 {
t.ok().and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok()).map(|d| d.as_secs()).unwrap_or(0)
}
fn io_error(e: &std::io::Error) -> u64 {
match e.kind() {
std::io::ErrorKind::NotFound => FT_NOT_FOUND,
std::io::ErrorKind::PermissionDenied => FT_PERMISSION,
_ if e.raw_os_error() == Some(libc::ENOSPC) => FT_DISK,
_ => FT_IO,
}
}
/// Mirrors the official Mac path translation (UURemoteServer 0x1000b8100): backslashes
/// become "/", a leading "~" is the user's home directory (the viewer opens on "~/"),
/// anything else is rooted at "/".
pub fn normalize(path: &str) -> PathBuf {
let p = path.replace('\\', "/");
// The host registers as a PC, so the viewer builds drive paths ("C:/x", or ":/" when it
// knows no drive letter). Linux has a single root: any drive prefix maps to "/".
let p = match p.split_once(':') {
Some((drive, rest)) if drive.len() <= 1 && drive.chars().all(|c| c.is_ascii_alphabetic())
&& (rest.is_empty() || rest.starts_with('/')) => rest.to_string(),
_ => p,
};
let (mut out, p) = match p.strip_prefix('~') {
Some(rest) if rest.is_empty() || rest.starts_with('/') => (home(), rest.to_string()),
_ => (PathBuf::from("/"), p),
};
for part in p.split('/') {
match part { "" | "." => {}, ".." => { out.pop(); }, x => out.push(x) }
}
out
}
fn home() -> PathBuf { std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("/")) }
/// GvPb_FileEntry {1 entry_type, 2 name, 3 size, 4 modified_time, 5 full_path, 6 icon_type}
fn entry(kind: u64, name: &str, size: u64, modified: u64, full: &str) -> Enc {
Enc::default().uint(1, kind).text(2, name).uint(3, size).uint(4, modified).text(5, full)
}
/// The viewer treats this host as a PC and opens "此电脑" by asking for the bare drive root
/// (":/" — no drive letter is known) or an empty path.
pub fn is_this_pc(path: &str) -> bool {
let p = path.trim().replace('\\', "/");
if p.is_empty() { return true; }
let p = p.trim_end_matches('/');
p.ends_with(':') && p.len() <= 2 && p[..p.len() - 1].chars().all(|c| c.is_ascii_alphabetic())
}
/// XDG user directory (e.g. XDG_DOCUMENTS_DIR="$HOME/文档") when it exists.
fn xdg_dir(key: &str) -> Option<PathBuf> {
let home = home();
let conf = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from).unwrap_or_else(|| home.join(".config"));
let text = std::fs::read_to_string(conf.join("user-dirs.dirs")).ok()?;
let value = text.lines().find_map(|l| l.trim().strip_prefix(&format!("{key}=")))?.trim().trim_matches('"').to_string();
let path = PathBuf::from(value.replace("$HOME", &home.to_string_lossy()));
(path != home && path.is_dir()).then_some(path)
}
/// "此电脑": like Windows, user folders first (Documents, Desktop, Downloads), then the home
/// folder, then the filesystem root as the only "drive".
fn this_pc() -> Vec<Enc> {
let home = home();
let name = |p: &Path| p.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| p.to_string_lossy().into_owned());
let modified = |p: &Path| unix_secs(std::fs::metadata(p).and_then(|m| m.modified()));
let mut out = Vec::new();
for key in ["XDG_DOCUMENTS_DIR", "XDG_DESKTOP_DIR", "XDG_DOWNLOAD_DIR"] {
if let Some(dir) = xdg_dir(key) { out.push(entry(FT_DIR, &name(&dir), 0, modified(&dir), &dir.to_string_lossy())); }
}
out.push(entry(FT_DIR, &name(&home), 0, modified(&home), &home.to_string_lossy()));
out.push(entry(FT_DIR_DRIVE, "/", 0, 0, "/"));
out
}
pub fn list_directory(path: &str) -> Result<Vec<Enc>, u64> {
if is_this_pc(path) { return Ok(this_pc()); }
let dir = normalize(path);
let read = std::fs::read_dir(&dir).map_err(|e| io_error(&e))?;
let mut list = Vec::new();
for item in read.flatten() {
let name = item.file_name().to_string_lossy().into_owned();
let full = dir.join(&name);
// Follow links so linked folders stay navigable.
let Ok(meta) = std::fs::metadata(&full).or_else(|_| item.metadata()) else { continue };
let kind = if meta.is_dir() { FT_DIR } else { FT_FILE };
let size = if meta.is_dir() { 0 } else { meta.len() };
list.push((meta.is_dir(), name.to_lowercase(), entry(kind, &name, size, unix_secs(meta.modified()), &full.to_string_lossy())));
}
list.sort_by(|a, b| b.0.cmp(&a.0).then_with(|| a.1.cmp(&b.1)));
Ok(list.into_iter().map(|(_, _, e)| e).collect())
}
/// Recursive file list for a download request: (folder_name, files). For a folder, rel paths are
/// relative to it; for a single file, folder_name is empty and rel_path is the file name.
fn collect_download(root: &Path) -> std::io::Result<(String, Vec<(FileInfo, PathBuf)>)> {
let meta = std::fs::metadata(root)?;
let name = root.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
let mut out = Vec::new();
if !meta.is_dir() {
out.push((FileInfo { rel_path: name.clone(), size: meta.len(), modified: unix_secs(meta.modified()) }, root.to_path_buf()));
return Ok((String::new(), out));
}
let mut stack = vec![root.to_path_buf()];
while let Some(dir) = stack.pop() {
for item in std::fs::read_dir(&dir)?.flatten() {
let p = item.path();
let Ok(m) = std::fs::metadata(&p) else { continue };
if m.is_dir() { stack.push(p); continue; }
if !m.is_file() { continue; }
let rel = p.strip_prefix(root).map(|r| r.to_string_lossy().into_owned()).unwrap_or_default();
// Relative to folder_name, which the response carries separately.
out.push((FileInfo { rel_path: rel, size: m.len(), modified: unix_secs(m.modified()) }, p));
}
}
Ok((name, out))
}
fn unique_path(p: &Path) -> PathBuf {
if !p.exists() { return p.to_path_buf(); }
let stem = p.file_stem().map(|s| s.to_string_lossy().into_owned()).unwrap_or_default();
let ext = p.extension().map(|e| format!(".{}", e.to_string_lossy())).unwrap_or_default();
for i in 1..10_000 {
let c = p.with_file_name(format!("{stem} ({i}){ext}"));
if !c.exists() { return c; }
}
p.to_path_buf()
}
struct UploadTask { target: PathBuf, folder: String, strategy: u64, files: Vec<FileInfo>, open: HashMap<u64, (std::fs::File, PathBuf, u64)> }
/// Per-connection file-transfer state. Outgoing messages are fully framed `Message`s.
pub struct FileSession {
out: mpsc::UnboundedSender<Vec<u8>>,
seq: Arc<AtomicU64>,
next_request: AtomicU64,
/// Like the official host's FileTransferDownloadResponseKey: replies are matched by
/// (response case, task, file index, block id) because the viewer's RpcResponse header
/// does not echo the host's request_id (observed 0).
pending: Mutex<HashMap<(u32, u64, u64, u64), oneshot::Sender<Vec<u8>>>>,
uploads: Mutex<HashMap<u64, UploadTask>>,
/// Downloads run one at a time, in request order (the viewer may ask for several at once).
downloading: Arc<tokio::sync::Mutex<()>>,
first_upload_block: Mutex<Option<u64>>,
}
fn now() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs() }
impl FileSession {
pub fn new(out: mpsc::UnboundedSender<Vec<u8>>, seq: Arc<AtomicU64>) -> Arc<Self> {
Arc::new(Self { out, seq, next_request: AtomicU64::new(1 << 32), pending: Mutex::new(HashMap::new()),
uploads: Mutex::new(HashMap::new()), downloading: Arc::new(Default::default()), first_upload_block: Mutex::new(None) })
}
fn send(&self, which: u32, body: Enc) {
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
let _ = self.out.send(crate::initialization::envelope(seq, now(), which, &body.0));
}
/// RpcResponse{1 header{1 request_id}, 4 ftp{case}}
fn respond(&self, request_id: u64, case: u32, body: Enc) {
let header = Enc::default().uint(1, request_id);
self.send(22, Enc::default().msg(1, header).msg(4, Enc::default().msg(case, body)));
}
/// Host-initiated RpcRequest{1 header, 8 ftp{case}}; resolves with the response's ftp payload.
async fn request(&self, case: u32, body: Enc, key: (u32, u64, u64, u64)) -> Option<Vec<u8>> {
let id = self.next_request.fetch_add(1, Ordering::Relaxed);
let (tx, rx) = oneshot::channel();
self.pending.lock().unwrap().insert(key, tx);
let header = Enc::default().uint(1, id);
self.send(21, Enc::default().msg(1, header).msg(8, Enc::default().msg(case, body)));
match tokio::time::timeout(std::time::Duration::from_secs(30), rx).await {
Ok(Ok(v)) => Some(v),
_ => { self.pending.lock().unwrap().remove(&key); None }
}
}
/// Key of a FileTransferFtpResponse: 3 file_confirm{id}, 4 block_confirm{id, block_id}, 6 result{id}.
fn response_key(ftp: &[u8]) -> Option<(u32, u64, u64, u64)> {
let fields = decode_wire(ftp).ok()?;
let case = fields.iter().find(|f| matches!(f.value, WireValue::Bytes(_)))?;
let WireValue::Bytes(inner) = case.value else { return None };
let inner = decode_wire(inner).ok()?;
let id = TaskId::parse(&inner);
let block = if case.number == 4 { get_uint(&inner, 2) } else { 0 };
Some((case.number, id.task, id.index, block))
}
/// Handles one decoded Message. Returns true when it carried file-transfer RPC.
pub fn handle(self: &Arc<Self>, message: &[WireField]) -> bool {
let mut handled = false;
for field in message {
match (field.number, &field.value) {
(21, WireValue::Bytes(rpc)) => {
let Ok(rpc) = decode_wire(rpc) else { continue };
let Some(ftp) = get_bytes(&rpc, 8) else { continue };
let request_id = get_bytes(&rpc, 1).and_then(|h| decode_wire(h).ok()).map(|h| get_uint(&h, 1)).unwrap_or(0);
handled = true;
if let Ok(ftp) = decode_wire(ftp) { self.on_request(request_id, &ftp); }
}
(22, WireValue::Bytes(rpc)) => {
let Ok(rpc) = decode_wire(rpc) else { continue };
let Some(ftp) = get_bytes(&rpc, 4) else { continue };
handled = true;
match Self::response_key(ftp) {
Some(key) => match self.pending.lock().unwrap().remove(&key) {
Some(tx) => { let _ = tx.send(ftp.to_vec()); }
None => log::info!("File transfer response without pending request: case={} task={} index={} block={}", key.0, key.1, key.2, key.3),
},
None => log::info!("File transfer response undecodable: bytes={}", ftp.len()),
}
}
_ => {}
}
}
handled
}
fn on_request(self: &Arc<Self>, rid: u64, ftp: &[WireField]) {
let Some(case) = ftp.iter().find(|f| matches!(f.value, WireValue::Bytes(_))) else {
log::warn!("File transfer request without payload: fields={:?}", ftp.iter().map(|f| f.number).collect::<Vec<_>>());
return;
};
let WireValue::Bytes(body) = case.value else { return };
let Ok(f) = decode_wire(body) else { log::warn!("File transfer request {} undecodable", case.number); return };
match case.number {
10 => self.read_dir(rid, &f),
1 => self.receive_request(rid, &f),
3 => self.file_ask(rid, &f),
4 => self.file_block(rid, &f),
9 => self.complete(rid, &f),
2 => self.send_request(rid, &f),
5 | 6 | 7 | 8 => self.file_operation(rid, case.number, &f),
11 => self.file_exist(rid, &f),
12 => { log::info!("File transfer clear_send_temp"); self.respond(rid, 5, Enc::default().uint(1, FT_SUCCEEDED)); }
n => log::info!("File transfer request case {} not implemented: fields={:?}", n, f.iter().map(|x| x.number).collect::<Vec<_>>()),
}
}
/// read_dir {1 id, 2 path} -> file_directory {1 id, 2 path, 3 entries, 4 file_error}
fn read_dir(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f);
let requested = get_text(f, 2);
let drive = requested.len() >= 2 && requested.as_bytes()[1] == b':' && requested.as_bytes()[0].is_ascii_alphabetic();
log::info!("File transfer read_dir path shape: len={} drive_letter={} backslashes={} leading_slash={} exists={}",
requested.chars().count(), drive, requested.matches('\\').count(), requested.starts_with('/'),
!requested.is_empty() && normalize(&requested).is_dir());
if !requested.is_empty() && requested.chars().count() <= 16 && !normalize(&requested).is_dir() {
// Short unresolved names are viewer-side virtual locations; record them to map correctly.
log::info!("File transfer read_dir unresolved short path: {:?}", requested);
}
// Like the official Mac reader: only the virtual root path lists roots; anything else
// is read as-is (backslashes normalized) and errors are reported, never redirected.
let path = requested;
let mut body = id.enc();
body = Enc::default().msg(1, body).text(2, &path);
match list_directory(&path) {
Ok(entries) => {
// FF_FILE_TRANSFER_FTP_LIST_COMPRESS: the official host sends the listing as
// zlib(DirectoryData{1 entries}) in dir_data; entries are kept for older viewers.
let mut listing = Enc::default();
for e in &entries { listing = listing.bytes(1, &e.0); }
let compressed = zlib(&listing.0);
log::info!("File transfer read_dir: request_id={} root={} entries={} dir_data_bytes={}", rid, path.is_empty(), entries.len(), compressed.len());
for e in entries { body = body.msg(3, e); }
body = body.uint(4, FT_SUCCEEDED).bytes(5, &compressed);
}
Err(code) => { log::info!("File transfer read_dir failed: request_id={} error={}", rid, code); body = body.uint(4, code); }
}
self.respond(rid, 7, body);
}
/// rename{1 path,2 new_name} dir_create{1 path} remove_file{1 path} remove_dir{1 id,2 path,3 recursive}
fn file_operation(&self, rid: u64, case: u32, f: &[WireField]) {
let path_field = if case == 8 { 2 } else { 1 };
let raw = get_text(f, path_field);
let path = normalize(&raw);
let result = match case {
5 => { let new = get_text(f, 2); if new.contains('/') || new.contains('\\') || new.is_empty() { Err(std::io::Error::from(std::io::ErrorKind::InvalidInput)) } else { std::fs::rename(&path, path.with_file_name(new)) } }
6 => std::fs::create_dir_all(&path),
7 => std::fs::remove_file(&path),
// The viewer confirms with the user and sends remove_dir for any selected item without
// the recursive flag (like Explorer): files are unlinked, folders removed with contents.
_ => match std::fs::symlink_metadata(&path) {
Ok(m) if m.is_dir() => std::fs::remove_dir_all(&path),
Ok(_) => std::fs::remove_file(&path),
Err(e) => Err(e),
},
};
let code = match &result { Ok(()) => FT_SUCCEEDED, Err(e) => io_error(e) };
log::info!("File transfer operation: case={} result={} os_error={:?}", case, code, result.as_ref().err().and_then(|e| e.raw_os_error()));
let msg = result.err().map(|e| e.to_string()).unwrap_or_default();
if case == 8 {
// Official removeDir reply (UURemoteServer "文件操作-removeDir 回包"): the response oneof is
// `result` (field 6) = FileTransferResult{1 id, 2 file_error} echoing the request's TaskId,
// not operation_result; the viewer reported 删除文件失败 for operation_result.
self.respond(rid, 6, Enc::default().msg(1, TaskId::parse(f).enc()).uint(2, code));
return;
}
self.respond(rid, 5, Enc::default().uint(1, code).text(2, &msg).text(3, &raw));
}
/// file_exist{1 path, 2 names} -> file_exist_response{1 path, 2 results{1 name,2 has_same,3 has_transfering}}
fn file_exist(&self, rid: u64, f: &[WireField]) {
let raw = get_text(f, 1);
let dir = normalize(&raw);
let mut body = Enc::default().text(1, &raw);
let names = get_all(f, 2);
let mut same = 0;
for n in &names {
let name = String::from_utf8_lossy(n);
let exists = dir.join(name.as_ref()).exists();
same += exists as usize;
body = body.msg(2, Enc::default().text(1, &name).boolean(2, exists));
}
log::info!("File transfer file_exist: names={} existing={}", names.len(), same);
self.respond(rid, 8, body);
}
/// Upload to this host. receive_request{1 id,2 path,3 files,4 strategy,5 folder_name,6 list_data,7 task_unique_id}
fn receive_request(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f);
let target = normalize(&get_text(f, 2));
let folder = get_text(f, 5);
let strategy = get_uint(f, 4);
let files = parse_files(get_all(f, 3), get_bytes(f, 6));
let prefixed = files.iter().filter(|x| !folder.is_empty() && x.rel_path.replace('\\', "/").starts_with(&format!("{folder}/"))).count();
log::info!("File transfer receive_request: task={} files={} bytes={} folder={} rel_prefixed={} strategy={} target_dir={}",
id.task, files.len(), files.iter().map(|x| x.size).sum::<u64>(), !folder.is_empty(), prefixed, strategy, target.is_dir());
let err = if !target.is_dir() { FT_NOT_FOUND } else { FT_SUCCEEDED };
let mut body = Enc::default().msg(1, id.enc());
for x in &files { body = body.msg(2, x.enc()); }
body = body.uint(3, err);
if err == FT_SUCCEEDED && !folder.is_empty() {
// Like the official createEmptyFolderIfNeeded: a folder (possibly empty) is created even
// when its file list is empty.
let mut dir = target.clone();
for part in folder.replace('\\', "/").split('/') { match part { "" | "." | ".." => {}, x => dir.push(x) } }
if let Err(e) = std::fs::create_dir_all(&dir) { log::warn!("File transfer folder create failed: {}", io_error(&e)); }
}
if err == FT_SUCCEEDED {
self.uploads.lock().unwrap().insert(id.task, UploadTask { target, folder, strategy, files, open: HashMap::new() });
}
self.respond(rid, 1, body);
}
/// TaskId.file_index is 1-based (observed: the first file of a task is index 1).
fn file_slot(index: u64) -> Option<usize> { (index as usize).checked_sub(1) }
fn upload_path(task: &UploadTask, index: u64) -> Option<PathBuf> {
let info = task.files.get(Self::file_slot(index)?)?;
let rel = info.rel_path.replace('\\', "/");
let rel = if !task.folder.is_empty() && !rel.starts_with(&format!("{}/", task.folder)) { format!("{}/{}", task.folder, rel) } else { rel };
let mut p = task.target.clone();
for part in rel.split('/') { match part { "" | "." | ".." => {}, x => p.push(x) } }
Some(p)
}
/// file_ask{1 id,2 last_modified,3 file_size} -> file_confirm{1 id,2 skip,3 err,4 resume_point}
fn file_ask(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f);
let size = get_uint(f, 3);
let mut uploads = self.uploads.lock().unwrap();
let (skip, err, resume) = match uploads.get_mut(&id.task) {
None => (false, FT_PROTOCOL, 0),
Some(task) => match Self::upload_path(task, id.index) {
None => (false, FT_PROTOCOL, 0),
Some(mut path) => {
let existing = std::fs::metadata(&path).ok().filter(|m| m.is_file()).map(|m| m.len());
if existing.is_some() && task.strategy == FOS_SKIP { (true, FT_SUCCEEDED, 0) }
else {
let resume = if task.strategy == FOS_RESUME { existing.filter(|e| *e <= size).unwrap_or(0) } else { 0 };
if existing.is_some() && task.strategy == FOS_DUPLICATE { path = unique_path(&path); }
let opened = path.parent().map(std::fs::create_dir_all).unwrap_or(Ok(()))
.and_then(|_| std::fs::OpenOptions::new().create(true).write(true).truncate(resume == 0).open(&path))
.and_then(|mut file| { file.seek(SeekFrom::Start(resume))?; Ok(file) });
match opened {
Ok(file) => { task.open.insert(id.index, (file, path, resume)); (false, FT_SUCCEEDED, resume) }
Err(e) => (false, io_error(&e), 0),
}
}
}
},
};
log::info!("File transfer file_ask: task={} index={} size={} skip={} err={} resume={}", id.task, id.index, size, skip, err, resume);
self.respond(rid, 3, Enc::default().msg(1, id.enc()).boolean(2, skip).uint(3, err).uint(4, resume));
}
/// file_block{1 id,2 block_id,3 data} -> block_confirm{1 id,2 block_id,3 err,4 block_len}
fn file_block(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f);
let block = get_uint(f, 2);
let data = get_bytes(f, 3).unwrap_or_default();
{
let mut first = self.first_upload_block.lock().unwrap();
if first.is_none() { *first = Some(block); log::info!("File transfer first upload block: block_id={} len={}", block, data.len()); }
}
let err = match self.uploads.lock().unwrap().get_mut(&id.task).and_then(|t| t.open.get_mut(&id.index)) {
None => FT_PROTOCOL,
Some((file, _, written)) => match file.write_all(data) { Ok(()) => { *written += data.len() as u64; FT_SUCCEEDED } Err(e) => io_error(&e) },
};
if err != FT_SUCCEEDED { log::warn!("File transfer block failed: task={} index={} block={} err={}", id.task, id.index, block, err); }
self.respond(rid, 4, Enc::default().msg(1, id.enc()).uint(2, block).uint(3, err).uint(4, data.len() as u64));
}
/// complete{1 id,2 error} -> result{1 id,2 file_error,3 err_msg}
fn complete(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f);
let error = get_uint(f, 2);
let mut uploads = self.uploads.lock().unwrap();
let mut code = FT_SUCCEEDED;
if let Some(task) = uploads.get_mut(&id.task) {
if let Some((file, path, written)) = task.open.remove(&id.index) {
let expected = Self::file_slot(id.index).and_then(|i| task.files.get(i)).map(|x| x.size).unwrap_or(written);
drop(file);
if error != FT_SUCCEEDED && error != 0 { let _ = std::fs::remove_file(&path); code = error; }
else if written != expected { code = FT_IO; }
log::info!("File transfer upload file done: task={} index={} bytes={} expected={} viewer_error={} result={}", id.task, id.index, written, expected, error, code);
}
if task.open.is_empty() && id.index as usize >= task.files.len() { uploads.remove(&id.task); }
}
self.respond(rid, 6, Enc::default().msg(1, id.enc()).uint(2, code));
}
/// Download from this host. send_request{1 id,2 path,3 list_data} -> send_response{1 id,2 err,3 files,4 folder_name}
fn send_request(self: &Arc<Self>, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f);
let raw = get_text(f, 2);
let path = normalize(&raw);
let collected = collect_download(&path).map_err(|e| io_error(&e));
let mut body = Enc::default().msg(1, id.enc());
match collected {
Ok((folder, files)) => {
log::info!("File transfer send_request: task={} files={} bytes={} folder={}", id.task, files.len(), files.iter().map(|x| x.0.size).sum::<u64>(), !folder.is_empty());
body = body.uint(2, FT_SUCCEEDED);
for (info, _) in &files { body = body.msg(3, info.enc()); }
// The viewer indexes this list by file_index; with LIST_COMPRESS it reads list_data.
let infos: Vec<FileInfo> = files.iter().map(|(i, _)| i.clone()).collect();
body = body.text(4, &folder).bytes(5, &list_data(&infos));
self.respond(rid, 2, body);
let me = self.clone();
tokio::spawn(async move {
let _turn = me.downloading.clone().lock_owned().await;
me.run_download(id.task, files).await;
});
}
Err(code) => {
log::info!("File transfer send_request failed: task={} error={}", id.task, code);
self.respond(rid, 2, body.uint(2, code));
}
}
}
async fn run_download(self: &Arc<Self>, task: u64, files: Vec<(FileInfo, PathBuf)>) {
let ok = self.download_files(task, &files).await;
// Official host (FileTransferDownloadCoordinator.startDownloadTransfer, 0x1001cd860): after the
// last file it sends, without waiting, complete{id{task, file_index = -1}, error}. The viewer
// treats an index past its list as the task end and marks the download accepted.
let id = TaskId { task, index: u64::MAX }; // int32 -1, sign-extended varint
self.send(21, Enc::default().msg(1, Enc::default().uint(1, self.next_request.fetch_add(1, Ordering::Relaxed)))
.msg(8, Enc::default().msg(9, Enc::default().msg(1, id.enc()).uint(2, if ok { FT_SUCCEEDED } else { FT_UNEXPECTED }))));
log::info!("File transfer download task done: task={} files={} ok={}", task, files.len(), ok);
}
async fn download_files(self: &Arc<Self>, task: u64, files: &[(FileInfo, PathBuf)]) -> bool {
// Block ids follow the viewer's own uploads (observed 0-based); file indexes are 1-based.
let first_block = self.first_upload_block.lock().unwrap().unwrap_or(0);
for (index, (info, path)) in files.iter().enumerate() {
let index = index + 1;
let id = TaskId { task, index: index as u64 };
let Some(confirm) = self.request(3, Enc::default().msg(1, id.enc()).uint(2, info.modified).uint(3, info.size), (3, id.task, id.index, 0)).await else {
log::warn!("File transfer download: no file_confirm task={} index={}", task, index); return false;
};
let [skip, err, resume] = case_uints(&confirm, 3, [2, 3, 4]);
let skip = skip != 0;
log::info!("File transfer download file_confirm: task={} index={} skip={} err={} resume={}", task, index, skip, err, resume);
if err == FT_CANCELED { return false; }
if skip || (err != FT_SUCCEEDED && err != 0) { continue; }
let result = self.send_file(id, path, resume.min(info.size), first_block).await;
let code = match result { Ok(()) => FT_SUCCEEDED, Err(c) => c };
let reply = self.request(9, Enc::default().msg(1, id.enc()).uint(2, code), (6, id.task, id.index, 0)).await;
let r = reply.map(|r| case_uints(&r, 6, [2])[0]).unwrap_or(0);
log::info!("File transfer download file done: task={} index={} bytes={} result={} viewer_result={}", task, index, info.size, code, r);
if code == FT_CANCELED { return false; }
}
true
}
async fn send_file(self: &Arc<Self>, id: TaskId, path: &Path, resume: u64, first_block: u64) -> Result<(), u64> {
let mut file = std::fs::File::open(path).map_err(|e| io_error(&e))?;
file.seek(SeekFrom::Start(resume)).map_err(|e| io_error(&e))?;
let mut block_id = first_block + resume / DOWNLOAD_BLOCK as u64;
let mut inflight = tokio::task::JoinSet::new();
loop {
let mut buf = vec![0u8; DOWNLOAD_BLOCK];
let n = file.read(&mut buf).map_err(|e| io_error(&e))?;
if n == 0 { break; }
buf.truncate(n);
while inflight.len() >= DOWNLOAD_WINDOW {
if let Some(Ok(code)) = inflight.join_next().await { if code != FT_SUCCEEDED { return Err(code); } }
}
let me = self.clone();
let body = Enc::default().msg(1, id.enc()).uint(2, block_id).bytes(3, &buf);
let key = (4, id.task, id.index, block_id);
inflight.spawn(async move {
match me.request(4, body, key).await {
Some(r) => { let [e] = case_uints(&r, 4, [3]); if e == 0 { FT_SUCCEEDED } else { e } }
None => FT_IO,
}
});
block_id += 1;
}
while let Some(r) = inflight.join_next().await {
if let Ok(code) = r { if code != FT_SUCCEEDED { return Err(code); } }
}
Ok(())
}
}
/// Reads varint fields of one FileTransferFtpResponse case (0 when absent).
fn case_uints<const N: usize>(ftp: &[u8], case: u32, numbers: [u32; N]) -> [u64; N] {
let fields = decode_wire(ftp).ok().and_then(|f| get_bytes(&f, case)).and_then(|b| decode_wire(b).ok()).unwrap_or_default();
numbers.map(|n| get_uint(&fields, n))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn normalizes_windows_and_relative_paths() {
assert_eq!(normalize("C:\\..\\home\\a\\.\\b"), PathBuf::from("/home/a/b"));
assert_eq!(normalize("/tmp//x/../y"), PathBuf::from("/tmp/y"));
assert_eq!(normalize("~/"), home());
assert_eq!(normalize("~\\a"), home().join("a"));
assert_eq!(normalize("~x"), PathBuf::from("/~x"));
assert_eq!(normalize(":/"), PathBuf::from("/"));
assert_eq!(normalize("C:\\home\\a"), PathBuf::from("/home/a"));
assert_eq!(normalize(":/home/a"), PathBuf::from("/home/a"));
assert!(is_this_pc(":/") && is_this_pc("") && is_this_pc("C:\\") && is_this_pc("c:"));
assert!(!is_this_pc("/") && !is_this_pc(":/home") && !is_this_pc("ab:/"));
assert_eq!(normalize("/tmp/a:b"), PathBuf::from("/tmp/a:b"));
}
#[test]
fn read_dir_round_trip_uses_official_field_numbers() {
let dir = std::env::temp_dir().join(format!("uu-ft-{}", std::process::id()));
std::fs::create_dir_all(dir.join("sub")).unwrap();
std::fs::write(dir.join("a.txt"), b"hello").unwrap();
let (tx, mut rx) = mpsc::unbounded_channel();
let s = FileSession::new(tx, Arc::new(AtomicU64::new(1)));
let read = Enc::default().msg(1, TaskId { task: 7, index: 0 }.enc()).text(2, &dir.to_string_lossy());
let rpc = Enc::default().msg(1, Enc::default().uint(1, 99)).msg(8, Enc::default().msg(10, read));
let msg = crate::initialization::envelope(5, 6, 21, &rpc.0);
assert!(s.handle(&decode_wire(&msg).unwrap()));
let out = rx.try_recv().unwrap();
let outer = decode_wire(&out).unwrap();
let rsp = decode_wire(get_bytes(&outer, 22).unwrap()).unwrap();
assert_eq!(get_uint(&decode_wire(get_bytes(&rsp, 1).unwrap()).unwrap(), 1), 99);
let ftp = decode_wire(get_bytes(&rsp, 4).unwrap()).unwrap();
let fd = decode_wire(get_bytes(&ftp, 7).unwrap()).unwrap();
assert_eq!(get_uint(&fd, 4), FT_SUCCEEDED);
let mut listing = Vec::new();
flate2::read::ZlibDecoder::new(get_bytes(&fd, 5).unwrap()).read_to_end(&mut listing).unwrap();
assert_eq!(get_all(&decode_wire(&listing).unwrap(), 1).len(), 2);
let entries: Vec<_> = get_all(&fd, 3).into_iter().map(|e| decode_wire(e).unwrap()).collect();
assert_eq!(entries.len(), 2);
assert_eq!(get_text(&entries[0], 2), "sub");
assert_eq!(get_uint(&entries[0], 1), FT_DIR);
assert_eq!(get_text(&entries[1], 2), "a.txt");
assert_eq!(get_uint(&entries[1], 1), FT_FILE);
assert_eq!(get_uint(&entries[1], 3), 5);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn list_data_round_trips_through_compression() {
let files = vec![FileInfo { rel_path: "d/a.txt".into(), size: 3, modified: 9 }];
assert_eq!(parse_files(vec![], Some(&list_data(&files))), files);
let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
let mut plain = Enc::default(); plain = plain.msg(1, files[0].enc());
gz.write_all(&plain.0).unwrap();
assert_eq!(parse_files(vec![], Some(&gz.finish().unwrap())), files);
}
#[test]
fn upload_writes_blocks_and_confirms() {
let dir = std::env::temp_dir().join(format!("uu-up-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let (tx, mut rx) = mpsc::unbounded_channel();
let s = FileSession::new(tx, Arc::new(AtomicU64::new(1)));
let id = TaskId { task: 3, index: 1 };
let call = |case: u32, body: Enc| {
let rpc = Enc::default().msg(1, Enc::default().uint(1, 1)).msg(8, Enc::default().msg(case, body));
s.handle(&decode_wire(&crate::initialization::envelope(1, 1, 21, &rpc.0)).unwrap());
};
let info = FileInfo { rel_path: "x.bin".into(), size: 6, modified: 0 };
call(1, Enc::default().msg(1, id.enc()).text(2, &dir.to_string_lossy()).msg(3, info.enc()));
call(3, Enc::default().msg(1, id.enc()).uint(3, 6));
call(4, Enc::default().msg(1, id.enc()).uint(2, 1).bytes(3, b"abc"));
call(4, Enc::default().msg(1, id.enc()).uint(2, 2).bytes(3, b"def"));
call(9, Enc::default().msg(1, id.enc()).uint(2, FT_SUCCEEDED));
let mut cases = Vec::new();
while let Ok(m) = rx.try_recv() {
let o = decode_wire(&m).unwrap();
let r = decode_wire(get_bytes(&o, 22).unwrap()).unwrap();
let ftp = decode_wire(get_bytes(&r, 4).unwrap()).unwrap();
cases.push(ftp[0].number);
}
assert_eq!(cases, vec![1, 3, 4, 4, 6]);
assert_eq!(std::fs::read(dir.join("x.bin")).unwrap(), b"abcdef");
std::fs::remove_dir_all(dir).unwrap();
}
}
+296
View File
@@ -0,0 +1,296 @@
//! Official CONTROL initialization protobuf payloads recovered from the Mac app.
//! See analysis/protocol-fix-20261013/control/screen-state-field-maps.json.
//! The caller supplies measured Linux geometry, track binding and permissions.
//! No hardware capabilities or successful actions are inferred here.
fn varint(mut value: u64, out: &mut Vec<u8>) {
while value >= 128 {
out.push((value as u8 & 127) | 128);
value >>= 7;
}
out.push(value as u8);
}
fn integer(number: u32, value: i32, out: &mut Vec<u8>) {
if value != 0 {
varint(u64::from(number) << 3, out);
varint(value as i64 as u64, out);
}
}
fn boolean(number: u32, value: bool, out: &mut Vec<u8>) {
if value { integer(number, 1, out); }
}
fn bytes(number: u32, value: &[u8], out: &mut Vec<u8>) {
varint((u64::from(number) << 3) | 2, out);
varint(value.len() as u64, out);
out.extend_from_slice(value);
}
fn text(number: u32, value: &str, out: &mut Vec<u8>) {
if !value.is_empty() { bytes(number, value.as_bytes(), out); }
}
pub fn envelope(seq: u64, timestamp: u64, which: u32, payload: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
if seq != 0 { out.push(8); varint(seq, &mut out); }
if timestamp != 0 { out.push(16); varint(timestamp, &mut out); }
bytes(which, payload, &mut out);
out
}
#[derive(Debug, Clone, Copy)]
pub struct WinRect {
pub left: i32,
pub top: i32,
pub width: i32,
pub height: i32,
pub pixel_width: i32,
pub pixel_height: i32,
}
impl WinRect {
fn encode(self) -> Result<Vec<u8>, String> {
if self.width <= 0 || self.height <= 0 || self.pixel_width <= 0 || self.pixel_height <= 0 {
return Err("Screen geometry must have positive logical and pixel dimensions".into());
}
let mut out = Vec::new();
for (field, value) in [(1,self.left),(2,self.top),(3,self.width),(4,self.height),(5,self.pixel_width),(6,self.pixel_height)] {
integer(field, value, &mut out);
}
Ok(out)
}
}
pub struct Screen<'a> {
pub id: i32,
pub fps: i32,
pub resolution: WinRect,
pub primary: bool,
/// Measured pixel/logical scale; never zero or guessed from a display name.
pub dpr: f64,
pub display_name: &'a str,
pub video_track_index: i32,
/// Official enum: 0 physical, 1 virtual, 2 super-screen.
pub screen_type: i32,
/// Official enum: 0 unknown, 1 built-in, 2 not built-in.
pub builtin_screen_type: i32,
/// Further selectable (scaled) stream sizes besides `resolution`, for 其他分辨率.
pub scaled: &'a [(i32, i32)],
/// Size currently streamed when it differs from `resolution`.
pub current: Option<(i32, i32)>,
}
impl Screen<'_> {
fn encode(&self) -> Result<Vec<u8>, String> {
if self.id < 0 || self.fps <= 0 || self.video_track_index < 0 {
return Err("Screen id/track must be nonnegative and fps positive".into());
}
if !self.dpr.is_finite() || self.dpr <= 0.0 {
return Err("Screen dpr must be positive and finite".into());
}
if !(0..=2).contains(&self.screen_type) || !(0..=2).contains(&self.builtin_screen_type) {
return Err("Unknown Screen enum value".into());
}
let rect = self.resolution.encode()?;
let mut out = Vec::new();
integer(1, self.id, &mut out);
integer(2, self.fps, &mut out);
bytes(3, &rect, &mut out); // the measured native resolution first
let sized = |(width, height): (i32, i32)| WinRect { width, height, pixel_width: width, pixel_height: height, ..self.resolution }.encode();
for size in self.scaled { bytes(3, &sized(*size)?, &mut out); }
let current = match self.current { Some(size) => sized(size)?, None => rect.clone() };
bytes(4, &current, &mut out); // current_resolution
integer(5, self.screen_type, &mut out);
bytes(6, &rect, &mut out); // init_resolution
boolean(7, self.primary, &mut out);
out.push(65); // field 8 Double: fixed64, not varint
out.extend_from_slice(&self.dpr.to_le_bytes());
// Field 9 dpi_scale omitted: no unmeasured monitor-DPI claim.
text(10, self.display_name, &mut out);
// Field 11 resolution_type omitted: default UNKNOWN is truthful.
integer(12, self.video_track_index, &mut out);
integer(13, self.builtin_screen_type, &mut out);
Ok(out)
}
}
/// Message.which field 7 ScreenSources, including the selected screen id.
pub fn encode_screen_sources(seq: u64, timestamp: u64, screens: &[Screen<'_>], current_id: i32) -> Result<Vec<u8>, String> {
if screens.is_empty() || !screens.iter().any(|s| s.id == current_id) {
return Err("Selected screen must exist in the measured inventory".into());
}
let mut ids = std::collections::HashSet::new();
let mut tracks = std::collections::HashSet::new();
let mut payload = Vec::new();
for screen in screens {
if !ids.insert(screen.id) || !tracks.insert(screen.video_track_index) {
return Err("Screen ids and video track indices must be unique".into());
}
bytes(1, &screen.encode()?, &mut payload);
}
integer(2, current_id, &mut payload);
Ok(envelope(seq, timestamp, 7, &payload))
}
/// Message.which field 8 CaptureChange. Enum: desktop=0, window=1,
/// MuMu=2, hook=3, none=99. Caller confirms the active capture before emitting.
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());
}
let mut payload = Vec::new();
integer(1, capture_type, &mut payload);
integer(2, type_value, &mut payload);
text(3, description, &mut payload);
Ok(envelope(seq, timestamp, 8, &payload))
}
/// Minimal initialization for the caller's measured single Linux framebuffer.
/// Current deployment binding is source_id=0, video_track_index=0. Dimensions
/// describe the source desktop, not the downscaled H264 bitstream. No monitor
/// DPI, audio, input permission, or optional feature versions are advertised.
/// Invalid dimensions/fps produce no messages, never invented fallback values.
pub fn initial_messages(width: u32, height: u32, fps: u32) -> Vec<(u32, Vec<u8>)> {
let (Ok(width), Ok(height), Ok(fps)) = (i32::try_from(width), i32::try_from(height), i32::try_from(fps)) else { return Vec::new(); };
let screen = Screen {
id: 0, fps,
resolution: WinRect { left: 0, top: 0, width, height, pixel_width: width, pixel_height: height },
primary: true, dpr: 1.0, display_name: "", video_track_index: 0,
screen_type: 0, builtin_screen_type: 0, scaled: &[], current: None,
};
let Ok(encoded_screen) = screen.encode() else { return Vec::new(); };
let mut inventory = Vec::new();
bytes(1, &encoded_screen, &mut inventory);
// current_screen_id=0 is an ordinary scalar default. CaptureChange's
// desktop=0/type_value=0 defaults are still represented by the which tag.
vec![(7, inventory), (8, Vec::new())]
}
#[derive(Debug, Clone, Copy)]
pub struct Permissions {
pub assistant: bool,
pub video_capture_allowed: bool,
pub capture_content_visible: bool,
pub audio_capture_allowed: bool,
pub floating_ball: bool,
}
/// Message.field15 SystemStateChange.field3 PermissionState.
pub fn encode_permissions(seq: u64, timestamp: u64, permissions: Permissions) -> Vec<u8> {
let mut state = Vec::new();
for (n, v) in [(1,permissions.assistant),(2,permissions.video_capture_allowed),(3,permissions.capture_content_visible),(4,permissions.audio_capture_allowed),(5,permissions.floating_ball)] {
boolean(n, v, &mut state);
}
let mut change = Vec::new();
bytes(3, &state, &mut change);
envelope(seq, timestamp, 15, &change)
}
/// QuerySystemState StateId=1 expects this secure desktop state notification.
/// Locked/SAS/support flags must come from the current Linux session's evidence.
pub fn encode_secure_desktop(seq: u64, timestamp: u64, locked: bool, sas_shown: bool, supports_auto_logon: bool) -> Vec<u8> {
let mut state = Vec::new();
boolean(1, locked, &mut state);
boolean(2, sas_shown, &mut state);
boolean(5, supports_auto_logon, &mut state);
let mut change = Vec::new();
bytes(1, &state, &mut change);
envelope(seq, timestamp, 15, &change)
}
/// Message.field12 ReportError { 2: error_code, 3: error_msg } (action left default, as the
/// Mac host does for a failed AUTO_UNLOCK_SYSTEM).
pub fn encode_report_error(seq: u64, timestamp: u64, error_code: i32, error_msg: &str) -> Vec<u8> {
let mut report = Vec::new();
integer(2, error_code, &mut report);
text(3, error_msg, &mut report);
envelope(seq, timestamp, 12, &report)
}
#[cfg(test)]
#[path = "protocol.rs"]
mod wire_test_support;
#[cfg(test)]
mod tests {
use super::*;
use super::wire_test_support::{decode_wire, WireValue};
fn nested(data: &[u8], field: u32) -> Vec<u8> {
decode_wire(data).unwrap().into_iter().find_map(|f| {
if f.number == field { if let WireValue::Bytes(b) = f.value { return Some(b.to_vec()); } }
None
}).expect("expected nested field")
}
fn number(data: &[u8], field: u32) -> Option<u64> {
decode_wire(data).unwrap().into_iter().find_map(|f| {
if f.number == field { if let WireValue::Varint(v) = f.value { return Some(v); } }
None
})
}
fn screen() -> Screen<'static> {
Screen { id: 1, fps: 10, resolution: WinRect { left: -1920, top: 0, width: 1920, height: 1080, pixel_width: 1920, pixel_height: 1080 }, primary: true, dpr: 1.0, display_name: "test display", video_track_index: 0, screen_type: 0, builtin_screen_type: 0, scaled: &[], current: None }
}
#[test]
fn screen_inventory_uses_correct_nested_rect_and_fixed64_scale() {
let msg = encode_screen_sources(7, 9, &[screen()], 1).unwrap();
let inventory = nested(&msg, 7);
assert_eq!(number(&inventory, 2), Some(1));
let display = nested(&inventory, 1);
let rect = nested(&display, 4);
assert_eq!(number(&rect, 1), Some((-1920i64) as u64));
assert_eq!(number(&rect, 3), Some(1920));
assert_eq!(number(&rect, 4), Some(1080));
assert_eq!(number(&rect, 5), Some(1920));
assert_eq!(number(&rect, 6), Some(1080));
assert_eq!(number(&display, 12).unwrap_or(0), 0);
assert!(decode_wire(&display).unwrap().iter().any(|f| f.number == 8 && f.value == WireValue::Fixed64(1.0f64.to_le_bytes())));
assert_eq!(nested(&display, 3), rect);
assert_eq!(nested(&display, 6), rect);
}
#[test]
fn minimal_messages_preserve_actual_source_size_and_binding_zero() {
let m = initial_messages(1920, 1080, 10);
assert_eq!(m.len(), 2);
assert_eq!(m[0].0, 7);
assert_eq!(m[1], (8, Vec::<u8>::new()));
let display = nested(&m[0].1, 1);
assert_eq!(number(&display, 1).unwrap_or(0), 0);
assert_eq!(number(&display, 12).unwrap_or(0), 0);
let rect = nested(&display, 4);
assert_eq!(number(&rect, 3), Some(1920));
assert_eq!(number(&rect, 4), Some(1080));
assert!(initial_messages(0, 1080, 10).is_empty());
assert!(initial_messages(u32::MAX, 1080, 10).is_empty());
}
#[test]
fn rejects_missing_or_invalid_measured_inventory() {
assert!(encode_screen_sources(1, 1, &[], 1).is_err());
assert!(encode_screen_sources(1, 1, &[screen()], 2).is_err());
let mut s = screen(); s.resolution.width = 0;
assert!(encode_screen_sources(1, 1, &[s], 1).is_err());
let mut s = screen(); s.dpr = f64::NAN;
assert!(encode_screen_sources(1, 1, &[s], 1).is_err());
assert!(encode_screen_sources(1, 1, &[screen(), screen()], 1).is_err());
}
#[test]
fn permission_state_does_not_claim_audio_or_extra_features() {
let m = encode_permissions(1, 2, Permissions { assistant: false, video_capture_allowed: true, capture_content_visible: true, audio_capture_allowed: false, floating_ball: false });
let p = nested(&nested(&m, 15), 3);
assert_eq!(number(&p, 2), Some(1));
assert_eq!(number(&p, 3), Some(1));
assert_eq!(number(&p, 4), None);
assert_eq!(number(&p, 5), None);
}
#[test]
fn default_secure_state_is_explicitly_present() {
let report = encode_report_error(3, 4, -5, "linux auto unlock failed");
let error = nested(&report, 12);
assert_eq!(number(&error, 2), Some((-5i64) as u64)); // int32 negative: 10-byte varint
assert_eq!(number(&error, 1), None);
let state = encode_secure_desktop(1, 2, false, false, false);
assert_eq!(nested(&nested(&state, 15), 1), Vec::<u8>::new());
}
#[test]
fn capture_change_preserves_official_desktop_enum_default() {
let c = encode_capture_change(1, 2, 0, 1, "test capture").unwrap();
let p = nested(&c, 8);
assert_eq!(number(&p, 1).unwrap_or(0), 0);
assert_eq!(number(&p, 2), Some(1));
assert!(encode_capture_change(1, 2, 4, 1, "").is_err());
}
}
+200
View File
@@ -0,0 +1,200 @@
//! Native Linux X11 Input Injection Engine via XTest
#[cfg(target_os = "linux")]
extern "C" {
fn x11_mouse_move(x: libc::c_int, y: libc::c_int) -> libc::c_int;
fn x11_mouse_relative(dx: libc::c_int, dy: libc::c_int) -> libc::c_int;
fn x11_mouse_button(button: libc::c_int, is_press: libc::c_int) -> libc::c_int;
fn x11_pointer_state(x:*mut libc::c_int,y:*mut libc::c_int,mask:*mut libc::c_uint)->libc::c_int;
fn x11_key_symbol(symbol: libc::c_ulong, is_press: libc::c_int) -> libc::c_int;
fn x11_key_event(keycode: libc::c_int, is_press: libc::c_int) -> libc::c_int;
}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_mouse_move(_: libc::c_int, _: libc::c_int) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_mouse_button(_: libc::c_int, _: libc::c_int) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_key_event(_: libc::c_int, _: libc::c_int) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_key_symbol(_: libc::c_ulong, _: libc::c_int) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_mouse_relative(_: libc::c_int, _: libc::c_int) -> libc::c_int {0}
#[derive(Default)]
struct PendingPointer {
absolute: Option<(i32,i32)>,
relative: (i64,i64),
scroll: (i64,i64),
}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_pointer_state(_: *mut libc::c_int,_:*mut libc::c_int,_:*mut libc::c_uint)->libc::c_int {-1}
#[derive(Default)]
struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collections::BTreeSet<u64> }
pub struct InputInjector { portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput> }
impl InputInjector {
pub fn new() -> Self {
Self { portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
}
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) { *self.portal.lock().unwrap()=session; }
pub fn mouse_move(&self, x: i32, y: i32) {
self.inject_move(x,y,false);
}
pub fn mouse_absolute_normalized(&self, x: f64, y: f64, size: (u32,u32)) {
if let Some(position) = crate::input_mapping::normalized_pointer(x,y,size.0,size.1) {
let mut pending = self.pending.lock().unwrap();
pending.absolute = Some(position);
pending.relative = (0,0);
}
}
pub fn mouse_relative(&self, dx: i32, dy: i32) {
if dx.unsigned_abs() <= 65535 && dy.unsigned_abs() <= 65535 {
let mut pending = self.pending.lock().unwrap();
pending.relative.0 = (pending.relative.0 + i64::from(dx)).clamp(-65535,65535);
pending.relative.1 = (pending.relative.1 + i64::from(dy)).clamp(-65535,65535);
}
}
pub fn mouse_scroll(&self, dx: i32, dy: i32) {
// Official Mac normal wheel=120; precise trackpads use smaller values.
let mut pending = self.pending.lock().unwrap();
pending.scroll.0 = (pending.scroll.0 + i64::from(dx)).clamp(-12000,12000);
pending.scroll.1 = (pending.scroll.1 + i64::from(dy)).clamp(-12000,12000);
}
pub fn start_pointer_worker(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> {
let input = self.clone();
tokio::spawn(async move {
let mut tick = tokio::time::interval(std::time::Duration::from_millis(4));
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop { tick.tick().await; input.flush_pointer(); }
})
}
pub fn discard_pointer(&self) { *self.pending.lock().unwrap() = PendingPointer::default(); }
pub fn flush_pointer(&self) {
// Hold the queue lock through injection so an older timer tick cannot
// overwrite a newer position flushed before a button transition.
let mut pending = self.pending.lock().unwrap();
let motion = std::mem::take(&mut *pending);
pending.scroll = (motion.scroll.0 % 120, motion.scroll.1 % 120);
if let Some((x,y)) = motion.absolute { self.inject_move(x,y,false); }
if motion.relative != (0,0) { self.inject_move(motion.relative.0 as i32,motion.relative.1 as i32,true); }
for (value, positive, negative) in [(motion.scroll.1,4,5),(motion.scroll.0,7,6)] {
let count = value / 120;
let button = if count > 0 { positive } else { negative };
for _ in 0..count.unsigned_abs().min(100) {
self.inject_button(button,true); self.inject_button(button,false);
}
}
}
pub fn wire_mouse_button(&self, button: i32, is_press: bool) {
if let Some(mapped) = crate::input_mapping::mouse_button_to_x11(button) { self.mouse_button(mapped,is_press); }
}
pub fn mouse_button(&self, button: i32, is_press: bool) {
self.flush_pointer();
let result = self.inject_button(button,is_press);
if result == 0 {
let mut held = self.held.lock().unwrap();
if is_press { held.buttons.insert(button); } else { held.buttons.remove(&button); }
} else { log::warn!("Desktop mouse injection failed: {}",result); }
static BUTTON_AUDIT:std::sync::atomic::AtomicUsize=std::sync::atomic::AtomicUsize::new(0);
if self.backend==crate::desktop_backend::DesktopBackend::X11 && BUTTON_AUDIT.fetch_add(1,std::sync::atomic::Ordering::Relaxed)<24 {
let (mut x,mut y,mut mask)=(0,0,0);
let query=unsafe {x11_pointer_state(&mut x,&mut y,&mut mask)};
log::info!("Pointer button audit: button={} down={} result={} query={} x={} y={} mask={}",button,is_press,result,query,x,y,mask);
}
}
pub fn windows_key_event(&self, key: i32, is_press: bool) {
if let Some(symbol) = crate::input_mapping::windows_vk_to_keysym(key) {
let result = self.inject_key(symbol,is_press);
static AUDIT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if AUDIT.fetch_add(1,std::sync::atomic::Ordering::Relaxed) < 8 {
log::info!("Desktop keyboard injection outcome: result={result}");
}
if result == 0 {
let mut held=self.held.lock().unwrap();
if is_press {held.keys.insert(symbol);} else {held.keys.remove(&symbol);}
}
}
}
pub fn release_held(&self) {
self.discard_pointer();
let mut held=self.held.lock().unwrap();
for button in &held.buttons {self.inject_button(*button,false);}
for key in &held.keys {self.inject_key(*key,false);}
*held=HeldInput::default();
}
fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return if portal.move_pointer(f64::from(x),f64::from(y),relative).is_ok() {0} else {-1}; }
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return -1;}
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::move_pointer(x,y,relative) }
else if relative { unsafe { x11_mouse_relative(x,y) } } else { unsafe { x11_mouse_move(x,y) } }
}
fn inject_button(&self,button:i32,pressed:bool)->i32 {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return if portal.button(button,pressed).is_ok() {0} else {-1}; }
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return -1;}
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::button(button,pressed) }
else { unsafe { x11_mouse_button(button,i32::from(pressed)) } }
}
fn inject_key(&self,symbol:u64,pressed:bool)->i32 {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return if portal.key(symbol,pressed).is_ok() {0} else {-1}; }
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return -1;}
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::key(symbol,pressed) }
else { unsafe { x11_key_symbol(symbol as libc::c_ulong,i32::from(pressed)) } }
}
pub fn key_event(&self, keycode: i32, is_press: bool) {
if self.backend!=crate::desktop_backend::DesktopBackend::X11 { return; }
unsafe { x11_key_event(keycode, if is_press { 1 } else { 0 }) };
}
}
#[cfg(test)]
mod motion_tests {
use super::*;
#[test]
fn coalesces_absolute_history_to_latest_position() {
let input = InputInjector::new();
input.mouse_absolute_normalized(0.1,0.1,(1920,1080));
input.mouse_absolute_normalized(0.9,0.9,(1920,1080));
assert_eq!(input.pending.lock().unwrap().absolute,Some((1727,971)));
}
#[test]
fn preserves_relative_distance_after_latest_absolute() {
let input = InputInjector::new();
input.mouse_relative(10,20);
input.mouse_absolute_normalized(0.5,0.5,(1920,1080));
input.mouse_relative(3,-2); input.mouse_relative(4,5);
let state = input.pending.lock().unwrap();
assert_eq!(state.absolute,Some((960,540)));
assert_eq!(state.relative,(7,3));
}
#[test]
fn button_transition_flushes_motion_and_teardown_discards_pending() {
let input = InputInjector::new();
input.mouse_absolute_normalized(0.5,0.5,(1920,1080));
input.mouse_button(1,true);
assert!(input.pending.lock().unwrap().absolute.is_none());
input.mouse_relative(1,2); input.discard_pointer();
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
}
}
#[cfg(test)]
mod scroll_tests {
use super::*;
#[test]
fn precise_scroll_accumulates_sub_notch_remainder() {
let input = InputInjector::new();
input.mouse_scroll(0, 2); input.flush_pointer();
assert_eq!(input.pending.lock().unwrap().scroll,(0,2));
input.mouse_scroll(0,118); input.flush_pointer();
assert_eq!(input.pending.lock().unwrap().scroll,(0,0));
input.mouse_scroll(-125,-125); input.flush_pointer();
assert_eq!(input.pending.lock().unwrap().scroll,(-5,-5));
}
}
+174
View File
@@ -0,0 +1,174 @@
//! Translate UU's verified Windows-VK input path into X11 KeySyms.
//! A KeySym is not an X11 keycode: the input engine must resolve it against the
//! active X keyboard mapping (e.g. XKeysymToKeycode) before XTest injection.
//! Letters use the unshifted lowercase symbol; separate modifier events carry
//! Shift/Ctrl/Alt state. Unknown VKs are ignored instead of injecting raw values.
/// Map an official Windows virtual-key identifier to a base X11 KeySym.
/// The wire has no extended-key bit; VK_RETURN consequently means Return.
/// OEM punctuation follows the US base-symbol interpretation; other physical
/// layouts may need their own OEM policy. OEM_102 is deliberately unsupported.
pub fn windows_vk_to_keysym(vk: i32) -> Option<u64> {
let keysym = match vk {
0x30..=0x39 => vk as u64, // 0..9
0x41..=0x5a => (vk + 0x20) as u64, // A..Z -> a..z
0x60..=0x69 => 0xffb0 + (vk - 0x60) as u64, // KP_0..KP_9
0x70..=0x87 => 0xffbe + (vk - 0x70) as u64, // F1..F24
0x08 => 0xff08, // BackSpace
0x09 => 0xff09, // Tab
0x0c => 0xff0b, // Clear
0x0d => 0xff0d, // Return
0x10 | 0xa0 => 0xffe1, // Shift / Shift_L
0xa1 => 0xffe2, // Shift_R
0x11 | 0xa2 => 0xffe3, // Control / Control_L
0xa3 => 0xffe4, // Control_R
0x12 | 0xa4 => 0xffe9, // Alt / Alt_L
0xa5 => 0xffea, // Alt_R
0x13 => 0xff13, // Pause
0x14 => 0xffe5, // Caps_Lock
0x1b => 0xff1b, // Escape
0x20 => 0x0020, // space
0x21 => 0xff55, // Prior / Page_Up
0x22 => 0xff56, // Next / Page_Down
0x23 => 0xff57, // End
0x24 => 0xff50, // Home
0x25 => 0xff51, // Left
0x26 => 0xff52, // Up
0x27 => 0xff53, // Right
0x28 => 0xff54, // Down
0x2c => 0xff61, // Print
0x2d => 0xff63, // Insert
0x2e => 0xffff, // Delete
0x5b => 0xffeb, // Super_L
0x5c => 0xffec, // Super_R
0x5d => 0xff67, // Menu
0x6a => 0xffaa, // KP_Multiply
0x6b => 0xffab, // KP_Add
0x6c => 0xffac, // KP_Separator
0x6d => 0xffad, // KP_Subtract
0x6e => 0xffae, // KP_Decimal
0x6f => 0xffaf, // KP_Divide
0x90 => 0xff7f, // Num_Lock
0x91 => 0xff14, // Scroll_Lock
0xba => 0x003b, // OEM_1: semicolon
0xbb => 0x003d, // OEM_PLUS: equal
0xbc => 0x002c, // OEM_COMMA
0xbd => 0x002d, // OEM_MINUS
0xbe => 0x002e, // OEM_PERIOD
0xbf => 0x002f, // OEM_2: slash
0xc0 => 0x0060, // OEM_3: grave
0xdb => 0x005b, // OEM_4: bracketleft
0xdc => 0x005c, // OEM_5: backslash
0xdd => 0x005d, // OEM_6: bracketright
0xde => 0x0027, // OEM_7: apostrophe
// OEM_102 depends on the physical keyboard/layout; do not guess.
_ => return None,
};
Some(keysym)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn verified_shift_and_left_use_named_keysyms() {
assert_eq!(windows_vk_to_keysym(160), Some(0xffe1));
assert_eq!(windows_vk_to_keysym(37), Some(0xff51));
assert_ne!(windows_vk_to_keysym(160), Some(160));
}
#[test]
fn letters_use_unshifted_symbols_and_digits_keep_ascii() {
assert_eq!(windows_vk_to_keysym(65), Some(u64::from(b'a')));
assert_eq!(windows_vk_to_keysym(90), Some(u64::from(b'z')));
for digit in b'0'..=b'9' {
assert_eq!(windows_vk_to_keysym(i32::from(digit)), Some(u64::from(digit)));
}
}
#[test]
fn modifiers_preserve_left_and_right_identity() {
let variants = [
(0x10, 0xffe1), (0xa0, 0xffe1), (0xa1, 0xffe2),
(0x11, 0xffe3), (0xa2, 0xffe3), (0xa3, 0xffe4),
(0x12, 0xffe9), (0xa4, 0xffe9), (0xa5, 0xffea),
(0x5b, 0xffeb), (0x5c, 0xffec),
];
for (vk, expected) in variants {
assert_eq!(windows_vk_to_keysym(vk), Some(expected));
}
}
#[test]
fn function_and_keypad_ranges_have_correct_endpoints() {
assert_eq!(windows_vk_to_keysym(112), Some(0xffbe));
assert_eq!(windows_vk_to_keysym(135), Some(0xffd5));
assert_eq!(windows_vk_to_keysym(96), Some(0xffb0));
assert_eq!(windows_vk_to_keysym(105), Some(0xffb9));
assert_eq!(windows_vk_to_keysym(106), Some(0xffaa));
assert_eq!(windows_vk_to_keysym(111), Some(0xffaf));
}
#[test]
fn navigation_and_oem_base_keys_are_not_raw_keycodes() {
assert_eq!(windows_vk_to_keysym(46), Some(0xffff));
assert_eq!(windows_vk_to_keysym(36), Some(0xff50));
assert_eq!(windows_vk_to_keysym(186), Some(u64::from(b';')));
assert_eq!(windows_vk_to_keysym(187), Some(u64::from(b'=')));
assert_eq!(windows_vk_to_keysym(220), Some(u64::from(b'\\')));
assert_eq!(windows_vk_to_keysym(222), Some(u64::from(b'\'')));
}
#[test]
fn unknown_or_layout_specific_keys_are_ignored() {
for vk in [-1, 0, 7, 21, 136, 226, 255, 256, i32::MAX] {
assert_eq!(windows_vk_to_keysym(vk), None);
}
}
}
/// Official Mac CONTROL absolute coordinates are normalized to the source screen.
pub fn normalized_pointer(x: f64, y: f64, width: u32, height: u32) -> Option<(i32, i32)> {
if width == 0 || height == 0 || width > i32::MAX as u32 || height > i32::MAX as u32
|| !x.is_finite() || !y.is_finite() || !(0.0..=1.0).contains(&x) || !(0.0..=1.0).contains(&y) { return None; }
Some(((x * (width - 1) as f64).round() as i32, (y * (height - 1) as f64).round() as i32))
}
#[cfg(test)]
mod pointer_tests {
use super::normalized_pointer;
#[test]
fn maps_source_screen_edges_and_center() {
assert_eq!(normalized_pointer(0.0, 0.0, 1920, 1080), Some((0,0)));
assert_eq!(normalized_pointer(1.0, 1.0, 1920, 1080), Some((1919,1079)));
assert_eq!(normalized_pointer(0.5, 0.5, 1920, 1080), Some((960,540)));
}
#[test]
fn maps_observed_editor_titlebar_coordinate() {
assert_eq!(normalized_pointer(0.6805736636245111, 0.15990730011587487,1920,1080),Some((1306,173)));
}
#[test]
fn rejects_invalid_coordinate_or_screen_dimensions() {
assert_eq!(normalized_pointer(f64::NAN,0.5,1920,1080),None);
assert_eq!(normalized_pointer(0.5,f64::INFINITY,1920,1080),None);
assert_eq!(normalized_pointer(-0.1,0.5,1920,1080),None);
assert_eq!(normalized_pointer(0.5,1.1,1920,1080),None);
assert_eq!(normalized_pointer(0.5,0.5,0,1080),None);
}
}
/// Official Mac sends mouse button bitmasks, not X11 button ordinals.
pub fn mouse_button_to_x11(button: i32) -> Option<i32> {
match button { 1 => Some(1), 2 => Some(3), 4 => Some(2), _ => None }
}
#[cfg(test)]
mod button_tests {
#[test]
fn maps_verified_button_bitmasks() {
assert_eq!(super::mouse_button_to_x11(1),Some(1));
assert_eq!(super::mouse_button_to_x11(2),Some(3));
assert_eq!(super::mouse_button_to_x11(4),Some(2));
assert_eq!(super::mouse_button_to_x11(3),None);
}
}
+374
View File
@@ -0,0 +1,374 @@
//! `uuremote-server login`: register this machine as a UU PC host and bind it to an account
//! by scanning a QR code with the UU mobile app, the same flow as the official clients:
//! 1. POST /api/v1/device/windows/init (anonymous, hardware summary) -> device_id
//! 2. POST /api/v1/qrcode/gen/login -> qrcode_jump_url (QR content), token (login ticket)
//! 3. POST /api/v1/qrcode/login/status {token, qrcode_jump_url, login_status}: long poll, 1..4
//! 4. POST /api/v1/login/by_qrcode {token, qrcode_jump_url} -> user_id, token (JWT carries csrf)
//! Field names: server 422 validation and the official Mac client's Codable models
//! (analysis/tools-fix-20261013/viewer-fieldmd.json). Results are written to the private
//! config file (chmod 600). Tokens and tickets are never printed or logged.
use crate::auth::{Credentials, UUAuthClient};
use crate::login_ui::{LoginUi, Tone};
use serde_json::{json, Value};
use std::time::Duration;
fn read(path: &str) -> String { std::fs::read_to_string(path).map(|s| s.trim().to_string()).unwrap_or_default() }
fn random_uuid() -> String {
let mut b = [0u8; 16];
if let Ok(mut f) = std::fs::File::open("/dev/urandom") { use std::io::Read; let _ = f.read_exact(&mut b); }
b[6] = (b[6] & 0x0f) | 0x40;
b[8] = (b[8] & 0x3f) | 0x80;
let h = hex::encode(b);
format!("{}-{}-{}-{}-{}", &h[..8], &h[8..12], &h[12..16], &h[16..20], &h[20..])
}
/// /etc/machine-id as a GUID, the closest Linux analogue of Windows MachineGuid.
fn machine_guid() -> String {
let id = read("/etc/machine-id");
if id.len() == 32 && id.bytes().all(|c| c.is_ascii_hexdigit()) {
format!("{}-{}-{}-{}-{}", &id[..8], &id[8..12], &id[12..16], &id[16..20], &id[20..])
} else { random_uuid() }
}
fn os_name() -> String {
read("/etc/os-release").lines().find_map(|l| l.strip_prefix("PRETTY_NAME=")).map(|v| v.trim_matches('"').to_string())
.unwrap_or_else(|| "Linux".into())
}
fn cpu_name() -> String {
read("/proc/cpuinfo").lines().find_map(|l| l.strip_prefix("model name").and_then(|r| r.split_once(':')).map(|(_, v)| v.trim().to_string()))
.unwrap_or_else(|| std::env::consts::ARCH.into())
}
fn base_board() -> String {
let v = [read("/sys/class/dmi/id/board_vendor"), read("/sys/class/dmi/id/board_name")].join(" ");
if v.trim().is_empty() { "Unknown".into() } else { v.trim().to_string() }
}
fn video() -> Vec<String> {
if let Ok(out) = std::process::Command::new("lspci").output() {
let list: Vec<String> = String::from_utf8_lossy(&out.stdout).lines()
.filter(|l| l.contains("VGA compatible controller") || l.contains("3D controller") || l.contains("Display controller"))
.filter_map(|l| l.splitn(2, ": ").nth(1).map(str::to_owned)).collect();
if !list.is_empty() { return list; }
}
let mut list = Vec::new();
if let Ok(dir) = std::fs::read_dir("/sys/class/drm") {
for e in dir.flatten() {
let n = e.file_name().to_string_lossy().into_owned();
if n.starts_with("card") && !n.contains('-') {
let dev = e.path().join("device");
list.push(format!("PCI {}:{}", read(&dev.join("vendor").to_string_lossy()).trim_start_matches("0x"),
read(&dev.join("device").to_string_lossy()).trim_start_matches("0x")));
}
}
}
if list.is_empty() { list.push("Unknown".into()); }
list
}
/// Short GPU name for display: lspci "Vendor Corporation Chip [Marketing name] (rev x)" -> "Vendor Marketing name".
fn gpu_label(line: &str) -> String {
let vendor = match line.split_whitespace().next().unwrap_or("") { "Advanced" => "AMD", v => v };
match (line.rfind('['), line.rfind(']')) {
(Some(a), Some(b)) if a < b && &line[a + 1..b] != "AMD/ATI" => format!("{vendor} {}", &line[a + 1..b]),
_ => line.split(" (rev").next().unwrap_or(line).to_string(),
}
}
/// MAC of the first physical interface (one backed by a device), uppercase dash form like Windows.
fn mac() -> String {
let mut names: Vec<String> = std::fs::read_dir("/sys/class/net").map(|d| d.flatten()
.filter(|e| e.path().join("device").exists()).map(|e| e.file_name().to_string_lossy().into_owned()).collect()).unwrap_or_default();
names.sort();
names.iter().map(|n| read(&format!("/sys/class/net/{n}/address"))).find(|m| !m.is_empty() && m != "00:00:00:00:00:00")
.map(|m| m.to_uppercase().replace(':', "-")).unwrap_or_default()
}
fn memory_mb() -> u64 {
read("/proc/meminfo").lines().find_map(|l| l.strip_prefix("MemTotal:"))
.and_then(|v| v.trim().trim_end_matches("kB").trim().parse::<u64>().ok()).map(|kb| kb / 1024).unwrap_or(0)
}
fn screen() -> String {
crate::capture::ScreenCapture::new().map(|c| format!("{}x{}", c.width, c.height)).unwrap_or_else(|_| "1920x1080".into())
}
fn hostname() -> String {
let h = read("/proc/sys/kernel/hostname");
if h.is_empty() { "Linux".into() } else { h }
}
/// csrf claim inside the JWT access token.
fn csrf_from_token(token: &str) -> Option<String> {
use base64::Engine;
let payload = token.split('.').nth(1)?;
let bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(payload.trim_end_matches('=')).ok()?;
serde_json::from_slice::<Value>(&bytes).ok()?.get("csrf")?.as_str().map(str::to_owned)
}
fn data<'a>(path: &str, status: u16, body: &'a Value) -> Result<&'a Value, String> {
let code = body.get("code").and_then(|c| c.as_i64()).unwrap_or(-1);
if status == 200 && code == 0 { return Ok(body.get("data").unwrap_or(&Value::Null)); }
let fields: Vec<String> = body.get("data").and_then(|d| d.as_array()).map(|a| a.iter()
.filter_map(|e| e.get("loc").map(|l| l.to_string())).collect()).unwrap_or_default();
Err(format!("{path}: http {status} code {code} {} {}", body.get("msg").and_then(|m| m.as_str()).unwrap_or(""),
if fields.is_empty() { String::new() } else { format!("fields={}", fields.join(",")) }))
}
fn render_qr(content: &str) -> Result<String, String> {
let code = qrcode::QrCode::new(content.as_bytes()).map_err(|e| format!("QR encode failed: {e}"))?;
Ok(code.render::<qrcode::render::unicode::Dense1x2>().quiet_zone(true)
.dark_color(qrcode::render::unicode::Dense1x2::Light).light_color(qrcode::render::unicode::Dense1x2::Dark).build())
}
/// API code for an expired login QR code.
const QR_EXPIRED: i64 = 1190;
/// QR modules as RGBA pixels: `scale` pixels per module, `quiet` light modules around the code.
fn qr_rgba(content: &str, scale: usize, quiet: usize) -> Result<(Vec<u8>, usize), String> {
let code = qrcode::QrCode::new(content.as_bytes()).map_err(|e| format!("QR encode failed: {e}"))?;
let edge = (code.width() + 2 * quiet) * scale;
let mut rgba = vec![255; edge * edge * 4];
for y in 0..code.width() { for x in 0..code.width() {
if code[(x, y)] == qrcode::Color::Dark {
for dy in 0..scale { for dx in 0..scale {
let offset = (((y + quiet) * scale + dy) * edge + (x + quiet) * scale + dx) * 4;
rgba[offset..offset + 3].fill(0);
}}
}
}}
Ok((rgba, edge))
}
fn write_config(cfg: &Value) -> Result<std::path::PathBuf, String> {
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let path = crate::config::path();
let dir = path.parent().ok_or("config path has no parent")?;
std::fs::create_dir_all(dir).map_err(|e| format!("create {}: {e}", dir.display()))?;
let tmp = path.with_extension("json.tmp");
let mut f = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(&tmp)
.map_err(|e| format!("write {}: {e}", tmp.display()))?;
f.write_all(serde_json::to_string_pretty(cfg).unwrap_or_default().as_bytes()).map_err(|e| e.to_string())?;
f.sync_all().map_err(|e| e.to_string())?;
std::fs::set_permissions(&tmp, std::fs::Permissions::from_mode(0o600)).map_err(|e| e.to_string())?;
std::fs::rename(&tmp, &path).map_err(|e| format!("replace {}: {e}", path.display()))?;
Ok(path)
}
/// One login at a time per config file (a manual `login` and the service's window would race
/// for the same QR session). The lock is released when the returned file is dropped.
fn single_instance() -> Result<std::fs::File, String> {
use std::os::unix::{fs::OpenOptionsExt, io::AsRawFd};
let path = crate::config::path().with_file_name("login.lock");
if let Some(dir) = path.parent() { std::fs::create_dir_all(dir).map_err(|e| format!("create {}: {e}", dir.display()))?; }
let file = std::fs::OpenOptions::new().create(true).write(true).mode(0o600).open(&path)
.map_err(|e| format!("open {}: {e}", path.display()))?;
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
return Err("another login is already in progress (login window already open)".into());
}
Ok(file)
}
/// Service side: no usable login. Like the official host, show the login window, as a `login`
/// child process so GTK never runs inside the daemon, when a display is available and
/// UU_LOGIN_WINDOW is not 0. Returns once the config holds credentials whose token differs
/// from `stale_token` (written by that window or by a manual `uuremote-server login`).
pub async fn wait_for_credentials(stale_token: Option<String>) -> Credentials {
let display = std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some();
let mut window = None;
if display && std::env::var("UU_LOGIN_WINDOW").map_or(true, |v| v != "0") {
// stdout carries the terminal QR (a login ticket): never into the journal.
match std::env::current_exe().and_then(|exe| tokio::process::Command::new(exe).arg("login")
.stdin(std::process::Stdio::null()).stdout(std::process::Stdio::null()).spawn()) {
Ok(child) => { log::info!("Opened the QR login window on the desktop"); window = Some(child); }
Err(e) => log::error!("Opening the login window failed: {e}"),
}
}
if window.is_none() {
log::error!("UU login required: run `uuremote-server login` and scan the QR code; watching {}", crate::config::path().display());
}
loop {
tokio::time::sleep(Duration::from_secs(2)).await;
if let Some(child) = window.as_mut() {
if let Ok(Some(status)) = child.try_wait() {
log::info!("Login window exited ({status}); run `uuremote-server login` to sign in later");
window = None;
}
}
if let Ok(creds) = crate::config::read_fresh().and_then(|f| Credentials::load(f.as_ref())) {
if stale_token.as_deref() != Some(creds.token.as_str()) {
log::info!("UU login found in {}; going online", crate::config::path().display());
return creds; // a still-open window keeps showing its success page until closed
}
}
}
}
/// `gui`: also show the GTK login window when one can be opened (the terminal QR is always printed).
pub async fn run(gui: bool) -> Result<(), String> {
let _lock = single_instance().map_err(|e| { eprintln!("login failed: {e}"); e })?;
let ui = if gui { LoginUi::open(&hostname(), &os_name(), &cpu_name(), &video().iter().map(|v| gpu_label(v)).collect::<Vec<_>>().join("\n")) } else { LoginUi::none() };
let result = tokio::select! {
r = flow(&ui) => r,
_ = ui.wait_closed() => Err("login window closed".into()),
};
match &result {
Ok(name) => {
ui.done(&format!("登录成功\n{name}"));
ui.status("登录信息已保存到本机配置,可以关闭此窗口", Tone::Ok);
}
Err(e) => { eprintln!("login failed: {e}"); ui.status(&format!("登录失败:{e}"), Tone::Error); }
}
if ui.shown() { ui.wait_closed().await; }
result.map(|_| ())
}
/// Returns the account nickname (or user id) on success.
async fn flow(ui: &LoginUi) -> Result<String, String> {
let mut cfg = crate::config::file()?.cloned().unwrap_or_else(|| json!({}));
let get = |cfg: &Value, k: &str| std::env::var(format!("UU_{}", k.to_uppercase())).ok().filter(|v| !v.is_empty())
.or_else(|| cfg.get(k).and_then(|v| v.as_str()).map(str::to_owned)).unwrap_or_default();
let sign_key = Some(get(&cfg, "sign_key")).filter(|k| !k.is_empty()).unwrap_or_else(|| crate::auth::DEFAULT_SIGN_KEY.into());
// Stable host identity: reused across logins so the account keeps one device.
for (key, make) in [("client_id", random_uuid as fn() -> String), ("system_id", || random_uuid().to_uppercase()), ("machine_guid", machine_guid)] {
if get(&cfg, key).is_empty() { cfg[key] = json!(make()); }
}
let mut creds = Credentials { client_id: get(&cfg, "client_id"), system_id: get(&cfg, "system_id"), sign_key, ..Default::default() };
if get(&cfg, "device_id").is_empty() {
let body = json!({
"name": hostname(), "client_id": creds.client_id, "system_id": creds.system_id, "machine_guid": get(&cfg, "machine_guid"),
"os": os_name(), "base_board": base_board(), "cpu": cpu_name(), "video": video(), "mac": mac(),
"memory": memory_mb(), "screen": screen(),
});
let (status, resp) = UUAuthClient::new(creds.clone()).post_json("/api/v1/device/windows/init", &body).await?;
let d = data("device init", status, &resp)?;
let id = d.get("device_id").and_then(|v| v.as_str()).ok_or("device init returned no device_id")?;
println!("Registered device: name={} id={}", d.get("alias").and_then(|v| v.as_str()).unwrap_or(""), id);
cfg["device_id"] = json!(id);
write_config(&cfg)?; // keep the device even if the QR step is abandoned
}
creds.device_id = get(&cfg, "device_id");
let client = UUAuthClient::new(creds.clone());
loop {
let (status, resp) = client.post_json("/api/v1/qrcode/gen/login", &json!({})).await?;
let d = data("qrcode gen", status, &resp)?;
let url = d.get("qrcode_jump_url").and_then(|v| v.as_str()).ok_or("qrcode gen returned no qrcode_jump_url")?.to_string();
let ticket = d.get("token").or_else(|| d.get("status_query_ticket")).and_then(|v| v.as_str())
.ok_or("qrcode gen returned no token")?.to_string();
if ui.shown() {
let modules = qrcode::QrCode::new(url.as_bytes()).map_err(|e| e.to_string())?.width() + 2;
let (rgba, edge) = qr_rgba(&url, (224 / modules).max(2), 1)?;
ui.qr(&rgba, edge);
ui.status("等待扫码…", Tone::Info);
}
if let Some(path)=std::env::var_os("UU_LOGIN_QR_PNG") {
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
let (rgba, edge) = qr_rgba(&url, 8, 4)?;
let mut file=std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(path).map_err(|e|e.to_string())?;
file.write_all(&crate::cursor::encode_png(edge as u32,edge as u32,&rgba)).map_err(|e|e.to_string())?;
}
println!("\nScan with the UU Remote mobile app (网易UU远程 App 扫码登录):\n{}", render_qr(&url)?);
// Status is a long poll: send the state already shown (server enum 1..4; observed:
// 1 waiting, 2 scanned, 4 after the phone confirmed); the server answers when it changes.
let mut login_status = 1i64;
let mut expired = false;
for _ in 0..150 {
let query = json!({"token": ticket, "qrcode_jump_url": url, "login_status": login_status});
let (status, resp) = match client.post_json("/api/v1/qrcode/login/status", &query).await {
Ok(r) => r,
Err(_) => continue, // long-poll timeout: ask again
};
// Code 1190 (HTTP 400, "二维码已失效"): the QR expired; generate a new one.
if resp.get("code").and_then(|c| c.as_i64()) == Some(QR_EXPIRED) {
ui.status("二维码已过期,正在刷新…", Tone::Info);
expired = true; break;
}
let st = data("qrcode status", status, &resp)?.get("status").and_then(|v| v.as_i64()).unwrap_or(login_status);
if st == login_status { continue; }
login_status = st;
match st {
2 => {
println!("已扫码,请在手机上确认 (scanned, confirm on the phone)");
ui.status("已扫码,请在手机上确认登录", Tone::Ok);
}
3 | 4 => {
// A final state: confirmed logs in; cancelled/expired is refused and a new QR follows.
let body = json!({"token": ticket, "qrcode_jump_url": url});
let (status, resp) = client.post_json("/api/v1/login/by_qrcode", &body).await?;
let d = match data("qrcode login", status, &resp) {
Ok(d) => d,
Err(e) => {
println!("QR status {st}: login not granted ({e})");
ui.status("手机端未确认登录,正在刷新二维码…", Tone::Error);
expired = true; break;
}
};
let token = d.get("token").and_then(|v| v.as_str()).ok_or("login returned no token")?;
let user = d.get("user_id").and_then(|v| v.as_str()).ok_or("login returned no user_id")?;
cfg["token"] = json!(token);
cfg["user_id"] = json!(user);
cfg["csrf"] = json!(csrf_from_token(token).ok_or("token carries no csrf claim")?);
let path = write_config(&cfg)?;
let nickname = d.get("nickname").and_then(|v| v.as_str()).unwrap_or("");
println!("Logged in as {} ({}); saved to {}", nickname, user, path.display());
return Ok(if nickname.is_empty() { user.to_string() } else { nickname.to_string() });
}
_ => { println!("QR status: {st}"); ui.status("二维码已失效,正在刷新…", Tone::Error); expired = true; break; }
}
}
println!("{}", if expired { "QR code expired; generating a new one" } else { "QR code timed out; generating a new one" });
tokio::time::sleep(Duration::from_secs(1)).await; // never spin if the server keeps refusing
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn service_waits_until_a_new_token_is_saved() {
let dir = std::env::temp_dir().join(format!("uu-login-wait-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
let creds = |token: &str| json!({"user_id": "u", "device_id": "d", "client_id": "c", "system_id": "s", "token": token, "csrf": "x"});
std::fs::write(&path, creds("old").to_string()).unwrap();
std::env::set_var("UU_CONFIG", &path);
std::env::set_var("UU_LOGIN_WINDOW", "0");
let writer = path.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(2500)).await;
std::fs::write(&writer, creds("new").to_string()).unwrap();
});
let got = tokio::time::timeout(Duration::from_secs(10), wait_for_credentials(Some("old".into()))).await.unwrap();
assert_eq!(got.token, "new"); // the expired token in the file is not accepted
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn csrf_is_read_from_jwt_payload() {
use base64::Engine;
let payload = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(br#"{"sub":"u","csrf":"c-1"}"#);
assert_eq!(csrf_from_token(&format!("h.{payload}.s")), Some("c-1".into()));
assert_eq!(csrf_from_token("bad"), None);
}
#[test]
fn generated_ids_are_uuid_shaped() {
let u = random_uuid();
assert_eq!(u.len(), 36);
assert_eq!(u.as_bytes()[14], b'4');
assert!(render_qr("https://example.com/x").unwrap().lines().count() > 10);
assert_eq!(gpu_label("NVIDIA Corporation GA102 [GeForce RTX 3090] (rev a1)"), "NVIDIA GeForce RTX 3090");
assert_eq!(gpu_label("Advanced Micro Devices, Inc. [AMD/ATI] Navi 21 [Radeon RX 6800] (rev c1)"), "AMD Radeon RX 6800");
assert_eq!(gpu_label("Advanced Micro Devices, Inc. [AMD/ATI] Navi 21 (rev c1)"), "Advanced Micro Devices, Inc. [AMD/ATI] Navi 21");
let (rgba, edge) = qr_rgba("https://example.com/x", 3, 1).unwrap();
assert_eq!(rgba.len(), edge * edge * 4);
assert_eq!(&rgba[..4], &[255, 255, 255, 255]); // quiet zone is light
assert_eq!(&rgba[(3 * edge + 3) * 4..(3 * edge + 3) * 4 + 3], &[0, 0, 0]); // finder corner is dark
}
}
+78
View File
@@ -0,0 +1,78 @@
//! Optional GTK3 window for `uuremote-server login` (c_engine/login_window.c). Built only when
//! gtk+-3.0 is available (cfg uu_gtk); otherwise, and with `--no-gui` or no display, every call
//! is a no-op and the terminal QR remains the only UI.
#[cfg(uu_gtk)]
extern "C" {
fn uu_login_ui_start(name: *const libc::c_char, os: *const libc::c_char, cpu: *const libc::c_char, gpu: *const libc::c_char) -> libc::c_int;
fn uu_login_ui_set_qr(rgba: *const u8, edge: libc::c_int);
fn uu_login_ui_set_status(text: *const libc::c_char, kind: libc::c_int);
fn uu_login_ui_set_done(text: *const libc::c_char);
fn uu_login_ui_closed() -> libc::c_int;
fn uu_login_ui_close();
}
#[derive(Clone, Copy)]
pub enum Tone { Info = 0, Ok = 1, Error = 2 }
pub struct LoginUi { shown: bool }
#[cfg(uu_gtk)]
fn cstr(s: &str) -> std::ffi::CString { std::ffi::CString::new(s.replace('\0', "")).unwrap_or_default() }
impl LoginUi {
pub fn none() -> Self { LoginUi { shown: false } }
/// Opens the window when built with GTK and a display is present; falls back silently otherwise.
#[allow(unused_variables)]
pub fn open(name: &str, os: &str, cpu: &str, gpu: &str) -> Self {
#[cfg(uu_gtk)]
if std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some() {
let (n, o, c, g) = (cstr(name), cstr(os), cstr(cpu), cstr(gpu));
if unsafe { uu_login_ui_start(n.as_ptr(), o.as_ptr(), c.as_ptr(), g.as_ptr()) } == 0 {
return LoginUi { shown: true };
}
eprintln!("Login window unavailable; using the terminal QR code");
}
LoginUi::none()
}
pub fn shown(&self) -> bool { self.shown }
#[allow(unused_variables)]
pub fn qr(&self, rgba: &[u8], edge: usize) {
#[cfg(uu_gtk)]
if self.shown && rgba.len() == edge * edge * 4 { unsafe { uu_login_ui_set_qr(rgba.as_ptr(), edge as libc::c_int) } }
}
#[allow(unused_variables)]
pub fn status(&self, text: &str, tone: Tone) {
#[cfg(uu_gtk)]
if self.shown { let t = cstr(text); unsafe { uu_login_ui_set_status(t.as_ptr(), tone as libc::c_int) } }
}
#[allow(unused_variables)]
pub fn done(&self, text: &str) {
#[cfg(uu_gtk)]
if self.shown { let t = cstr(text); unsafe { uu_login_ui_set_done(t.as_ptr()) } }
}
pub fn closed(&self) -> bool {
#[cfg(uu_gtk)]
if self.shown { return unsafe { uu_login_ui_closed() } != 0; }
false
}
/// Resolves when the user closes the window; never resolves without a window.
pub async fn wait_closed(&self) {
if !self.shown { return std::future::pending().await; }
while !self.closed() { tokio::time::sleep(std::time::Duration::from_millis(200)).await; }
}
}
impl Drop for LoginUi {
fn drop(&mut self) {
#[cfg(uu_gtk)]
if self.shown { unsafe { uu_login_ui_close() } }
}
}
+345
View File
@@ -0,0 +1,345 @@
//! UU Remote Pure Native Linux Server (Rust Edition)
//! Zero-Wine, Zero-Python, Single-Binary, 5 Native Tools Integrated
mod desktop_backend;
mod portal;
mod network_diagnostics;
mod session_ice;
mod wayland;
mod auth;
mod config;
mod login;
mod login_ui;
mod session_lock;
mod capture;
mod file_trans;
mod input;
mod input_mapping;
mod port_forward;
mod power;
mod signaling;
mod terminal;
mod webrtc;
mod video;
mod capture_setting;
mod audio;
mod system_actions;
mod capability;
mod protocol;
mod control_protocol;
mod rtp_metadata;
mod initialization;
mod system_metrics;
mod clipboard;
mod clipboard_protocol;
mod clipboard_rich;
mod viewer_metrics;
mod cursor;
use auth::{Credentials, UUAuthClient};
mod clipboard_probe;
use capture::ScreenCapture;
use input::InputInjector;
use signaling::{SignalingClient, SignalingEvent, SoacMessage};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::{mpsc, Mutex};
use webrtc::WebRtcSession;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
if std::env::args().nth(1).as_deref() == Some("clipboard-acceptance") {
return tokio::task::spawn_blocking(clipboard_probe::run).await?.map_err(Into::into);
}
if std::env::args().nth(1).as_deref() == Some("portal-acceptance") {
if std::fs::read_to_string("/proc/sys/kernel/hostname").unwrap_or_default().trim()!="uu-hyprland-test" {
return Err("Portal input acceptance is restricted to the isolated test VM".into());
}
let screen=ScreenCapture::new()?;
if screen.portal.is_none() { return Err("Portal acceptance requires the Portal backend".into()); }
// Give the consent dialog time to release focus before fixed lab events.
tokio::time::sleep(std::time::Duration::from_secs(3)).await;
let input=InputInjector::new();
input.bind_portal(screen.portal.clone());
input.mouse_absolute_normalized(0.25,0.25,(screen.width,screen.height));input.flush_pointer();
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
input.mouse_absolute_normalized(0.5,0.5,(screen.width,screen.height));input.flush_pointer();
input.mouse_button(1,true);input.mouse_button(1,false);
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
input.mouse_relative(32,0);input.flush_pointer();
for key in b"UUWAYLAND" { input.windows_key_event(i32::from(*key),true);input.windows_key_event(i32::from(*key),false); }
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
input.release_held();
let report:serde_json::Value=serde_json::from_slice(&std::fs::read("/tmp/uuremote-input-acceptance.json")?)?;
for key in ["native_wayland","window_active","motion","click","keyboard","text_input"] {
if report.get(key).and_then(serde_json::Value::as_bool)!=Some(true) { return Err(format!("Portal native GTK acceptance failed: {key}").into()); }
}
println!("Portal native GTK input acceptance passed: motion/click/keyboard/text");
let path=std::env::args().nth(2);
return video::probe((screen.width,screen.height),screen.display.clone(),screen.portal.clone(),path).await.map_err(|e|e.into());
}
if std::env::args().nth(1).as_deref() == Some("wayland-input-probe") {
return wayland::input_probe().map_err(|e|e.into());
}
if std::env::args().nth(1).as_deref() == Some("wayland-capture") {
return wayland::capture_stdout().map_err(|e| e.into());
}
if std::env::args().nth(1).as_deref() == Some("desktop-probe") {
let screen=ScreenCapture::new()?;
capture::keep_display_awake()?;
let frame=screen.capture_frame()?;
if let Some(path)=std::env::args().nth(2) {
use std::io::Write;
let mut rgba=frame.clone();
for pixel in rgba.chunks_exact_mut(4) { pixel.swap(0,2); pixel[3]=255; }
let png=cursor::encode_png(screen.width,screen.height,&rgba);
let mut file=std::fs::OpenOptions::new().write(true).create_new(true).open(path)?;
file.write_all(&png)?;
}
println!("backend={:?} width={} height={} frame_bytes={}",screen.backend,screen.width,screen.height,frame.len());
return Ok(());
}
if std::env::args().nth(1).as_deref() == Some("desktop-video-probe") {
let screen=ScreenCapture::new()?;
capture::keep_display_awake()?;
return video::probe((screen.width,screen.height),screen.display.clone(),screen.portal.clone(),std::env::args().nth(2)).await.map_err(|e|e.into());
}
if std::env::args().nth(1).as_deref() == Some("unlock-check") {
return session_lock::check_from_stdin().map_err(|e| e.into());
}
if std::env::args().nth(1).as_deref() == Some("login") {
// Interactive: register this host and bind it to an account via QR scan
// (GTK window when available; `login --no-gui` keeps it terminal-only).
let gui = !std::env::args().skip(2).any(|a| a == "--no-gui");
if login::run(gui).await.is_err() { std::process::exit(1); } // error already shown
return Ok(());
}
log::info!("Starting UU Remote Pure Native Rust Server v1.0.0...");
let mut capture = Arc::new((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 { ScreenCapture::new() }).unwrap_or_else(|error| {
log::warn!("Desktop unavailable; terminal and file tools remain available: {error}");
ScreenCapture::unavailable(error)
}));
let input = Arc::new(InputInjector::new());
let _pointer_worker = input.start_pointer_worker();
#[cfg(target_os="linux")]
{
let shutdown_input=input.clone();
tokio::spawn(async move {
if let Ok(mut term)=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) {
term.recv().await; shutdown_input.release_held(); terminal::shutdown_all(); std::process::exit(0);
}
});
}
let creds = match config::file().and_then(Credentials::load) {
Ok(creds) => creds,
Err(e) => {
log::warn!("Not logged in: {e} ({} or UU_* environment variables)", config::path().display());
login::wait_for_credentials(None).await
}
};
let mut auth = Arc::new(UUAuthClient::new(creds));
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id.
let webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>> = Arc::new(Mutex::new(HashMap::new()));
let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
loop {
log::info!("Requesting fresh room credentials from NetEase cloud...");
let room_data = match auth.create_room().await {
Ok(data) => data,
Err(auth::RoomError::LoginExpired) => {
// Like the official client: an expired token needs a new QR login, not retries.
log::error!("UU login is invalid or expired; a new QR login is required");
let stale = config::read_fresh().ok().flatten().and_then(|f| f.get("token").and_then(|t| t.as_str()).map(str::to_owned));
auth = Arc::new(UUAuthClient::new(login::wait_for_credentials(stale).await));
continue;
}
Err(e) => {
log::error!("Failed to create room: {}. Retrying in 5s...", e);
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
continue;
}
};
log::info!(
"Acquired room signaling target: {}",
room_data.signaling_server
);
let (tx_event, mut rx_event) = mpsc::channel::<SignalingEvent>(64);
let tx_timer = tx_event.clone();
let signaling_client = match SignalingClient::connect(
&room_data.signaling_server,
&room_data.token,
tx_event,
)
.await
{
Ok(cli) => {
let renewal_peers=webrtc_sessions.clone();
tokio::spawn(async move {
tokio::time::sleep(tokio::time::Duration::from_secs(900)).await;
loop {
if tx_timer.is_closed() { return; }
let active=renewal_peers.lock().await.values().any(|session| {
use ::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
session.pc.connection_state()==RTCPeerConnectionState::Connected
});
if !active {
log::info!("Idle room renewal timer elapsed; refreshing signaling room");
let _=tx_timer.send(SignalingEvent::Disconnected).await; return;
}
log::info!("Room renewal deferred while remote connection is active");
tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
}
});
Arc::new(cli)
}
Err(e) => {
log::error!("Failed to connect signaling: {}. Retrying in 5s...", e);
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
continue;
}
};
// 事件处理主循环
while let Some(evt) = rx_event.recv().await {
match evt {
SignalingEvent::Connected => {
log::info!("Signaling handshake established.");
}
SignalingEvent::RoomInfoAck(val) => {
log::info!(
"RoomInfo acknowledged by NetEase server: room_id={}",
val.get("room_id")
.and_then(|v| v.as_str())
.unwrap_or("unknown")
);
}
SignalingEvent::DeviceInfoChanged(val) => {
log::info!(
"Device status synchronized: status={:?}, availability={:?}",
val.get("data")
.and_then(|d| d.get("status"))
.and_then(|s| s.as_str()),
val.get("data")
.and_then(|d| d.get("publisher_availability_status"))
.and_then(|s| s.as_str())
);
}
SignalingEvent::ConnectRequest { capture_type, ice_id, transport } => {
// Pending cloud credentials live only within this room; cap
// requests that never receive an offer rather than retain them.
if capture_types.len()>=32 { capture_types.clear(); }
match ice_id { Some(id) => { capture_types.insert(id, (capture_type,transport)); } None => next_capture_type = Some((capture_type,transport)) }
}
SignalingEvent::BeControlled(val) => {
let _ = val;
log::info!("Incoming remote control session request; awaiting offer");
}
SignalingEvent::Soac(soac) => {
log::info!(
"SOAC signaling received: type={}, ice_id={:?}",
soac.msg_type,
soac.ice_id
);
let ice = soac.ice_id.as_ref().map(|v| v.as_str().map(str::to_owned).unwrap_or_else(|| v.to_string())).unwrap_or_default();
let mut sessions = webrtc_sessions.lock().await;
// Drop peers that already ended.
let ended: Vec<String> = sessions.iter().filter(|(_, s)| matches!(s.pc.connection_state(),
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(k, _)| k.clone()).collect();
for k in ended { if let Some(old) = sessions.remove(&k) { let _ = old.pc.close().await; } }
if soac.msg_type == "offer" {
let (capture_type,transport) = capture_types.remove(&ice).or_else(|| next_capture_type.take()).unwrap_or((1,crate::session_ice::SessionIce::default()));
// CaptureType: 0 unknown, 1 desktop, 2 window; 5 file transfer, 8 terminal, 9 port mapping.
let desktop = capture_type <= 2;
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; } }
}
let stale_portal=capture.portal.as_ref().is_some_and(|session|!session.is_alive())
&& crate::session_lock::locked_now() == Some(false);
let session_capture=if desktop && (capture.init_error.is_some() || stale_portal) {
if stale_portal {
input.release_held();input.bind_portal(None);
capture=Arc::new(ScreenCapture::unavailable("Portal authorization expired".into()));
}
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; },
Err(_)=>{log::warn!("Desktop initialization worker failed");continue;},
}
} 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 {
Ok(sess) => match sess.handle_offer(&soac).await {
Ok(answer_sdp) => {
log::info!("Local SDP Answer generated, emitting soac response...");
let resp = SoacMessage {
msg_type: "answer".into(),
sdp: Some(answer_sdp),
gzip_sdp: None,
candidate: None,
ice_id: soac.ice_id.clone(),
sdp_mid: None,
sdp_mline_index: None,
client_id: soac.client_id.clone(),
app_control_id: soac.app_control_id.clone(),
};
if let Err(e) = signaling_client.emit_soac(resp).await { log::error!("Answer signaling send failed: {}", e); }
sessions.insert(ice, sess);
}
Err(e) => { log::error!("Failed to handle offer: {}", e); let _ = sess.pc.close().await; }
},
Err(e) => log::error!("Create peer failed: {}", e),
}
} else if soac.msg_type == "candidate" {
if let Some(sess) = sessions.get(&ice) {
if let Err(e) = sess.add_candidate(&soac).await { log::error!("Remote ICE candidate failed: {}", e); }
} else {
log::warn!("Remote ICE candidate for unknown connection");
}
}
}
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 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());
for k in targets {
if let Some(old) = sessions.remove(&k) {
if let Err(e) = old.pc.close().await { log::warn!("Close released peer failed: {}", e); }
}
}
}
SignalingEvent::Disconnected => {
capture_types.clear();
next_capture_type=None;
log::warn!("Signaling connection lost. Initiating reconnect loop...");
break;
}
}
}
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
}
}
+227
View File
@@ -0,0 +1,227 @@
//! Address-free ICE path diagnostics. A host pair may still traverse a VPN;
//! `direct` means no ICE relay candidate, not proof of a shared LAN.
use std::sync::{atomic::{AtomicU64, Ordering}, Weak};
use std::time::Instant;
use webrtc::peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState};
use webrtc::stats::StatsReportType;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CandidateSummary {
pub protocol: &'static str,
pub kind: &'static str,
}
fn protocol(value: &str) -> &'static str {
if value.eq_ignore_ascii_case("udp") { "udp" }
else if value.eq_ignore_ascii_case("tcp") { "tcp" }
else { "unknown" }
}
fn kind(value: &str) -> &'static str {
match value { "host" => "host", "srflx" => "srflx", "prflx" => "prflx", "relay" => "relay", _ => "unknown" }
}
/// Parse only protocol/type from an SDP candidate. Never return arbitrary input.
pub fn candidate_summary(sdp: &str) -> CandidateSummary {
let fields: Vec<_> = sdp.split_whitespace().collect();
CandidateSummary {
protocol: fields.get(2).map_or("unknown", |v| protocol(v)),
kind: if fields.get(6) == Some(&"typ") { fields.get(7).map_or("unknown", |v| kind(v)) } else { "unknown" },
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PathSummary {
pub local: CandidateSummary,
pub remote: CandidateSummary,
pub route: &'static str,
}
/// webrtc 0.10 keeps RTCIceCandidatePair fields private. Its Display is
/// `(local) <protocol> <type> <endpoint> <-> (remote) ...`. Restrict output to
/// allowlisted enums; fail closed if upstream changes this representation.
fn selected_pair_summary(display: &str) -> Option<PathSummary> {
let (local, remote) = display.strip_prefix("(local) ")?.split_once(" <-> (remote) ")?;
fn side(value: &str) -> CandidateSummary {
let mut fields = value.split_whitespace();
CandidateSummary { protocol: protocol(fields.next().unwrap_or("")), kind: kind(fields.next().unwrap_or("")) }
}
let local = side(local);
let remote = side(remote);
let route = if local.kind == "relay" || remote.kind == "relay" { "relay" }
else if local.kind == "unknown" || remote.kind == "unknown" || local.protocol == "unknown" || remote.protocol == "unknown" { "unknown" }
else { "direct" };
Some(PathSummary { local, remote, route })
}
pub async fn selected_path(pc: &RTCPeerConnection) -> Option<PathSummary> {
let transport = pc.dtls_transport();
let pair = transport.ice_transport().get_selected_candidate_pair().await?;
Some(selected_pair_summary(&pair.to_string()).unwrap_or(PathSummary {
local: CandidateSummary { protocol: "unknown", kind: "unknown" },
remote: CandidateSummary { protocol: "unknown", kind: "unknown" },
route: "unknown",
}))
}
#[derive(Default)]
struct RateCounter { previous: Option<(Instant, u64, u64)> }
impl RateCounter {
fn sample(&mut self, now: Instant, sent: u64, received: u64) -> Option<(u64, u64)> {
let old = self.previous.replace((now, sent, received))?;
let seconds = now.checked_duration_since(old.0)?.as_secs_f64();
if seconds <= 0.0 || sent < old.1 || received < old.2 { return None; }
Some((((sent - old.1) as f64 * 8.0 / seconds) as u64, ((received - old.2) as f64 * 8.0 / seconds) as u64))
}
}
static SESSION_SEQUENCE: AtomicU64 = AtomicU64::new(1);
/// Spawn once per peer. Weak ownership and closed-state exit prevent leaked
/// peer sessions. Reconnects reset counters. No IP, candidate ID or SDP is logged.
pub fn start(peer: Weak<RTCPeerConnection>) {
let session = SESSION_SEQUENCE.fetch_add(1, Ordering::Relaxed);
tokio::spawn(async move {
let mut interval = tokio::time::interval(std::time::Duration::from_secs(5));
interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut rate = RateCounter::default();
let mut last_path = None;
let mut ticks = 0;
loop {
interval.tick().await;
let Some(pc) = peer.upgrade() else { break };
let state = pc.connection_state();
if state == RTCPeerConnectionState::Closed { break; }
if state != RTCPeerConnectionState::Connected {
rate = RateCounter::default();
last_path = None;
continue;
}
let Some(path) = selected_path(&pc).await else { continue };
let report = pc.get_stats().await;
let (mut sent, mut received) = (0u64, 0u64);
for stats in report.reports.values() {
// SCTPTransport repeats the same ICE totals; count Transport only.
if let StatsReportType::Transport(stats) = stats {
sent = sent.saturating_add(stats.bytes_sent as u64);
received = received.saturating_add(stats.bytes_received as u64);
}
}
let rates = rate.sample(Instant::now(), sent, received);
ticks += 1;
if last_path != Some(path) || ticks % 6 == 0 {
log::info!("ICE path: session={} route={} local={}/{} remote={}/{} tx_bps={:?} rx_bps={:?} rtt=unavailable",
session, path.route, path.local.protocol, path.local.kind, path.remote.protocol, path.remote.kind,
rates.map(|r| r.0), rates.map(|r| r.1));
// webrtc-ice 0.10 candidate-pair RTT/packet/byte fields are zero
// placeholders, not measured metrics. Do not publish them.
last_path = Some(path);
}
}
});
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_real_pair_format_and_both_relay_sides() {
use webrtc::ice_transport::{ice_candidate::RTCIceCandidate, ice_candidate_pair::RTCIceCandidatePair, ice_candidate_type::RTCIceCandidateType, ice_protocol::RTCIceProtocol};
for (local, remote, expected) in [
(RTCIceCandidateType::Host, RTCIceCandidateType::Srflx, "direct"),
(RTCIceCandidateType::Relay, RTCIceCandidateType::Host, "relay"),
(RTCIceCandidateType::Host, RTCIceCandidateType::Relay, "relay"),
(RTCIceCandidateType::Unspecified, RTCIceCandidateType::Host, "unknown"),
] {
let candidate = |typ| RTCIceCandidate { typ, protocol: RTCIceProtocol::Udp, address: "192.0.2.42".into(), port: 1234, ..Default::default() };
let summary = selected_pair_summary(&RTCIceCandidatePair::new(candidate(local), candidate(remote)).to_string()).unwrap();
assert_eq!(summary.route, expected);
assert!(!format!("{summary:?}").contains("192.0.2.42"));
}
}
#[test]
fn candidate_log_is_allowlisted() {
let summary = candidate_summary("candidate:x 1 UDP 123 192.0.2.5 4444 typ relay raddr 10.0.0.1 rport 123 ufrag secret");
assert_eq!(summary, CandidateSummary { protocol: "udp", kind: "relay" });
assert_eq!(candidate_summary("malformed secret"), CandidateSummary { protocol: "unknown", kind: "unknown" });
assert!(selected_pair_summary("unexpected secret").is_none());
}
#[test]
fn rates_reset_on_counter_restart() {
let mut rates = RateCounter::default();
let now = Instant::now();
assert_eq!(rates.sample(now, 100, 200), None);
assert_eq!(rates.sample(now + std::time::Duration::from_secs(2), 300, 300), Some((800, 400)));
assert_eq!(rates.sample(now + std::time::Duration::from_secs(3), 0, 0), None);
}
/// Exercises actual ICE nomination and SCTP delivery between local peers, without
/// login, public STUN, external endpoints or production configuration.
#[tokio::test]
#[ignore = "opens local UDP sockets; run explicitly for network acceptance"]
async fn local_selected_pair_and_payload() {
use std::sync::Arc;
use webrtc::api::{APIBuilder, setting_engine::SettingEngine};
use webrtc::peer_connection::configuration::RTCConfiguration;
let mut settings = SettingEngine::default();
// This crate excludes loopback addresses during ICE gathering. Both
// peers still run in this process and use only gathered local addresses.
settings.set_ice_multicast_dns_mode(webrtc::ice::mdns::MulticastDnsMode::Disabled);
let mut media = webrtc::api::media_engine::MediaEngine::default();
media.register_default_codecs().unwrap();
let api = APIBuilder::new().with_media_engine(media).with_setting_engine(settings).build();
let left = Arc::new(api.new_peer_connection(RTCConfiguration::default()).await.unwrap());
let right = Arc::new(api.new_peer_connection(RTCConfiguration::default()).await.unwrap());
for (label, peer) in [("left", &left), ("right", &right)] {
peer.on_peer_connection_state_change(Box::new(move |state| {
eprintln!("isolated ICE probe {label}: {state}");
Box::pin(async {})
}));
}
let (received_tx, mut received_rx) = tokio::sync::mpsc::channel(1);
right.on_data_channel(Box::new(move |channel| {
let tx = received_tx.clone();
Box::pin(async move {
channel.on_message(Box::new(move |message| {
let tx = tx.clone();
Box::pin(async move { let _ = tx.send(message.data).await; })
}));
})
}));
let channel = left.create_data_channel("network-acceptance", None).await.unwrap();
let sender = Arc::downgrade(&channel);
channel.on_open(Box::new(move || {
let sender = sender.clone();
Box::pin(async move {
if let Some(channel) = sender.upgrade() {
channel.send(&bytes::Bytes::from_static(b"isolated-ice-probe")).await.unwrap();
}
})
}));
let acceptance = async {
let mut gathered = left.gathering_complete_promise().await;
left.set_local_description(left.create_offer(None).await.unwrap()).await.unwrap();
let _ = gathered.recv().await;
eprintln!("left SDP candidate count={}", left.local_description().await.unwrap().sdp.lines().filter(|s| s.starts_with("a=candidate:")).count());
right.set_remote_description(left.local_description().await.unwrap()).await.unwrap();
let mut gathered = right.gathering_complete_promise().await;
right.set_local_description(right.create_answer(None).await.unwrap()).await.unwrap();
let _ = gathered.recv().await;
eprintln!("right SDP candidate count={}", right.local_description().await.unwrap().sdp.lines().filter(|s| s.starts_with("a=candidate:")).count());
left.set_remote_description(right.local_description().await.unwrap()).await.unwrap();
eprintln!("isolated ICE probe: descriptions exchanged");
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
eprintln!("isolated ICE probe: left_ice={} right_ice={} selected={:?}", left.ice_connection_state(), right.ice_connection_state(), selected_path(&left).await);
assert_eq!(received_rx.recv().await.unwrap().as_ref(), b"isolated-ice-probe");
let path = selected_path(&left).await.unwrap();
assert_eq!(path.route, "direct");
assert_eq!(path.local.kind, "host");
assert_eq!(path.remote.kind, "host");
let stats = left.get_stats().await;
assert!(stats.reports.values().any(|v| matches!(v, StatsReportType::Transport(t) if t.bytes_sent > 0 && t.bytes_received > 0)));
};
let outcome = tokio::time::timeout(std::time::Duration::from_secs(15), acceptance).await;
left.close().await.unwrap();
right.close().await.unwrap();
outcome.expect("isolated local ICE/SCTP did not connect within 15 seconds");
}
}
+61
View File
@@ -0,0 +1,61 @@
//! Native TCP Port Forwarding & SSH Tunneling via DataChannel
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::Mutex;
use webrtc::data_channel::data_channel_message::DataChannelMessage;
use webrtc::data_channel::RTCDataChannel;
pub struct PortForwarder;
impl PortForwarder {
/// 将 DataChannel 桥接到本地指定 TCP 端口(默认 127.0.0.1:22 SSH)
pub async fn bridge_tcp(
target_addr: &str,
channel: Arc<RTCDataChannel>,
) -> Result<(), String> {
let stream = TcpStream::connect(target_addr)
.await
.map_err(|e| format!("Failed to connect to {}: {}", target_addr, e))?;
log::info!("Connected to local service {}", target_addr);
let (mut tcp_read, mut tcp_write) = stream.into_split();
let channel_for_write = channel.clone();
// 协程 1: 从本地 TCP (如 SSH) 读取数据并写入 DataChannel
tokio::spawn(async move {
let mut buf = [0u8; 4096];
loop {
match tcp_read.read(&mut buf).await {
Ok(0) => break,
Ok(n) => {
let bytes = bytes::Bytes::copy_from_slice(&buf[..n]);
if let Err(e) = channel_for_write.send(&bytes).await {
log::warn!("DataChannel send failed: {}", e);
break;
}
}
Err(e) => {
log::warn!("TCP read error: {}", e);
break;
}
}
}
});
// 协程 2: 绑定 DataChannel on_message 写入本地 TCP
let tcp_write = Arc::new(Mutex::new(tcp_write));
let tcp_write_clone = tcp_write.clone();
channel.on_message(Box::new(move |msg: DataChannelMessage| {
let tcp = tcp_write_clone.clone();
Box::pin(async move {
let mut lock = tcp.lock().await;
let _ = lock.write_all(&msg.data).await;
})
}));
Ok(())
}
}
+182
View File
@@ -0,0 +1,182 @@
//! 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;
#[cfg(unix)]
#[path = "portal_permissions.rs"]
mod permissions;
#[cfg(all(target_os = "linux", feature = "portal"))]
mod native {
use std::{ffi::c_void, ptr::NonNull, sync::Mutex};
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_clipboard_ready(portal: *mut c_void) -> i32;
fn uu_portal_clipboard_set(portal: *mut c_void, text: *const u8, length: usize) -> i32;
fn uu_portal_clipboard_poll(portal: *mut c_void, text: *mut u8, capacity: usize) -> i32;
fn uu_portal_close(portal: *mut c_void);
fn uu_portal_alive(portal: *mut c_void) -> i32;
fn uu_portal_reset_frame(portal: *mut c_void);
fn uu_portal_capture(portal: *mut c_void, bgra: *mut u8, length: usize) -> i32;
fn uu_portal_move(portal: *mut c_void, x: f64, y: f64, relative: i32) -> i32;
fn uu_portal_button(portal: *mut c_void, button: i32, pressed: i32) -> i32;
fn uu_portal_key(portal: *mut c_void, keysym: u32, pressed: i32) -> i32;
}
struct Handle(NonNull<c_void>);
// The engine owns callback threads; public calls are serialized by Mutex.
unsafe impl Send for Handle {}
impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } }
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, retry_at: Mutex<Option<std::time::Instant>>, pub width: u32, pub height: u32 }
impl Session {
pub fn is_alive(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
}
pub fn open() -> Result<Self, String> {
let (mut error, mut width, mut height) = (0, 0, 0);
let directory = super::permissions::directory();
let key = super::permissions::desktop_key();
let token = directory.as_deref().and_then(|dir| super::permissions::take(dir, key))
.and_then(|value| std::ffi::CString::new(value).ok());
let mut cache = (directory, key);
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
// Callback is synchronous during open; cache lives through the call.
let result = std::panic::catch_unwind(|| unsafe {
let cache = &*(data as *const (Option<std::path::PathBuf>, &'static str));
if let (Some(dir), Ok(value)) = (cache.0.as_deref(), std::ffi::CStr::from_ptr(token).to_str()) {
if super::permissions::save(dir, cache.1, value).is_err() { log::warn!("Portal permission cache could not be saved"); }
}
});
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))?;
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(true), retry_at: Mutex::new(None), width, height })
}
pub fn capture(&self, frame: &mut [u8]) -> Result<(), String> {
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
let locked = *self.locked.borrow() != Some(false);
if locked || self.was_locked.swap(locked, std::sync::atomic::Ordering::AcqRel) {
self.was_locked.store(locked, std::sync::atomic::Ordering::Release);
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
super::blank(frame); return Ok(());
}
if unsafe { uu_portal_alive(handle.0.as_ptr()) } == 0 {
// GNOME can close the stream before the periodic lock watcher updates.
if crate::session_lock::locked_now() != Some(false) {
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
super::blank(frame); return Ok(());
}
// logind's LockedHint can lag compositor stream closure. Give it a
// full watcher interval before attempting another permission session.
let mut retry = self.retry_at.lock().map_err(|_| "Portal recovery lock poisoned")?;
let deadline = retry.get_or_insert_with(|| std::time::Instant::now() + std::time::Duration::from_secs(1));
if std::time::Instant::now() < *deadline { super::blank(frame); return Ok(()); }
let replacement = match Self::open() {
Ok(value) => value,
Err(error) => {
log::warn!("Portal capture recovery deferred: {error}");
*retry = Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
super::blank(frame); return Ok(());
}
};
*retry = None;
if replacement.width != self.width || replacement.height != self.height {
return Err("Portal dimensions changed; reconnect required".into());
}
*handle = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
log::info!("Portal capture session restored after closure");
}
let code = unsafe { uu_portal_capture(handle.0.as_ptr(), frame.as_mut_ptr(), frame.len()) };
if code == 10 || code == 9 { super::blank(frame); Ok(()) } else { super::check(code) }
}
pub fn clipboard_ready(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_ready(handle.0.as_ptr()) != 0 })
}
pub fn clipboard_set(&self, text: &str) -> Result<(), String> {
if text.len()>crate::clipboard::MAX_TEXT || *self.locked.borrow()!=Some(false) { return Err("Portal clipboard unavailable".into()); }
let handle=self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
if unsafe { uu_portal_clipboard_set(handle.0.as_ptr(),text.as_ptr(),text.len()) }==0 {Ok(())} else {Err("Portal clipboard ownership failed".into())}
}
pub fn clipboard_poll(&self) -> Option<String> {
if *self.locked.borrow()!=Some(false) { return None; }
let handle=self.handle.lock().ok()?;
let mut bytes=vec![0;crate::clipboard::MAX_TEXT];
let length=unsafe { uu_portal_clipboard_poll(handle.0.as_ptr(),bytes.as_mut_ptr(),bytes.len()) };
if length<0 { return None; }
bytes.truncate(length as usize); String::from_utf8(bytes).ok()
}
pub fn move_pointer(&self, x: f64, y: f64, relative: bool) -> Result<(), String> {
if *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_move(handle.0.as_ptr(), x, y, i32::from(relative)) })
}
pub fn button(&self, button: i32, pressed: bool) -> Result<(), String> {
if pressed && *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_button(handle.0.as_ptr(), button, i32::from(pressed)) })
}
pub fn key(&self, symbol: u64, pressed: bool) -> Result<(), String> {
if pressed && *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let symbol = u32::try_from(symbol).map_err(|_| "Invalid Portal keysym")?;
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, i32::from(pressed)) })
}
}
}
fn blank(frame: &mut [u8]) { for pixel in frame.chunks_exact_mut(4) { pixel.copy_from_slice(&[0, 0, 0, 255]); } }
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",
};
format!("Portal {reason} (code {code})")
}
fn check(code: i32) -> Result<(), String> { if code == 0 { Ok(()) } else { Err(error(code)) } }
#[cfg(all(target_os = "linux", feature = "portal"))]
pub use native::Session as PortalSession;
#[cfg(not(all(target_os = "linux", feature = "portal")))]
pub struct PortalSession { pub width: u32, pub height: u32 }
#[cfg(not(all(target_os = "linux", feature = "portal")))]
impl PortalSession {
pub fn clipboard_ready(&self) -> bool { false }
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 open() -> Result<Self, String> { Err("Portal backend requires Linux and --features portal".into()) }
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(2)) }
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(2)) }
pub fn button(&self, _: i32, _: bool) -> Result<(), String> { Err(error(2)) }
pub fn key(&self, _: u64, _: bool) -> Result<(), String> { Err(error(2)) }
}
/// Forward frames in-process into encoder stdin. Cancellation drops the Arc;
/// the caller keeps one owning Arc for all subsequent desktop reconnects.
pub fn write_frames(session: Arc<PortalSession>, mut output: impl std::io::Write, cancelled: &std::sync::atomic::AtomicBool) -> Result<(), String> {
let length = (session.width as usize).checked_mul(session.height as usize).and_then(|n| n.checked_mul(4)).ok_or("Portal frame too large")?;
let mut frame = vec![0; length];
let interval = std::time::Duration::from_nanos(1_000_000_000 / crate::video::FPS);
while !cancelled.load(std::sync::atomic::Ordering::Acquire) {
let started = std::time::Instant::now();
session.capture(&mut frame)?;
output.write_all(&frame).map_err(|_| "Portal encoder input closed")?;
if let Some(left) = interval.checked_sub(started.elapsed()) { std::thread::sleep(left); }
}
Ok(())
}
#[cfg(test)]
mod tests {
#[test]
fn locked_frames_hide_old_content() { let mut frame = [42; 8]; super::blank(&mut frame); assert_eq!(frame, [0,0,0,255,0,0,0,255]); }
#[test]
fn errors_never_include_remote_messages_or_identifiers() {
assert!(super::check(4).unwrap_err().contains("cancelled or denied"));
assert!(super::check(9).unwrap_err().contains("closed or stream lost"));
}
}
+71
View File
@@ -0,0 +1,71 @@
//! Single-use Portal permissions. Never log the token or reuse it after an attempt.
use std::{fs::{self, OpenOptions}, io::{Read, Write}, path::{Path, PathBuf}};
use std::os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt};
pub fn directory() -> Option<PathBuf> {
let base = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from)
.filter(|p| p.is_absolute()).or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))?;
let dir = base.join("uuremote/portal-permissions");
// Reject symlinks in the parent chain; do not redirect credential storage.
for parent in dir.ancestors() {
if let Ok(meta) = fs::symlink_metadata(parent) {
if meta.file_type().is_symlink() { return None; }
}
}
fs::create_dir_all(&dir).ok()?;
fs::set_permissions(&dir, fs::Permissions::from_mode(0o700)).ok()?;
let meta = fs::symlink_metadata(&dir).ok()?;
(meta.is_dir() && meta.uid() == unsafe { libc::getuid() }).then_some(dir)
}
pub fn desktop_key() -> &'static str {
let desktop = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().to_lowercase();
if desktop.split(':').any(|v| v == "kde") { "kde" } else { "gnome" }
}
pub fn take(dir: &Path, key: &str) -> Option<String> {
let path = dir.join(key);
let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?;
let meta = file.metadata().ok()?;
if !meta.is_file() || meta.uid() != unsafe { libc::getuid() } || meta.mode() & 0o077 != 0 || meta.len() > 4096 { return None; }
let mut token = String::new();
file.read_to_string(&mut token).ok()?;
// Consume before contacting the Portal: a timeout may still consume the upstream token.
fs::remove_file(path).ok()?;
(!token.is_empty() && !token.contains('\0')).then_some(token)
}
pub fn save(dir: &Path, key: &str, token: &str) -> std::io::Result<()> {
if token.is_empty() || token.len() > 4096 || token.contains('\0') {
return Err(std::io::Error::from(std::io::ErrorKind::InvalidInput));
}
static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let temp = dir.join(format!(".{}.{}", std::process::id(), NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)));
let result = (|| {
let mut file = OpenOptions::new().write(true).create_new(true).mode(0o600).open(&temp)?;
file.write_all(token.as_bytes())?; file.sync_all()?;
fs::rename(&temp, dir.join(key))?;
std::fs::File::open(dir)?.sync_all()
})();
if result.is_err() { let _ = fs::remove_file(temp); }
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn permissions_are_private_single_use_and_reject_symlinks() {
let dir = std::env::temp_dir().join(format!("uu-portal-cache-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
save(&dir, "kde", "test-token").unwrap();
assert_eq!(fs::metadata(dir.join("kde")).unwrap().mode() & 0o777, 0o600);
assert_eq!(take(&dir, "kde").as_deref(), Some("test-token"));
assert!(take(&dir, "kde").is_none());
save(&dir, "gnome", "second-token").unwrap();
std::os::unix::fs::symlink(dir.join("gnome"), dir.join("kde")).unwrap();
assert!(take(&dir, "kde").is_none());
assert!(save(&dir, "gnome", &"x".repeat(4097)).is_err());
fs::remove_dir_all(dir).unwrap();
}
}
+35
View File
@@ -0,0 +1,35 @@
//! Native System Power Management (Reboot & Shutdown)
use std::process::Command;
pub struct PowerManager;
impl PowerManager {
pub fn reboot() -> Result<(), String> {
log::info!("Executing system reboot command...");
let status = Command::new("systemctl")
.arg("reboot")
.status()
.map_err(|e| format!("Failed to invoke systemctl reboot: {}", e))?;
if status.success() {
Ok(())
} else {
Err(format!("systemctl reboot exited with status {}", status))
}
}
pub fn shutdown() -> Result<(), String> {
log::info!("Executing system poweroff command...");
let status = Command::new("systemctl")
.arg("poweroff")
.status()
.map_err(|e| format!("Failed to invoke systemctl poweroff: {}", e))?;
if status.success() {
Ok(())
} else {
Err(format!("systemctl poweroff exited with status {}", status))
}
}
}
+108
View File
@@ -0,0 +1,108 @@
//! Dependency-free protobuf wire inspection for the official binary control channel.
//! This decodes fields only. It intentionally assigns no heartbeat/input semantics
//! and sends no acknowledgements: those require evidence from the application
//! callback above libstreamer::ControlledControlDataHandler::OnReceiveData.
#[derive(Debug, PartialEq, Eq)]
pub enum WireValue<'a> {
Varint(u64),
Fixed64([u8; 8]),
Bytes(&'a [u8]),
Fixed32([u8; 4]),
}
#[derive(Debug, PartialEq, Eq)]
pub struct WireField<'a> {
pub number: u32,
pub value: WireValue<'a>,
}
#[derive(Debug, PartialEq, Eq)]
pub enum WireError {
Truncated,
VarintOverflow,
InvalidField,
UnsupportedWireType(u8),
}
fn varint(input: &[u8], offset: &mut usize) -> Result<u64, WireError> {
let mut result = 0;
for shift in (0..70).step_by(7) {
let byte = *input.get(*offset).ok_or(WireError::Truncated)?;
*offset += 1;
if shift == 63 && byte > 1 {
return Err(WireError::VarintOverflow);
}
result |= u64::from(byte & 127) << shift;
if byte & 128 == 0 {
return Ok(result);
}
}
Err(WireError::VarintOverflow)
}
fn take<'a>(input: &'a [u8], offset: &mut usize, length: usize) -> Result<&'a [u8], WireError> {
let end = offset.checked_add(length).ok_or(WireError::Truncated)?;
let value = input.get(*offset..end).ok_or(WireError::Truncated)?;
*offset = end;
Ok(value)
}
/// Inspect a complete protobuf message, preserving opaque nested payloads.
/// Deprecated groups are rejected. No payload contents should be logged.
pub fn decode_wire(input: &[u8]) -> Result<Vec<WireField<'_>>, WireError> {
let mut offset = 0;
let mut fields = Vec::new();
while offset < input.len() {
let key = varint(input, &mut offset)?;
let number = key >> 3;
if number == 0 || number > 0x1fff_ffff {
return Err(WireError::InvalidField);
}
let value = match (key & 7) as u8 {
0 => WireValue::Varint(varint(input, &mut offset)?),
1 => WireValue::Fixed64(take(input, &mut offset, 8)?.try_into().unwrap()),
2 => {
let length = usize::try_from(varint(input, &mut offset)?)
.map_err(|_| WireError::Truncated)?;
WireValue::Bytes(take(input, &mut offset, length)?)
}
5 => WireValue::Fixed32(take(input, &mut offset, 4)?.try_into().unwrap()),
wire => return Err(WireError::UnsupportedWireType(wire)),
};
fields.push(WireField { number: number as u32, value });
}
Ok(fields)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn preserves_mixed_unknown_fields_and_nested_bytes() {
let bytes = [8, 150, 1, 18, 2, 8, 3, 29, 1, 2, 3, 4];
assert_eq!(decode_wire(&bytes), Ok(vec![
WireField { number: 1, value: WireValue::Varint(150) },
WireField { number: 2, value: WireValue::Bytes(&[8, 3]) },
WireField { number: 3, value: WireValue::Fixed32([1, 2, 3, 4]) },
]));
}
#[test]
fn rejects_truncation_and_u64_overflow() {
assert_eq!(decode_wire(&[18, 4, 1]), Err(WireError::Truncated));
assert_eq!(decode_wire(&[8, 128]), Err(WireError::Truncated));
let mut bytes = vec![8];
bytes.extend_from_slice(&[255; 9]);
bytes.push(2);
assert_eq!(decode_wire(&bytes), Err(WireError::VarintOverflow));
}
#[test]
fn rejects_invalid_fields_and_groups() {
assert_eq!(decode_wire(&[0]), Err(WireError::InvalidField));
assert_eq!(decode_wire(&[11]), Err(WireError::UnsupportedWireType(3)));
assert_eq!(decode_wire(&[255, 255, 255, 255, 31]), Err(WireError::InvalidField));
}
}
+65
View File
@@ -0,0 +1,65 @@
//! UU capture-source metadata used by the official streaming core.
//! URI and big-endian uint16 layout are verified in the official ARM64 library.
//! Source index 0 is this implementation's sole primary capture source.
use webrtc::rtp::extension::HeaderExtension;
use webrtc::util::{Marshal, MarshalSize};
pub const CAPTURE_INDEX_URI: &str =
"http://www.webrtc.org/experiments/rtp-hdrext/video-capture-index";
pub const NEW_FRAME_URI: &str =
"http://www.webrtc.org/experiments/rtp-hdrext/video-frame-is-new-frame";
pub struct NewFrame(pub bool);
impl MarshalSize for NewFrame { fn marshal_size(&self) -> usize { 1 } }
impl Marshal for NewFrame {
fn marshal_to(&self, buffer: &mut [u8]) -> webrtc::util::Result<usize> {
let byte = buffer.first_mut().ok_or_else(|| webrtc::util::Error::Other("New frame buffer too short".into()))?;
*byte = u8::from(self.0);
Ok(1)
}
}
pub fn new_frame() -> HeaderExtension {
HeaderExtension::Custom { uri: NEW_FRAME_URI.into(), extension: Box::new(NewFrame(true)) }
}
#[derive(Debug)]
pub struct CaptureIndex(pub u16);
impl MarshalSize for CaptureIndex {
fn marshal_size(&self) -> usize { 2 }
}
impl Marshal for CaptureIndex {
fn marshal_to(&self, buffer: &mut [u8]) -> webrtc::util::Result<usize> {
let target = buffer.get_mut(..2)
.ok_or_else(|| webrtc::util::Error::Other("Capture index buffer too short".into()))?;
target.copy_from_slice(&self.0.to_be_bytes());
Ok(2)
}
}
pub fn capture_index(index: u16) -> HeaderExtension {
HeaderExtension::Custom {
uri: CAPTURE_INDEX_URI.into(), extension: Box::new(CaptureIndex(index)),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn encodes_network_order_without_truncation() {
let mut bytes = [0u8; 2];
assert_eq!(CaptureIndex(0x1234).marshal_to(&mut bytes).unwrap(), 2);
assert_eq!(bytes, [0x12, 0x34]);
assert!(CaptureIndex(1).marshal_to(&mut [0u8; 1]).is_err());
}
#[test]
fn new_frame_is_one_byte_boolean() {
let mut bytes = [0];
NewFrame(true).marshal_to(&mut bytes).unwrap();
assert_eq!(bytes, [1]);
NewFrame(false).marshal_to(&mut bytes).unwrap();
assert_eq!(bytes, [0]);
}
}
+64
View File
@@ -0,0 +1,64 @@
//! Per-connection cloud ICE configuration. Never derive Debug or log credentials.
use serde_json::Value;
use webrtc::ice_transport::ice_server::RTCIceServer;
use webrtc::peer_connection::{configuration::RTCConfiguration,policy::ice_transport_policy::RTCIceTransportPolicy};
#[derive(Clone, Default)]
pub struct SessionIce {
servers: Vec<RTCIceServer>,
relay_only: bool,
}
impl SessionIce {
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));
let mut result=Self { relay_only:field("force_relay").and_then(Value::as_bool).unwrap_or(false),..Default::default() };
if let Some(servers)=field("iceServers").and_then(Value::as_array) {
for server in servers.iter().take(16) {
let urls=server.get("urls").or_else(||server.get("url"));
let urls:Vec<String>=match urls {
Some(Value::String(url))=>vec![url.clone()],
Some(Value::Array(urls))=>urls.iter().filter_map(Value::as_str).take(16).map(str::to_owned).collect(),
_=>Vec::new(),
}.into_iter().filter(|url|url.len()<=2048 && ["stun:","stuns:","turn:","turns:"].iter().any(|prefix|url.starts_with(prefix))).collect();
if urls.is_empty() { continue; }
let string=|name|server.get(name).and_then(Value::as_str).filter(|s|s.len()<=4096).unwrap_or("").to_owned();
result.servers.push(RTCIceServer { urls,username:string("username"),credential:string("credential"),
credential_type:webrtc::ice_transport::ice_credential_type::RTCIceCredentialType::Password });
}
}
result
}
pub fn configuration(self)->Result<RTCConfiguration,String> {
let has_turn=self.servers.iter().any(|server|server.urls.iter().any(|url|url.starts_with("turn:")||url.starts_with("turns:")));
if self.relay_only && !has_turn { return Err("Relay-only session requested without usable TURN configuration".into()); }
let supplied=!self.servers.is_empty();
let servers=if supplied { self.servers } else { vec![RTCIceServer {
urls:vec!["stun:stun.l.google.com:19302".into(),"stun:stun1.l.google.com:19302".into(),"stun:stun.miwifi.com:3478".into()],..Default::default()
}] };
log::info!("Session ICE configuration: cloud_supplied={} server_count={} turn_available={} relay_only={}",supplied,servers.len(),has_turn,self.relay_only);
Ok(RTCConfiguration { ice_servers:servers,
ice_transport_policy:if self.relay_only { RTCIceTransportPolicy::Relay } else { RTCIceTransportPolicy::All },..Default::default() })
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cloud_credentials_are_scoped_to_peer_and_relay_policy_is_honored() {
let config=SessionIce::from_header(&serde_json::json!({"data":{"iceServers":[{"urls":["turn:example.invalid:3478?transport=udp"],"username":"test-user","credential":"test-secret"}],"force_relay":true}})).configuration().unwrap();
assert_eq!(config.ice_transport_policy,RTCIceTransportPolicy::Relay);
assert_eq!(config.ice_servers[0].username,"test-user");
assert_eq!(config.ice_servers[0].credential,"test-secret");
}
#[test]
fn unsupported_server_urls_are_rejected_and_relay_never_silently_falls_back() {
assert!(SessionIce::from_header(&serde_json::json!({"force_relay":true,"iceServers":[{"urls":"https://example.invalid"}]})).configuration().is_err());
let config=SessionIce::default().configuration().unwrap();
assert_eq!(config.ice_transport_policy,RTCIceTransportPolicy::All);
assert_eq!(config.ice_servers.len(),1);
assert!(config.ice_servers[0].urls.iter().all(|s|s.starts_with("stun:")));
}
}
+207
View File
@@ -0,0 +1,207 @@
//! Lock-screen state and remote auto-unlock for the desktop session.
//!
//! Official protocol (UURemoteServer LockScreenManager / SimpleActionHandler, see
//! analysis/protocol-fix-20261013/control): the host reports Message 15 SystemStateChange
//! { 1: SecureDesktopState { 1 is_locked, 2 is_sas_shown, 5 is_support_auto_logon } } and the
//! viewer's saved password arrives as SimpleAction { 1: 15 AUTO_UNLOCK_SYSTEM, 2: {"key": ...} }.
//! A failed unlock is answered with Message 12 ReportError { 2: -5, 3: "... auto unlock failed" }.
//!
//! The Mac host types the password into loginwindow through Accessibility and waits for the
//! unlock. Here the password is verified with PAM and the session is unlocked through logind
//! (`loginctl unlock-session`, allowed for the session owner), which avoids remote keystrokes
//! and gives an exact wrong-password result. The password is never logged or stored.
use std::process::Command;
use std::sync::OnceLock;
use std::time::Duration;
use tokio::sync::watch;
/// Official UnlockResult cases (LockScreenManager).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UnlockResult { Success, WrongPassword, NoLoggedInUser, NoPermission, Failed }
/// Official ReportError.error_code for a failed auto unlock.
pub const UNLOCK_FAILED_CODE: i32 = -5;
#[cfg(target_os = "linux")]
extern "C" {
fn uu_pam_available() -> libc::c_int;
fn uu_pam_check(service: *const libc::c_char, user: *const libc::c_char, password: *const libc::c_char) -> libc::c_int;
}
fn loginctl(args: &[&str]) -> Option<String> {
let out = Command::new("loginctl").args(args).output().ok()?;
if !out.status.success() { return None; }
Some(String::from_utf8_lossy(&out.stdout).trim().to_string()).filter(|s| !s.is_empty())
}
/// The logind session that owns this user's graphical display.
fn display_session() -> Option<String> {
let uid = unsafe { libc::getuid() }.to_string();
loginctl(&["show-user", &uid, "-p", "Display", "--value"])
}
pub fn locked_now() -> Option<bool> { display_session().as_deref().and_then(session_locked) }
fn session_locked(session: &str) -> Option<bool> {
loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).map(|v| v == "yes")
}
fn user_name() -> Option<String> {
let pw = unsafe { libc::getpwuid(libc::getuid()) };
if pw.is_null() { return None; }
unsafe { std::ffi::CStr::from_ptr((*pw).pw_name) }.to_str().ok().map(str::to_owned)
}
fn pam_available() -> bool {
#[cfg(target_os = "linux")]
{ unsafe { uu_pam_available() != 0 } }
#[cfg(not(target_os = "linux"))]
{ false }
}
/// PAM "login" service check of the user's own password: 0 ok, 1 wrong, -1 unavailable.
#[cfg(target_os = "linux")]
fn pam_check(user: &str, password: &str) -> i32 {
let (Ok(service), Ok(user), Ok(pass)) = (std::ffi::CString::new("login"), std::ffi::CString::new(user),
std::ffi::CString::new(password)) else { return -1 };
let verdict = unsafe { uu_pam_check(service.as_ptr(), user.as_ptr(), pass.as_ptr()) };
pass.into_bytes_with_nul().fill(0);
verdict
}
#[cfg(not(target_os = "linux"))]
fn pam_check(_user: &str, _password: &str) -> i32 { -1 }
/// Auto unlock is offered when there is a graphical logind session and PAM can be loaded.
pub fn supported() -> bool {
static SUPPORTED: OnceLock<bool> = OnceLock::new();
*SUPPORTED.get_or_init(|| pam_available() && display_session().is_some())
}
/// Current lock state (None = unknown), refreshed every second by one background thread.
pub fn watch_locked() -> watch::Receiver<Option<bool>> {
static STATE: OnceLock<watch::Sender<Option<bool>>> = OnceLock::new();
STATE.get_or_init(|| {
let (tx, _) = watch::channel(None);
let sender = tx.clone();
std::thread::Builder::new().name("uu-lock-state".into()).spawn(move || {
let mut session = None;
loop {
if session.is_none() { session = display_session(); }
let locked = session.as_deref().and_then(session_locked);
if locked.is_none() { session = None; } // session ended or changed: look it up again
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
*current = locked; true
} else { false });
std::thread::sleep(Duration::from_secs(1));
}
}).expect("spawn lock state thread");
tx
}).subscribe()
}
/// Verifies the session user's password and unlocks the display session. Blocking (PAM may
/// delay a failure by seconds); call from spawn_blocking. Consumes and wipes the password.
pub fn unlock(password: String) -> UnlockResult {
let mut password = password;
let result = unlock_with(&password);
unsafe { password.as_bytes_mut().fill(0); }
result
}
fn unlock_with(password: &str) -> UnlockResult {
let Some(session) = display_session() else { return UnlockResult::NoLoggedInUser };
if session_locked(&session) == Some(false) { return UnlockResult::Success; }
let Some(user) = user_name() else { return UnlockResult::NoLoggedInUser };
if password.is_empty() || password.contains('\0') { return UnlockResult::WrongPassword; }
match pam_check(&user, password) { 0 => {}, 1 => return UnlockResult::WrongPassword, _ => return UnlockResult::Failed }
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
// 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; }
std::thread::sleep(Duration::from_millis(100));
}
UnlockResult::Failed
}
type Channel = std::sync::Arc<webrtc::data_channel::RTCDataChannel>;
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) {
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}"); }
}
/// 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) {
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);
}
tokio::select! {
changed = state.changed() => if changed.is_err() { return; },
_ = tokio::time::sleep(Duration::from_secs(2)) => {},
}
if channel.ready_state() != RTCDataChannelState::Open { return; }
}
}
/// SimpleAction AUTO_UNLOCK_SYSTEM: unlock, log only the outcome, report failure like the Mac host.
pub async fn handle_auto_unlock(password: Option<String>, channel: Channel, sequence: Sequence) {
let result = match password {
Some(password) => tokio::task::spawn_blocking(move || unlock(password)).await.unwrap_or(UnlockResult::Failed),
None => UnlockResult::WrongPassword,
};
log::info!("Auto unlock result: {:?}", result);
if result != UnlockResult::Success {
let seq = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let message = crate::initialization::encode_report_error(seq, now(), UNLOCK_FAILED_CODE, "linux auto unlock failed");
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await { log::warn!("Auto unlock failure report failed: {e}"); }
}
}
/// `uuremote-server unlock-check`: diagnostics for auto unlock; password from stdin, never echoed.
pub fn check_from_stdin() -> Result<(), String> {
let session = display_session();
println!("display_session={} locked={:?} pam={} auto_unlock_supported={}", session.as_deref().unwrap_or("-"),
session.as_deref().and_then(session_locked), pam_available(), supported());
let mut password = String::new();
std::io::stdin().read_line(&mut password).map_err(|e| e.to_string())?;
let mut password = password.trim_end_matches(['\r', '\n']).to_string();
let user = user_name().ok_or("no user name")?;
let verdict = pam_check(&user, &password);
unsafe { password.as_bytes_mut().fill(0); }
println!("password={}", match verdict { 0 => "accepted", 1 => "rejected", _ => "unverifiable (PAM unavailable/error)" });
Ok(())
}
/// The `key` (password) from SimpleAction.args JSON.
pub fn password_from_args(args: &[u8]) -> Option<String> {
let value: serde_json::Value = serde_json::from_slice(args).ok()?;
value.get("key")?.as_str().map(str::to_owned)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn password_comes_from_the_official_key_field() {
assert_eq!(password_from_args(br#"{"key":"p@ss word"}"#).as_deref(), Some("p@ss word"));
assert_eq!(password_from_args(br#"{"password":"x"}"#), None);
assert_eq!(password_from_args(b"not json"), None);
}
}
+250
View File
@@ -0,0 +1,250 @@
//! Lightweight Native Engine.IO v4 / Socket.IO Signaling Client
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::sync::Arc;
use tokio::sync::mpsc;
use tokio_tungstenite::connect_async;
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::Message;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoacMessage {
#[serde(rename = "type")]
pub msg_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub sdp: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub gzip_sdp: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub candidate: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ice_id: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sdp_mid: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sdp_mline_index: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub app_control_id: Option<Value>,
}
pub enum SignalingEvent {
Connected,
RoomInfoAck(Value),
DeviceInfoChanged(Value),
BeControlled(Value),
/// be-controlled with its binary app_data (ConnectOptions): capture type and the
/// ice_id it announces, when present.
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce },
Soac(SoacMessage),
Released(Value),
Left(Value),
Disconnected,
}
pub struct SignalingClient {
tx_outgoing: mpsc::Sender<String>,
}
impl SignalingClient {
pub async fn connect(
url: &str,
room_token: &str,
event_sender: mpsc::Sender<SignalingEvent>,
) -> Result<Self, String> {
let ws_url = format!(
"{}/socket.io/?transport=websocket&EIO=4",
url.trim_end_matches('/')
);
let mut req = ws_url
.clone()
.into_client_request()
.map_err(|e| format!("Invalid WS request: {}", e))?;
req.headers_mut().insert(
"X-NRD-AUTH",
room_token.parse().map_err(|_| "Invalid token header")?,
);
let (ws_stream, _) = connect_async(req)
.await
.map_err(|e| format!("WS connect failed: {}", e))?;
log::info!("Connected to Engine.IO / Socket.IO at {}", ws_url);
let (mut write, mut read) = ws_stream.split();
let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<String>(32);
// 发送协程
tokio::spawn(async move {
while let Some(msg) = rx_outgoing.recv().await {
if let Err(e) = write.send(Message::Text(msg)).await {
log::warn!("WS send error: {}", e);
break;
}
}
});
let tx_out_clone = tx_outgoing.clone();
// 接收与状态机协程
tokio::spawn(async move {
let mut req_counter = 10;
// Socket.IO binary event awaiting attachments: (event name, header JSON).
let mut pending_binary: Option<(String, Value)> = None;
while let Some(msg_res) = read.next().await {
match msg_res {
Ok(Message::Text(txt)) => {
// Engine.IO 报文处理
if txt.starts_with('0') {
// Open packet -> 发送 Socket.IO connect
let _ = tx_out_clone.send("40".into()).await;
} else if txt == "2" {
// Ping -> 回复 Pong
let _ = tx_out_clone.send("3".into()).await;
} else if txt.starts_with("40") {
// Socket.IO connected -> 发送 room_info 请求
req_counter += 1;
let room_req = format!("42{}[\"room_info\"]", req_counter);
let _ = tx_out_clone.send(room_req).await;
let _ = event_sender.send(SignalingEvent::Connected).await;
} else if txt.starts_with("43") {
// Socket.IO ack 回调
let payload = &txt[txt.find('[').unwrap_or(2)..];
if let Ok(v) = serde_json::from_str::<Value>(payload) {
let _ = event_sender.send(SignalingEvent::RoomInfoAck(v)).await;
}
} else if txt.starts_with("45") || txt.starts_with("46") {
// Socket.IO binary event/ack: header text, attachments follow as binary frames.
let body = txt.trim_start_matches(|c: char| c.is_ascii_digit() || c == '-');
let name = serde_json::from_str::<Value>(body).ok()
.and_then(|v| v.get(0).and_then(|n| n.as_str()).map(str::to_owned))
.unwrap_or_default();
let name: String = name.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '_' || *c == '-').take(48).collect();
log::info!("Socket.IO binary packet: kind={} event={} header_bytes={}", &txt[..2], name, txt.len());
let header = serde_json::from_str::<Value>(body).ok().and_then(|v| v.get(1).cloned()).unwrap_or(Value::Null);
pending_binary = Some((name, header));
} else if txt.starts_with("42") {
// Socket.IO event
let payload = &txt[2..];
log::debug!("Socket.IO event received ({} bytes)", payload.len());
if let Ok(Value::Array(arr)) = serde_json::from_str::<Value>(payload) {
if arr.len() >= 2 {
let event_name = arr[0].as_str().unwrap_or_default();
let data = &arr[1];
log::info!("Socket.IO event dispatch: name={}", event_name);
match event_name {
"bmsg_push" => {
let _ = event_sender
.send(SignalingEvent::DeviceInfoChanged(data.clone()))
.await;
}
"be-controlled" => {
let _ = event_sender
.send(SignalingEvent::BeControlled(data.clone()))
.await;
}
"soac" => {
let (target_val, client_id_opt) = if let Some(inner) = data.get("data") {
(inner.clone(), data.get("client_id").and_then(|v| v.as_str()).map(|s| s.to_string()))
} else {
(data.clone(), None)
};
match serde_json::from_value::<SoacMessage>(target_val.clone()) {
Ok(mut soac) => {
if soac.client_id.is_none() {
soac.client_id = client_id_opt;
}
let _ = event_sender
.send(SignalingEvent::Soac(soac))
.await;
}
Err(e) => {
log::error!("Failed to deserialize SoacMessage: error={}, raw={}", e, data);
}
}
}
"released" => {
let _ = event_sender
.send(SignalingEvent::Released(data.clone()))
.await;
}
"left" | "leave" => {
let ice_id = data.get("ice_id").and_then(|v| v.as_str()).unwrap_or("");
if ice_id.is_empty() {
log::warn!("Room expired from NetEase cloud (leave event). Triggering room renewal...");
let _ = event_sender.send(SignalingEvent::Disconnected).await;
} else {
let _ = event_sender
.send(SignalingEvent::Left(data.clone()))
.await;
}
}
_ => {
let keys: Vec<String> = data.as_object().map(|o| o.keys().take(16).cloned().collect()).unwrap_or_default();
log::info!("Unhandled Socket.IO event: {} keys={:?}", event_name, keys);
}
}
}
}
}
}
Ok(Message::Binary(data)) => {
// Engine.IO v4 sends attachments raw; tolerate a legacy 0x04 prefix.
let data: &[u8] = if data.first() == Some(&4) && crate::protocol::decode_wire(&data).is_err() { &data[1..] } else { &data };
let fields = crate::protocol::decode_wire(data).ok();
let shape: Vec<(u32, Option<u64>)> = fields.as_ref().map(|f| f.iter().map(|x| (x.number, match x.value {
crate::protocol::WireValue::Varint(v) => Some(v), _ => None })).collect()).unwrap_or_default();
log::info!("Socket.IO binary attachment: bytes={} protobuf_fields={:?}", data.len(), shape);
if let Some((name, header)) = pending_binary.take() {
if name == "be-controlled" {
let capture_type = shape.iter().find(|(n, _)| *n == 1).and_then(|(_, v)| *v).unwrap_or(0);
let keys: Vec<String> = header.as_object().map(|o| o.keys().take(24).cloned().collect()).unwrap_or_default();
let ice_id = ["ice_id", "iceId"].iter().find_map(|k| header.get(*k).or_else(|| header.get("data").and_then(|d| d.get(*k))))
.and_then(|v| v.as_str()).map(str::to_owned);
log::info!("be-controlled connect request: capture_type={} header_keys={:?} ice_id_present={}", capture_type, keys, ice_id.is_some());
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header) }).await;
}
}
}
Ok(Message::Close(_)) | Err(_) => {
let _ = event_sender.send(SignalingEvent::Disconnected).await;
break;
}
_ => {}
}
}
});
Ok(Self { tx_outgoing })
}
pub async fn emit_event(&self, event: &str, payload: serde_json::Value) -> Result<(), String> {
let packet = format!("42{}", serde_json::json!([event, payload]));
log::info!("Emitting signaling event: {}", event);
self.tx_outgoing.send(packet).await.map_err(|e| e.to_string())
}
/// 发送 SOAC 消息(Answer 或 Candidate)
pub async fn emit_soac(&self, soac: SoacMessage) -> Result<(), String> {
let payload = if let Some(cid) = &soac.client_id {
serde_json::json!({
"client_id": cid,
"data": soac
}).to_string()
} else {
serde_json::to_string(&soac).map_err(|e| e.to_string())?
};
let msg = format!("42[\"soac\",{}]", payload);
log::info!("Emitting soac packet: type={}", soac.msg_type);
self.tx_outgoing
.send(msg)
.await
.map_err(|e| format!("Send soac error: {}", e))
}
}
+274
View File
@@ -0,0 +1,274 @@
//! Official SimpleAction system commands from the viewer's 安全 / 更多 menus, mapped to the
//! Linux desktop session: lock (logind), show desktop, system monitor, reboot/power-off
//! (systemctl through logind/polkit), host mute (wpctl / pactl) and lock-after-session.
//! Declared through FeatureFlag ff_simple_action = FF_SIMPLE_ACTION_AUTO_LOCK (2, includes
//! MUTING) and ff_system_metrics = FF_SYSTEM_METRICS_SETTING_AUTO_LOCK (2).
use std::process::{Command, Stdio};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Mutex;
pub const FF_SIMPLE_ACTION: u8 = 2;
pub const FF_SYSTEM_METRICS: u8 = 2;
pub const SHOW_DESKTOP: u64 = 2;
pub const REBOOT_SYSTEM: u64 = 9;
pub const LOCK_SYSTEM: u64 = 10;
pub const SHUTDOWN_SYSTEM: u64 = 12;
pub const SHOW_TASKMGR: u64 = 13;
pub const MUTE_SYSTEM: u64 = 14;
pub const MUTE_RESTORE: u64 = 16;
pub const MUTE_PERMANENT: u64 = 17;
pub const MUTE_TEMPORARY: u64 = 18;
pub const SET_AUTO_LOCK: u64 = 19;
/// Host settings from the viewer's 安全 menu. The viewer sends them only when a switch is toggled
/// and shows what SystemMetrics reports, so they are host-wide and persisted (like the official
/// host), not per connection: a reconnect must still lock / mute.
#[derive(Debug, Default, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
struct Settings {
#[serde(default)] auto_lock: bool,
#[serde(default)] keep_mute: bool,
#[serde(default)] mute_permanent: bool,
}
struct HostState {
settings: Settings,
/// Host mute state before remote control muted it (restored by MUTE_RESTORE / last session end).
restore: Option<bool>,
desktop_sessions: usize,
}
fn settings_path() -> std::path::PathBuf { crate::config::path().with_file_name("host_settings.json") }
fn state() -> &'static Mutex<HostState> {
static STATE: std::sync::OnceLock<Mutex<HostState>> = std::sync::OnceLock::new();
STATE.get_or_init(|| {
let settings = std::fs::read(settings_path()).ok()
.and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default();
Mutex::new(HostState { settings, restore: None, desktop_sessions: 0 })
})
}
fn save(settings: &Settings) {
let path = settings_path();
let result = serde_json::to_vec_pretty(settings).map_err(|e| e.to_string())
.and_then(|json| std::fs::write(&path, json).map_err(|e| e.to_string()));
if let Err(e) = result { log::warn!("Host settings not saved: {}", e); }
}
/// Handle for one desktop connection (system actions are host-wide).
#[derive(Default)]
pub struct PeerActions { started: AtomicBool }
fn quiet(program: &str, args: &[&str]) -> bool {
Command::new(program).args(args).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
.status().map(|s| s.success()).unwrap_or(false)
}
fn detached(program: &str, args: &[&str]) -> bool {
Command::new(program).args(args).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
.spawn().map(|mut child| { std::thread::spawn(move || child.wait()); true }).unwrap_or(false)
}
/// Current mute state of the default output (None = no audio control available).
pub fn host_muted() -> Option<bool> {
if let Ok(out) = Command::new("wpctl").args(["get-volume", "@DEFAULT_AUDIO_SINK@"]).output() {
if out.status.success() { return Some(String::from_utf8_lossy(&out.stdout).contains("MUTED")); }
}
let out = Command::new("pactl").args(["get-sink-mute", "@DEFAULT_SINK@"]).output().ok()?;
out.status.success().then(|| String::from_utf8_lossy(&out.stdout).contains("yes"))
}
pub fn set_host_muted(muted: bool) -> bool {
let flag = if muted { "1" } else { "0" };
quiet("wpctl", &["set-mute", "@DEFAULT_AUDIO_SINK@", flag]) || quiet("pactl", &["set-sink-mute", "@DEFAULT_SINK@", flag])
}
pub fn lock_session() -> bool { quiet("loginctl", &["lock-session"]) }
/// The on/off value of a toggle action: SimpleAction.value (field 5), else args JSON/text; default on.
pub fn toggle_value(value: Option<u64>, args: &[u8]) -> bool {
if let Some(v) = value { return v != 0; }
let text = String::from_utf8_lossy(args);
let text = text.trim();
if let Ok(json) = serde_json::from_str::<serde_json::Value>(text) {
let scalar = |v: &serde_json::Value| v.as_bool().or_else(|| v.as_i64().map(|n| n != 0))
.or_else(|| v.as_str().map(|s| matches!(s, "1" | "true" | "on")));
if let Some(b) = scalar(&json) { return b; }
if let Some(b) = json.as_object().and_then(|o| o.values().find_map(scalar)) { return b; }
}
!matches!(text, "0" | "false" | "off")
}
/// Shape of action args for diagnostics: JSON keys and scalar types, never values.
pub fn args_shape(args: &[u8]) -> String {
match serde_json::from_slice::<serde_json::Value>(args) {
Ok(serde_json::Value::Object(o)) => format!("{:?}", o.iter().map(|(k, v)| (k.chars().take(32).collect::<String>(), match v {
serde_json::Value::Bool(_) => "bool", serde_json::Value::Number(_) => "number",
serde_json::Value::String(_) => "string", _ => "other" })).collect::<Vec<_>>()),
Ok(_) => "json scalar".into(),
Err(_) => format!("{} bytes non-json", args.len()),
}
}
fn mute_for_session(state: &mut HostState) {
if state.restore.is_none() { state.restore = host_muted(); }
set_host_muted(true);
}
fn restore_mute(state: &mut HostState) {
if let Some(previous) = state.restore.take() { set_host_muted(previous); }
}
impl PeerActions {
/// Runs one system action; returns true when the settings report should be resent.
/// Blocking (spawns system tools); call from spawn_blocking.
pub fn handle(&self, action: u64, value: Option<u64>, args: &[u8], show_desktop: impl FnOnce()) -> bool {
match action {
SHOW_DESKTOP => { show_desktop(); log::info!("System action show_desktop"); return false }
LOCK_SYSTEM => { log::info!("System action lock_system: ok={}", lock_session()); return false }
SHOW_TASKMGR => {
let ok = detached("gnome-system-monitor", &[]) || detached("plasma-systemmonitor", &[]) || detached("xfce4-taskmanager", &[]);
log::info!("System action show_taskmgr: ok={}", ok); return false
}
REBOOT_SYSTEM => { log::warn!("System action reboot_system requested by viewer"); log::info!("reboot ok={}", quiet("systemctl", &["reboot"])); return false }
SHUTDOWN_SYSTEM => { log::warn!("System action shutdown_system requested by viewer"); log::info!("poweroff ok={}", quiet("systemctl", &["poweroff"])); return false }
_ => {}
}
let mut state = state().lock().unwrap();
let before = state.settings;
match action {
// 静音运行 on: the viewer sends MUTE_SYSTEM + MUTE_TEMPORARY (observed), off: MUTE_RESTORE.
MUTE_SYSTEM | MUTE_TEMPORARY => {
let on = toggle_value(value, args);
state.settings.keep_mute = on;
if on { mute_for_session(&mut state); } else { restore_mute(&mut state); }
log::info!("System action mute (action {}): on={} muted={:?}", action, on, host_muted());
}
// Keep the host muted after the session (远程结束后,恢复被控端声音设置 unchecked).
MUTE_PERMANENT => {
let on = toggle_value(value, args);
state.settings.mute_permanent = on;
if on { state.settings.keep_mute = true; mute_for_session(&mut state); }
log::info!("System action mute_permanent: on={} muted={:?}", on, host_muted());
}
MUTE_RESTORE => {
state.settings.keep_mute = false;
state.settings.mute_permanent = false;
restore_mute(&mut state);
log::info!("System action mute_restore: muted={:?}", host_muted());
}
SET_AUTO_LOCK => {
// Observed: enabling 远程结束后自动锁屏 sends value 2 and disabling value 1.
let on = match value { Some(v) => v == 2, None => toggle_value(None, args) };
state.settings.auto_lock = on;
log::info!("System action set_auto_lock: on={}", on);
}
_ => return false,
}
if state.settings != before { save(&state.settings); }
true
}
/// Desktop connection started: re-apply 静音运行 for the first remote session.
pub fn session_started(&self) {
if self.started.swap(true, Ordering::Relaxed) { return; }
let mut state = state().lock().unwrap();
state.desktop_sessions += 1;
if state.desktop_sessions == 1 && state.settings.keep_mute {
mute_for_session(&mut state);
log::info!("Host muted for remote session (静音运行)");
}
}
/// Desktop connection ended. After the last one: undo a session-only mute and lock if the
/// viewer asked for it.
pub fn session_ended(&self) {
if !self.started.swap(false, Ordering::Relaxed) { return; }
let mut state = state().lock().unwrap();
state.desktop_sessions = state.desktop_sessions.saturating_sub(1);
if state.desktop_sessions > 0 { return; }
if !state.settings.mute_permanent { restore_mute(&mut state); }
if state.settings.auto_lock {
log::info!("Auto lock after remote session: ok={}", lock_session());
}
}
/// Message 13 SystemMetrics: permissions, file-transfer folder and the current settings.
pub fn metrics_payload(&self, sound: bool, desktop: crate::system_metrics::Permission) -> Vec<u8> {
use crate::system_metrics::payload_with_settings;
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
let current = state().lock().unwrap().settings;
payload_with_settings(desktop, desktop, desktop, &home, &crate::system_metrics::Settings {
sound, keep_mute: current.keep_mute, mute_permanent: current.mute_permanent, auto_lock: current.auto_lock,
})
}
}
/// Session RPCs answered with success: 15 send_video_track_req -> 11 (the single desktop track
/// 0 is always sent), 21 virtual_audio_driver_policy_req -> 17 (no virtual driver needed: the
/// sink monitor is captured directly). Responses carry error_code 0 (default).
pub fn session_rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
use crate::protocol::{decode_wire, WireValue};
let body = |n: u32| rpc.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Bytes(b)) if x == n => Some(*b), _ => None });
let (request, response_field) = [(15u32, 11u8), (21, 17)].into_iter().find_map(|(req, resp)| body(req).map(|b| (b, resp)))?;
let value = decode_wire(request).ok().and_then(|f| f.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }));
log::info!("Session RPC answered: response_field={} value={:?}", response_field, value);
let header = body(1).unwrap_or(&[]);
let mut out = vec![10, header.len() as u8];
out.extend_from_slice(header);
out.extend_from_slice(&[response_field << 3 | 2, 0]);
Some(out)
}
/// Plugin RPCs (魔兽世界排队提醒工具): no plugins exist on Linux. Query answers "disabled"
/// (QueryPluginSettingResponse field 12); enable/install/notification requests answer error_code 1.
pub fn plugin_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
use crate::protocol::{decode_wire, WireValue};
fn varint(mut v: u64, out: &mut Vec<u8>) { while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; } out.push(v as u8); }
fn bytes(field: u64, v: &[u8], out: &mut Vec<u8>) { varint(field << 3 | 2, out); varint(v.len() as u64, out); out.extend_from_slice(v); }
let body = |n: u32| rpc.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Bytes(b)) if x == n => Some(*b), _ => None });
// (request field, response field, plugin_id field in the response)
let (request, response_field, id_field): (&[u8], u64, u64) = [(16u32, 12u64, 3u64), (17, 13, 3), (18, 14, 2), (19, 15, 2), (20, 16, 2)]
.into_iter().find_map(|(req, resp, id)| body(req).map(|b| (b, resp, id)))?;
let plugin_id = decode_wire(request).ok()?.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Bytes(b)) => Some(b.to_vec()), _ => None }).unwrap_or_default();
let mut payload = Vec::new();
if response_field != 12 { payload.extend_from_slice(&[8, 1]); } // error_code 1: unsupported
bytes(id_field, &plugin_id, &mut payload); // query: error_code 0, enable false (defaults)
let mut out = Vec::new();
bytes(1, body(1).unwrap_or(&[]), &mut out);
bytes(response_field, &payload, &mut out);
log::info!("Plugin RPC answered: response_field={} (no Linux plugins)", response_field);
Some(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn toggle_values_from_value_field_json_and_text() {
assert!(!toggle_value(Some(0), b"1"));
assert!(toggle_value(Some(1), b""));
assert!(!toggle_value(None, br#"{"enable":false}"#));
assert!(toggle_value(None, br#"{"value":1}"#));
assert!(!toggle_value(None, b"0"));
assert!(toggle_value(None, b""));
}
#[test]
fn plugin_query_answers_disabled_with_same_request_and_plugin_id() {
use crate::protocol::{decode_wire, WireValue};
// RpcRequest { 1 header{1:9}, 16 query{1:"wow"} }
let request = [10, 2, 8, 9, 130, 1, 5, 10, 3, b'w', b'o', b'w'];
let response = plugin_response(&decode_wire(&request).unwrap()).unwrap();
let fields = decode_wire(&response).unwrap();
assert_eq!(fields[0].value, WireValue::Bytes(&[8, 9]));
assert_eq!(fields[1].number, 12);
assert_eq!(fields[1].value, WireValue::Bytes(&[26, 3, b'w', b'o', b'w']));
assert!(plugin_response(&decode_wire(&[10, 2, 8, 9]).unwrap()).is_none());
}
#[test]
fn args_shape_never_contains_values() {
let shape = args_shape(br#"{"enable":true,"secret":"abc"}"#);
assert!(shape.contains("enable") && !shape.contains("abc"));
}
}
+118
View File
@@ -0,0 +1,118 @@
//! Verified SystemMetrics protobuf shape for ordinary Linux X11 control.
//! Official maps/types: analysis/protocol-fix-20261013/control/system-metrics-*.json.
//! This reports observations supplied by the caller; it never unlocks a session,
//! sends SAS, enables audio, advertises Windows, or changes desktop settings.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u64)]
pub enum Permission {
Unknown = 0,
Reject = 1,
Allow = 2,
}
/// Payload for Message.which field 13 SystemMetrics. Use initialization::envelope
/// with fresh local sequence/current UNIX seconds. Current locked state belongs
/// to a separate SystemStateChange notification, not this capability message.
pub fn payload(capture: Permission, operation: Permission, control: Permission) -> Vec<u8> {
payload_with_location(capture, operation, control, "")
}
/// Same, plus SettingMetric field 5 file_transfer_save_location: the host directory the
/// viewer's file-transfer window opens on (the official Mac host reports its receive folder).
pub fn payload_with_location(capture: Permission, operation: Permission, control: Permission, location: &str) -> Vec<u8> {
payload_with_settings(capture, operation, control, location, &Settings::default())
}
/// Optional host settings the viewer shows in 声音 / 安全 (SettingMetric 1 keep_mute,
/// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support).
#[derive(Debug, Default, Clone, Copy)]
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool }
pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec<u8> {
let mut setting = Vec::new();
for (field, on) in [(1u8, settings.keep_mute), (2, settings.mute_permanent), (3, settings.auto_lock)] {
if on { setting.push(field << 3); setting.push(1); }
}
if !location.is_empty() {
setting.push(5 << 3 | 2);
varint(location.len() as u64, &mut setting);
setting.extend_from_slice(location.as_bytes());
}
for (field, state) in [(8u8, capture), (9u8, operation), (10u8, control)] {
if state != Permission::Unknown {
setting.push(field << 3);
setting.push(state as u8);
}
}
// SystemMetrics.general: system_sound_support = SS_SUPPORT (2) when desktop audio is streamed
// (GvPb_SystemSoundSupport: 0 unknown, 1 nonsupport, 2 support).
let mut out = if settings.sound { vec![26, 2, 16, 2] } else { vec![26, 0] };
// No support_touch, sound capability, win_os_ver, private-screen, virtual
// mouse, auto-lock, file path or optional feature claims are fabricated.
out.push(34); // SystemMetrics.setting field 4
varint(setting.len() as u64, &mut out);
out.extend_from_slice(&setting);
out
}
fn varint(mut v: u64, out: &mut Vec<u8>) {
while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; }
out.push(v as u8);
}
/// Message field 26 RemoteDownloadPath{1 download_path}.
pub fn remote_download_path(path: &str) -> Vec<u8> {
let mut out = vec![10];
varint(path.len() as u64, &mut out);
out.extend_from_slice(path.as_bytes());
out
}
#[cfg(test)]
#[path = "protocol.rs"]
mod wire_test_support;
#[cfg(test)]
mod tests {
use super::*;
use super::wire_test_support::{decode_wire, WireValue};
#[test]
fn measured_allow_capabilities_use_official_enum_values() {
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
let fields = decode_wire(&p).unwrap();
assert_eq!(fields.len(), 2);
assert_eq!(fields[0].number, 3);
assert_eq!(fields[0].value, WireValue::Bytes(&[]));
let WireValue::Bytes(setting) = fields[1].value else { panic!("setting not a message") };
assert_eq!(fields[1].number, 4);
let s = decode_wire(setting).unwrap();
assert_eq!(s.iter().map(|f| f.number).collect::<Vec<_>>(), vec![8, 9, 10]);
assert!(s.iter().all(|f| f.value == WireValue::Varint(2)));
}
#[test]
fn rejected_and_unknown_observations_are_not_promoted_to_allow() {
assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![26, 0, 34, 0]);
assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![26, 0, 34, 6, 64, 2, 72, 1, 80, 1]);
}
#[test]
fn emits_no_audio_touch_windows_or_auto_unlock_capability() {
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
let fields = decode_wire(&p).unwrap();
let WireValue::Bytes(general) = fields[0].value else { panic!() };
assert!(general.is_empty());
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
assert!(decode_wire(setting).unwrap().iter().all(|f| (8..=10).contains(&f.number)));
}
#[test]
fn reports_file_transfer_save_location_as_setting_field_5() {
let home = "/home/user/".repeat(12);
let p = payload_with_location(Permission::Allow, Permission::Allow, Permission::Allow, &home);
let fields = decode_wire(&p).unwrap();
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
let s = decode_wire(setting).unwrap();
assert_eq!(s[0].number, 5);
assert_eq!(s[0].value, WireValue::Bytes(home.as_bytes()));
assert_eq!(decode_wire(&remote_download_path("/home/x")).unwrap()[0].value, WireValue::Bytes(b"/home/x"));
}
}
+321
View File
@@ -0,0 +1,321 @@
//! UU remote terminal (CT_TERMINAL) over BINARY_DATA_CHANNEL.
//! Frame layout recovered from the official Mac host codec (UURemoteServer 0x1001a7834 decode,
//! 0x1001a7480 encode): "TERM", version u8 = 1, type u8, two flag bytes, session_id u32 LE,
//! payload_len u32 LE (<= 1 MiB), payload. Type values are TerminalFrameType case index + 1.
//! Control payloads are JSON (cols/rows/shell/option, code/message, exit_code, password).
//! Sessions outlive a viewer connection (like the official tmux-backed sessions) and replay
//! a bounded scrollback on reattach. Terminal input/output bytes are never logged.
use std::collections::{HashMap, VecDeque};
use std::io::Read;
use std::os::fd::{AsRawFd, OwnedFd};
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use tokio::sync::mpsc::UnboundedSender;
pub const OPEN: u8 = 1;
pub const STDIN: u8 = 2;
pub const RESIZE: u8 = 3;
pub const CLOSE: u8 = 4;
pub const STDOUT: u8 = 5;
pub const EXIT: u8 = 6;
pub const SIGNAL: u8 = 7;
pub const ERROR: u8 = 8;
pub const LIST_REQ: u8 = 9;
pub const LIST_RESP: u8 = 10;
pub const KILL_REQ: u8 = 11;
pub const KILL_RESP: u8 = 12;
pub const OPEN_RESP: u8 = 13;
pub const UNLOCK_REQ: u8 = 14;
pub const UNLOCK_RESP: u8 = 15;
pub const DETACH: u8 = 16;
const MAGIC: &[u8; 4] = b"TERM";
const HEADER: usize = 16;
const MAX_PAYLOAD: usize = 0x10_0000;
const SCROLLBACK: usize = 256 * 1024;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Frame { pub kind: u8, pub flags: [u8; 2], pub session: u32, pub payload: Vec<u8> }
pub fn encode(kind: u8, session: u32, payload: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(HEADER + payload.len());
out.extend_from_slice(MAGIC);
out.push(1);
out.push(kind);
out.extend_from_slice(&[0, 0]);
out.extend_from_slice(&session.to_le_bytes());
out.extend_from_slice(&(payload.len() as u32).to_le_bytes());
out.extend_from_slice(payload);
out
}
pub fn decode(data: &[u8]) -> Option<Frame> {
if data.len() < HEADER || &data[..4] != MAGIC { return None; }
let kind = data[5];
if !(1..=16).contains(&kind) { return None; }
let session = u32::from_le_bytes(data[8..12].try_into().ok()?);
let len = u32::from_le_bytes(data[12..16].try_into().ok()?) as usize;
if len > MAX_PAYLOAD || data.len() != HEADER + len { return None; }
Some(Frame { kind, flags: [data[6], data[7]], session, payload: data[HEADER..].to_vec() })
}
pub fn is_frame(data: &[u8]) -> bool { data.len() >= 4 && &data[..4] == MAGIC }
struct Session {
id: u32,
shell: String,
created_ms: u64,
master: OwnedFd,
pid: i32,
sink: Mutex<Option<UnboundedSender<Vec<u8>>>>,
scrollback: Mutex<VecDeque<u8>>,
}
impl Session {
fn emit(&self, kind: u8, payload: &[u8]) -> bool {
let mut sink = self.sink.lock().unwrap();
if let Some(tx) = sink.as_ref() {
if tx.send(encode(kind, self.id, payload)).is_ok() { return true; }
*sink = None;
}
false
}
fn resize(&self, cols: u16, rows: u16) {
let win = libc::winsize { ws_row: rows, ws_col: cols, ws_xpixel: 0, ws_ypixel: 0 };
unsafe { libc::ioctl(self.master.as_raw_fd(), libc::TIOCSWINSZ as _, &win); }
}
fn write(&self, data: &[u8]) {
let mut off = 0;
while off < data.len() {
let n = unsafe { libc::write(self.master.as_raw_fd(), data[off..].as_ptr().cast(), data.len() - off) };
if n <= 0 { break; }
off += n as usize;
}
}
fn signal(&self, sig: i32) { unsafe { libc::kill(-self.pid, sig); } }
}
fn registry() -> &'static Mutex<HashMap<u32, Arc<Session>>> {
static REG: OnceLock<Mutex<HashMap<u32, Arc<Session>>>> = OnceLock::new();
REG.get_or_init(Default::default)
}
static NEXT_ID: AtomicU32 = AtomicU32::new(1);
fn now_ms() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_millis() as u64 }
fn spawn(cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, String> {
use std::os::unix::process::CommandExt;
let win = nix::pty::Winsize { ws_row: rows.max(1), ws_col: cols.max(1), ws_xpixel: 0, ws_ypixel: 0 };
let pty = nix::pty::openpty(Some(&win), None).map_err(|e| format!("openpty failed: {e}"))?;
let shell = shell.filter(|s| s.starts_with('/') && std::path::Path::new(s).exists()).map(str::to_owned)
.or_else(|| std::env::var("SHELL").ok().filter(|s| std::path::Path::new(s).exists()))
.unwrap_or_else(|| "/bin/bash".into());
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
let slave = pty.slave;
let io = |fd: &OwnedFd| fd.try_clone().map(std::process::Stdio::from).map_err(|e| format!("pty dup failed: {e}"));
let mut cmd = std::process::Command::new(&shell);
cmd.arg("-l").current_dir(&home)
.env("TERM", "xterm-256color").env("COLORTERM", "truecolor")
.env("LANG", std::env::var("LANG").unwrap_or_else(|_| "C.UTF-8".into()))
.stdin(io(&slave)?).stdout(io(&slave)?).stderr(io(&slave)?);
unsafe {
cmd.pre_exec(|| {
if libc::setsid() < 0 { return Err(std::io::Error::last_os_error()); }
if libc::ioctl(0, libc::TIOCSCTTY as _, 0) < 0 { return Err(std::io::Error::last_os_error()); }
Ok(())
});
}
let mut child = cmd.spawn().map_err(|e| format!("shell spawn failed: {e}"))?;
drop(slave);
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
let session = Arc::new(Session { id, shell: shell.clone(), created_ms: now_ms(), pid: child.id() as i32,
master: pty.master, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()) });
let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?);
let worker = session.clone();
std::thread::Builder::new().name(format!("uu-term-{id}")).spawn(move || {
let mut buf = vec![0u8; 16 * 1024];
loop {
match reader.read(&mut buf) {
Ok(0) | Err(_) => break,
Ok(n) => {
{
let mut sb = worker.scrollback.lock().unwrap();
sb.extend(&buf[..n]);
let excess = sb.len().saturating_sub(SCROLLBACK);
sb.drain(..excess);
}
worker.emit(STDOUT, &buf[..n]);
}
}
}
let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1);
log::info!("Terminal session exited: id={} exit_code={}", worker.id, code);
worker.emit(EXIT, serde_json::json!({"exit_code": code}).to_string().as_bytes());
registry().lock().unwrap().remove(&worker.id);
}).map_err(|e| format!("reader thread failed: {e}"))?;
registry().lock().unwrap().insert(id, session.clone());
log::info!("Terminal session spawned: id={} cols={} rows={}", id, cols, rows);
Ok(session)
}
/// Ends every terminal session (interactive shells ignore SIGTERM, which otherwise
/// makes systemd wait for its stop timeout). Called when the server shuts down.
pub fn shutdown_all() {
let sessions: Vec<Arc<Session>> = registry().lock().unwrap().values().cloned().collect();
for s in &sessions { s.signal(libc::SIGHUP); }
if !sessions.is_empty() {
std::thread::sleep(std::time::Duration::from_millis(300));
for s in &sessions { s.signal(libc::SIGKILL); }
log::info!("Terminal sessions closed on shutdown: count={}", sessions.len());
}
}
fn json(payload: &[u8]) -> serde_json::Value { serde_json::from_slice(payload).unwrap_or(serde_json::Value::Null) }
fn dims(v: &serde_json::Value) -> (u16, u16) {
let get = |k: &str, d: u64| v.get(k).and_then(|x| x.as_u64().or_else(|| x.as_f64().map(|f| f as u64))).unwrap_or(d).clamp(1, 1000) as u16;
(get("cols", 80), get("rows", 24))
}
fn signal_number(payload: &[u8]) -> i32 {
let text = String::from_utf8_lossy(payload);
let v = json(payload);
let name = v.as_str().map(str::to_owned).or_else(|| v.as_object().and_then(|o| o.values().find_map(|x| x.as_str().map(str::to_owned))))
.unwrap_or_else(|| text.into_owned());
if let Some(n) = v.as_object().and_then(|o| o.values().find_map(|x| x.as_i64())) { return n as i32; }
match name.trim().trim_start_matches("SIG") {
"TERM" => libc::SIGTERM, "KILL" => libc::SIGKILL, "HUP" => libc::SIGHUP, "QUIT" => libc::SIGQUIT,
"ABRT" => libc::SIGABRT, "PIPE" => libc::SIGPIPE, "FPE" => libc::SIGFPE, "SEGV" => libc::SIGSEGV, "ILL" => libc::SIGILL,
_ => libc::SIGINT,
}
}
fn reply(code: i64, message: &str) -> Vec<u8> { serde_json::json!({"code": code, "message": message}).to_string().into_bytes() }
/// One viewer connection's terminal endpoint; `out` sends complete frames on BINARY_DATA_CHANNEL.
pub struct TerminalConn { out: UnboundedSender<Vec<u8>> }
impl TerminalConn {
pub fn new(out: UnboundedSender<Vec<u8>>) -> Self { Self { out } }
fn send(&self, kind: u8, session: u32, payload: &[u8]) { let _ = self.out.send(encode(kind, session, payload)); }
pub fn handle(&self, data: &[u8]) {
let Some(frame) = decode(data) else { log::warn!("Terminal frame rejected: bytes={}", data.len()); return; };
if frame.kind != STDIN { log::info!("Terminal frame: type={} session={} payload_bytes={}", frame.kind, frame.session, frame.payload.len()); }
let existing = registry().lock().unwrap().get(&frame.session).cloned();
match frame.kind {
OPEN => {
let v = json(&frame.payload);
let (cols, rows) = dims(&v);
let session = match existing {
Some(s) => { s.resize(cols, rows); Ok(s) }
None => spawn(cols, rows, v.get("shell").and_then(|s| s.as_str())),
};
match session {
Ok(s) => {
*s.sink.lock().unwrap() = Some(self.out.clone());
self.send(OPEN_RESP, s.id, &reply(0, "ok"));
let replay: Vec<u8> = s.scrollback.lock().unwrap().iter().copied().collect();
if !replay.is_empty() { self.send(STDOUT, s.id, &replay); }
}
Err(e) => { log::warn!("Terminal open failed: {}", e); self.send(OPEN_RESP, frame.session, &reply(1, &e)); }
}
}
STDIN => if let Some(s) = existing { s.write(&frame.payload) },
RESIZE => if let Some(s) = existing { let (c, r) = dims(&json(&frame.payload)); s.resize(c, r) },
SIGNAL => if let Some(s) = existing { s.signal(signal_number(&frame.payload)) },
CLOSE => if let Some(s) = existing { *s.sink.lock().unwrap() = None; s.signal(libc::SIGHUP); },
DETACH => if let Some(s) = existing { *s.sink.lock().unwrap() = None },
KILL_REQ => {
let id = if frame.session != 0 { frame.session } else {
json(&frame.payload).get("session_id").and_then(|x| x.as_u64()).unwrap_or(0) as u32
};
let target = registry().lock().unwrap().get(&id).cloned();
match target {
Some(s) => { *s.sink.lock().unwrap() = None; s.signal(libc::SIGHUP); s.signal(libc::SIGKILL); self.send(KILL_RESP, id, &reply(0, "ok")); }
None => self.send(KILL_RESP, id, &reply(1, "Session not found")),
}
}
LIST_REQ => {
let sessions: Vec<serde_json::Value> = registry().lock().unwrap().values().map(|s| {
let attached = s.sink.lock().unwrap().is_some();
serde_json::json!({"session_id": s.id, "name": format!("bash-{}", s.id), "shell": s.shell,
"state": if attached { "running" } else { "detached" }, "created_at_ms": s.created_ms})
}).collect();
log::info!("Terminal list sessions: count={}", sessions.len());
self.send(LIST_RESP, 0, serde_json::json!({"code": 0, "message": "ok", "sessions": sessions}).to_string().as_bytes());
}
UNLOCK_REQ => self.send(UNLOCK_RESP, frame.session, &reply(0, "ok")),
_ => self.send(ERROR, frame.session, &reply(1, "unsupported frame")),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn frame_round_trip_matches_official_layout() {
let f = encode(OPEN_RESP, 7, b"{}");
assert_eq!(&f[..8], &[b'T', b'E', b'R', b'M', 1, 13, 0, 0]);
assert_eq!(&f[8..16], &[7, 0, 0, 0, 2, 0, 0, 0]);
assert_eq!(decode(&f), Some(Frame { kind: 13, flags: [0, 0], session: 7, payload: b"{}".to_vec() }));
assert_eq!(decode(&f[..17]), None);
let mut bad = f.clone(); bad[5] = 17; assert_eq!(decode(&bad), None);
}
#[test]
fn signal_names_map_to_posix_numbers() {
assert_eq!(signal_number(b"SIGTERM"), libc::SIGTERM);
assert_eq!(signal_number(br#"{"signal":"SIGKILL"}"#), libc::SIGKILL);
assert_eq!(signal_number(b"whatever"), libc::SIGINT);
}
#[test]
fn open_spawns_shell_and_streams_output() {
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let conn = TerminalConn::new(tx);
conn.handle(&encode(OPEN, 0, br#"{"cols":100,"rows":30,"shell":"/bin/sh"}"#));
let resp = decode(&rx.blocking_recv().unwrap()).unwrap();
assert_eq!(resp.kind, OPEN_RESP);
assert_eq!(json(&resp.payload)["code"], 0);
conn.handle(&encode(STDIN, resp.session, b"echo uu-term-ok; exit 3\n"));
let mut seen = Vec::new();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
let mut exit = None;
while std::time::Instant::now() < deadline && exit.is_none() {
if let Ok(m) = rx.try_recv() {
let f = decode(&m).unwrap();
if f.kind == STDOUT { seen.extend(f.payload) } else if f.kind == EXIT { exit = Some(json(&f.payload)["exit_code"].clone()) }
} else { std::thread::sleep(std::time::Duration::from_millis(20)); }
}
assert!(String::from_utf8_lossy(&seen).contains("uu-term-ok"));
assert_eq!(exit, Some(serde_json::json!(3)));
}
}
/// Terminal RPCs carried in Message 21 RpcRequest: 28 terminal_check_env_req (CheckEnvReq, empty)
/// -> RpcResponse 24 CheckEnvResp{1 code, 2 message}; 29 RenameSessionReq{1 session_id, 2 name}
/// -> RpcResponse 26 RenameSessionResp{1 session_id, 2 code, 3 message}. Returns the RpcResponse body.
pub fn rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
use crate::protocol::WireValue;
fn varint(mut v: u64, out: &mut Vec<u8>) { while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; } out.push(v as u8); }
fn bytes(field: u64, v: &[u8], out: &mut Vec<u8>) { varint(field << 3 | 2, out); varint(v.len() as u64, out); out.extend_from_slice(v); }
let header = rpc.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Bytes(b)) => Some(*b), _ => None }).unwrap_or(&[]);
let mut out = Vec::new();
bytes(1, header, &mut out);
if rpc.iter().any(|f| f.number == 28) {
let mut body = Vec::new();
bytes(2, b"ok", &mut body); // code 0 (default) = available
bytes(24, &body, &mut out);
log::info!("Terminal check_env answered: available");
return Some(out);
}
if let Some(WireValue::Bytes(req)) = rpc.iter().find(|f| f.number == 29).map(|f| &f.value) {
let fields = crate::protocol::decode_wire(req).ok()?;
let session = fields.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }).unwrap_or(0);
let mut body = Vec::new();
if session != 0 { varint(1 << 3, &mut body); varint(session, &mut body); }
bytes(3, b"ok", &mut body);
bytes(26, &body, &mut out);
log::info!("Terminal rename answered: session={}", session);
return Some(out);
}
None
}
+410
View File
@@ -0,0 +1,410 @@
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::io::AsyncReadExt;
use tokio::process::Command;
use tokio::sync::mpsc;
use webrtc::media::Sample;
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
use webrtc::peer_connection::RTCPeerConnection;
use webrtc::track::track_local::track_local_static_sample::TrackLocalStaticSample;
use crate::capture_setting::VideoSettings;
/// Default frame rate; the viewer's 帧率 setting overrides it per connection.
pub const FPS: u64 = 60;
/// IDR every 0.5s. All-intra 60fps measured 30 Mbit/s on the real desktop (saturating
/// the viewer's Wi-Fi: 3-6 fps received); GOP 30 measured 2.7 Mbit/s at the same CQ18.
/// A broken prediction chain therefore freezes at most this long.
const GOP: u64 = 30;
const MAX_ACCESS_UNIT: usize = 8 * 1024 * 1024;
fn nal_offsets(bytes: &[u8], kind: u8) -> Vec<usize> {
let mut result = Vec::new();
let mut i = 0;
while i + 3 < bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue };
if i + prefix < bytes.len() && bytes[i + prefix] & 31 == kind { result.push(i); }
i += prefix;
}
result
}
fn aud_offsets(bytes: &[u8]) -> Vec<usize> { nal_offsets(bytes, 9) }
fn is_independent_frame(bytes: &[u8]) -> bool {
!nal_offsets(bytes, 5).is_empty() && nal_offsets(bytes, 1).is_empty()
}
#[derive(Debug)]
struct CompleteFrame {
sequence: u64,
completed_at: Instant,
data: Vec<u8>,
}
const RTP_CLOCK: u64 = 90_000;
/// `UU_VIDEO_ENCODER=cpu` keeps the virtual CPU display entirely off the GPU.
pub fn gpu_encoder_requested() -> bool {
std::env::var("UU_VIDEO_ENCODER").map_or(true, |v| v != "cpu")
}
/// Round UP (+1ns float guard) so webrtc's floor(duration*90000) yields exactly `ticks`.
fn ticks_to_duration(ticks: u64) -> Duration {
Duration::from_nanos((ticks * 1_000_000_000 + RTP_CLOCK - 1) / RTP_CLOCK + 1)
}
/// RTP timestamps follow when frames actually leave the encoder, not a nominal
/// 60fps count: a starved X11 capture would otherwise stamp 5fps as 60fps.
/// webrtc-rs stamps a sample with the running timestamp and only then advances it
/// by the sample duration, so each duration predicts the gap to the NEXT frame
/// (one nominal frame after this one). A stall costs one frame of timing error
/// and is corrected on the following frame instead of accumulating.
struct RtpTimeline { origin: Option<Instant>, stamp: u64, fps: u64 }
impl Default for RtpTimeline { fn default() -> Self { Self { origin: None, stamp: 0, fps: FPS } } }
impl RtpTimeline {
fn duration_after(&mut self, completed_at: Instant) -> Duration {
let origin = *self.origin.get_or_insert(completed_at);
let real = ((completed_at.saturating_duration_since(origin).as_nanos() * u128::from(RTP_CLOCK) + 500_000_000) / 1_000_000_000) as u64;
let advance = (real + RTP_CLOCK / self.fps).saturating_sub(self.stamp).max(1);
self.stamp += advance;
ticks_to_duration(advance)
}
}
/// Frames travel through a short queue so P-frames are never silently replaced.
/// After an overflow, dependent frames are skipped until the next IDR, so the
/// viewer never receives a broken prediction chain and no backlog can build up.
struct DependencyGate {needs_idr:bool}
impl Default for DependencyGate {fn default()->Self{Self{needs_idr:true}}}
impl DependencyGate{
fn submit(&mut self,tx:&mpsc::Sender<Arc<CompleteFrame>>,frame:Arc<CompleteFrame>){
if self.needs_idr&&!is_independent_frame(&frame.data){return;}
match tx.try_send(frame){
Ok(())=>self.needs_idr=false,
Err(mpsc::error::TrySendError::Full(_))=>self.needs_idr=true,
Err(mpsc::error::TrySendError::Closed(_))=>{},
}
}
}
// Aborting the owner task drops Child, whose kill_on_drop kills only this encoder.
struct EncoderTask(tokio::task::JoinHandle<Result<(), String>>);
impl Drop for EncoderTask { fn drop(&mut self) { self.0.abort(); } }
async fn read_encoder(
size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
latest: mpsc::Sender<Arc<CompleteFrame>>,
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>,
) -> Result<(), String> {
// The sequence is shared so a CPU fallback or settings restart continues it (skip statistics stay correct).
if !gpu_encoder_requested() { return read_encoder_with(size,display,portal,latest,false,sequence,settings).await; }
match read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),true,sequence.clone(),settings).await {
Ok(())=>Ok(()),
Err(error) if !latest.is_closed()=>{
log::warn!("NVENC stream unavailable; switching scoped encoder to CPU: {}",error);
read_encoder_with(size,display,portal,latest,false,sequence,settings).await
},
Err(error)=>Err(error),
}
}
/// Rate-control arguments: constant quality capped at 30M (自动), or capped at the viewer's
/// chosen bitrate. The VBV buffer stays at most 500k so a cap never adds queueing latency.
fn rate_args(settings: &VideoSettings) -> (String, String) {
let max_kbps = settings.max_kbps().unwrap_or(30_000);
let buffer_kbits = (max_kbps / 8).clamp(100, 500);
(format!("{max_kbps}k"), format!("{buffer_kbits}k"))
}
async fn read_encoder_with(
size: (u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,latest:mpsc::Sender<Arc<CompleteFrame>>,gpu:bool,sequence:Arc<std::sync::atomic::AtomicU64>,
mut settings: VideoSettings,
)->Result<(),String>{
let size = format!("{}x{}", size.0, size.1);
let wayland=display.starts_with("wayland:");
// The separate wayland-capture process produces frames at its own fixed rate.
if wayland && portal.is_none() { settings.fps = FPS as u32; }
let fps = settings.fps.to_string();
// Keep the IDR interval at 0.5 s whatever the frame rate.
let gop = (u64::from(settings.fps) * GOP / FPS).max(1).to_string();
let (maxrate, bufsize) = rate_args(&settings);
let cq = settings.cq().to_string();
let target = settings.max_kbps().map_or("16M".to_string(), |k| format!("{}k", k * 3 / 4));
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,if gpu{"h264_nvenc"}else{"libx264"});
// A bundled FFmpeg prefix (config ffmpeg_root / UU_FFMPEG_ROOT) or `ffmpeg` on PATH.
let mut command=match crate::config::ffmpeg_root() {
Some(root) => { let mut c=Command::new(root.join("bin/ffmpeg")); c.env("LD_LIBRARY_PATH",root.join("lib/x86_64-linux-gnu")); c }
None => Command::new("ffmpeg"),
};
command.args(["-hide_banner","-loglevel","error","-nostdin"]);
if wayland {
command.args(["-f","rawvideo","-pixel_format","bgra","-video_size",&size,
"-framerate",&fps,"-i","pipe:0","-an"]);
} else {
// The viewer draws its local pointer; do not bake a second into video.
command.args(["-f","x11grab","-draw_mouse","0","-framerate",&fps,
"-video_size",&size,"-i",&display,"-an"]);
}
// 其他分辨率: scale the captured desktop (the host display mode is left untouched).
if let Some((width, height)) = settings.output {
command.args(["-vf", &format!("scale={width}:{height}:flags=bilinear")]);
}
if gpu{
command.args(["-c:v","h264_nvenc","-preset","p4","-tune","ull",
"-profile:v","baseline","-pix_fmt","yuv420p","-g",&gop,"-bf","0",
"-rc","vbr","-cq",&cq,"-b:v",&target,"-maxrate",&maxrate,"-bufsize",&bufsize,
"-rc-lookahead","0","-zerolatency","1","-delay","0","-aud","1"]);
}else{
let x264 = format!("aud=1:repeat-headers=1:scenecut=0:keyint={gop}:min-keyint={gop}");
command.args([
"-c:v", "libx264", "-preset", "superfast", "-tune", "zerolatency",
"-profile:v", "baseline", "-pix_fmt", "yuv420p", "-g", &gop, "-threads", "4",
"-crf", &cq, "-maxrate", &maxrate, "-bufsize", &bufsize,
"-x264-params", &x264]);
}
// x11grab paces against an absolute schedule; after a capture stall it grabs
// back-to-back to "catch up" (measured 69 frames in 200ms). vfr on a 1/FPS
// timebase drops those same-slot frames instead of encoding a burst.
let time_base = format!("1/{fps}");
if wayland { command.stdin(std::process::Stdio::piped()); }
let mut child=command.args(["-fps_mode","vfr","-enc_time_base",&time_base,"-f","h264","pipe:1"])
.kill_on_drop(true)
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.spawn().map_err(|e| format!("Start scoped encoder: {e}"))?;
// Scope capture to this encoder. Dropping either task kills its child.
let _capture=if let Some(session)=portal {
let mut sink=child.stdin.take().ok_or("Encoder stdin missing")?;
Some(EncoderTask(tokio::spawn(async move {
use tokio::io::AsyncWriteExt;
let interval=Duration::from_nanos(1_000_000_000/u64::from(settings.fps));
let mut tick=tokio::time::interval(interval);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
tick.tick().await;
let session=session.clone();
let frame=tokio::task::spawn_blocking(move || {
let mut frame=vec![0;(session.width as usize)*(session.height as usize)*4];
session.capture(&mut frame)?;
Ok::<_,String>(frame)
}).await.map_err(|e|format!("Portal capture worker: {e}"))??;
sink.write_all(&frame).await.map_err(|e|format!("Portal encoder pipe: {e}"))?;
}
})))
} else if wayland {
// Linux keeps the running executable inode accessible after a scoped
// development/release replacement; current_exe may name a deleted path.
#[cfg(target_os="linux")]
let executable=std::path::PathBuf::from("/proc/self/exe");
#[cfg(not(target_os="linux"))]
let executable=std::env::current_exe().map_err(|e|format!("Capture executable: {e}"))?;
let mut capture=Command::new(executable).arg("wayland-capture")
.kill_on_drop(true).stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::inherit())
.spawn().map_err(|e|format!("Start Wayland capture: {e}"))?;
let mut source=capture.stdout.take().ok_or("Capture stdout missing")?;
let mut sink=child.stdin.take().ok_or("Encoder stdin missing")?;
Some(EncoderTask(tokio::spawn(async move {
let result=tokio::io::copy(&mut source,&mut sink).await;
drop(capture);
result.map(|_|()).map_err(|e|format!("Wayland frame pipe: {e}"))
})))
} else { None };
let mut stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
let mut pending = Vec::new();
let mut chunk = [0u8; 16384];
let mut gate = DependencyGate::default();
loop {
let count = stdout.read(&mut chunk).await.map_err(|e| format!("Encoder read: {e}"))?;
if count == 0 { return Err("Encoder output ended".into()); }
pending.extend_from_slice(&chunk[..count]);
// A chunk can include the next AUD, so split before enforcing the bound.
loop {
let aud = aud_offsets(&pending);
if aud.len() < 2 { break; }
let next = aud[1];
if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
let frame: Vec<u8> = pending.drain(..next).collect();
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
gate.submit(&latest, Arc::new(CompleteFrame {
sequence, completed_at: Instant::now(), data: frame,
}));
if latest.is_closed() { return Ok(()); }
}
if pending.len() > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
}
}
fn transport_closed(pc: &RTCPeerConnection) -> bool {
matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed)
|| pc.sctp().state() == webrtc::sctp_transport::sctp_transport_state::RTCSctpTransportState::Closed
}
/// Exercise the real capture/encoder chain without UU auth or a network peer.
pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,path:Option<String>)->Result<(),String> {
use std::io::Write;
let mut file=match path {
Some(path)=>Some(std::fs::OpenOptions::new().write(true).create_new(true).open(path).map_err(|e|format!("Video probe file: {e}"))?),
None=>None,
};
let (tx,mut rx)=mpsc::channel(4);
let sequence=Arc::new(std::sync::atomic::AtomicU64::new(0));
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,VideoSettings::default(),sequence)));
let mut count=0;
let mut bytes=0;
tokio::time::timeout(Duration::from_secs(15),async {
while count<5 {
let frame=rx.recv().await.ok_or("Video probe encoder ended")?;
if count==0 && !is_independent_frame(&frame.data) { return Err("Video probe did not begin with IDR".to_owned()); }
if let Some(file)=file.as_mut() { file.write_all(&frame.data).map_err(|e|e.to_string())?; }
bytes+=frame.data.len(); count+=1;
}
Ok::<(),String>(())
}).await.map_err(|_|"Video probe timed out".to_owned())??;
println!("Encoded capture probe: frames={count} h264_bytes={bytes} first_frame_idr=true");
Ok(())
}
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<TrackLocalStaticSample>, size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>) -> Result<(), String> {
loop {
if transport_closed(&pc) { return Ok(()); }
if pc.connection_state() == RTCPeerConnectionState::Connected
&& 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()?;
let (latest, mut receiver) = mpsc::channel(4);
let sequence = Arc::new(std::sync::atomic::AtomicU64::new(0));
let current = *settings.borrow_and_update();
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone())));
let mut previous = None;
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
let mut settings_open = true;
let mut frames = 0u64;
let mut skipped = 0u64;
let mut max_age_ms = 0u128;
let mut max_send_ms = 0u128;
let mut health = tokio::time::interval(Duration::from_millis(200));
health.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut stats = Instant::now();
loop {
tokio::select! {
result = &mut reader.0 => return result.map_err(|e| format!("Encoder reader task: {e}"))?,
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
changed = settings.changed(), if settings_open => {
if changed.is_err() { settings_open = false; continue; }
// Restart the encoder with the viewer's new 帧率/画质; it begins with an IDR, and frames
// still queued from the old encoder remain a valid chain before it.
let next = *settings.borrow_and_update();
timeline.fps = u64::from(next.fps);
reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone())));
},
frame = receiver.recv() => {
// A closed queue means the reader ended; its JoinHandle carries the reason.
let Some(frame) = frame else { return (&mut reader.0).await.map_err(|e| format!("Encoder reader task: {e}"))?; };
let duration = timeline.duration_after(frame.completed_at);
if let Some(last) = previous { skipped += frame.sequence.saturating_sub(last + 1); }
max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis());
// Continue monitoring close even if the network send stalls.
let sample = Sample {
data: frame.data.clone().into(), duration, ..Default::default()
};
let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()];
let send = track.write_sample_with_extensions(&sample, &extensions);
let send_started=Instant::now();
tokio::pin!(send);
loop {
tokio::select! {
result = &mut send => { result.map_err(|e| format!("Video send: {e}"))?; break; },
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
}
}
previous = Some(frame.sequence);
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()?;
log::info!("Desktop latest-frame stats: sent={} skipped={} latest_seq={} max_slot_age_ms={} max_send_ms={}", frames, skipped, frame.sequence, max_age_ms,max_send_ms);
stats = Instant::now();
max_age_ms = 0;
max_send_ms = 0;
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn boundaries_accept_complete_idr_and_reject_dependent_frames() {
let bytes = [0,0,0,1,9,240,0,0,1,7,1,0,0,1,5,42,0,0,1,9,240];
assert_eq!(aud_offsets(&bytes), vec![0,16]);
assert!(is_independent_frame(&bytes[..16]));
assert!(!is_independent_frame(&[0,0,1,9,240,0,0,1,1,42]));
assert!(!is_independent_frame(&[0,0,1,7,1,0,0,0,1]));
}
#[test]
fn rtp_ticks_survive_webrtc_floor_conversion(){
for ticks in (1..=200_000).chain([90_000*60, 90_000*3600]) {
assert_eq!((ticks_to_duration(ticks).as_secs_f64()*90000.) as u64,ticks);
}
}
fn stamps(offsets_ms:&[u64])->Vec<u64>{
let start=Instant::now();
let mut timeline=RtpTimeline::default();
let mut stamp=0;
offsets_ms.iter().map(|ms|{
let current=stamp;
stamp+=(timeline.duration_after(start+Duration::from_millis(*ms)).as_secs_f64()*90000.) as u64;
current
}).collect()
}
#[test]
fn steady_60fps_keeps_exact_1500_tick_spacing_for_an_hour(){
let start=Instant::now();
let mut timeline=RtpTimeline::default();
let mut stamp=0u64;
for frame in 0..216_000u64 {
let at=start+Duration::from_nanos(frame*1_000_000_000/FPS);
assert_eq!(stamp,frame*1500);
stamp+=(timeline.duration_after(at).as_secs_f64()*90000.) as u64;
}
}
#[test]
fn starved_capture_is_stamped_at_real_time_not_nominal_60fps(){
// 5fps capture: frames 200ms apart must be ~18000 ticks apart, not 1500.
let s=stamps(&[0,200,400,600,800]);
assert_eq!(s[0],0);
for pair in s.windows(2).skip(1) { assert_eq!(pair[1]-pair[0],18_000); }
}
#[test]
fn stall_costs_one_frame_then_timeline_matches_real_time(){
let s=stamps(&[0,17,517,534,551]);
assert_eq!(s[2],17*90+1500); // predicted before the stall was visible
assert_eq!(s[3],517*90+1500); // realigned: one nominal frame after real stall end
assert_eq!(s[4],534*90+1500); // no residual offset accumulates
assert!(s.windows(2).all(|p|p[1]>p[0]));
}
#[tokio::test]
async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){
let(tx,mut rx)=mpsc::channel(1);
let mut gate=DependencyGate::default();
let frame=|sequence,idr|Arc::new(CompleteFrame{sequence,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet
gate.submit(&tx,frame(2,true));
gate.submit(&tx,frame(3,false)); // queue full: P3 lost
assert_eq!(rx.recv().await.unwrap().sequence,2);
gate.submit(&tx,frame(4,false)); // P4 references lost P3
assert!(rx.try_recv().is_err());
gate.submit(&tx,frame(31,true));assert_eq!(rx.recv().await.unwrap().sequence,31);
gate.submit(&tx,frame(32,false));assert_eq!(rx.recv().await.unwrap().sequence,32);
}
#[test]
fn nvenc_idr_with_parameter_sets_is_independent(){
// AUD, SPS, PPS, IDR slice as h264_nvenc emits every GOP (verified on the 3090).
let idr=[0,0,0,1,9,16,0,0,0,1,7,66,0,0,0,1,8,206,0,0,1,5,136];
assert!(is_independent_frame(&idr));
assert!(!is_independent_frame(&[0,0,0,1,9,48,0,0,1,1,154]));
}
}
+72
View File
@@ -0,0 +1,72 @@
//! Bounded viewer telemetry extraction. Payloads and nonnumeric values never log.
use base64::Engine;
use std::io::Read;
use serde_json::Value;
const LIMIT:usize=256*1024;
fn permitted(key:&str)->bool{
["avg_received_fps","avg_decode_fps","avg_render_fps","avg_assembly_ms_interval","avg_current_delay_ms_interval","avg_decode_ms_interval","avg_delay_ms_interval","avg_jitter_buffer_ms_interval","avg_processing_delay_interval","avg_render_delay_ms_interval","avg_target_delay_ms_interval","received_framerate","actual_received_framerate","decode_framerate","render_framerate","actual_framerate",
"current_delay","average_delay","max_delay","current_delay_ms_interval","target_delay_ms_interval",
"jitter_buffer_ms_interval","render_delay_ms_interval","assembly_ms_interval","decode_ms_interval",
"processing_delay_interval","sending_delay_interval","frames_received","frames_decoded","frames_actual_rendered",
"packets_received","packets_lost","packet_loss_rate","current_packet_loss_rate",
"frame_capture_delay_ms_interval","frame_encode_delay_ms_interval","frame_pacer_delay_ms_interval",
"frame_transport_delay_ms_interval","frame_decode_delay_ms_interval","frame_e2e_delay_ms_interval"].contains(&key)
}
fn unpack(text:&str)->Option<Value>{
if text.len()>LIMIT{return None;}
if let Ok(value)=serde_json::from_str(text){return Some(value);}
let bytes=base64::engine::general_purpose::STANDARD.decode(text).ok()?;
let mut output=Vec::new();
if bytes.starts_with(&[31,139]){
flate2::read::GzDecoder::new(&bytes[..]).take(LIMIT as u64+1).read_to_end(&mut output).ok()?;
}else if bytes.first()==Some(&0x78){
flate2::read::ZlibDecoder::new(&bytes[..]).take(LIMIT as u64+1).read_to_end(&mut output).ok()?;
}else{output=bytes;}
if output.len()>LIMIT{return None;}serde_json::from_slice(&output).ok()
}
pub fn collect(event:&Value)->Vec<(String,f64)>{
fn walk(v:&Value,path:&str,selected:bool,depth:usize,budget:&mut usize,out:&mut Vec<(String,f64)>){
if depth>12||*budget==0||out.len()>=128{return;}*budget-=1;
match v{
Value::Number(n) if selected=>{if let Some(n)=n.as_f64(){out.push((path.into(),n));}},
Value::Object(map)=>for(k,v)in map{
let allowed=permitted(k);
// After selecting a metric, only numeric aggregation keys are retained.
let aggregation=selected&&["min","max","avg","mean","sum","count","value","current","total"].contains(&k.as_str());
let next=if allowed||aggregation{format!("{path}.{k}")}else{path.into()};
walk(v,&next,allowed||aggregation,depth+1,budget,out);
},
Value::Array(a)=>for v in a{walk(v,path,selected,depth+1,budget,out);},
Value::String(text)=>{
if selected{if let Ok(number)=text.parse::<f64>(){if number.is_finite(){out.push((path.into(),number));return;}}}
if let Some(unpacked)=unpack(text){walk(&unpacked,path,selected,depth+1,budget,out);}
},_=>{}
}
}
let mut output=Vec::new();walk(event,"stats",false,0,&mut 8192,&mut output);output
}
pub fn safe_shape(event:&Value)->Vec<(String,&'static str)>{
fn walk(v:&Value,path:&str,depth:usize,out:&mut Vec<(String,&'static str)>){
if depth>3||out.len()>=24{return;}
let kind=match v{Value::Object(_)=>"object",Value::Array(_)=>"array",Value::String(_)=>"string",Value::Number(_)=>"number",Value::Bool(_)=>"bool",Value::Null=>"null"};
out.push((path.into(),kind));
if let Value::Object(map)=v{for(k,v)in map{
if k.len()<=48&&k.bytes().all(|b|b.is_ascii_alphanumeric()||b==b'_'){walk(v,&format!("{path}.{k}"),depth+1,out);}
}}
}
let mut output=Vec::new();walk(event,"event",0,&mut output);output
}
#[cfg(test)]mod tests{
use super::*;
#[test]fn extracts_compressed_metrics_but_no_private_values(){
use std::io::Write;
let text=r#"{"token":"secret","current_delay_ms_interval":{"avg":17},"render_framerate":60}"#;
let mut z=flate2::write::GzEncoder::new(Vec::new(),flate2::Compression::default());z.write_all(text.as_bytes()).unwrap();
let encoded=base64::engine::general_purpose::STANDARD.encode(z.finish().unwrap());
assert_eq!(collect(&serde_json::json!({"data":encoded})),vec![("stats.current_delay_ms_interval.avg".into(),17.),("stats.render_framerate".into(),60.)]);
}
#[test]fn limits_depth_and_preserves_numeric_strings(){
assert_eq!(collect(&serde_json::json!({"render_framerate":"59.9","cookie":12})),vec![("stats.render_framerate".into(),59.9)]);
assert!(unpack(&"A".repeat(LIMIT+1)).is_none());
}
}
+90
View File
@@ -0,0 +1,90 @@
//! Hyprland/wlroots native backend. No XWayland fallback and no input logging.
#[cfg(all(target_os="linux", feature="wayland"))]
extern "C" {
fn uu_wl_init(out_w: *mut i32, out_h: *mut i32) -> i32;
fn uu_wl_capture(buffer: *mut u8, length: usize) -> i32;
fn uu_wl_move(x: i32, y: i32, relative: i32) -> i32;
fn uu_wl_button(button: i32, pressed: i32) -> i32;
fn uu_wl_key(symbol: u64, pressed: i32) -> i32;
fn uu_wl_wake() -> i32;
}
pub fn init() -> Result<(u32,u32),String> {
#[cfg(all(target_os="linux", feature="wayland"))]
{
let (mut w,mut h)=(0,0);
let result=unsafe { uu_wl_init(&mut w,&mut h) };
if result != 0 || w <= 0 || h <= 0 {
return Err(format!("Wayland initialization failed ({result}); requires screencopy, virtual keyboard and virtual pointer. Check UU_WAYLAND_OUTPUT and session environment."));
}
return Ok((w as u32,h as u32));
}
#[cfg(not(all(target_os="linux", feature="wayland")))]
Err("Wayland backend requires Linux and a build with --features wayland".into())
}
pub fn capture(buffer:&mut [u8]) -> Result<(),String> {
#[cfg(all(target_os="linux", feature="wayland"))]
{ let result=unsafe { uu_wl_capture(buffer.as_mut_ptr(),buffer.len()) }; if result==0 { return Ok(()) } return Err(format!("Wayland capture failed ({result})")); }
#[cfg(not(all(target_os="linux", feature="wayland")))]
{ let _=buffer; Err("Wayland capture unavailable".into()) }
}
pub fn wake()->Result<(),String> {
#[cfg(all(target_os="linux", feature="wayland"))]
{ let result=unsafe { uu_wl_wake() }; if result==0 { return Ok(()); } return Err("Wayland output power control unavailable".into()); }
#[cfg(not(all(target_os="linux", feature="wayland")))]
Err("Wayland output power control unavailable".into())
}
pub fn move_pointer(x:i32,y:i32,relative:bool)->i32 {
#[cfg(all(target_os="linux", feature="wayland"))]
{ return unsafe { uu_wl_move(x,y,i32::from(relative)) }; }
#[cfg(not(all(target_os="linux", feature="wayland")))]
{ let _=(x,y,relative); -1 }
}
pub fn button(button:i32,pressed:bool)->i32 {
#[cfg(all(target_os="linux", feature="wayland"))]
{ return unsafe { uu_wl_button(button,i32::from(pressed)) }; }
#[cfg(not(all(target_os="linux", feature="wayland")))]
{ let _=(button,pressed); -1 }
}
pub fn key(symbol:u64,pressed:bool)->i32 {
#[cfg(all(target_os="linux", feature="wayland"))]
{ return unsafe { uu_wl_key(symbol,i32::from(pressed)) }; }
#[cfg(not(all(target_os="linux", feature="wayland")))]
{ let _=(symbol,pressed); -1 }
}
/// A separate process owns capture; encoder cancellation closes its pipe.
pub fn capture_stdout() -> Result<(),String> {
use std::io::Write;
let (w,h)=init()?;
let mut frame=vec![0u8;(w as usize)*(h as usize)*4];
let mut stdout=std::io::stdout().lock();
let interval=std::time::Duration::from_nanos(1_000_000_000/crate::video::FPS);
loop {
let start=std::time::Instant::now();
capture(&mut frame)?;
stdout.write_all(&frame).map_err(|e|format!("Capture pipe: {e}"))?;
if let Some(left)=interval.checked_sub(start.elapsed()) { std::thread::sleep(left); }
}
}
/// Use only in an isolated acceptance desktop; emits fixed test events, no logs.
pub fn input_probe()->Result<(),String> {
let (w,h)=init()?;
wake()?;
if move_pointer((w/4) as i32,(h/4) as i32,false)!=0 { return Err("Pointer probe failed".into()); }
std::thread::sleep(std::time::Duration::from_millis(50));
if move_pointer((w/2) as i32,(h/2) as i32,false)!=0 { return Err("Pointer probe failed".into()); }
std::thread::sleep(std::time::Duration::from_millis(100));
if button(1,true)!=0 || button(1,false)!=0 { return Err("Button probe failed".into()); }
std::thread::sleep(std::time::Duration::from_millis(100));
if move_pointer(32,0,true)!=0 { return Err("Relative pointer probe failed".into()); }
std::thread::sleep(std::time::Duration::from_millis(100));
for symbol in b"uuwayland" {
if key(u64::from(*symbol),true)!=0 || key(u64::from(*symbol),false)!=0 {
return Err("Keyboard probe failed".into());
}
}
std::thread::sleep(std::time::Duration::from_millis(250));
println!("Wayland test events sent; verify the native GTK acceptance report.");
Ok(())
}
+942
View File
@@ -0,0 +1,942 @@
//! Native Rust WebRTC Engine (PeerConnection, DataChannels, Input & Video)
use crate::capture::ScreenCapture;
use crate::input::InputInjector;
use crate::signaling::SoacMessage;
use base64::Engine;
use flate2::read::GzDecoder;
use std::io::Read;
use std::sync::Arc;
use tokio::sync::Mutex;
use webrtc::api::media_engine::MediaEngine;
use webrtc::api::APIBuilder;
use webrtc::data_channel::data_channel_message::DataChannelMessage;
use webrtc::data_channel::RTCDataChannel;
use webrtc::ice_transport::ice_candidate::RTCIceCandidateInit;
use webrtc::ice_transport::ice_server::RTCIceServer;
use webrtc::peer_connection::configuration::RTCConfiguration;
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
use webrtc::peer_connection::sdp::session_description::RTCSessionDescription;
use webrtc::peer_connection::RTCPeerConnection;
use webrtc::media::Sample;
use webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;
use webrtc::dtls_transport::dtls_role::DTLSRole;
use webrtc::track::track_local::track_local_static_sample::TrackLocalStaticSample;
use webrtc::track::track_local::TrackLocalWriter;
#[derive(Debug, Default, Clone)]
pub struct SessionContext {
pub client_id: Option<String>,
pub ice_id: Option<serde_json::Value>,
pub app_control_id: Option<serde_json::Value>,
pub bundle_media: Option<(String, u16)>,
}
pub struct WebRtcSession {
pub pc: Arc<RTCPeerConnection>,
pub capture: Arc<ScreenCapture>,
pub input: Arc<InputInjector>,
pub desktop: bool,
pub context: Arc<Mutex<SessionContext>>,
}
impl WebRtcSession {
pub async fn new(
capture: Arc<ScreenCapture>,
input: Arc<InputInjector>,
signaling_client: Arc<crate::signaling::SignalingClient>,
desktop: bool,
transport:crate::session_ice::SessionIce,
) -> Result<Self, String> {
let mut m = MediaEngine::default();
m.register_default_codecs()
.map_err(|e| format!("Register standard codecs failed: {}", e))?;
m.register_header_extension(
webrtc::rtp_transceiver::rtp_codec::RTCRtpHeaderExtensionCapability { uri: crate::rtp_metadata::CAPTURE_INDEX_URI.into() },
webrtc::rtp_transceiver::rtp_codec::RTPCodecType::Video, None,
).map_err(|e| format!("Register UU capture metadata failed: {}", e))?;
m.register_header_extension(
webrtc::rtp_transceiver::rtp_codec::RTCRtpHeaderExtensionCapability { uri: crate::rtp_metadata::NEW_FRAME_URI.into() },
webrtc::rtp_transceiver::rtp_codec::RTPCodecType::Video, None,
).map_err(|e| format!("Register UU fresh-frame metadata failed: {}", e))?;
let registry = webrtc::api::interceptor_registry::register_default_interceptors(
webrtc::interceptor::registry::Registry::new(), &mut m,
).map_err(|e| format!("Register RTP/RTCP interceptors failed: {}", e))?;
let mut se = webrtc::api::setting_engine::SettingEngine::default();
se.set_answering_dtls_role(DTLSRole::Server)
.map_err(|e| format!("Configure DTLS answer role failed: {}", e))?;
se.set_ice_multicast_dns_mode(webrtc::ice::mdns::MulticastDnsMode::Disabled);
// The viewer picked a ZeroTier pair even on the same LAN (36-81 ms, Wi-Fi + overlay);
// offering only physical interfaces keeps LAN direct, else srflx/relay like official hosts.
se.set_interface_filter(Box::new(|name: &str| ice_interface_allowed(name)));
let api = APIBuilder::new()
.with_media_engine(m)
.with_setting_engine(se)
.with_interceptor_registry(registry)
.build();
let config = transport.configuration()?;
let pc = Arc::new(
api.new_peer_connection(config)
.await
.map_err(|e| format!("Create PeerConnection failed: {}", e))?,
);
let context = Arc::new(Mutex::new(SessionContext::default()));
crate::network_diagnostics::start(Arc::downgrade(&pc));
// 监听本地 ICE Candidate 并自动发回信令服务器与客户端
let context_ice = context.clone();
let sig_ice = signaling_client.clone();
pc.on_ice_candidate(Box::new(move |c: Option<webrtc::ice_transport::ice_candidate::RTCIceCandidate>| {
let ctx = context_ice.clone();
let sig = sig_ice.clone();
Box::pin(async move {
if let Some(cand) = c {
if let Ok(init) = cand.to_json() {
let summary=crate::network_diagnostics::candidate_summary(&init.candidate);
log::info!("Local ICE candidate gathered: protocol={} type={}",summary.protocol,summary.kind);
let lock = ctx.lock().await;
if let Some(cid) = &lock.client_id {
let Some((mid, mline)) = lock.bundle_media.clone() else {
log::warn!("Local ICE candidate has no negotiated media section");
return;
};
let cand_msg = SoacMessage {
msg_type: "candidate".into(),
sdp: None,
gzip_sdp: None,
candidate: Some(serde_json::json!({
"candidate": init.candidate,
"sdpMid": mid,
"sdpMLineIndex": mline,
})),
ice_id: lock.ice_id.clone(),
sdp_mid: None,
sdp_mline_index: None,
client_id: Some(cid.clone()),
app_control_id: lock.app_control_id.clone(),
};
if let Err(e) = sig.emit_soac(cand_msg).await {
log::error!("ICE signaling send failed: {}", e);
}
} else {
log::warn!("Local ICE candidate gathered but client_id not set yet");
}
}
} else {
log::info!("Local ICE candidate gathering completed.");
}
})
}));
pc.on_ice_connection_state_change(Box::new(|state| {
log::info!("ICE Connection State changed: {:?}", state);
Box::pin(async move {})
}));
let connected_context = context.clone();
let connection_input=input.clone();
let connected_signal = signaling_client.clone();
let notified = Arc::new(std::sync::atomic::AtomicBool::new(false));
pc.on_peer_connection_state_change(Box::new(move |state| {
let ctx = connected_context.clone();
let input=connection_input.clone();
let sig = connected_signal.clone();
let notified = notified.clone();
Box::pin(async move {
log::info!("PeerConnection State changed: {:?}", state);
if matches!(state,RTCPeerConnectionState::Closed|RTCPeerConnectionState::Failed|RTCPeerConnectionState::Disconnected) {input.release_held();}
if state == RTCPeerConnectionState::Connected && !notified.swap(true, std::sync::atomic::Ordering::AcqRel) {
tokio::spawn(async move {
let ctx = ctx.lock().await.clone();
if let (Some(client), Some(ice)) = (&ctx.client_id, ctx.ice_id.as_ref().and_then(|v| v.as_str())) {
let payload = crate::capability::h264_device_capability(client, ice, 0, crate::video::FPS as i32, 5);
if let Err(e) = sig.emit_event(crate::capability::FORWARD_SETTING_EVENT, payload).await {
log::error!("Device capability notification failed: {}", e);
}
if let Some(control) = ctx.app_control_id.as_ref().and_then(|v| v.as_str()) {
if let Err(e) = sig.emit_event(crate::capability::ICE_FINISHED_EVENT,
crate::capability::ice_finished(ice, control)).await {
log::error!("Connection completion notification failed: {}", e);
}
}
}
});
}
})
}));
// 注册视频轨
let video_track = Arc::new(TrackLocalStaticSample::new(
RTCRtpCodecCapability {
mime_type: "video/H264".to_owned(),
..Default::default()
},
"video_0".to_owned(),
"video_0".to_owned(),
));
let sender = pc.add_track(video_track.clone()).await
.map_err(|e| format!("Add video track failed: {}", e))?;
tokio::spawn(async move {
let mut feedback = [0u8; 1500];
let mut reports = 0usize;
let mut feedback_counts = FeedbackCounts::default();
while let Ok((packets, _)) = sender.read(&mut feedback).await {
for packet in packets {
feedback_counts.observe(packet.as_any());
if let Some(report) = packet.as_any().downcast_ref::<webrtc::rtcp::receiver_report::ReceiverReport>() {
reports += 1;
if reports == 1 || reports % 10 == 0 {
for r in &report.reports {
let now=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default();
let ntp=(((now.as_secs()+2_208_988_800)&0xffff)<<16) as u32 | ((u64::from(now.subsec_nanos())*65536/1_000_000_000) as u32);
let elapsed=ntp.wrapping_sub(r.last_sender_report).wrapping_sub(r.delay);
let rtt=if r.last_sender_report!=0&&elapsed<65536*30 {Some(f64::from(elapsed)*1000./65536.)}else{None};
log::info!("Video receiver report: ssrc={} last_sequence={} lost={} fraction_lost={} rtcp_rtt_ms={:?}",r.ssrc,r.last_sequence_number,r.total_lost,r.fraction_lost,rtt);
}
log::info!("Video feedback totals: nack_packets={} pli={} fir={}",feedback_counts.nack_packets,feedback_counts.pli,feedback_counts.fir);
}
}
}
}
});
// Desktop sound on the viewer's audio m-line (it always offers Opus).
if desktop && crate::audio::enabled() {
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(),
));
match pc.add_track(audio_track.clone()).await {
Ok(audio_sender) => {
// Drain RTCP so the interceptors keep running.
tokio::spawn(async move { let mut rtcp = [0u8; 1500]; while audio_sender.read(&mut rtcp).await.is_ok() {} });
tokio::spawn(crate::audio::stream_audio(pc.clone(), audio_track));
}
Err(e) => log::warn!("Add audio track failed: {}", e),
}
}
// Encode current X11 frames only while a peer is connected.
let streaming_pc = pc.clone();
let capture_size = (capture.width, capture.height);
let capture_display = capture.display.clone();
// Per-connection 画质/帧率, changed by the viewer's capture-setting RPCs.
let (video_settings, video_settings_rx) = tokio::sync::watch::channel(crate::capture_setting::VideoSettings::default());
let video_settings = Arc::new(video_settings);
// 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 {
let (end_pc, actions) = (pc.clone(), peer_actions.clone());
tokio::spawn(async move {
{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
// Count the session once it is actually connected (a failed offer is not a session).
while end_pc.connection_state() != State::Connected {
if matches!(end_pc.connection_state(), State::Closed | State::Failed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
let starting = actions.clone();
let _ = tokio::task::spawn_blocking(move || starting.session_started()).await;
}
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
while !matches!(end_pc.connection_state(), State::Closed | State::Failed) {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
drop(end_pc);
let _ = tokio::task::spawn_blocking(move || actions.session_ended()).await;
});
}
let portal=capture.portal.clone();
// File/terminal/port-mapping connections carry no desktop video.
if desktop {
tokio::spawn(async move {
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx).await {
log::error!("Live desktop stream stopped: {}", e);
}
});
} else {
drop((streaming_pc, video_track, capture_size, capture_display, video_settings_rx));
}
let input_clone = input.clone();
let control_capture = capture.clone();
let control_sequence = Arc::new(std::sync::atomic::AtomicU64::new(1));
let text_clipboard_ready = Arc::new(std::sync::atomic::AtomicBool::new(false));
// 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.
let file_channel: Arc<std::sync::Mutex<Option<Arc<RTCDataChannel>>>> = Arc::new(std::sync::Mutex::new(None));
let (file_tx, mut file_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let peer_files = crate::file_trans::FileSession::new(file_tx, control_sequence.clone());
{
let slot = file_channel.clone();
tokio::spawn(async move {
while let Some(message) = file_rx.recv().await {
let mut channel = slot.lock().unwrap().clone();
for _ in 0..100 {
if channel.is_some() { break; }
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
channel = slot.lock().unwrap().clone();
}
let Some(channel) = channel else { log::warn!("File transfer reply dropped: no FILE_DATA_CHANNEL"); continue; };
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await { log::warn!("FILE_DATA_CHANNEL send failed: {}", e); }
}
});
}
// 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string();
log::info!("New DataChannel received: {}", label);
let input_inst = input_clone.clone();
let screen = control_capture.clone();
let out_sequence = control_sequence.clone();
let shared_clipboard_ready = text_clipboard_ready.clone();
let peer_files = peer_files.clone();
let peer_video_settings = video_settings.clone();
let peer_actions = peer_actions.clone();
if label == "FILE_DATA_CHANNEL" { *file_channel.lock().unwrap() = Some(d.clone()); }
Box::pin(async move {
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();
let clipboard_input = Arc::new(std::sync::Mutex::new(None::<tokio::sync::watch::Sender<Option<String>>>));
let clipboard_assembly = Arc::new(std::sync::Mutex::new(crate::clipboard_protocol::Assembly::default()));
let rich_state=Arc::new(std::sync::Mutex::new(crate::clipboard_rich::State::default()));
let clipboard_enabled = shared_clipboard_ready.clone();
// Ordered outbound queue for protocol replies produced outside this callback.
let (outbound, mut outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
{
let out_channel = d.clone();
let out_label = label.clone();
tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await {
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break;
}
}
});
}
// 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())
} else { None };
// CT_TERMINAL: TERM frames and terminal RPCs (check_env/rename) on BINARY.
let terminal_conn = if label == "BINARY_DATA_CHANNEL" {
Some(Arc::new(crate::terminal::TerminalConn::new(outbound.clone())))
} else { None };
if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" {
let channel = d.clone();
let initial_sequence = out_sequence.clone();
let clipboard_sink = clipboard_input.clone();
let clipboard_ready = clipboard_enabled.clone();
let rich_outgoing=rich_state.clone();
let open_actions = channel_actions.clone();
let open_video = channel_video_settings.clone();
d.on_open(Box::new(move || {
let init_actions = open_actions.clone();
let init_video = open_video.clone();
let channel = channel.clone();
let sequence = initial_sequence.clone();
let screen = screen.clone();
let clipboard_sink = clipboard_sink.clone();
let clipboard_ready = clipboard_ready.clone();
let rich_outgoing=rich_outgoing.clone();
Box::pin(async move {
if channel.label() == "TEXT_DATA_CHANNEL" {
if !desktop { return; }
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();
let clipboard_sequence = sequence.clone();
let clipboard_cleanup = clipboard_sink.clone();
let ready = bridge.ready.await.unwrap_or(false);
clipboard_ready.store(ready,std::sync::atomic::Ordering::Relaxed);
tokio::spawn(async move {
if !ready {
*clipboard_cleanup.lock().unwrap() = None;
log::warn!("Native text clipboard unavailable"); return;
}
log::info!("Native text clipboard bridge ready");
let mut updates = bridge.outgoing;
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
loop {
tokio::select! {
_ = health.tick() => {
if clipboard_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; }
},
changed = updates.changed() => {
if changed.is_err() { break; }
let text = updates.borrow_and_update().clone();
let Some(text) = text else { continue; };
{
let request_id=clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed);
let payload = match rich_outgoing.lock().unwrap().offer(request_id,text.clone()) {
Ok(payload)=>payload,Err(reason)=>{log::warn!("Clipboard offer rejected: {}",reason);continue;}
};
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::initialization::envelope(clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,21,&payload);
if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),clipboard_channel.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))) {
log::warn!("Native clipboard RPC send failed"); break;
}
}
log::info!("Native clipboard text format offered: bytes={}",text.len());
}
}
}
*clipboard_cleanup.lock().unwrap() = None;
clipboard_ready.store(false,std::sync::atomic::Ordering::Relaxed);
});
return;
}
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);
// Default file-transfer folder: the desktop user's home directory.
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
let desktop_permission=if screen.init_error.is_none() {
crate::system_metrics::Permission::Allow
} else { crate::system_metrics::Permission::Reject };
let messages = [
(8, crate::initialization::encode_capture_change(next_seq(), timestamp, 0, 0, "Linux desktop")),
(13, Ok(crate::initialization::envelope(next_seq(), timestamp, 13, &init_actions.metrics_payload(desktop_sound, desktop_permission)))),
(26, Ok(crate::initialization::envelope(next_seq(), timestamp, 26,
&crate::system_metrics::remote_download_path(&home)))),
(7, crate::capture_setting::screen_sources(next_seq(), timestamp, (screen.width, screen.height), init_video.borrow().output, "Linux desktop")),
];
for (field, message) in messages {
if screen.init_error.is_some() && matches!(field,7|8) { continue; }
let message = match message {
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
}
log::info!("CONTROL initialization field {} sent", field);
}
// 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;
loop {
let current = shapes.borrow_and_update().clone();
if let Some(cursor) = current {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::cursor::encode_cursor_shape(next_seq(), timestamp, &cursor);
if channel.send(&bytes::Bytes::from(message)).await.is_err() { break; }
sent += 1;
if sent <= 3 || sent % 100 == 0 {
log::info!("Cursor shape sent: count={} size={}x{} hotspot={},{} png_bytes={}", sent, cursor.width, cursor.height, cursor.hot_x, cursor.hot_y, cursor.png.len());
}
}
loop {
tokio::select! {
changed = shapes.changed() => { if changed.is_err() { return; } break; },
_ = health.tick() => {
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
},
}
}
}
})
}));
}
d.on_message(Box::new(move |msg: DataChannelMessage| {
let channel_name = lbl.clone();
let input_worker = inp.clone();
let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone();
let reply_chan = d_reply.clone();
let out_sequence = reply_sequence.clone();
let clipboard_sink = clipboard_input.clone();
let clipboard_assembly = clipboard_assembly.clone();
let clipboard_ready = clipboard_enabled.clone();
let rich_incoming=rich_state.clone();
let file_worker = file_session.clone();
let video_settings = channel_video_settings.clone();
let actions = channel_actions.clone();
Box::pin(async move {
if let Some(term) = &terminal_worker {
if crate::terminal::is_frame(&msg.data) { term.handle(&msg.data); 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 output_before = video_settings.borrow().output;
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::capture_setting::handle_rpc(r, &video_settings, input_size)) {
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));
return;
}
if let Some(response) = rpc.and_then(|r| crate::protocol::decode_wire(r).ok()).and_then(|r| crate::terminal::rpc_response(&r)) {
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return;
}
}
if let Some(files) = &file_worker {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
if files.handle(&fields) {
static ROUTE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if ROUTE.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 20 {
log::info!("File transfer RPC received on {}", channel_name);
}
return;
}
}
}
// Temporary bounded clipboard routing diagnostics: schema only,
// never text values, payload bytes, key values or clipboard content.
if channel_name == "TEXT_DATA_CHANNEL" || channel_name == "BINARY_DATA_CHANNEL" || channel_name == "FILE_DATA_CHANNEL" {
static CLIPBOARD_SHAPES: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
static TOOL_SHAPES: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
let counter = if channel_name == "TEXT_DATA_CHANNEL" { &CLIPBOARD_SHAPES } else { &TOOL_SHAPES };
if counter.fetch_add(1,std::sync::atomic::Ordering::Relaxed) < 40 {
let shape = if let Ok(value) = serde_json::from_slice::<serde_json::Value>(&msg.data) {
fn shape(v:&serde_json::Value,depth:usize)->serde_json::Value {
use serde_json::{Value,json};
match v {
Value::Object(o) if depth<2 => Value::Object(o.iter().take(24).filter(|(k,_)|k.len()<=48&&k.bytes().all(|b|b.is_ascii_alphanumeric()||b==b'_')).map(|(k,v)|(k.clone(),shape(v,depth+1))).collect()),
Value::String(_)=>json!("string"), Value::Number(_)=>json!("number"), Value::Bool(_)=>json!("bool"),
Value::Array(_)=>json!("array"),Value::Object(_)=>json!("object"),Value::Null=>json!("null"),
}
}
shape(&value,0).to_string()
} else if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
format!("protobuf fields={:?}",fields.iter().map(|f|f.number).collect::<Vec<_>>())
} else { "opaque".to_string() };
log::info!("Clipboard channel schema: channel={} bytes={} schema={}",channel_name,msg.data.len(),shape);
}
}
if channel_name == "CONTROL_DATA_CHANNEL" || channel_name == "TEXT_DATA_CHANNEL" {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
use crate::protocol::WireValue;
for field in &fields {
if let (22,WireValue::Bytes(payload))=(field.number,&field.value) {
let update=rich_incoming.lock().unwrap().response(payload);
match update {
Ok(Some(text))=>{if let Some(sink)=clipboard_sink.lock().unwrap().as_ref(){log::info!("Native desktop clipboard text received: bytes={}",text.len());sink.send_replace(Some(text));}},
Err(reason)=>log::warn!("Clipboard desktop response rejected: {}",reason),
_=>{},
}
if let Ok(response)=crate::protocol::decode_wire(payload) {
if let Some(WireValue::Bytes(status))=response.iter().find(|f|f.number==6).map(|f|&f.value) {
if let Ok(status)=crate::protocol::decode_wire(status) {
let success=status.iter().any(|f|f.number==1&&f.value==WireValue::Varint(1));
log::info!("Native clipboard RPC text acknowledged: success={}",success);
}
}
}
}
}
for field in &fields {
if let (21, WireValue::Bytes(payload)) = (field.number,&field.value) {
let ids=crate::clipboard_rich::format_ids(payload);
if !ids.is_empty(){log::info!("Clipboard offered format IDs: {:?}",ids);}
let rich_result={
let mut next=||out_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed);
rich_incoming.lock().unwrap().request(payload,&mut next)
};
match rich_result {
Ok(result)=>{
if let Some(text)=result.text {if let Some(sink)=clipboard_sink.lock().unwrap().as_ref(){log::info!("Native desktop clipboard text received: bytes={}",text.len());sink.send_replace(Some(text));}}
let count=result.messages.len();
for (kind,payload) in result.messages {
let timestamp=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message=crate::initialization::envelope(out_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,kind,&payload);
if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),reply_chan.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))){log::warn!("Clipboard desktop reply failed");break;}
}
if count>0{log::info!("Clipboard desktop protocol replies: count={}",count);}
}
Err(reason)=>log::warn!("Clipboard desktop request rejected: {}",reason),
}
let received=crate::clipboard_protocol::read_text_request(payload);
match received {
Ok(Some((header,text))) => {
let sink=clipboard_sink.lock().unwrap().clone();
if let Some(sink)=sink {
log::info!("Native clipboard RPC text received: bytes={}",text.len());
sink.send_replace(Some(text));
let payload=crate::clipboard_protocol::text_response(&header);
let timestamp=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message=crate::initialization::envelope(out_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,22,&payload);
let _=reply_chan.send(&bytes::Bytes::from(message)).await;
}
}
Ok(None)=> {if let Ok(nested)=crate::protocol::decode_wire(payload){log::info!("Clipboard RPC request schema: fields={:?}",nested.iter().map(|f|f.number).collect::<Vec<_>>());}},
Err(reason)=>log::warn!("Clipboard RPC rejected: {}",reason),
}
}
}
for field in &fields {
if let (17, WireValue::Bytes(payload)) = (field.number, &field.value) {
match clipboard_assembly.lock().unwrap().accept(payload) {
Ok(Some(text)) => {
if let Some(sink) = clipboard_sink.lock().unwrap().as_ref() {
log::info!("Native clipboard text received: bytes={}",text.len());
sink.send_replace(Some(text));
}
}
Ok(None) => {},
Err(reason) => log::warn!("Native clipboard message rejected: {}",reason),
}
}
}
if fields.iter().any(|f|f.number==20) {
static INPUT_SHAPE:std::sync::atomic::AtomicUsize=std::sync::atomic::AtomicUsize::new(0);
if INPUT_SHAPE.fetch_add(1,std::sync::atomic::Ordering::Relaxed)<12 {
let shape:Vec<(u32,&str,usize)>=fields.iter().map(|f|match &f.value {
WireValue::Bytes(b)=>(f.number,"bytes",b.len()),
_=>(f.number,"number",0)
}).collect();
log::info!("CONTROL protobuf input field shape: {:?}",shape);
}
}
let seq = fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Varint(v), 1) => Some(*v), _ => None });
let _timestamp = fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Varint(v), 2) => Some(*v), _ => None });
let simple = fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 3) => Some(*v), _ => None });
// Diagnostics: which non-input CONTROL messages the viewer sends (numbers only, no contents).
if !fields.iter().any(|f| f.number == 20) {
static SEEN: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if SEEN.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 300 {
let numbers: Vec<u32> = fields.iter().map(|f| f.number).collect();
let action = simple.and_then(|b| crate::protocol::decode_wire(b).ok()).and_then(|a| a.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Varint(v), 1) => Some(*v), _ => None }));
log::info!("CONTROL message: fields={:?} simple_action={:?}", numbers, action);
}
}
// 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 }));
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;
}
}
if let Some(simple) = simple {
let seq = seq.unwrap_or(0);
if let Ok(action_fields) = crate::protocol::decode_wire(simple) {
let action = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Varint(v), 1) => Some(*v), _ => None }).unwrap_or(0);
if action == 15 {
// AUTO_UNLOCK_SYSTEM: args JSON {"key": saved password}; never logged.
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(*v), _ => None }).unwrap_or(&[]);
let password = crate::session_lock::password_from_args(args);
let (chan, seq_out) = (reply_chan.clone(), out_sequence.clone());
tokio::spawn(crate::session_lock::handle_auto_unlock(password, chan, seq_out));
}
use crate::system_actions as sa;
if matches!(action, sa::SHOW_DESKTOP | sa::REBOOT_SYSTEM | sa::LOCK_SYSTEM | sa::SHUTDOWN_SYSTEM | sa::SHOW_TASKMGR
| sa::MUTE_SYSTEM | sa::MUTE_RESTORE | sa::MUTE_PERMANENT | sa::MUTE_TEMPORARY | sa::SET_AUTO_LOCK) {
let value = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Varint(v), 5) => Some(*v), _ => None });
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(v.to_vec()), _ => None }).unwrap_or_default();
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());
tokio::spawn(async move {
let worker = actions.clone();
let report = tokio::task::spawn_blocking(move || worker.handle(action, value, &args, || {
// GNOME/KDE "show desktop" shortcut (Super+D) through the desktop's own input path.
input.windows_key_event(0x5B, true); input.windows_key_event(0x44, true);
input.windows_key_event(0x44, false); input.windows_key_event(0x5B, false);
})).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));
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
}
});
} else if action > 1 && action != 15 {
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(*v), _ => None }).unwrap_or(&[]);
log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));
}
if action == 0 {
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,
clipboard_ready.load(std::sync::atomic::Ordering::Relaxed));
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");
}
}
}
}
}
}
}
if let Ok(txt) = std::str::from_utf8(&msg.data) {
log::debug!("DataChannel [{}] received UTF-8 data: {} bytes", channel_name, txt.len());
if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) {
if channel_name.contains("CONTROL") {
match crate::control_protocol::decode_control(&msg.data) {
Ok(crate::control_protocol::ControlMessage::Input(event)) => {
use crate::control_protocol::ControlInput;
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,input_size),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
_ => {}
}
},
_ => {}
}
} else if channel_name.contains("STREAMER") {
log::debug!("STREAMER channel JSON received");
if let Some(event)=val.get("connection_period_stats_event") {
let nums=crate::viewer_metrics::collect(event);
if nums.is_empty(){
static SHAPE:std::sync::atomic::AtomicUsize=std::sync::atomic::AtomicUsize::new(0);
if SHAPE.fetch_add(1,std::sync::atomic::Ordering::Relaxed)<3 {
log::info!("Viewer telemetry schema: {:?}",crate::viewer_metrics::safe_shape(event));
}
}
log::info!("Viewer delay/frame numeric metrics: {:?}",nums);
}
// 检查是否有 ping 或握手请求并回应
if val.get("type").and_then(|t| t.as_str()) == Some("ping") {
let _ = reply_chan.send(&bytes::Bytes::from_static(b"{\"type\":\"pong\"}")).await;
}
} else if channel_name.contains("TEXT") {
log::debug!("TEXT channel JSON received");
}
}
} else {
log::debug!("DataChannel [{}] received binary data: len={}", channel_name, msg.data.len());
}
})
}));
})
}));
Ok(Self {
pc,
capture,
input,
desktop,
context,
})
}
/// 应用远端 Offer,生成并返回 Answer
pub async fn handle_offer(&self, soac: &SoacMessage) -> Result<String, String> {
// 同步当前的客户端与房间会话上下文
{
let mut ctx = self.context.lock().await;
ctx.client_id = soac.client_id.clone();
ctx.ice_id = soac.ice_id.clone();
ctx.app_control_id = soac.app_control_id.clone();
log::info!("Updated WebRTC session context: client_id={:?}, ice_id={:?}", ctx.client_id, ctx.ice_id);
}
let mut sdp_str = soac.sdp.clone().unwrap_or_default();
if sdp_str.is_empty() {
if let Some(gzip_sdp) = &soac.gzip_sdp {
if let Ok(compressed) = base64::engine::general_purpose::STANDARD.decode(gzip_sdp) {
let mut decoder = GzDecoder::new(&compressed[..]);
let mut decompressed = String::new();
if decoder.read_to_string(&mut decompressed).is_ok() {
sdp_str = decompressed;
}
}
}
}
if sdp_str.is_empty() {
return Err("Offer SDP is empty".into());
}
let quic_value = sdp_str.lines().find_map(|line| line.strip_prefix("a=x-uuremote-quic"));
let quic_summary = match quic_value.map(str::trim) {
None => "absent", Some("") => "present", Some(":0") => "0", Some(":1") => "1",
Some(":false") => "false", Some(":true") => "true", _ => "present non-boolean value (not logged)",
};
log::info!("Offer x-uuremote-quic: {}", quic_summary);
log::info!("Offer includes UU capture-index extension: {}", sdp_str.lines().any(|l| l.starts_with("a=extmap:") && l.contains(crate::rtp_metadata::CAPTURE_INDEX_URI)));
let offer = RTCSessionDescription::offer(sdp_str)
.map_err(|e| format!("Invalid offer: {}", e))?;
self.pc
.set_remote_description(offer)
.await
.map_err(|e| format!("Set remote desc failed: {}", e))?;
let answer = self
.pc
.create_answer(None)
.await
.map_err(|e| format!("Create answer failed: {}", e))?;
log::info!("Answer includes x-uuremote-quic: {}", answer.sdp.lines().any(|l| l == "a=x-uuremote-quic"));
log::info!("Answer media sections: {:?}", answer.sdp.lines().filter(|l| l.starts_with("m=")).collect::<Vec<_>>());
let bundle_media = negotiated_bundle_media(&answer.sdp)
.ok_or("Answer has no active BUNDLE transport")?;
self.context.lock().await.bundle_media = Some(bundle_media);
self.pc
.set_local_description(answer.clone())
.await
.map_err(|e| format!("Set local desc failed: {}", e))?;
Ok(answer.sdp)
}
/// 接收远端 ICE Candidate
pub async fn add_candidate(&self, soac: &SoacMessage) -> Result<(), String> {
if let Some(cand_val) = &soac.candidate {
let (cand_str, sdp_mid, sdp_mline) = if let Some(s) = cand_val.as_str() {
(s.to_string(), soac.sdp_mid.clone().or_else(|| Some("0".to_string())), soac.sdp_mline_index.map(|i| i as u16).or(Some(0)))
} else {
let cs = cand_val.get("candidate").and_then(|v| v.as_str()).unwrap_or("").to_string();
let mid = cand_val.get("sdpMid").and_then(|v| v.as_str()).map(|s| s.to_string())
.or_else(|| soac.sdp_mid.clone())
.or_else(|| Some("0".to_string()));
let mline = cand_val.get("sdpMLineIndex").and_then(|v| v.as_u64()).map(|i| i as u16)
.or_else(|| soac.sdp_mline_index.map(|i| i as u16))
.or(Some(0));
(cs, mid, mline)
};
if !cand_str.is_empty() {
let init = RTCIceCandidateInit {
candidate: cand_str.clone(),
sdp_mid,
sdp_mline_index: sdp_mline,
..Default::default()
};
let summary=crate::network_diagnostics::candidate_summary(&cand_str);
log::info!("Injecting Remote ICE Candidate: protocol={} type={}",summary.protocol,summary.kind);
self.pc
.add_ice_candidate(init)
.await
.map_err(|e| format!("Add candidate error: {}", e))?;
}
}
Ok(())
}
}
fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> {
let preferred: Vec<&str> = sdp.lines().find_map(|l| l.strip_prefix("a=group:BUNDLE "))?
.split_whitespace().collect();
let mut sections: Vec<(bool, Option<String>)> = Vec::new();
for line in sdp.lines() {
if let Some(media) = line.strip_prefix("m=") {
let port = media.split_whitespace().nth(1)?;
sections.push((port != "0", None));
} else if let Some(mid) = line.strip_prefix("a=mid:") {
if let Some(section) = sections.last_mut() { section.1 = Some(mid.to_string()); }
}
}
for mid in preferred {
for (index, (active, section_mid)) in sections.iter().enumerate() {
if *active && section_mid.as_deref() == Some(mid) {
return Some((mid.to_string(), index.try_into().ok()?));
}
}
}
None
}
#[cfg(test)]
mod tests {
use super::negotiated_bundle_media;
#[test]
fn skips_rejected_audio_for_ice_transport() {
let sdp = "a=group:BUNDLE 1 2\r\nm=audio 0 RTP 0\r\na=mid:0\r\nm=video 9 RTP 98\r\na=mid:1\r\nm=application 9 SCTP 0\r\na=mid:2\r\n";
assert_eq!(negotiated_bundle_media(sdp), Some(("1".into(), 1)));
}
#[test]
fn follows_bundle_order_not_first_media() {
let sdp = "a=group:BUNDLE data video\nm=video 9 RTP 98\na=mid:video\nm=application 9 SCTP 0\na=mid:data\n";
assert_eq!(negotiated_bundle_media(sdp), Some(("data".into(), 1)));
}
}
/// 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))
}
/// Viewer feedback seen on the video sender: retransmission and keyframe requests.
#[derive(Default)]
pub(crate) struct FeedbackCounts { pub nack_packets: u64, pub pli: u64, pub fir: u64 }
impl FeedbackCounts {
pub(crate) fn observe(&mut self, packet: &dyn std::any::Any) {
use webrtc::rtcp::{payload_feedbacks::{full_intra_request::FullIntraRequest, picture_loss_indication::PictureLossIndication}, transport_feedbacks::transport_layer_nack::TransportLayerNack};
if let Some(nack) = packet.downcast_ref::<TransportLayerNack>() {
self.nack_packets += nack.nacks.iter().map(|pair| 1 + u64::from(pair.lost_packets.count_ones())).sum::<u64>();
} else if packet.is::<PictureLossIndication>() { self.pli += 1; }
else if packet.is::<FullIntraRequest>() { self.fir += 1; }
}
}
#[cfg(test)]
mod network_tests {
use super::*;
#[test]
fn ice_skips_overlay_and_container_interfaces_only() {
for name in ["ztfp6jdvog", "docker0", "br-1a2b", "veth12", "virbr0", "lo"] { assert!(!ice_interface_allowed(name), "{name}"); }
for name in ["eno1", "enp5s0", "wlp3s0", "eth0"] { assert!(ice_interface_allowed(name), "{name}"); }
}
#[test]
fn feedback_counts_nacked_packets_and_keyframe_requests() {
use webrtc::rtcp::{payload_feedbacks::picture_loss_indication::PictureLossIndication, transport_feedbacks::transport_layer_nack::{NackPair, TransportLayerNack}};
let mut counts = FeedbackCounts::default();
counts.observe(&TransportLayerNack { nacks: vec![NackPair { packet_id: 10, lost_packets: 0b101 }], ..Default::default() });
counts.observe(&PictureLossIndication::default());
assert_eq!((counts.nack_packets, counts.pli, counts.fir), (3, 1, 0));
}
}