Add the experimental native viewer (uuremote-viewer) (#36)

* Add the experimental native viewer (uuremote-viewer)

A Linux viewer/controller for UU Remote hosts, built separately with
--features native-viewer,viewer-sdl; the host build and behaviour are
unchanged.

- Cloud join by device and remote assistance by share ID + code (code
  via stdin only), WebRTC offer side, SDL desktop window with ffmpeg CLI
  H.264 decoding, Opus sound, keyboard/mouse, view-only mode, text
  clipboard on TEXT_DATA_CHANNEL.
- Tools: file browser/transfer (zero- and one-based download blocks),
  terminal and terminal session list, port mapping (127.0.0.1 only),
  reboot/shutdown; tools reuse the desktop peer while one is open.
- GTK launcher with device list and tool windows.
- CI builds and tests the viewer; release tarballs include it.

Logs carry field numbers, sizes and states only.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

* ci: install the ffmpeg CLI for the viewer audio tests

Co-Authored-By: Claude Opus 5.5 <[email protected]>

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
This commit is contained in:
authored and GitHub committed 2026-10-17 15:41:20 +08:00
1 parent 6f1dd77ab5
commit 809ce1697d
40 files changed
+5333 -7

No files matched your search

+334
View File
@@ -0,0 +1,334 @@
use crate::auth::UUAuthClient;
use serde::Deserialize;
use serde_json::{json, Value};
use std::time::Duration;
// No Debug: room/report tokens and signaling URLs are credentials.
#[derive(Deserialize)]
pub struct JoinData {
#[serde(default)] pub token: String,
#[serde(default)] pub signaling_list: Vec<String>,
#[serde(default)] pub ws_connect_timeout_ms: i32,
pub report_token: String,
pub report_url: String,
#[serde(default)] pub report_server_address: String,
#[serde(default)] pub streamer_retry_delta_ms: i32,
#[serde(default)] pub international_connect: bool,
}
#[derive(Debug, PartialEq, Eq)]
pub enum Error { AuthenticationExpired, Api(i32, String), InvalidResponse, Transport, MissingRoom, InvalidDevice, InvalidAssist }
impl std::fmt::Display for Error {
// The server's short message is user-facing (e.g. 2002 「被控端正在被远控中,无法发起连接」).
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::Api(code, msg) if !msg.is_empty() => write!(f, "{msg} (code {code})"),
Error::AuthenticationExpired => write!(f, "登录已过期,请重新登录"),
Error::Transport => write!(f, "网络连接失败"),
Error::InvalidAssist => write!(f, "请输入对方的设备 ID 和有效验证码"),
Error::InvalidResponse => write!(f, "服务器响应格式无效"),
Error::MissingRoom => write!(f, "服务器未返回可用的房间或信令信息"),
Error::Api(code, _) => write!(f, "连接请求失败(错误码 {code})"),
_ => write!(f, "viewer API: {self:?}"),
}
}
}
// Mirrors Windows 0x140b77cd0 / 0x140b7a6d0, not host RoomData.
pub fn parse_join(status: u16, value: Value) -> Result<JoinData, Error> {
let code = value.get("code").and_then(Value::as_i64).and_then(|v| i32::try_from(v).ok()).ok_or(Error::InvalidResponse)?;
let msg = value.get("msg").and_then(Value::as_str).ok_or(Error::InvalidResponse)?.chars().take(120).collect::<String>();
if code == 1120 { return Err(Error::AuthenticationExpired); }
let code = if code == 0 && status != 200 { i32::from(status) } else { code };
// Error responses carry an empty data object (observed: 400 / 2002 with data {}); report the code.
if code != 0 { return Err(Error::Api(code, msg)); }
let data = match value.get("data") {
Some(Value::Object(o)) => Some(serde_json::from_value::<JoinData>(Value::Object(o.clone())).map_err(|_| Error::InvalidResponse)?),
_ => None,
};
data.ok_or(Error::MissingRoom)
}
fn parse_share(status: u16, mut body: Value, secrets: &[&str]) -> Result<JoinData, Error> {
if let Some(Value::String(msg)) = body.get_mut("msg") {
// A server error must not echo credentials to stderr or the launcher.
for secret in secrets {
if !secret.is_empty() { *msg = msg.replace(secret, "[已隐藏]"); }
}
*msg = msg.chars().filter(|c| !c.is_control()).collect();
}
let room = parse_join(status, body)?;
if room.token.is_empty() || room.signaling_list.is_empty() { return Err(Error::MissingRoom); }
Ok(room)
}
pub fn retry_delay(error: &Error, retries: usize, enabled: bool) -> Option<Duration> {
match error {
Error::Api(code, _) if enabled && retries < 5 && ![-1, 2002, 2006, 2007, 4042].contains(code) => Some(Duration::from_millis(3000)),
_ => None,
}
}
pub struct Api {
signer: UUAuthClient,
http: reqwest::Client,
base: String,
}
impl Api {
pub fn new(signer: UUAuthClient, base: &str) -> Self {
Self { signer, base: base.trim_end_matches('/').into(), http: reqwest::Client::builder().timeout(Duration::from_secs(12)).build().unwrap() }
}
pub async fn join_share(&self, connect_id: &str, connect_code: &str) -> Result<JoinData, Error> {
if connect_id.trim().is_empty() || connect_code.trim().is_empty() || connect_id.chars().chain(connect_code.chars()).any(char::is_control) { return Err(Error::InvalidAssist); }
// Win LiteInner 0x140b6db90 sends plaintext connect_code; Mac uses the v1 path.
let text = json!({"connect_id":connect_id,"connect_code":connect_code}).to_string();
for version in [2, 1] {
let path = format!("/api/v{version}/room/join/share/by_code");
let response = self.http.post(format!("{}{path}", self.base))
.headers(self.signer.build_headers("POST", &path, &text)).body(text.clone())
.send().await.map_err(|_| Error::Transport)?;
let status = response.status().as_u16();
log::info!("Assist join response: status={status}");
// A missing endpoint may return HTML; inspect HTTP status before decoding JSON.
if version == 2 && matches!(status, 404 | 405) { continue; }
let body = response.json().await.map_err(|_| Error::InvalidResponse)?;
return parse_share(status, body, &[connect_code, &self.signer.creds.token, &self.signer.creds.csrf]);
}
unreachable!()
}
async fn request(&self, method: reqwest::Method, path: &str, body: Option<Value>) -> Result<(u16, Value), Error> {
let text = body.map(|v| v.to_string()).unwrap_or_default();
let response = self.http.request(method.clone(), format!("{}{path}", self.base))
.headers(self.signer.build_headers(method.as_str(), path, &text)).body(text)
.send().await.map_err(|_| Error::Transport)?;
let status = response.status().as_u16();
Ok((status, response.json().await.map_err(|_| Error::InvalidResponse)?))
}
pub async fn join(&self, device: &str, force_join: bool, retry: bool) -> Result<JoinData, Error> {
// Treat the caller's device string as one opaque path segment, never a URL/query.
if device.is_empty() || device=="." || device==".." { return Err(Error::InvalidDevice); }
let encoded=device.bytes().map(|b|if b.is_ascii_alphanumeric() || b"-._~".contains(&b) {(b as char).to_string()}else{format!("%{b:02X}")}).collect::<String>();
let path = format!("/api/v1/room/join/by_device/{encoded}");
let mut retries = 0;
loop {
let result = match self.request(reqwest::Method::POST, &path, Some(json!({"force_join":force_join}))).await {
Ok((status, body)) => {
// Structure only (codes and key names), never the room token or URLs.
let shape = crate::protocol::json_shape(&body, 3);
let server_msg = body.get("msg").and_then(Value::as_str).map(|m| m.chars().take(120).collect::<String>());
let parsed = parse_join(status, body);
if parsed.is_err() {
// UU_VIEWER_DEBUG=1 adds the server's short error message (like UU_ASSIST_DEBUG on the host).
let msg = std::env::var("UU_VIEWER_DEBUG").is_ok_and(|v| v == "1").then_some(server_msg).flatten();
log::warn!("Join response: status={status} shape={shape} msg={msg:?}");
}
parsed
}
Err(e) => Err(e),
};
match result {
Ok(data) => {
if data.token.is_empty() || data.signaling_list.is_empty() { return Err(Error::MissingRoom); }
return Ok(data);
}
Err(error) => match retry_delay(&error, retries, retry) {
Some(delay) => { tokio::time::sleep(delay).await; retries += 1; }
None => return Err(error),
},
}
}
}
/// Structure-only probe of the device list (status, JSON keys/types/lengths, never values).
pub async fn devices_shape(&self, method: reqwest::Method) -> Result<String, Error> {
let path = "/api/v1/device/list";
let response = self.http.request(method.clone(), format!("{}{path}", self.base))
.headers(self.signer.build_headers(method.as_str(), path, "")).send().await.map_err(|_| Error::Transport)?;
let status = response.status().as_u16();
let bytes = response.bytes().await.map_err(|_| Error::InvalidResponse)?;
Ok(match serde_json::from_slice::<Value>(&bytes) {
Ok(v) => format!("status={status} shape={}", crate::protocol::json_shape(&v, 7)),
Err(_) => format!("status={status} non_json_bytes={}", bytes.len()),
})
}
/// GET /api/v1/device/list → data {current_device, my_binded_devices[], others_shared_devices[]} (observed live).
pub async fn device_list(&self) -> Result<Value, Error> {
let (status, body) = self.request(reqwest::Method::GET, "/api/v1/device/list", None).await?;
if body.get("code").and_then(Value::as_i64) == Some(1120) { return Err(Error::AuthenticationExpired); }
if status != 200 || body.get("code").and_then(Value::as_i64) != Some(0) { return Err(Error::InvalidResponse); }
body.get("data").cloned().ok_or(Error::InvalidResponse)
}
/// Method and wire-key mapping remain unverified. Caller must select both explicitly.
pub async fn devices(&self, method: reqwest::Method, array_pointer: &str) -> Result<Vec<Value>, Error> {
let (status, body) = self.request(method, "/api/v1/device/list", None).await?;
if body.get("code").and_then(Value::as_i64) == Some(1120) { return Err(Error::AuthenticationExpired); }
if status != 200 || body.get("code").and_then(Value::as_i64) != Some(0) { return Err(Error::InvalidResponse); }
body.pointer(array_pointer).and_then(Value::as_array).cloned().ok_or(Error::InvalidResponse)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn assistance_response_validation_and_safe_user_errors() {
let mut fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
fixture["data"]["publisher_device_id"]=json!("synthetic-publisher");
fixture["data"]["share_id"]=json!("synthetic-share");
assert!(!parse_share(200,fixture.clone(),&[]).unwrap().token.is_empty());
for key in ["token","signaling_list"] {
let mut v=fixture.clone();v["data"].as_object_mut().unwrap().remove(key);
assert_eq!(parse_share(200,v,&[]).err().unwrap(),Error::MissingRoom);
}
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
assert_eq!(parse_share(422,json!({"code":9876,"msg":msg}),&[]).err().unwrap().to_string(),format!("{msg} (code 9876)"));
}
assert_eq!(parse_share(422,json!({"code":9876,"msg":"fixture-code\nfixture-token"}),&["fixture-code","fixture-token",""]).err().unwrap(),Error::Api(9876,"[已隐藏][已隐藏]".into()));
assert_eq!(parse_share(422,json!({"code":1120,"msg":"expired"}),&[]).err().unwrap(),Error::AuthenticationExpired);
assert_eq!(parse_share(200,json!({"code":0,"msg":"","data":{}}),&[]).err().unwrap(),Error::InvalidResponse);
}
#[test]
fn join_schema_defaults_required_types_and_error_policy() {
let fixture: Value = serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
let data = parse_join(200, fixture.clone()).unwrap();
assert_eq!(data.signaling_list.len(), 1);
for key in ["report_token", "report_url"] {
let mut v = fixture.clone(); v["data"].as_object_mut().unwrap().remove(key);
assert!(matches!(parse_join(200,v), Err(Error::InvalidResponse)));
let mut v = fixture.clone(); v["data"][key] = Value::Null;
assert!(matches!(parse_join(200,v), Err(Error::InvalidResponse)));
}
let v = json!({"code":0,"msg":"","data":{"report_token":"","report_url":""}});
let d = parse_join(200,v).unwrap();
assert!(d.token.is_empty() && d.signaling_list.is_empty() && !d.international_connect);
assert_eq!(d.ws_connect_timeout_ms,0); assert_eq!(d.streamer_retry_delta_ms,0);
assert!(matches!(parse_join(503,fixture),Err(Error::Api(503, _))));
for data in [Value::Null,json!([]),json!("ignored")] {
assert!(matches!(parse_join(422,json!({"code":1120,"msg":"","data":data})),Err(Error::AuthenticationExpired)));
}
for code in [-1,2002,2006,2007,4042] { assert_eq!(retry_delay(&Error::Api(code,String::new()),0,true),None); }
for retries in 0..5 { assert_eq!(retry_delay(&Error::Api(5000,String::new()),retries,true),Some(Duration::from_millis(3000))); }
assert_eq!(retry_delay(&Error::Api(5000,String::new()),5,true),None);
assert_eq!(retry_delay(&Error::Api(5000,String::new()),0,false),None);
for error in [Error::Transport,Error::InvalidResponse,Error::AuthenticationExpired] { assert_eq!(retry_delay(&error,0,true),None); }
}
}
#[cfg(test)]
mod http_tests {
use super::*;
use crate::auth::Credentials;
use tokio::{io::{AsyncReadExt,AsyncWriteExt},net::TcpListener};
pub async fn server(replies:Vec<(u16,Value)>)->(String,tokio::task::JoinHandle<Vec<String>>) {
server_raw(replies.into_iter().map(|(status,body)|(status,body.to_string())).collect()).await
}
async fn server_raw(replies:Vec<(u16,String)>)->(String,tokio::task::JoinHandle<Vec<String>>) {
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();
let url=format!("http://{}",listener.local_addr().unwrap());
let job=tokio::spawn(async move {
let mut requests=Vec::new();
for (status,body) in replies {
let(mut stream,_)=listener.accept().await.unwrap();let mut request=Vec::new();let mut buf=[0;1024];
loop {
let n=stream.read(&mut buf).await.unwrap();assert_ne!(n,0);request.extend_from_slice(&buf[..n]);
if let Some(end)=request.windows(4).position(|w|w==b"\r\n\r\n") {
let headers=String::from_utf8_lossy(&request[..end]);
let length=headers.lines().find_map(|l|l.to_lowercase().strip_prefix("content-length:").map(str::trim).and_then(|s|s.parse::<usize>().ok())).unwrap_or(0);
if request.len()>=end+4+length {break}
}
}
requests.push(String::from_utf8(request).unwrap());
let reply=format!("HTTP/1.1 {status} Mock\r\nContent-Type: application/json\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{body}",body.len());
stream.write_all(reply.as_bytes()).await.unwrap();
}
requests
});
(url,job)
}
fn signer()->UUAuthClient {UUAuthClient::new(Credentials{token:"synthetic-auth".into(),sign_key:"synthetic-key".into(),..Default::default()})}
#[tokio::test]
async fn signed_join_and_explicit_device_list_use_only_loopback_http() {
let fixture=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
let(url,job)=server(vec![(200,json!({"code":0,"data":{"synthetic_devices":[{"id":"synthetic-device","name":"fixture"}]}})),(200,fixture)]).await;
let api=Api::new(signer(),&url);
let devices=api.devices(reqwest::Method::GET,"/data/synthetic_devices").await.unwrap();assert_eq!(devices.len(),1);
assert!(api.join("",true,true).await.is_err());
api.join("synthetic-device",true,true).await.unwrap();
let requests=job.await.unwrap();assert!(requests[0].starts_with("GET /api/v1/device/list "));
assert!(requests[1].starts_with("POST /api/v1/room/join/by_device/synthetic-device "));
assert!(requests[1].to_lowercase().contains("x-param-sign:"));
assert_eq!(requests[1].split("\r\n\r\n").nth(1).unwrap(),r#"{"force_join":true}"#);
}
#[tokio::test]
async fn assistance_uses_signed_json_and_only_http_endpoint_fallback() {
let mut fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
// Extra share identity fields do not change the existing room parser.
fixture["data"]["share_id"]=json!("synthetic-share");
fixture["data"]["publisher_device_id"]=json!("synthetic-publisher");
fixture["data"]["publisher_platform"]=json!(1);
for status in [200,404,405] {
let replies=if status==200 {vec![(200,fixture.to_string())]} else {vec![(status,"<html>endpoint unavailable</html>".into()),(200,fixture.to_string())]};
let(url,job)=server_raw(replies).await;
let room=Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.unwrap();
assert!(!room.token.is_empty());assert_eq!(room.signaling_list.len(),1);
let requests=job.await.unwrap();assert_eq!(requests.len(),if status==200{1}else{2});
for (i,request) in requests.iter().enumerate() {
let version=if i==0{2}else{1};
assert!(request.starts_with(&format!("POST /api/v{version}/room/join/share/by_code ")));
let(headers,body)=request.split_once("\r\n\r\n").unwrap();
assert!(!headers.contains("synthetic-code"));
assert!(headers.to_lowercase().contains("x-param-sign:"));
assert!(headers.to_lowercase().contains("content-type: application/json"));
assert_eq!(serde_json::from_str::<Value>(body).unwrap(),json!({"connect_id":"synthetic-id","connect_code":"synthetic-code"}));
}
}
}
#[tokio::test]
async fn assistance_reports_actual_errors_without_retrying_or_echoing_secrets() {
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
let(url,job)=server(vec![(422,json!({"code":9876,"msg":msg}))]).await;
let error=Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.err().unwrap();
assert_eq!(error.to_string(),format!("{msg} (code 9876)"));assert_eq!(job.await.unwrap().len(),1);
}
for (status,body,expected) in [
(200,json!({"code":405,"msg":"业务拒绝"}),Error::Api(405,"业务拒绝".into())),
(500,json!({"code":5000,"msg":"服务忙"}),Error::Api(5000,"服务忙".into())),
(422,json!({"code":1120,"msg":""}),Error::AuthenticationExpired),
(200,json!({"code":0,"msg":"","data":{"report_url":"","report_token":""}}),Error::MissingRoom),
(200,json!({"code":0,"msg":"","data":{}}),Error::InvalidResponse),
(422,json!({"code":9876,"msg":"synthetic-code synthetic-auth"}),Error::Api(9876,"[已隐藏] [已隐藏]".into())),
] {
let(url,job)=server(vec![(status,body)]).await;
assert_eq!(Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.err().unwrap(),expected);
assert_eq!(job.await.unwrap().len(),1);
}
let api=Api::new(signer(),"http://127.0.0.1:1");
for (id,code) in [("","fixture"),("id",""),("id","a\nb")] {assert_eq!(api.join_share(id,code).await.err().unwrap(),Error::InvalidAssist);}
}
#[tokio::test]
async fn retry_stops_after_five_delays_and_terminal_errors_stop_immediately() {
let(url,job)=server(vec![(503,json!({"code":5000,"msg":"fixture"}));6]).await;
let start=tokio::time::Instant::now();
assert!(matches!(Api::new(signer(),&url).join("synthetic-device",false,true).await,Err(Error::Api(5000, _))));
assert!(start.elapsed()>=Duration::from_secs(15));assert_eq!(job.await.unwrap().len(),6);
for code in [-1,1120,2002,2006,2007,4042] {
let(url,job)=server(vec![(422,json!({"code":code,"msg":"fixture"}))]).await;
let error=Api::new(signer(),&url).join("synthetic-device",false,true).await.err().unwrap();
if code==1120 {assert_eq!(error,Error::AuthenticationExpired)} else {assert!(matches!(error,Error::Api(c,_) if c==code))}
assert_eq!(job.await.unwrap().len(),1);
}
}
}
#[cfg(test)]
mod strict_tests {
use super::*;
#[test]
fn rejects_wrong_json_types_and_missing_envelope_members() {
let fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
for (key,bad) in [("token",json!(false)),("signaling_list",json!([7])),("ws_connect_timeout_ms",json!(2147483648u64)),("streamer_retry_delta_ms",json!(null)),("international_connect",json!(1)),("report_token",json!(null)),("report_url",json!(7)),("report_server_address",json!([]))] {
let mut v=fixture.clone();v["data"][key]=bad;assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
}
for key in ["code","msg"] {
let mut v=fixture.clone();v.as_object_mut().unwrap().remove(key);assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
}
assert!(matches!(parse_join(200,json!({"code":0,"msg":"","data":{}})),Err(Error::InvalidResponse)));
assert!(matches!(parse_join(200,json!({"code":2147483648u64,"msg":""})),Err(Error::InvalidResponse)));
}
}
+45
View File
@@ -0,0 +1,45 @@
//! Assistance secrets travel only through memory and the child's stdin pipe.
use std::{io::BufRead,path::Path,process::Stdio};
use tokio::{io::AsyncWriteExt,process::{Child,Command}};
pub fn read_code(input: impl BufRead) -> Result<String,String> {
let mut code=String::new();
input.take(1025).read_line(&mut code).map_err(|_|"无法从 stdin 读取验证码")?;
if code.len()>1024 {return Err("验证码过长".into())}
if code.ends_with('\n') {code.pop();if code.ends_with('\r'){code.pop();}}
if code.trim().is_empty() || code.chars().any(char::is_control) {return Err("请输入有效验证码".into())}
Ok(code)
}
pub fn command(exe:&Path,id:&str)->Command {
let mut command=Command::new(exe);
command.args(["assist",id]).stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::piped()).kill_on_drop(true);
command
}
pub async fn send_code(child:&mut Child,code:&str)->Result<(),String> {
let result=async {
let mut stdin=child.stdin.take().ok_or("无法打开会话输入管道")?;
stdin.write_all(code.as_bytes()).await.map_err(|_|"无法向会话传递验证码")?;
stdin.write_all(b"\n").await.map_err(|_|"无法向会话传递验证码")?;
stdin.shutdown().await.map_err(|_|"无法关闭会话输入管道")
}.await;
if result.is_err() {let _=child.kill().await;}
result.map_err(str::to_owned)
}
#[cfg(test)] mod tests {
use super::*;
#[test] fn stdin_reads_one_line_without_changing_code() {
assert_eq!(read_code(&b"a b\r\nignored\n"[..]).unwrap(),"a b");
assert_eq!(read_code(&b"fixture"[..]).unwrap(),"fixture");
for input in ["","\n"," \r\n","a\tb\n","a\0b\n",&"x".repeat(1025)] {assert!(read_code(input.as_bytes()).is_err());}
}
#[tokio::test] async fn launcher_passes_only_id_in_arguments_and_closes_stdin() {
let command=command(Path::new("/bin/sh"),"synthetic-id");
assert_eq!(command.as_std().get_args().collect::<Vec<_>>(),["assist","synthetic-id"]);
// Local process mock: echo the pipe after EOF, without files or credentials.
let mut child=Command::new("/bin/sh").args(["-c","cat"]).stdin(Stdio::piped()).stdout(Stdio::piped()).spawn().unwrap();
send_code(&mut child,"synthetic-code").await.unwrap();
let output=child.wait_with_output().await.unwrap();
assert!(output.status.success());assert_eq!(output.stdout,b"synthetic-code\n");
}
}
+170
View File
@@ -0,0 +1,170 @@
use super::media::Latest;
const PACKETS:usize=12;
const MAX_PACKET:usize=8192;
#[derive(Clone)]
pub struct Packet { seq:u16, data:Vec<u8> }
#[derive(Clone)]
pub struct Audio { packets:Latest<Packet>, enabled:bool }
impl Default for Audio {
fn default()->Self {Self{packets:Latest::new(PACKETS),enabled:std::env::var("UU_VIEWER_AUDIO").map_or(true,|v|v!="0")}}
}
impl Audio {
#[cfg(test)] pub fn pop(&self)->Option<Vec<u8>> {self.packets.pop().map(|p|p.data)}
pub fn push(&self,seq:u16,data:&[u8]) {
if self.enabled && data.len()<=MAX_PACKET && samples(data).is_some() {self.packets.push(Packet{seq,data:data.to_vec()});}
}
}
fn samples(data:&[u8])->Option<u64> {
let toc=*data.first()?;
let frame=if toc&0x80!=0 {120u64<<(toc>>3&3)} else if toc&0x60==0x60 {if toc&8!=0 {960}else{480}} else {match toc>>3&3 {3=>2880,n=>480u64<<n}};
let count=match toc&3 {0=>1,1|2=>2,_=>u64::from(*data.get(1)?&63)};
let total=frame*count;(count>0 && total<=5760).then_some(total)
}
// One complete packet per page; zero pre-skip because RTP has no encoder pre-skip header.
#[derive(Default)]
struct Ogg { sequence:u32, granule:u64, last:Option<u16> }
impl Ogg {
fn page(&mut self,payload:&[u8],flags:u8)->Vec<u8> {
let mut page=b"OggS\0".to_vec();page.push(flags);page.extend(self.granule.to_le_bytes());
page.extend(1u32.to_le_bytes());page.extend(self.sequence.to_le_bytes());self.sequence=self.sequence.wrapping_add(1);
page.extend([0;4]);page.push((payload.len()/255+1) as u8);
page.extend(std::iter::repeat(255).take(payload.len()/255));page.push((payload.len()%255) as u8);page.extend(payload);
let mut crc=0u32;
for byte in &page {crc^=u32::from(*byte)<<24;for _ in 0..8 {crc=if crc&0x80000000!=0 {(crc<<1)^0x04c11db7}else{crc<<1};}}
page[22..26].copy_from_slice(&crc.to_le_bytes());page
}
fn headers(&mut self)->Vec<u8> {
let mut head=b"OpusHead\x01\x02\0\0".to_vec();head.extend(48000u32.to_le_bytes());head.extend([0,0,0]);
let mut out=self.page(&head,2);let mut tags=b"OpusTags".to_vec();tags.extend([0;8]);out.extend(self.page(&tags,0));out
}
fn packet(&mut self,packet:Packet)->Option<Vec<u8>> {
if self.last.is_some_and(|last|{let delta=packet.seq.wrapping_sub(last);delta==0 || delta>=0x8000}) {return None}
self.granule+=samples(&packet.data)?;self.last=Some(packet.seq);Some(self.page(&packet.data,0))
}
}
#[cfg(feature="viewer-sdl")]
mod playback {
use super::*;
use tokio::{io::{AsyncReadExt,AsyncWriteExt},process::{Child,Command},task::JoinHandle};
use std::{process::Stdio,time::Duration};
const PCM_SAMPLES:usize=1920;
const PCM_BYTES:usize=PCM_SAMPLES*2;
const SDL_BYTES:u32=48000*2*2/10;
struct Decoder { child:Option<Child>, tasks:Vec<JoinHandle<()>>, pcm:Latest<Vec<i16>> }
impl Decoder {
fn new(audio:Audio)->Result<Self,String> {
let mut child=Command::new(std::env::var_os("UU_VIEWER_FFMPEG").unwrap_or_else(||"ffmpeg".into()))
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-f","ogg","-i","pipe:0","-vn","-ac","2","-ar","48000","-c:a","pcm_s16le","-f","s16le","-flush_packets","1","pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|"Audio decoder start failed")?;
let mut input=child.stdin.take().ok_or("Audio decoder stdin missing")?;
let mut output=child.stdout.take().ok_or("Audio decoder stdout missing")?;
let pcm=Latest::new(PACKETS);let decoded=pcm.clone();
let writer=tokio::spawn(async move {
let mut ogg=Ogg::default();
let result:std::io::Result<()>=async {
input.write_all(&ogg.headers()).await?;
let mut tick=tokio::time::interval(Duration::from_millis(4));
loop {
tick.tick().await;
while let Some(packet)=audio.packets.pop() {if let Some(page)=ogg.packet(packet) {
tokio::time::timeout(Duration::from_secs(1),input.write_all(&page)).await??;
}}
}
}.await;
if result.is_err() {log::warn!("Viewer audio decoder input stopped");}
});
let reader=tokio::spawn(async move {
let mut bytes=[0u8;PCM_BYTES];
while output.read_exact(&mut bytes).await.is_ok() {
decoded.push(bytes.chunks_exact(2).map(|b|i16::from_le_bytes([b[0],b[1]])).collect());
}
});
Ok(Self{child:Some(child),tasks:vec![writer,reader],pcm})
}
fn alive(&mut self)->bool {self.child.as_mut().is_some_and(|child|matches!(child.try_wait(),Ok(None))) && self.tasks.iter().all(|t|!t.is_finished())}
}
impl Drop for Decoder {
fn drop(&mut self) {
for task in &self.tasks {task.abort();}
if let Some(mut child)=self.child.take() {let _=child.start_kill();tokio::spawn(async move {let _=child.wait().await;});}
}
}
pub struct Playback { queue:sdl2::audio::AudioQueue<i16>, decoder:Decoder }
impl Playback {
pub fn new(sdl:&sdl2::Sdl,audio:Audio)->Option<Self> {
if !audio.enabled {return None}
let result=(|| {
let subsystem=sdl.audio()?;
let queue=subsystem.open_queue::<i16,_>(None,&sdl2::audio::AudioSpecDesired{freq:Some(48000),channels:Some(2),samples:Some(960)})?;
let decoder=Decoder::new(audio)?;queue.resume();Ok::<_,String>(Self{queue,decoder})
})();
match result {Ok(p)=>Some(p),Err(_)=>{log::warn!("Viewer audio playback unavailable");None}}
}
pub fn pump(&mut self)->Result<(),String> {
if !self.decoder.alive() {return Err("Audio decoder stopped".into())}
while let Some(samples)=self.decoder.pcm.pop() {
if self.queue.size()+samples.len() as u32*2>SDL_BYTES {self.queue.clear();}
self.queue.queue_audio(&samples).map_err(|_|"Audio queue failed")?;
}Ok(())
}
}
#[cfg(test)] mod tests {
use super::*;
#[tokio::test] async fn sdl_dummy_queue_is_bounded_and_audio_can_be_disabled() {
if std::env::var_os("UU_VIEWER_AUDIO_TEST_CHILD").is_none() {
let output=std::process::Command::new(std::env::current_exe().unwrap()).args(["--exact","viewer::audio::playback::tests::sdl_dummy_queue_is_bounded_and_audio_can_be_disabled","--test-threads=1"])
.env("SDL_AUDIODRIVER","dummy").env("UU_VIEWER_AUDIO_TEST_CHILD","1").output().unwrap();
assert!(output.status.success(),"{}",String::from_utf8_lossy(&output.stdout));return
}
let sdl=sdl2::init().unwrap();
assert!(Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:false}).is_none());
let mut playback=Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:true}).unwrap();playback.queue.pause();
for value in 0..100 {playback.decoder.pcm.push(vec![value;PCM_SAMPLES]);}
playback.pump().unwrap();assert!(playback.queue.size()>0 && playback.queue.size()<=SDL_BYTES);
assert!(playback.decoder.pcm.pop().is_none());
}
#[tokio::test] async fn ffmpeg_streams_pcm_before_eof_and_is_reaped() {
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};let mut decoder=Decoder::new(audio.clone()).unwrap();
let id=decoder.child.as_ref().unwrap().id().unwrap();
tokio::time::timeout(Duration::from_secs(5),async {
for seq in 0..250 {audio.push(seq,&[0xf8,0xff,0xfe]);tokio::time::sleep(Duration::from_millis(8)).await;
if let Some(pcm)=decoder.pcm.pop() {assert_eq!(pcm.len(),PCM_SAMPLES);assert!(decoder.alive());return}
}panic!("No PCM before EOF");
}).await.unwrap();
drop(decoder);
tokio::time::timeout(Duration::from_secs(2),async {while unsafe{libc::kill(id as i32,0)}==0 {tokio::time::sleep(Duration::from_millis(10)).await;}}).await.unwrap();
}
}
}
#[cfg(feature="viewer-sdl")] pub use playback::Playback;
#[cfg(test)] mod tests {
use super::*;
#[test] fn duration_bounds_and_latest_packets() {
assert_eq!(samples(&[0xf8,0xff,0xfe]),Some(960));assert_eq!(samples(&[0x98]),Some(960));
assert_eq!(samples(&[0x18]),Some(2880));assert_eq!(samples(&[0x83,48]),Some(5760));
assert_eq!(samples(&[0x83,49]),None);assert_eq!(samples(&[3,0]),None);assert_eq!(samples(&[]),None);
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};
for seq in 0..1000 {audio.push(seq,&[0xf8,0xff,0xfe]);}
audio.push(1000,&vec![0;MAX_PACKET+1]);audio.push(1000,&[]);
for seq in 988..1000 {assert_eq!(audio.packets.pop().unwrap().seq,seq);}assert!(audio.packets.pop().is_none());
let disabled=Audio{enabled:false,..audio};disabled.push(0,&[0xf8,0xff,0xfe]);assert!(disabled.packets.pop().is_none());
}
#[test] fn ogg_headers_crc_lacing_and_sequence_wrap() {
let mut ogg=Ogg::default();let headers=ogg.headers();assert_eq!(&headers[..4],b"OggS");assert_eq!(&headers[28..36],b"OpusHead");
let page=ogg.page(&vec![0;255],0);assert_eq!(&page[27..29],&[255,0]);
let mut stream=headers;stream.extend(&page);
let (mut reader,head)=webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream.clone()),true).unwrap();
assert_eq!(head.channels,2);assert_eq!(head.sample_rate,48000);
assert!(reader.parse_next_page().unwrap().0.starts_with(b"OpusTags"));
assert_eq!(reader.parse_next_page().unwrap().0.len(),255);
stream[28]^=1;assert!(webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream),true).is_err());
let packet=|seq|Packet{seq,data:vec![0xf8,0xff,0xfe]};
assert!(ogg.packet(packet(65535)).is_some());assert!(ogg.packet(packet(0)).is_some());
assert!(ogg.packet(packet(0)).is_none());assert!(ogg.packet(packet(65534)).is_none());assert_eq!(ogg.granule,1920);
}
}
+277
View File
@@ -0,0 +1,277 @@
//! Session-scoped text clipboard. Payloads never enter logs or process arguments.
use super::{rtc::Observed,wire};
use crate::{clipboard_protocol as text,clipboard_rich as rich,protocol::{decode_wire,WireValue}};
use std::{path::PathBuf,process::Stdio,sync::{Arc,atomic::{AtomicBool,Ordering}},time::Duration};
use tokio::{io::{AsyncReadExt,AsyncWriteExt},sync::mpsc};
use webrtc::data_channel::RTCDataChannel;
// Same limit as src/clipboard.rs; shared host codecs enforce it on both wire formats.
pub const MAX_TEXT:usize=30*1024;
pub const CHANNEL:usize=1; // TEXT_DATA_CHANNEL; native host clipboard state is scoped to this channel.
const POLL:Duration=Duration::from_millis(500);
static WARNED:AtomicBool=AtomicBool::new(false);
fn warn(){if !WARNED.swap(true,Ordering::Relaxed){log::warn!("Viewer text clipboard unavailable; synchronization disabled");}}
#[derive(Clone)]
struct Backend {read:PathBuf,read_args:Vec<&'static str>,write:PathBuf,write_args:Vec<&'static str>}
fn executable(name:&str)->Option<PathBuf>{
use std::os::unix::fs::PermissionsExt;
std::env::var_os("PATH").and_then(|p|std::env::split_paths(&p).map(|d|d.join(name))
.find(|p|std::fs::metadata(p).is_ok_and(|m|m.is_file() && m.permissions().mode()&0o111!=0)))
}
impl Backend {
fn detect()->Option<Self>{
if std::env::var("UU_VIEWER_CLIPBOARD").as_deref()==Ok("0"){return None}
// Unit sessions must never inspect or change the developer's real clipboard.
if !cfg!(target_os="linux") || cfg!(test){return None}
let selected=Self::select(std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty()),executable);
if selected.is_none(){warn();}selected
}
fn select(wayland:bool,find:impl Fn(&str)->Option<PathBuf>)->Option<Self>{
let selected=if wayland{
find("wl-paste").zip(find("wl-copy")).map(|(read,write)|Self{read,write,read_args:vec!["--no-newline","--type","text"],write_args:vec!["--type","text/plain;charset=utf-8"]})
}else{None};
selected.or_else(||find("xclip").map(|p|Self{read:p.clone(),write:p,read_args:vec!["-selection","clipboard","-out"],write_args:vec!["-selection","clipboard","-in"]}))
.or_else(||find("xsel").map(|p|Self{read:p.clone(),write:p,read_args:vec!["--clipboard","--output"],write_args:vec!["--clipboard","--input"]}))
}
async fn read(&self)->Result<Option<String>,()>{
let mut child=tokio::process::Command::new(&self.read).args(&self.read_args).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|())?;
let operation=async{
let mut data=Vec::new();child.stdout.take().ok_or(())?.take((MAX_TEXT+1) as u64).read_to_end(&mut data).await.map_err(|_|())?;
if data.len()>MAX_TEXT {let _=child.kill().await;return Ok(None)}
// No text selection (including an image-only selection) is not a fatal backend failure.
if !child.wait().await.map_err(|_|())?.success(){return Ok(None)}
Ok(String::from_utf8(data).ok())
};
tokio::time::timeout(Duration::from_secs(2),operation).await.map_err(|_|())?
}
async fn write(&self,value:&str)->Result<(),()>{
if value.len()>MAX_TEXT{return Err(())}
let mut child=tokio::process::Command::new(&self.write).args(&self.write_args).stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|())?;
let operation=async{
let mut stdin=child.stdin.take().ok_or(())?;stdin.write_all(value.as_bytes()).await.map_err(|_|())?;drop(stdin);
if child.wait().await.map_err(|_|())?.success(){Ok(())}else{Err(())}
};
tokio::time::timeout(Duration::from_secs(2),operation).await.map_err(|_|())?
}
}
#[derive(Default)]
struct SyncState {last:Option<String>,assembly:text::Assembly,rich:rich::State,seq:u64}
impl SyncState {
async fn apply(&mut self,backend:&Backend,value:String)->Result<(),()>{
backend.write(&value).await?;
log::info!("Viewer remote clipboard applied: bytes={}",value.len());
self.last=Some(value);Ok(())
}
fn next(&mut self)->u64{self.seq=self.seq.wrapping_add(1).max(100);self.seq}
fn local(&mut self,value:String)->Result<Option<Vec<u8>>,&'static str>{
if self.last.as_ref()==Some(&value){return Ok(None)}
let id=self.next();let payload=self.rich.offer(id,value.clone())?;
self.last=Some(value);Ok(Some(wire::envelope(self.next(),21,&payload)))
}
fn receive(&mut self,data:&[u8])->Result<(Vec<Vec<u8>>,Option<String>),&'static str>{
if data.len()>MAX_TEXT*2+1024{return Err("clipboard message exceeds limit")}
let fields=decode_wire(data).map_err(|_|"invalid clipboard envelope")?;
let mut replies=Vec::new();let mut value=None;
for field in fields {
let WireValue::Bytes(payload)=field.value else{continue};
match field.number {
17=>if let Some(text)=self.assembly.accept(payload)?{value=Some(text)},
21=>{
let seq=&mut self.seq;
let result=self.rich.request(payload,&mut ||{*seq=seq.wrapping_add(1).max(100);*seq})?;
if result.text.is_some(){value=result.text;}
for (kind,body) in result.messages {replies.push(wire::envelope(self.next(),kind,&body));}
if let Some((header,text))=text::read_text_request(payload)?{
value=Some(text);replies.push(wire::envelope(self.next(),22,&text::text_response(&header)));
}
},
22=>if let Some(text)=self.rich.response(payload)?{value=Some(text)},
_=>{},
}
}
Ok((replies,value))
}
}
async fn send(channel:&RTCDataChannel,message:Vec<u8>)->Result<(),()>{
tokio::time::timeout(Duration::from_secs(2),channel.send(&bytes::Bytes::from(message))).await.map_err(|_|())?.map_err(|_|())?;Ok(())
}
pub fn available()->bool{Backend::detect().is_some()}
pub struct Bridge {backend:Option<Backend>,pub enabled:bool,tx:Option<mpsc::Sender<Vec<u8>>>,task:Option<tokio::task::JoinHandle<()>>}
impl Bridge {
pub fn new(desktop:bool)->Self{
let backend=if desktop{Backend::detect()}else{None};let enabled=backend.is_some();
Self{backend,enabled,tx:None,task:None}
}
pub fn start(&mut self,channel:&Arc<RTCDataChannel>,control:&Arc<RTCDataChannel>,observed:Arc<Observed>){
let Some(backend)=self.backend.take() else{return};
let (tx,mut rx)=mpsc::channel::<Vec<u8>>(16);self.tx=Some(tx);
let channel=Arc::downgrade(channel);let control=Arc::downgrade(control);
self.task=Some(tokio::spawn(async move{
let mut state=SyncState::default();let mut tick=tokio::time::interval(POLL);
let mut retries=0;let mut last_probe=std::time::Instant::now();
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
let Some(channel)=channel.upgrade() else{break};
tokio::select!{
data=rx.recv()=>{
let Some(data)=data else{break};
if !observed.clipboard_supported.load(Ordering::Acquire){continue}
match state.receive(&data){
Ok((replies,value))=>{
if let Some(value)=value {
// Update only after the write succeeds; the next poll cannot echo it.
if state.apply(&backend,value).await.is_err(){warn();break}
}
let mut failed=false;for reply in replies{if send(&channel,reply).await.is_err(){failed=true;break}}
if failed{break}
},
Err(_)=>log::warn!("Viewer clipboard message rejected"),
}
},
_=tick.tick()=>{
if observed.echo_received.load(Ordering::Acquire) && !observed.control_open.load(Ordering::Acquire){break}
if !observed.echo_received.load(Ordering::Acquire){continue}
if !observed.clipboard_supported.load(Ordering::Acquire){
// Host TEXT-channel initialization may finish after the initial CONTROL echo.
if retries<5 && last_probe.elapsed()>=Duration::from_secs(1){
retries+=1;last_probe=std::time::Instant::now();
let Some(control)=control.upgrade() else{break};
if send(&control,wire::echo_request_with_clipboard(1,true)).await.is_err(){break}
}
continue
}
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open{continue}
match backend.read().await {
Ok(Some(value))=>{let length=value.len();match state.local(value){
Ok(Some(message))=>{if send(&channel,message).await.is_err(){break}log::info!("Viewer local clipboard offered: bytes={length}");},
Ok(None)=>{},Err(_)=>{},
}},
Ok(None)=>{},Err(())=>{warn();break},
}
}
}
}
}));
}
pub fn sender(&self)->Option<mpsc::Sender<Vec<u8>>>{self.tx.clone()}
pub fn stop(&self){if let Some(task)=&self.task{task.abort();}}
}
impl Drop for Bridge{fn drop(&mut self){self.stop();}}
#[cfg(test)] mod tests {
use super::*;
#[test] fn backend_priority_requires_a_complete_wayland_pair_and_falls_back(){
let select=|wayland,names:&[&str]|Backend::select(wayland,|n|names.contains(&n).then(||PathBuf::from(n)));
let all=["wl-copy","wl-paste","xclip","xsel"];
assert_eq!(select(true,&all).unwrap().write,PathBuf::from("wl-copy"));
assert_eq!(select(false,&all).unwrap().write,PathBuf::from("xclip"));
assert_eq!(select(true,&["wl-copy","xclip","xsel"]).unwrap().write,PathBuf::from("xclip"));
assert_eq!(select(true,&["xsel"]).unwrap().write,PathBuf::from("xsel"));
assert!(select(true,&[]).is_none());
}
#[test] fn limits_match_host_and_unchanged_or_remote_text_is_not_reoffered(){
assert!(include_str!("../clipboard.rs").contains("pub const MAX_TEXT: usize = 30 * 1024;"));
assert!(POLL>=Duration::from_millis(500));
let mut state=SyncState::default();
assert!(state.local("中文🙂\n".into()).unwrap().is_some());
assert!(state.local("中文🙂\n".into()).unwrap().is_none());
state.last=Some("remote".into());
assert!(state.local("remote".into()).unwrap().is_none());
assert!(state.local(String::new()).unwrap().is_some());
assert!(state.local(String::new()).unwrap().is_none());
assert!(state.local("a".repeat(MAX_TEXT+1)).is_err());
}
#[test] fn message17_fragments_and_mobile_rpc_keep_unicode_and_request_id(){
let mut state=SyncState::default();let value="中文🙂\n".repeat(2200);
let parts=text::chunks(&value).unwrap();
for (i,part) in parts.iter().enumerate(){
let (replies,received)=state.receive(&wire::envelope(1,17,&text::encode(3,part,i+1<parts.len()))).unwrap();
assert!(replies.is_empty());
assert_eq!(received,if i+1==parts.len(){Some(value.clone())}else{None});
}
let (replies,received)=state.receive(&wire::envelope(2,21,&text::text_request(73,"mobile"))).unwrap();
assert_eq!(received.as_deref(),Some("mobile"));assert_eq!(replies.len(),1);
let fields=decode_wire(&replies[0]).unwrap();
assert!(fields.iter().any(|f|f.number==22));
let WireValue::Bytes(response)=fields.iter().find(|f|f.number==22).unwrap().value else{panic!()};
let WireValue::Bytes(header)=decode_wire(response).unwrap().into_iter().find(|f|f.number==1).unwrap().value else{panic!()};
assert_eq!(decode_wire(header).unwrap()[0].value,WireValue::Varint(73));
assert!(state.receive(&wire::envelope(1,17,&[18,1,255])).is_err());
assert!(state.receive(&wire::envelope(1,17,&text::encode(1,&"a".repeat(MAX_TEXT+1),false))).is_err());
}
// Match webrtc.rs: CONTROL and TEXT have separate rich States, and only TEXT has a desktop sink.
fn native_host_exchange(outbound:usize,reverse:bool)->(Option<String>,bool){
let mut viewer=SyncState::default();let mut host=[rich::State::default(),rich::State::default()];let mut id=1000;
let value="clipboard-中文🙂\n".to_owned();
let offer=if reverse{wire::envelope(1,21,&host[1].offer(1,value.clone()).unwrap())}else{viewer.local(value.clone()).unwrap().unwrap()};
let mut queue=std::collections::VecDeque::from([(reverse,if reverse{1}else{outbound},offer)]);
let mut received=None;let mut unavailable=false;let mut steps=0;
while let Some((to_viewer,channel,packet))=queue.pop_front(){
steps+=1;assert!(steps<20);
if to_viewer {
// Capture DataConfirm status without reading or logging text.
for field in decode_wire(&packet).unwrap(){
if let (22,WireValue::Bytes(body))=(field.number,field.value){
if let Some(clip)=super::super::tools::blob(body,5){
if let Some(confirm)=super::super::tools::blob(clip,2){unavailable|=super::super::tools::uint(confirm,1)==2;}
}
}
}
let (replies,text)=viewer.receive(&packet).unwrap();if text.is_some(){received=text;}
queue.extend(replies.into_iter().map(|p|(false,outbound,p)));
}else{
for field in decode_wire(&packet).unwrap(){let WireValue::Bytes(body)=field.value else{continue};
if field.number==21 {let result=host[channel].request(body,&mut ||{id+=1;id}).unwrap();
if channel==1 && result.text.is_some(){received=result.text;}
queue.extend(result.messages.into_iter().map(|(kind,body)|(true,channel,wire::envelope(1,kind,&body))));
}else if field.number==22 {let text=host[channel].response(body).unwrap();if channel==1 && text.is_some(){received=text;}}
}
}
}
if reverse && received.is_some(){viewer.last=Some(value.clone());assert!(viewer.local(value).unwrap().is_none());}
(received,unavailable)
}
#[test] fn control_clipboard_reproduces_native_host_failures(){
assert_eq!(native_host_exchange(0,false),(None,false)); // Complete transfer, no CONTROL desktop sink.
assert_eq!(native_host_exchange(0,true),(None,true)); // TEXT offer, empty CONTROL provider.
}
#[test] fn text_clipboard_negotiates_both_directions_with_native_host(){
assert_eq!(wire::CHANNELS[CHANNEL],"TEXT_DATA_CHANNEL");
for reverse in [false,true]{
let (received,unavailable)=native_host_exchange(CHANNEL,reverse);
assert_eq!(received.as_deref(),Some("clipboard-中文🙂\n"));assert!(!unavailable);
}
}
#[test] fn clipboard_capability_is_version3_and_can_be_disabled(){
assert!(wire::echo_clipboard_supported(&wire::echo_request_with_clipboard(1,true)));
assert!(!wire::echo_clipboard_supported(&wire::echo_request_with_clipboard(1,false)));
assert!(wire::echo_matches(&wire::echo_response_with_clipboard(2,1,true),1));
assert!(!wire::echo_matches(&wire::echo_response_with_clipboard(2,7,true),1));
assert!(!Bridge::new(false).enabled);assert!(!Bridge::new(true).enabled);
let mut shape:wire::Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/shape.json")).unwrap();
shape.feature_flag=vec![[8,99]];
let options=shape.connect_options("synthetic-device").unwrap();
let WireValue::Bytes(flags)=decode_wire(&options).unwrap().into_iter().find(|f|f.number==11).unwrap().value else{panic!()};
assert!(!decode_wire(flags).unwrap().iter().any(|f|f.number==8));
}
#[tokio::test] async fn backend_uses_stdin_preserves_text_and_bounds_reads(){
use std::os::unix::fs::PermissionsExt;
let root=std::env::temp_dir().join(format!("uu-clipboard-mock-{}",wire::uuid()));std::fs::create_dir(&root).unwrap();
let script=root.join("mock");
std::fs::write(&script,b"#!/bin/sh\ncd -- \"${0%/*}\" || exit 1\ncase \"$1\" in read) cat data;; write) cat > data;; esac\n").unwrap();
std::fs::set_permissions(&script,std::fs::Permissions::from_mode(0o700)).unwrap();
let backend=Backend{read:script.clone(),write:script,read_args:vec!["read"],write_args:vec!["write"]};
let mut state=SyncState::default();
for value in ["中文🙂\n", "", "literal $(echo secret) `echo secret`"]{
state.apply(&backend,value.into()).await.unwrap();
let read=backend.read().await.unwrap().unwrap();assert_eq!(read,value);
assert!(state.local(read).unwrap().is_none());
}
let broken=Backend{write:root.join("missing"),..backend.clone()};
let previous=state.last.clone();assert!(state.apply(&broken,"failed".into()).await.is_err());assert_eq!(state.last,previous);
std::fs::write(root.join("data"),vec![b'a';MAX_TEXT+1]).unwrap();assert!(backend.read().await.unwrap().is_none());
std::fs::write(root.join("data"),[255]).unwrap();assert!(backend.read().await.unwrap().is_none());
assert!(backend.write(&"a".repeat(MAX_TEXT+1)).await.is_err());
std::fs::remove_dir_all(root).unwrap();
}
}
+36
View File
@@ -0,0 +1,36 @@
//! Uses the same optional FFmpeg dependency as the host inproc-av feature.
use super::desktop::{Decoder,Frame};
use ffmpeg_next as av;
pub struct Ffmpeg { decoder:av::decoder::Video }
impl Ffmpeg {
pub fn new()->Result<Self,String> {
av::init().map_err(|_|"FFmpeg initialization failed")?;
// Library diagnostics can contain bitstream data; suppress them globally in this viewer process.
av::log::set_level(av::log::Level::Quiet);
let codec=av::decoder::find(av::codec::Id::H264).ok_or("H264 decoder unavailable")?;
let decoder=av::codec::context::Context::new().decoder().open_as(codec).and_then(|d|d.video()).map_err(|_|"H264 decoder initialization failed")?;
Ok(Self{decoder})
}
}
impl Decoder for Ffmpeg {
fn reset(&mut self){self.decoder.flush();}
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String>{
self.decoder.send_packet(&av::Packet::copy(au)).map_err(|_|"H264 packet rejected")?;
let mut frames=Vec::new();let mut decoded=av::frame::Video::empty();
loop {
match self.decoder.receive_frame(&mut decoded) {
Ok(())=>{},
Err(av::Error::Other{errno}) if errno==libc::EAGAIN=>break,
Err(_)=>return Err("H264 decode failed".into()),
}
if decoded.is_corrupt(){return Err("Corrupt H264 frame".into())}
let (w,h)=(decoded.width(),decoded.height());
if w==0 || h==0 || w>8192 || h>8192 {return Err("Decoded dimensions exceed limit".into())}
let mut scaler=av::software::scaling::context::Context::get(decoded.format(),w,h,av::format::Pixel::RGB24,w,h,av::software::scaling::flag::Flags::BILINEAR).map_err(|_|"Frame conversion unavailable")?;
let mut rgb=av::frame::Video::empty();scaler.run(&decoded,&mut rgb).map_err(|_|"Frame conversion failed")?;
let mut data=Vec::with_capacity(w as usize*h as usize*3);
for row in 0..h as usize {let start=row*rgb.stride(0);data.extend_from_slice(&rgb.data(0)[start..start+w as usize*3]);}
frames.push(Frame{width:w,height:h,rgb:data});
} Ok(frames)
}
}
+61
View File
@@ -0,0 +1,61 @@
//! H.264 decoding through an external `ffmpeg` process, like the host's encoder pipeline.
//! Needs only the ffmpeg CLI (any recent version), not FFmpeg development libraries.
//! Output is scaled into a fixed letterboxed size so every frame has a known byte length.
use super::desktop::{Decoder,Frame};
use std::io::{Read,Write};
use std::process::{Child,ChildStdin,Command,Stdio};
use std::sync::mpsc::{Receiver,TryRecvError};
pub struct Cli { child:Child, input:ChildStdin, frames:Receiver<Vec<u8>>, width:u32, height:u32 }
impl Cli {
/// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary.
pub fn new()->Result<Self,String> {
let (width,height)=std::env::var("UU_VIEWER_SIZE").ok()
.and_then(|v|{let (w,h)=v.split_once('x')?;Some((w.parse().ok()?,h.parse().ok()?))})
.filter(|&(w,h):&(u32,u32)|(16..=8192).contains(&w)&&(16..=8192).contains(&h)&&w%2==0&&h%2==0)
.unwrap_or((1920,1080));
let ffmpeg=std::env::var("UU_VIEWER_FFMPEG").unwrap_or_else(|_|"ffmpeg".into());
let filter=format!("scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2");
let mut child=Command::new(ffmpeg)
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-fflags","nobuffer","-flags","low_delay","-f","h264","-i","pipe:0","-an","-vf",&filter,
"-pix_fmt","rgb24",
// Raw H.264 carries no timestamps; constant-rate output dropped almost every frame of
// the official Mac host's stream (270 → 2). Pass frames through unchanged.
"-fps_mode","passthrough","-f","rawvideo","pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null())
.spawn().map_err(|e|format!("Start ffmpeg decoder: {e}"))?;
let input=child.stdin.take().ok_or("ffmpeg stdin missing")?;
let mut output=child.stdout.take().ok_or("ffmpeg stdout missing")?;
let size=width as usize*height as usize*3;
// Bounded: a slow window drops decoded frames instead of growing memory.
let (tx,frames)=std::sync::mpsc::sync_channel(2);
std::thread::Builder::new().name("uu-viewer-decode".into()).spawn(move||{
loop {
let mut frame=vec![0;size];
if output.read_exact(&mut frame).is_err() {break;}
match tx.try_send(frame) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break }
}
}).map_err(|e|format!("Decoder reader: {e}"))?;
Ok(Self{child,input,frames,width,height})
}
}
impl Decoder for Cli {
fn reset(&mut self) {}
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String> {
self.input.write_all(au).and_then(|_|self.input.flush()).map_err(|_|"ffmpeg decoder exited")?;
let mut out=Vec::new();
loop {
match self.frames.try_recv() {
Ok(rgb)=>out.push(Frame{width:self.width,height:self.height,rgb}),
Err(TryRecvError::Empty)=>break,
Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()),
}
}
Ok(out)
}
}
impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.child.wait(); } }
+35
View File
@@ -0,0 +1,35 @@
use super::media::Latest;
use std::sync::{Arc, atomic::{AtomicBool,AtomicU32,Ordering}};
#[derive(Clone)]
pub struct Desktop { pub units:Latest<Vec<u8>>, pub pli:Arc<AtomicBool>, pub reset:Arc<AtomicBool>, pub ssrc:Arc<AtomicU32> }
impl Default for Desktop {
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
}
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8> }
pub trait Decoder { fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self); }
pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; }
/// Counts only (access units, presented frames, decode errors) for the periodic stats line.
pub static STATS:[std::sync::atomic::AtomicU64;3]=[std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0)];
pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],pli:&AtomicBool)->Result<(),String> {
STATS[0].fetch_add(1,Ordering::Relaxed);
// Local diagnostic: UU_VIEWER_DUMP_H264=path appends the first 300 access units (owner's own stream).
if STATS[0].load(Ordering::Relaxed)<=300 { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_H264") {
use std::io::Write; if let Ok(mut f)=std::fs::OpenOptions::new().create(true).append(true).open(path){let _=f.write_all(au);}
}}
match decoder.decode(au) {
Ok(frames)=>{for frame in frames {
sink.present(&frame)?;
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
}}
}Ok(())},
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Ok(())},
}
}
#[cfg(test)] mod tests {
use super::*;
struct Mock(bool);impl Decoder for Mock {fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3]}])}} fn reset(&mut self){self.0=false;}}
struct Sink(usize);impl FrameSink for Sink{fn present(&mut self,f:&Frame)->Result<(),String>{assert_eq!(f.rgb.len(),3);self.0+=1;Ok(())}}
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],&p).unwrap();assert_eq!(s.0,1);}
}
+94
View File
@@ -0,0 +1,94 @@
//! SDL scancodes are USB HID usages; translate physical keys, not typed text.
use serde_json::{json, Value};
use std::collections::{BTreeMap,BTreeSet};
pub fn windows_vk(scan: i32) -> Option<i32> {
Some(match scan {
4..=29 => 0x41 + scan - 4, 30..=38 => 0x31 + scan - 30, 39 => 0x30,
40=>0x0d,41=>0x1b,42=>8,43=>9,44=>0x20,
45=>0xbd,46=>0xbb,47=>0xdb,48=>0xdd,49=>0xdc,51=>0xba,52=>0xde,53=>0xc0,54=>0xbc,55=>0xbe,56=>0xbf,
57=>0x14,58..=69=>0x70+scan-58,70=>0x2c,71=>0x91,72=>0x13,
73=>0x2d,74=>0x24,75=>0x21,76=>0x2e,77=>0x23,78=>0x22,
79=>0x27,80=>0x25,81=>0x28,82=>0x26,83=>0x90,
84=>0x6f,85=>0x6a,86=>0x6d,87=>0x6b,88=>0x0d,
89..=97=>0x61+scan-89,98=>0x60,99=>0x6e,101=>0x5d,
104..=115=>0x7c+scan-104,
224=>0xa2,225=>0xa0,226=>0xa4,227=>0x5b,228=>0xa3,229=>0xa1,230=>0xa5,231=>0x5c,
_=>return None,
})
}
#[derive(Clone,Copy,Debug,PartialEq)]
pub struct Viewport { pub x:f64, pub y:f64, pub width:f64, pub height:f64 }
impl Viewport {
pub fn fit(window:(u32,u32), frame:(u32,u32))->Self {
let scale=(window.0 as f64 / frame.0.max(1) as f64).min(window.1 as f64 / frame.1.max(1) as f64);
let (w,h)=(frame.0 as f64*scale,frame.1 as f64*scale);
Self{x:(window.0 as f64-w)/2.,y:(window.1 as f64-h)/2.,width:w,height:h}
}
pub fn motion(self,x:f64,y:f64)->Option<Value> {
if self.width<=0. || self.height<=0. || !x.is_finite() || !y.is_finite() {return None}
Some(json!({"action":"mouse_move_absolute","abs_x":((x-self.x)/self.width).clamp(0.,1.),"abs_y":((y-self.y)/self.height).clamp(0.,1.)}))
}
}
#[derive(Default)]
pub struct Input { view_only:bool, keys:BTreeMap<i32,i32>, buttons:BTreeSet<i32> }
pub fn view_only(argument:Option<&str>,environment:Option<&str>)->Result<bool,String> {
match argument {None=>Ok(environment==Some("1")),Some("--view-only")=>Ok(true),_=>Err("Expected --view-only".into())}
}
impl Input {
pub fn new(view_only:bool)->Self {Self{view_only,..Default::default()}}
pub fn enabled(&self)->bool {!self.view_only}
pub fn key(&mut self,scan:i32,down:bool)->Option<Value> {
if self.view_only {return None}
let vk=windows_vk(scan)?;
let changed=if down {
if self.keys.contains_key(&scan) {return None}
let already=self.keys.values().any(|v|*v==vk);self.keys.insert(scan,vk);!already
}else{
if self.keys.remove(&scan).is_none(){return None}
!self.keys.values().any(|v|*v==vk)
};
changed.then(||json!({"action":if down{"kbd_press"}else{"kbd_release"},"key":vk}))
}
pub fn button(&mut self,button:i32,down:bool)->Option<Value> {
if self.view_only {return None}
if !matches!(button,1|2|4) {return None}
let changed=if down{self.buttons.insert(button)}else{self.buttons.remove(&button)};
changed.then(||json!({"action":if down{"mouse_press"}else{"mouse_release"},"button":button}))
}
pub fn release_all(&mut self)->Vec<Value> {
let mut out=Vec::new();
for key in std::mem::take(&mut self.keys).into_values().collect::<BTreeSet<_>>() {out.push(json!({"action":"kbd_release","key":key}));}
for button in std::mem::take(&mut self.buttons) {out.push(json!({"action":"mouse_release","button":button}));}
out
}
pub fn heartbeat()->Value {json!({"heartbeat":"kbd_heartbeat"})}
}
#[cfg(test)] mod tests {
use super::*;
#[test] fn watch_switch_is_explicit_and_validated(){
assert!(!view_only(None,None).unwrap());assert!(!view_only(None,Some("0")).unwrap());
assert!(view_only(None,Some("1")).unwrap());assert!(view_only(Some("--view-only"),Some("0")).unwrap());
assert!(view_only(Some("invalid"),None).is_err());
}
#[test] fn mappings_encoding_and_focus() {
for (scan,vk) in [(4,65),(29,90),(39,48),(58,112),(80,37),(224,162),(230,165),(52,222)] {assert_eq!(windows_vk(scan),Some(vk));}
assert_eq!(windows_vk(100),None);
let mut i=Input::default();assert_eq!(i.key(4,true).unwrap(),json!({"action":"kbd_press","key":65}));assert!(i.key(4,true).is_none());
i.key(225,true);i.button(2,true);let release=i.release_all();assert_eq!(release.len(),3);
assert!(release.iter().all(|v|v["action"].as_str().unwrap().ends_with("release")));
assert!(i.release_all().is_empty());
assert_eq!(Input::heartbeat(),json!({"heartbeat":"kbd_heartbeat"}));
}
#[test] fn aliased_physical_keys_release_only_after_last_keyup() {
let mut i=Input::default();assert!(i.key(40,true).is_some());assert!(i.key(88,true).is_none());
assert!(i.key(40,false).is_none());assert_eq!(i.key(88,false).unwrap(),json!({"action":"kbd_release","key":13}));
assert!(i.button(3,true).is_none());assert_eq!(i.button(4,true).unwrap()["button"],4);
}
#[test] fn letterbox() {
let v=Viewport::fit((1000,1000),(1920,1080));
assert_eq!(v.motion(500.,500.).unwrap()["abs_y"],0.5);
assert_eq!(v.motion(-10.,0.).unwrap()["abs_y"],0.0);
assert_eq!(v.motion(1010.,1000.).unwrap()["abs_x"],1.0);
assert!(v.motion(f64::NAN,0.).is_none());
}
}
+138
View File
@@ -0,0 +1,138 @@
//! Bounded RFC 6184 packetization-mode 1 receiver. No media contents in logs.
use std::{collections::VecDeque, sync::{Arc, Mutex}};
use std::time::{Duration,Instant};
const MAX_AU: usize = 8 * 1024 * 1024;
#[derive(Clone)]
pub struct Packet { pub seq: u16, pub timestamp: u32, pub marker: bool, pub payload: Vec<u8> }
#[derive(Default)]
pub struct Output { pub units: Vec<Vec<u8>>, pub pli: bool }
pub struct Receiver {
next: Option<u16>, pending: Vec<Packet>, timestamp: Option<u32>,
au: Vec<u8>, fragment: Option<u8>, damaged: bool, gap_since:Option<Instant>, last_packet:Instant,
}
impl Default for Receiver {
fn default() -> Self { Self { next: None, pending: Vec::new(), timestamp: None, au: Vec::new(), fragment: None, damaged: false, gap_since:None,last_packet:Instant::now() } }
}
impl Receiver {
pub fn push(&mut self, p: Packet) -> Output {
if p.payload.len()>65536 {return Output{units:Vec::new(),pli:true}}
let next = *self.next.get_or_insert(p.seq);
if p.seq.wrapping_sub(next) >= 32768 || self.pending.iter().any(|q| q.seq == p.seq) { return Output::default() }
self.last_packet=Instant::now();
self.pending.push(p);
let mut out = Output::default();
self.drain(&mut out);
if self.pending.len() >= 32 { self.skip_gap(&mut out); }
if self.pending.is_empty(){self.gap_since=None;}else{self.gap_since.get_or_insert(Instant::now());}
out
}
// A timer bounds latency even if the missing packet is the last packet sent.
pub fn expire(&mut self) -> Output {
self.expire_at(Instant::now())
}
fn expire_at(&mut self,now:Instant)->Output {
let mut out=Output::default();
if self.gap_since.is_some_and(|since|now.duration_since(since)>=Duration::from_millis(40)) && !self.pending.is_empty() {
self.skip_gap(&mut out);self.gap_since=if self.pending.is_empty(){None}else{Some(now)};
}
if !self.au.is_empty() && now.duration_since(self.last_packet)>=Duration::from_millis(200) {
self.au.clear();self.fragment=None;self.damaged=true;out.pli=true;
}
out
}
fn skip_gap(&mut self, out: &mut Output) {
let next = self.next.unwrap();
self.next = self.pending.iter().min_by_key(|p| p.seq.wrapping_sub(next)).map(|p| p.seq);
self.au.clear(); self.fragment = None; self.damaged = true; out.pli = true;
self.drain(out);
}
fn drain(&mut self, out: &mut Output) {
while let Some(i) = self.pending.iter().position(|p| Some(p.seq) == self.next) {
let p = self.pending.remove(i); self.next = Some(p.seq.wrapping_add(1));
if self.timestamp != Some(p.timestamp) {
// A timestamp transition without marker is an incomplete AU.
if !self.au.is_empty() || self.fragment.is_some() { out.pli = true; }
self.au.clear(); self.fragment = None; self.damaged = false; self.timestamp = Some(p.timestamp);
}
if !self.damaged && self.nal(&p.payload).is_err() { self.damaged = true; self.au.clear(); self.fragment = None; out.pli = true; }
if p.marker {
if self.fragment.is_some() { out.pli = true; self.damaged = true; }
if !self.damaged && !self.au.is_empty() { out.units.push(std::mem::take(&mut self.au)); }
self.au.clear(); self.fragment = None;
}
}
}
fn append(&mut self, bytes: &[u8]) -> Result<(), ()> {
if self.au.len() + bytes.len() > MAX_AU { return Err(()) }
self.au.extend_from_slice(bytes); Ok(())
}
fn nal(&mut self, p: &[u8]) -> Result<(), ()> {
let h = *p.first().ok_or(())?;
if h & 0x80 != 0 { return Err(()) }
match h & 31 {
1..=23 if self.fragment.is_none() => { self.append(&[0,0,0,1])?; self.append(p) }
24 if self.fragment.is_none() => {
let mut rest = &p[1..]; if rest.is_empty() { return Err(()) }
while !rest.is_empty() {
if rest.len() < 2 { return Err(()) }
let n = u16::from_be_bytes([rest[0], rest[1]]) as usize; rest = &rest[2..];
if n == 0 || rest.len() < n || rest[0] & 0x80 != 0 || !(1..=23).contains(&(rest[0] & 31)) { return Err(()) }
self.append(&[0,0,0,1])?; self.append(&rest[..n])?; rest = &rest[n..];
} Ok(())
}
28 if p.len() > 2 => {
let f = p[1]; let kind = f & 31; let start = f & 128 != 0; let end = f & 64 != 0;
if f & 32 != 0 || kind == 0 || kind > 23 || (start && end) { return Err(()) }
let header = (h & 0xe0) | kind;
if start {
if self.fragment.is_some() { return Err(()) }
self.append(&[0,0,0,1,header])?; self.fragment = Some(header);
} else if self.fragment != Some(header) { return Err(()) }
self.append(&p[2..])?;
if end { self.fragment = None; } Ok(())
}
_ => Err(()),
}
}
}
/// Drop the oldest item on overflow; never block the RTP reader on a decoder/UI.
pub struct Latest<T>(Arc<Mutex<VecDeque<T>>>, usize);
impl<T> Clone for Latest<T> { fn clone(&self) -> Self { Self(self.0.clone(), self.1) } }
impl<T> Latest<T> {
pub fn new(capacity: usize) -> Self { assert!(capacity > 0); Self(Arc::new(Mutex::new(VecDeque::new())), capacity) }
pub fn push(&self, value: T) -> bool { let mut q = self.0.lock().unwrap(); let dropped = q.len() == self.1; if dropped { q.pop_front(); } q.push_back(value); dropped }
pub fn pop(&self) -> Option<T> { self.0.lock().unwrap().pop_front() }
}
#[cfg(test)]
mod tests {
use super::*;
fn p(seq:u16, ts:u32, marker:bool, payload:&[u8])->Packet { Packet{seq,timestamp:ts,marker,payload:payload.into()} }
#[test] fn single_stap_and_boundary() {
let mut r=Receiver::default();
assert!(r.push(p(1,1,false,&[0x67,1])).units.is_empty());
assert_eq!(r.push(p(2,1,true,&[24,0,2,0x68,2,0,2,0x65,3])).units[0],vec![0,0,0,1,0x67,1,0,0,0,1,0x68,2,0,0,0,1,0x65,3]);
r.push(p(3,2,false,&[0x61,1]));
let o=r.push(p(4,3,true,&[0x65,4])); assert!(o.pli); assert_eq!(o.units.len(),1);
}
#[test] fn fu_reorder_wrap_duplicate_and_loss() {
let mut r=Receiver::default(); r.push(p(65535,1,false,&[0x7c,0x85,1]));
assert!(r.push(p(1,1,true,&[0x7c,0x45,3])).units.is_empty());
let o=r.push(p(0,1,false,&[0x7c,5,2])); assert_eq!(o.units[0],vec![0,0,0,1,0x65,1,2,3]);
assert!(r.push(p(0,1,false,&[0x61])).units.is_empty());
r.push(p(2,2,false,&[0x7c,0x85,1]));r.push(p(4,2,true,&[0x7c,0x45,3]));
let o=r.expire_at(Instant::now()+Duration::from_millis(50));assert!(o.pli);assert!(o.units.is_empty());
assert_eq!(r.push(p(5,3,true,&[0x65])).units.len(),1);
}
#[test] fn missing_tail_and_reorder_window_are_bounded() {
let mut r=Receiver::default();r.push(p(0,1,false,&[0x7c,0x85,1]));
assert!(!r.expire().pli);assert!(r.expire_at(Instant::now()+Duration::from_millis(201)).pli);
let mut pli=false;for seq in 2..34{pli|=r.push(p(seq,seq as u32,true,&[0x65])).pli;}
assert!(pli);assert!(r.pending.len()<32);
}
#[test] fn malformed_and_bounded() {
for bytes in [vec![],vec![24,0,4,0x65],vec![0x7c,0xc5,1],vec![0xff]] {
assert!(Receiver::default().push(p(1,1,true,&bytes)).pli);
}
let q=Latest::new(2);assert!(!q.push(1));q.push(2);assert!(q.push(3));assert_eq!(q.pop(),Some(2));assert_eq!(q.pop(),Some(3));
}
}
+37
View File
@@ -0,0 +1,37 @@
//! Opt-in controller session; independent of the host room and peer lifecycle.
pub mod api;
pub mod assist;
pub mod wire;
pub mod signal;
pub mod rtc;
pub mod session;
#[cfg(test)] mod tests;
pub mod media;
pub mod audio;
pub mod input;
pub mod desktop;
#[cfg(feature="viewer-ffmpeg")] pub mod decoder;
#[cfg(feature="viewer-sdl")] pub mod decoder_cli;
#[cfg(uu_gtk)] pub mod ui;
#[cfg(uu_gtk)] pub mod tools_ui;
#[cfg(feature="viewer-sdl")] pub mod sdl;
pub mod tools;
pub mod clipboard;
pub mod power;
fn device_label(name:Option<&str>)->&str{
name.filter(|name|!name.is_empty()).unwrap_or("远端设备")
}
#[cfg(test)]
mod device_label_tests {
#[test]
fn device_name_or_fallback(){
assert_eq!(super::device_label(Some("测试电脑")),"测试电脑");
assert_eq!(super::device_label(None),"远端设备");
assert_eq!(super::device_label(Some("")),"远端设备");
}
}
+70
View File
@@ -0,0 +1,70 @@
//! SimpleAction numbers are from src/system_actions.rs (REBOOT_SYSTEM / SHUTDOWN_SYSTEM).
use super::{session::Session,wire};
use std::{sync::atomic::Ordering,time::Duration};
#[derive(Clone,Copy,Debug,PartialEq)]
pub enum Action {Reboot,Shutdown}
impl Action {
pub fn parse(value:&str)->Result<Self,String>{match value{"reboot"=>Ok(Self::Reboot),"shutdown"=>Ok(Self::Shutdown),_=>Err("Power action must be reboot or shutdown".into())}}
pub fn message(self,seq:u64)->Vec<u8>{
let mut action=Vec::new();wire::int(1,match self{Self::Reboot=>9,Self::Shutdown=>12},&mut action);
wire::envelope(seq,3,&action)
}
}
pub async fn run(session:&mut Session,action:Action)->Result<(),String>{
let channel=session.peer.channels[0].clone();
let ready=async{
loop {
if session.peer.observed.control_open.load(Ordering::Acquire) && session.peer.observed.echo_received.load(Ordering::Acquire){return Ok::<_,String>(())}
tokio::select!{r=session.step()=>r?,_=tokio::time::sleep(Duration::from_millis(20))=>{}}
}
};
let send=async move {
tokio::time::timeout(Duration::from_secs(5),channel.send(&bytes::Bytes::from(action.message(2))))
.await.map_err(|_|"Power command send timed out")?.map_err(|_|"Power command send failed")?;
// Drain SCTP locally before closing; this is not a remote execution acknowledgement.
let drain=async{while channel.buffered_amount().await>0 {tokio::time::sleep(Duration::from_millis(20)).await;}};
tokio::time::timeout(Duration::from_secs(2),drain).await.map_err(|_|"Power command drain timed out")?;
tokio::time::sleep(Duration::from_millis(200)).await;Ok(())
};
after_echo(ready,send,Duration::from_secs(30)).await
}
async fn after_echo(ready:impl std::future::Future<Output=Result<(),String>>,send:impl std::future::Future<Output=Result<(),String>>,timeout:Duration)->Result<(),String>{
tokio::time::timeout(timeout,ready).await.map_err(|_|"CONTROL echo timed out")??;
send.await
}
#[cfg(test)] mod tests {
use super::*;
use crate::protocol::{decode_wire,WireValue};
#[test] fn only_host_evidenced_actions_are_encoded(){
for (name,number) in [("reboot",9),("shutdown",12)]{
let bytes=Action::parse(name).unwrap().message(2);let fields=decode_wire(&bytes).unwrap();
let WireValue::Bytes(body)=fields.iter().find(|f|f.number==3).unwrap().value else{panic!()};
assert_eq!(decode_wire(body).unwrap()[0].value,WireValue::Varint(number));
let host=include_str!("../system_actions.rs");
assert!(host.contains(&format!("pub const {}_SYSTEM: u64 = {number};",name.to_uppercase())));
}
for value in ["logout","wol","9",""]{assert!(Action::parse(value).is_err());}
}
#[tokio::test] async fn waits_for_echo_and_sends_once_without_retrying_failure(){
use std::sync::{Arc,atomic::AtomicUsize};
for fail in [false,true]{
let calls=Arc::new(AtomicUsize::new(0));let recorded=calls.clone();
let(tx,rx)=tokio::sync::oneshot::channel();
let operation=tokio::spawn(after_echo(async{rx.await.map_err(|_|"closed".into())},async move{
recorded.fetch_add(1,Ordering::Relaxed);if fail{Err("send failed".into())}else{Ok(())}
},Duration::from_secs(1)));
tokio::task::yield_now().await;assert_eq!(calls.load(Ordering::Relaxed),0);
tx.send(()).unwrap();assert_eq!(operation.await.unwrap().is_err(),fail);
assert_eq!(calls.load(Ordering::Relaxed),1);
}
}
#[tokio::test] async fn failed_or_missing_echo_never_sends(){
for failed in [false,true]{
let called=std::sync::atomic::AtomicBool::new(false);
let result=after_echo(async{if failed{return Err("connection closed".into())}std::future::pending().await},async{called.store(true,Ordering::Relaxed);Ok(())},Duration::from_millis(5)).await;
assert!(result.is_err());assert!(!called.load(Ordering::Relaxed));
}
}
}
+315
View File
@@ -0,0 +1,315 @@
use super::wire::{self, Shape, CHANNELS};
use serde_json::{json, Value};
use std::sync::{Arc,atomic::{AtomicBool,AtomicU64,Ordering}};
use tokio::sync::mpsc;
use webrtc::{api::{APIBuilder,media_engine::MediaEngine,setting_engine::SettingEngine}, peer_connection::{RTCPeerConnection,configuration::RTCConfiguration,sdp::session_description::RTCSessionDescription,policy::ice_transport_policy::RTCIceTransportPolicy}, ice_transport::{ice_server::RTCIceServer,ice_candidate::RTCIceCandidateInit}, data_channel::{RTCDataChannel,data_channel_init::RTCDataChannelInit}, rtp_transceiver::{rtp_codec::RTPCodecType,rtp_transceiver_direction::RTCRtpTransceiverDirection,RTCRtpTransceiverInit}};
pub fn configuration(result:&Value)->Result<RTCConfiguration,String> {
let list=result.get("iceServers").and_then(Value::as_array).ok_or("Control acknowledgement missing iceServers")?;
let mut servers=Vec::new();
for server in list {
let urls=match server.get("urls") {
Some(Value::String(s))=>vec![s.clone()],
Some(Value::Array(a))=>a.iter().map(|v|v.as_str().map(str::to_owned).ok_or("Invalid ICE URL")).collect::<Result<Vec<_>,_>>()?,
_=>return Err("Invalid ICE URLs".into()),
};
if urls.is_empty() || urls.iter().any(|u| !["stun:","stuns:","turn:","turns:"].iter().any(|p|u.starts_with(p))) {return Err("Invalid ICE URL scheme".into())}
let string=|key|match server.get(key) {Some(Value::String(s))=>Ok(s.clone()),None=>Ok(String::new()),_=>Err("Invalid ICE authentication")};
// webrtc-rs rejects TURN unless the credential type is Password (as in the host's session_ice.rs).
servers.push(RTCIceServer { urls,username:string("username")?,credential:string("credential")?,
credential_type:webrtc::ice_transport::ice_credential_type::RTCIceCredentialType::Password });
}
let relay=match result.get("force_relay") {None=>false,Some(Value::Bool(b))=>*b,_=>return Err("Invalid relay policy".into())};
if relay && !servers.iter().any(|s|s.urls.iter().any(|u|u.starts_with("turn:")||u.starts_with("turns:"))) {return Err("Relay-only session without TURN".into())}
// An empty cloud list means host candidates only. Never invent public STUN.
Ok(RTCConfiguration{ice_servers:servers,ice_transport_policy:if relay{RTCIceTransportPolicy::Relay}else{RTCIceTransportPolicy::All},..Default::default()})
}
#[derive(Clone,Copy)]
pub enum ReadyPolicy { EchoOnly, Explicit }
#[derive(Default)]
pub struct Observed {
pub control_open:AtomicBool,
pub echo_received:AtomicBool,
pub clipboard_supported:AtomicBool,
pub control_messages:AtomicU64,
pub other_messages:AtomicU64,
pub media_packets:AtomicU64,
}
pub struct Peer {
clipboard:super::clipboard::Bridge,
pub tools:super::tools::Inbox,
pub pc:Arc<RTCPeerConnection>,
pub channels:Vec<Arc<RTCDataChannel>>,
pub observed:Arc<Observed>,
pub desktop:super::desktop::Desktop,
pub audio:super::audio::Audio,
answered:bool,
early:Vec<RTCIceCandidateInit>,
app_id:String,
ice_id:String,
remote_client:String,
}
impl Peer {
pub async fn new(config:RTCConfiguration, shape:&Shape, app_id:&str, ice_id:&str, remote_client:&str, outbound:mpsc::Sender<Value>, settings:SettingEngine)->Result<Self,String> {
shape.validate_session()?;
let mut engine=MediaEngine::default();
use webrtc::rtp_transceiver::rtp_codec::{RTCRtpCodecParameters,RTCRtpCodecCapability};
for (kind,mime,rate,channels,fmtp,payload) in [
(RTPCodecType::Video,"video/H264",90000,0,"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",102),
(RTPCodecType::Audio,"audio/opus",48000,2,"minptime=10;useinbandfec=1",111),
] {
engine.register_codec(RTCRtpCodecParameters{capability:RTCRtpCodecCapability{mime_type:mime.into(),clock_rate:rate,channels,sdp_fmtp_line:fmtp.into(),..Default::default()},payload_type:payload,..Default::default()},kind).map_err(|_|"Codec initialization failed")?;
}
// UU RTP metadata the official Mac viewer offers (src/rtp_metadata.rs on the host side).
for uri in ["http://www.webrtc.org/experiments/rtp-hdrext/video-capture-index","http://www.webrtc.org/experiments/rtp-hdrext/video-frame-is-new-frame"] {
engine.register_header_extension(webrtc::rtp_transceiver::rtp_codec::RTCRtpHeaderExtensionCapability{uri:uri.into()},RTPCodecType::Video,None).map_err(|_|"RTP header extension registration failed")?;
}
let registry=webrtc::api::interceptor_registry::register_default_interceptors(webrtc::interceptor::registry::Registry::new(),&mut engine).map_err(|_|"RTP interceptor initialization failed")?;
let api=APIBuilder::new().with_media_engine(engine).with_setting_engine(settings).with_interceptor_registry(registry).build();
let pc=Arc::new(api.new_peer_connection(config).await.map_err(|e|format!("Peer creation failed: {}",crate::auth::transport_error(&e)))?);
let tools:super::tools::Inbox=Arc::new(std::sync::Mutex::new(None));
let inbox=tools.clone();
pc.on_peer_connection_state_change(Box::new(move |state|{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
log::info!("Viewer peer connection state: {state}");
if matches!(state,RTCPeerConnectionState::Failed|RTCPeerConnectionState::Closed){inbox.lock().unwrap().take();}
Box::pin(async{})
}));
let observed=Arc::new(Observed::default());
let (app,ice,client)=(app_id.to_owned(),ice_id.to_owned(),remote_client.to_owned());
let weak_pc=Arc::downgrade(&pc);
pc.on_ice_candidate(Box::new(move |candidate| {
let weak_pc=weak_pc.clone();let tx=outbound.clone();let(app,ice,client)=(app.clone(),ice.clone(),client.clone());
Box::pin(async move {if let Some(candidate)=candidate {if let Ok(mut value)=candidate.to_json() {
// Candidate callbacks can omit MID. Bind to the first actual bundled m-line.
if let Some(pc)=weak_pc.upgrade() {
if let Some(local)=pc.local_description().await {
if let Some(mid)=local.sdp.lines().find_map(|line|line.strip_prefix("a=mid:")) {
value.sdp_mid=Some(mid.trim().into());value.sdp_mline_index=Some(0);
}
}
}
let _=tx.send(json!({"client_id":client,"data":{"type":"candidate","candidate":value,"ice_id":ice,"app_control_id":app}})).await;
}}})
}));
let counters=observed.clone();
let desktop=super::desktop::Desktop::default();
let audio=super::audio::Audio::default();let sound=audio.clone();
let receiver=desktop.clone();let weak_pc=Arc::downgrade(&pc);
pc.on_track(Box::new(move |track,_,_| {
let counters=counters.clone();let desktop=receiver.clone();let audio=sound.clone();let weak_pc=weak_pc.clone();
// The handler must return: webrtc-rs awaits it before surfacing the next track,
// so an inline read loop on the audio track starved the video track.
Box::pin(async move { tokio::spawn(async move {
let video=track.kind()==RTPCodecType::Video;
log::info!("Viewer track: kind={} mime={} payload_type={}",track.kind(),track.codec().capability.mime_type,track.payload_type());
let opus=track.kind()==RTPCodecType::Audio && track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus");
if video && !track.codec().capability.mime_type.eq_ignore_ascii_case("video/H264") {return}
if video {desktop.ssrc.store(track.ssrc(),Ordering::Release);}
let mut receiver=super::media::Receiver::default();
let mut tick=tokio::time::interval(std::time::Duration::from_millis(40));
let mut last_pli=std::time::Instant::now()-std::time::Duration::from_secs(1);
loop {
let output=tokio::select! {
packet=track.read_rtp()=>match packet {
Ok((p,_))=>{
counters.media_packets.fetch_add(1,Ordering::Relaxed);
if !video {if opus {audio.push(p.header.sequence_number,&p.payload);}continue}
receiver.push(super::media::Packet{seq:p.header.sequence_number,timestamp:p.header.timestamp,marker:p.header.marker,payload:p.payload.to_vec()})
},
Err(_)=>break,
},
_=tick.tick()=>{if !video {continue} receiver.expire()},
};
if output.pli {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}
for au in output.units {if desktop.units.push(au) {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}}
if desktop.pli.load(Ordering::Acquire) && last_pli.elapsed()>=std::time::Duration::from_millis(250) {
desktop.pli.swap(false,Ordering::AcqRel);
if let Some(pc)=weak_pc.upgrade() {
use webrtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication;
let _=pc.write_rtcp(&[Box::new(PictureLossIndication{sender_ssrc:0,media_ssrc:track.ssrc()})]).await;
} else {break}
last_pli=std::time::Instant::now();
}
}
}); })
}));
let result=async {
if shape.capture_type==1 {
// The official Mac viewer offers five recvonly video sections (observed live).
let videos=std::env::var("UU_VIEWER_VIDEO_SECTIONS").ok().and_then(|v|v.parse::<usize>().ok()).filter(|n|(1..=8).contains(n)).unwrap_or(1);
for kind in std::iter::repeat(RTPCodecType::Video).take(videos).chain([RTPCodecType::Audio]) {
pc.add_transceiver_from_kind(kind,Some(RTCRtpTransceiverInit{direction:RTCRtpTransceiverDirection::Recvonly,send_encodings:vec![]})).await.map_err(|_|"Media transceiver failed")?;
}
}
let mut channels=Vec::new();
let mut clipboard=super::clipboard::Bridge::new(shape.capture_type==1);
let clipboard_enabled=clipboard.enabled;
// Diagnostic: hosts may open their own channels; log the label and message count only.
pc.on_data_channel(Box::new(|channel|Box::pin(async move {
let label=channel.label().to_owned();log::info!("Viewer remote data channel opened: label={label}");
let count=Arc::new(std::sync::atomic::AtomicU64::new(0));
channel.on_message(Box::new(move |m|{let n=count.fetch_add(1,Ordering::Relaxed);if n<8 {log::info!("Viewer remote channel message: label={label} bytes={} fields={:?}",m.data.len(),crate::protocol::decode_wire(&m.data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}Box::pin(async{})}));
})));
for label in CHANNELS {
channels.push(pc.create_data_channel(label,Some(RTCDataChannelInit{ordered:Some(true),..Default::default()})).await.map_err(|_|"Data channel creation failed")?);
}
// Native host TEXT offers are RPC 21/case 9; CONTROL replies hit a separate empty State.
// Keep clipboard offers/replies on TEXT, where the host desktop bridge lives.
clipboard.start(&channels[super::clipboard::CHANNEL],&channels[0],observed.clone());
for (index,channel) in channels.iter().enumerate() {
if index==0 {
let weak=Arc::downgrade(&channel);let state=observed.clone();
channel.on_open(Box::new(move ||Box::pin(async move {
state.control_open.store(true,Ordering::Release);
if let Some(channel)=weak.upgrade(){let _=channel.send(&bytes::Bytes::from(wire::echo_request_with_clipboard(1,clipboard_enabled))).await;}
})));
}
let closed=tools.clone();let state=observed.clone();
channel.on_close(Box::new(move ||{let closed=closed.clone();let state=state.clone();Box::pin(async move {
if index==0 {state.control_open.store(false,Ordering::Release);}
if [0,3,4].contains(&index){closed.lock().unwrap().take();}
})}));
let state=observed.clone();let inbox=tools.clone();let clipboard_tx=clipboard.sender();
let control_for_echo=if index==0 {Arc::downgrade(&channel)} else {std::sync::Weak::new()};
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();Box::pin(async move {
if index==0 {
let count=state.control_messages.fetch_add(1,Ordering::Relaxed);
if wire::echo_matches(&message.data,1) {state.clipboard_supported.store(wire::echo_clipboard_supported(&message.data),Ordering::Release);state.echo_received.store(true,Ordering::Release);}
if let Some(request)=wire::echo_request_seq(&message.data) {
if let Some(control)=control_for_echo.upgrade() {let _=control.send(&bytes::Bytes::from(wire::echo_response_with_clipboard(1_000_000+request,request,clipboard_enabled))).await;}
}
// Observe only protobuf field numbers; never print channel payloads.
if count<32 {if let Ok(fields)=crate::protocol::decode_wire(&message.data) {let action=fields.iter().find_map(|f|match(f.number,&f.value){(3,crate::protocol::WireValue::Bytes(b))=>Some(super::tools::uint(b,1)),_=>None});
log::info!("Viewer CONTROL fields={:?} simple_action={:?}",fields.iter().take(32).map(|f|f.number).collect::<Vec<_>>(),action);}}
}
if [0,1].contains(&index) && message.data.len()<=super::clipboard::MAX_TEXT*2+1024 {
if let Some(tx)=clipboard_tx {
if crate::protocol::decode_wire(&message.data).is_ok_and(|f|f.iter().any(|f|[17,21,22].contains(&f.number))){let _=tx.try_send(message.data.to_vec());}
}
}
// Tools need FILE/BINARY traffic and CONTROL RPC replies (Message 22) only. Official
// hosts stream many other CONTROL messages; a full queue drops that message instead of
// detaching the tool, which previously lost every later reply.
if index!=0 {let n=state.other_messages.fetch_add(1,Ordering::Relaxed);if n<8 {
// Shape only: protobuf field numbers or JSON keys, never values.
let shape=match serde_json::from_slice::<serde_json::Value>(&message.data){Ok(serde_json::Value::Object(o))=>format!("json{:?}",o.keys().collect::<Vec<_>>()),
_=>format!("pb{:?}",crate::protocol::decode_wire(&message.data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default())};
let inner=crate::protocol::decode_wire(&message.data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{crate::protocol::WireValue::Bytes(b) if x.number>2=>Some((x.number,crate::protocol::decode_wire(b).map(|g|g.iter().map(|y|y.number).collect::<Vec<_>>()).unwrap_or_default())),_=>None}));
log::info!("Viewer channel message: index={index} bytes={} shape={shape} inner={inner:?}",message.data.len());}}
// The official Windows host answers file RPCs (Message 21/22) on TEXT_DATA_CHANNEL (observed
// on SHARE: a 320-byte Message 22 on index 1); our host uses FILE. Treat both as the file channel.
let has=|n:&[u32]|crate::protocol::decode_wire(&message.data).is_ok_and(|f|f.iter().any(|x|n.contains(&x.number)));
let route=if index==1 && has(&[21,22,27]) {3} else {index};
// CONTROL carries host-initiated file RPCs (Message 21 with ftp case 8) during downloads too.
let route=if index==0 && crate::protocol::decode_wire(&message.data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{crate::protocol::WireValue::Bytes(b) if x.number==21=>Some(super::tools::blob(b,8).is_some()),_=>None}))==Some(true) {3} else {route};
let wanted=index==3 || index==4 || route==3 || (index==0 && has(&[22]));
let sender=inbox.lock().unwrap().clone();
if let (true,Some(sender))=(wanted,sender) {
if let Err(tokio::sync::mpsc::error::TrySendError::Closed(_))=sender.try_send((route,message.data.to_vec())) {
let mut slot=inbox.lock().unwrap();if slot.as_ref().is_some_and(|s|s.same_channel(&sender)){slot.take();}
}
}
})}));
}
Ok::<_,String>((channels,tools,clipboard))
}.await;
match result {
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
Err(e)=>{let _=pc.close().await;Err(e)},
}
}
pub async fn offer(&self)->Result<Value,String> {
let offer=self.pc.create_offer(None).await.map_err(|_|"Create offer failed")?;
let mut sdp=offer.sdp.clone();self.pc.set_local_description(offer).await.map_err(|_|"Set local offer failed")?;
// The official Mac viewer's offer carries a bare session-level a=x-uuremote-quic. Only the sent
// copy is changed: webrtc-rs rejects a modified local description.
if !sdp.contains("a=x-uuremote-quic") { if let Some(i)=sdp.find("a=group:BUNDLE") { sdp.insert_str(i,"a=x-uuremote-quic\r\n"); } }
// webrtc-rs omits a=max-message-size, so the host assumes 64 KB and drops larger replies (a 5600-entry
// directory listing compresses to ~73 KB). Advertise libwebrtc's 256 KB like the host does; the
// vendored data channel already accepts messages of that size.
sdp=with_max_message_size(&sdp);
// Local diagnostic: UU_VIEWER_DUMP_OFFER=path writes the sent offer SDP (stays on the operator's machine).
if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_OFFER") {let _=std::fs::write(path,&sdp);}
// ice_network_type=3 as sent by the official Mac viewer (observed on our host's SOAC shape log).
Ok(json!({"client_id":self.remote_client,"data":{"type":"offer","sdp":sdp,"ice_id":self.ice_id,"app_control_id":self.app_id,"ice_network_type":3}}))
}
pub async fn receive(&mut self,event:&Value)->Result<(),String> {
let body=event.get("data").unwrap_or(event);
if !self.matches_route(event) {return Ok(())}
match body.get("type").and_then(Value::as_str) {
Some("answer")=> {
if self.answered {return Ok(())}
let sdp=answer_sdp(body)?;
let answer=RTCSessionDescription::answer(sdp).map_err(|_|"Invalid answer")?;
self.pc.set_remote_description(answer).await.map_err(|_|"Set remote answer failed")?;
self.answered=true;
for c in self.early.drain(..) {self.pc.add_ice_candidate(c).await.map_err(|_|"Queued ICE candidate failed")?;}
}
Some("candidate")=> {
let value=body.get("candidate").ok_or("Missing candidate")?;
let candidate=if let Some(s)=value.as_str() {
RTCIceCandidateInit {candidate:s.into(),sdp_mid:body.get("sdp_mid").and_then(Value::as_str).map(str::to_owned),sdp_mline_index:body.get("sdp_mline_index").and_then(Value::as_u64).and_then(|v|u16::try_from(v).ok()),..Default::default()}
} else {serde_json::from_value(value.clone()).map_err(|_|"Invalid candidate")?};
if self.answered {self.pc.add_ice_candidate(candidate).await.map_err(|_|"ICE candidate failed")?;}
else {if self.early.len()>=256{return Err("Too many early ICE candidates".into())}self.early.push(candidate);}
}
_=>{},
}
Ok(())
}
pub fn matches_route(&self,event:&Value)->bool {
let body=event.get("data").unwrap_or(event);
!body.get("ice_id").is_some_and(|v|v.as_str()!=Some(self.ice_id.as_str()))
&& !body.get("app_control_id").is_some_and(|v|v.as_str()!=Some(self.app_id.as_str()))
&& !event.get("client_id").is_some_and(|v|v.as_str()!=Some(self.remote_client.as_str()))
}
pub fn ready(&self,policy:ReadyPolicy,explicit:bool)->bool {
self.observed.echo_received.load(Ordering::Acquire) && match policy {ReadyPolicy::EchoOnly=>true,ReadyPolicy::Explicit=>explicit}
}
pub async fn send_input(&self,value:&Value)->Result<(),String> {
let channel=&self.channels[0];
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {return Err("CONTROL is not open".into())}
channel.send(&bytes::Bytes::from(value.to_string())).await.map_err(|_|"CONTROL input send failed")?;Ok(())
}
pub async fn close(&self) {self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
}
fn answer_sdp(body:&Value)->Result<String,String> {
if let Some(s)=body.get("sdp").and_then(Value::as_str) {if s.len()<=1024*1024{return Ok(s.into())}}
if let Some(s)=body.get("gzip_sdp").and_then(Value::as_str) {
use base64::Engine;use std::io::Read;
if s.len()>2*1024*1024 {return Err("Compressed answer too large".into())}
let data=base64::engine::general_purpose::STANDARD.decode(s).map_err(|_|"Invalid compressed answer")?;
let mut output=String::new();flate2::read::GzDecoder::new(data.as_slice()).take(1024*1024+1).read_to_string(&mut output).map_err(|_|"Invalid compressed answer")?;
if output.len()<=1024*1024 {return Ok(output)}
}
Err("Answer missing or too large".into())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn compressed_answers_are_supported_and_bounded() {
use base64::Engine;use std::io::Write;
let mut encoder=flate2::write::GzEncoder::new(Vec::new(),flate2::Compression::default());
encoder.write_all(b"synthetic-sdp").unwrap();
let encoded=base64::engine::general_purpose::STANDARD.encode(encoder.finish().unwrap());
assert_eq!(answer_sdp(&json!({"gzip_sdp":encoded})).unwrap(),"synthetic-sdp");
assert!(answer_sdp(&json!({"gzip_sdp":"invalid!"})).is_err());
assert!(answer_sdp(&json!({"sdp":"x".repeat(1024*1024+1)})).is_err());
}
}
/// Adds `a=max-message-size:262144` after `a=sctp-port` when missing (sent copy only).
pub fn with_max_message_size(sdp:&str)->String{
if sdp.contains("a=max-message-size:"){return sdp.to_owned()}
let eol=if sdp.contains("\r\n"){"\r\n"}else{"\n"};
let mut out=String::with_capacity(sdp.len()+32);
for line in sdp.split_inclusive('\n'){out.push_str(line);if line.trim_end().starts_with("a=sctp-port:"){out.push_str("a=max-message-size:262144");out.push_str(eol);}}
out
}
#[cfg(test)] #[test] fn offer_advertises_max_message_size(){
assert_eq!(with_max_message_size("m=application 9\r\na=sctp-port:5000\r\na=mid:0\r\n"),"m=application 9\r\na=sctp-port:5000\r\na=max-message-size:262144\r\na=mid:0\r\n");
assert_eq!(with_max_message_size("a=max-message-size:1\r\n"),"a=max-message-size:1\r\n");
}
+156
View File
@@ -0,0 +1,156 @@
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool }
impl Window {
pub fn new()->Result<Self,String>{
let sdl=sdl2::init()?;let video=sdl.video()?;
let window=video.window("Native viewer (experimental)",1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
let canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
let events=sdl.event_pump()?;Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false})
}
fn viewport(&self)->Viewport {Viewport::fit(self.canvas.window().size(),self.frame)}
pub fn poll(&mut self,input:&mut Input)->(bool,Vec<serde_json::Value>){
let viewport=self.viewport();
translate_actions(self.events.poll_iter(),input,viewport,&mut self.focused,&mut self.files)
}
}
fn translate(events:impl IntoIterator<Item=Event>,input:&mut Input,viewport:Viewport,focused:&mut bool)->(bool,Vec<serde_json::Value>){
translate_actions(events,input,viewport,focused,&mut false)
}
fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewport:Viewport,focused:&mut bool,files:&mut bool)->(bool,Vec<serde_json::Value>){
let mut messages=Vec::new();let mut quit=false;
for event in events{
let message=match event {
Event::Quit{..}|Event::Window{win_event:WindowEvent::Close,..}=>{quit=true;messages.extend(input.release_all());None},
Event::Window{win_event:WindowEvent::FocusLost,..}=>{*focused=false;messages.extend(input.release_all());None},
Event::Window{win_event:WindowEvent::FocusGained,..}=>{*focused=true;None},
Event::KeyDown{scancode:Some(sdl2::keyboard::Scancode::F),keymod,repeat,..}
if *focused && keymod.intersects(sdl2::keyboard::Mod::LCTRLMOD|sdl2::keyboard::Mod::RCTRLMOD)
&& keymod.intersects(sdl2::keyboard::Mod::LALTMOD|sdl2::keyboard::Mod::RALTMOD)=>{
if !repeat{*files=true;messages.extend(input.release_all());}None
},
_ if !*focused || !input.enabled()=>None,
Event::KeyDown{scancode:Some(s),repeat:false,..}=>input.key(s as i32,true),
Event::KeyUp{scancode:Some(s),..}=>input.key(s as i32,false),
Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64),
Event::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)),
Event::MouseButtonUp{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,false)),
_=>None,
};if let Some(m)=message{messages.push(m);}
} (quit,messages)
}
fn button(b:MouseButton)->Option<i32>{match b{MouseButton::Left=>Some(1),MouseButton::Right=>Some(2),MouseButton::Middle=>Some(4),_=>None}}
impl FrameSink for Window {
fn present(&mut self,frame:&Frame)->Result<(),String>{
self.frame=(frame.width,frame.height);let v=self.viewport();let creator=self.canvas.texture_creator();
let mut texture=creator.create_texture_streaming(PixelFormatEnum::RGB24,frame.width,frame.height).map_err(|_|"Texture creation failed")?;
texture.update(None,&frame.rgb,frame.width as usize*3).map_err(|_|"Texture update failed")?;
self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear();
self.canvas.copy(&texture,None,Some(Rect::new(v.x as i32,v.y as i32,v.width as u32,v.height as u32)))?;self.canvas.present();Ok(())
}
}
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool)->Result<(),String>{
#[cfg(uu_gtk)]
let mut files:Option<tokio::task::JoinHandle<Result<(),String>>>=None;
let(tx,mut commands)=tokio::sync::mpsc::channel(8);
if std::env::var("UU_VIEWER_COMMANDS").as_deref()==Ok("1") {
std::thread::spawn(move||{
use std::io::Read;
let mut input=std::io::stdin().lock();let mut line=Vec::new();let mut byte=[0];
while input.read(&mut byte).ok()==Some(1){
if byte[0]==b'\n'{if line==b"files" && tx.blocking_send(()).is_err(){break}line.clear();}
else if line.len()<32{line.push(byte[0]);}else{break}
}
});
}else{drop(tx);}
let mut command_open=true;let mut requested=false;
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
let mut audio=super::audio::Playback::new(&window._sdl,session.peer.audio.clone());
let mut input=Input::new(view_only);let mut tick=tokio::time::interval(std::time::Duration::from_millis(8));
let mut heartbeat=tokio::time::interval(std::time::Duration::from_secs(1));
let deadline=tokio::time::sleep(std::time::Duration::from_secs(30));tokio::pin!(deadline);
let result=async {
loop {tokio::select!{
command=commands.recv(),if command_open=>{if command.is_some(){requested=true}else{command_open=false}},
_=terminate.recv()=>return Ok(()),
_=tokio::signal::ctrl_c()=>return Ok(()),
result=session.step()=>result?,
_=&mut deadline,if !session.peer.observed.echo_received.load(std::sync::atomic::Ordering::Acquire)=>return Err("CONTROL echo timed out".into()),
_=heartbeat.tick()=>{
if input.enabled() && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){session.peer.send_input(&Input::heartbeat()).await?;}
let o=&session.peer.observed;let s=&super::desktop::STATS;let r=std::sync::atomic::Ordering::Relaxed;
log::info!("Viewer desktop stats: control_open={} echo={} media_packets={} access_units={} presented={} decode_errors={}",
o.control_open.load(r),o.echo_received.load(r),o.media_packets.load(r),s[0].load(r),s[1].load(r),s[2].load(r));
},
_=tick.tick()=>{
if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}}
let (quit,messages)=window.poll(&mut input);
requested|=std::mem::take(&mut window.files);
#[cfg(uu_gtk)] {
if files.as_ref().is_some_and(|f|f.is_finished()){
if let Some(f)=files.take(){let _=f.await;}session.peer.tools.lock().unwrap().take();
}
if requested && !(files.is_some() && super::tools_ui::closed()) && session.peer.channels[super::tools::FILE].ready_state()==webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {
if files.is_some(){super::tools_ui::present();}
else {let(io,rx)=super::tools::attach(&session.peer)?;
let name=super::device_label(std::env::var("UU_VIEWER_DEVICE_NAME").ok().as_deref()).to_owned();
files=Some(tokio::spawn(async move{super::tools_ui::files(io,rx,&name).await}));}
requested=false;
}
}
#[cfg(not(uu_gtk))] {if requested{log::warn!("File window requires GTK3");requested=false;}}
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
else {input.release_all();}
if quit{return Ok(())}
// At most one AU per iteration keeps local event polling responsive.
if let Some(au)=session.peer.desktop.units.pop(){
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();}
super::desktop::display(decoder,window,&au,&session.peer.desktop.pli)?;}
}
}}
}.await;
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
result
}
#[cfg(test)] mod tests {
use super::*;
#[test] fn file_shortcut_is_local_in_control_and_watch_modes(){
use sdl2::keyboard::{Scancode as S,Mod as M};
for watch in [false,true]{
let mut input=Input::new(watch);let mut focused=true;let mut files=false;
input.key(S::LCtrl as i32,true);input.key(S::LAlt as i32,true);
let key=|repeat|Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(S::F),keymod:M::LCTRLMOD|M::LALTMOD,repeat};
let (_,out)=translate_actions([key(false),key(true),Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(S::F),keymod:M::NOMOD,repeat:false}],
&mut input,Viewport::fit((800,600),(1920,1080)),&mut focused,&mut files);
assert!(files);assert!(out.iter().all(|v|v["action"]=="kbd_release"));
assert!(input.release_all().is_empty());
}
}
#[test] fn watch_events_never_emit_input_and_still_close(){
let mut input=Input::new(true);let mut focused=true;
assert!(input.key(4,true).is_none());assert!(input.button(1,true).is_none());assert!(!input.enabled());
let events=[
Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false},
Event::MouseMotion{timestamp:0,window_id:1,which:0,mousestate:sdl2::mouse::MouseState::from_sdl_state(0),x:12,y:34,xrel:1,yrel:1},
Event::MouseButtonDown{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:12,y:34},
Event::MouseButtonUp{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:12,y:34},
Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false},
Event::Window{timestamp:0,window_id:1,win_event:WindowEvent::FocusLost},
Event::Window{timestamp:0,window_id:1,win_event:WindowEvent::FocusGained},Event::Quit{timestamp:0}];
let (quit,out)=translate(events,&mut input,Viewport::fit((800,600),(1920,1080)),&mut focused);
assert!(quit);assert!(out.is_empty());assert!(input.release_all().is_empty());
}
#[test] fn focus_event_releases_and_suppresses_input_until_focus_returns(){
let mut input=Input::default();input.key(4,true);input.button(1,true);let mut focused=true;
let focus=|win_event|Event::Window{timestamp:0,window_id:1,win_event};
let key=Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false};
let v=Viewport::fit((800,600),(1920,1080));
let (quit,out)=translate([focus(WindowEvent::FocusLost),key.clone()],&mut input,v,&mut focused);
assert!(!quit);assert_eq!(out.len(),2);assert!(input.release_all().is_empty());assert!(!focused);
let (_,out)=translate([focus(WindowEvent::FocusGained),key,Event::Quit{timestamp:0}],&mut input,v,&mut focused);
assert_eq!(out.len(),2);assert_eq!(out[0]["action"],"kbd_press");assert_eq!(out[1]["action"],"kbd_release");
}
}
+87
View File
@@ -0,0 +1,87 @@
use super::{api::JoinData,wire::{self,Shape},signal::Signal,rtc::{self,Peer,ReadyPolicy}};
use serde_json::Value;
use std::{sync::atomic::Ordering,time::Duration};
use tokio::sync::mpsc;
use webrtc::api::setting_engine::SettingEngine;
pub struct Options {pub timeout:Duration,pub legacy_prefix:bool,pub ready_policy:ReadyPolicy}
pub struct Session {pub peer:Peer,signal:Signal,candidates:mpsc::Receiver<Value>,policy:ReadyPolicy}
impl Session {
pub async fn open(room:&JoinData,shape:&Shape,device:&str,client:&str,options:Options,settings:SettingEngine)->Result<Self,String> {
shape.validate_session()?;
let app=wire::uuid();let ice=hex::encode(rand::random::<[u8;16]>());
let timeout=if room.ws_connect_timeout_ms>0 {Duration::from_millis(room.ws_connect_timeout_ms as u64)}else{options.timeout};
let mut signal=Signal::connect(&room.signaling_list,&room.token,timeout,options.legacy_prefix).await?;
let result=async {
let result=signal.control(shape.control(client,&app,&ice)?,shape.connect_options(device)?,options.timeout).await?;
// Key names per ICE entry and URL scheme only (no values) to see where TURN credentials live.
if let Some(list)=result.get("iceServers").and_then(Value::as_array) {
let summary:Vec<String>=list.iter().map(|s|{
let scheme=s.get("urls").and_then(|u|u.as_str().map(str::to_owned).or_else(||u.get(0).and_then(Value::as_str).map(str::to_owned))).unwrap_or_default();
let keys:Vec<&str>=s.as_object().map(|o|o.keys().map(String::as_str).collect()).unwrap_or_default();
format!("{}:{:?}",scheme.split(':').next().unwrap_or(""),keys)}).collect();
log::info!("Control ack ICE entries: {:?}",summary);
}
// Structure and relations only; never the ids or ICE credentials.
log::info!("Control ack shape={} app_control_id_matches={:?} ice_id_matches={:?}",crate::protocol::json_shape(&result,5),
result.get("app_control_id").map(|v|v.as_str()==Some(app.as_str())),result.get("ice_id").map(|v|v.as_str()==Some(ice.as_str())));
if result.get("app_control_id").is_some_and(|v|v.as_str()!=Some(app.as_str())) {return Err("Control acknowledgement belongs to another session".into())}
// Observed live: the cloud assigns the session ice_id in this ack rather than echoing ours.
let ice=result.get("ice_id").and_then(Value::as_str).filter(|s|!s.is_empty()&&s.len()<=128).map(str::to_owned).unwrap_or(ice);
let remote=result.get("client_id").and_then(Value::as_str).filter(|s|!s.is_empty()).ok_or("Control acknowledgement missing peer route")?;
let config=rtc::configuration(&result)?;
let(tx,rx)=mpsc::channel(256);
let peer=Peer::new(config,shape,&app,&ice,remote,tx,settings).await?;
// The official host drops an offer whose ice_id is not yet in its connection table
// (libstreamer 0xc3080); give it time to process be-controlled first.
let delay=std::env::var("UU_VIEWER_OFFER_DELAY_MS").ok().and_then(|v|v.parse().ok()).unwrap_or(0u64).min(10_000);
tokio::time::sleep(Duration::from_millis(delay)).await;
match peer.offer().await {
Ok(offer)=>match signal.soac(offer).await {Ok(())=>Ok((peer,rx)),Err(e)=>{peer.close().await;Err(e)}},
Err(e)=>{peer.close().await;Err(e)},
}
}.await;
match result {
Ok((peer,candidates))=>Ok(Self{peer,signal,candidates,policy:options.ready_policy}),
Err(e)=>{signal.close().await;Err(e)},
}
}
pub async fn step(&mut self)->Result<(),String> {
tokio::select! {
candidate=self.candidates.recv()=>if let Some(candidate)=candidate {self.signal.soac(candidate).await?},
event=self.signal.event()=> {
let event=event?;
// Event name and SOAC type only.
log::info!("Viewer signaling event: name={} soac_type={}",event.get(0).and_then(Value::as_str).unwrap_or("-"),
event.get(1).and_then(|b|b.get("type").or_else(||b.get("data").and_then(|d|d.get("type")))).and_then(Value::as_str).unwrap_or("-"));
match event.get(0).and_then(Value::as_str) {
Some("soac")=>if let Some(body)=event.get(1) {self.peer.receive(body).await?},
Some("released"|"left"|"leave")=> {
// An event for another peer must not tear down this session.
if self.peer.matches_route(event.get(1).unwrap_or(&Value::Null)) {return Err("Remote session released".into())}
}
_=>{},
}
}
}
Ok(())
}
pub async fn run(&mut self)->Result<(),String> {
let mut interval=tokio::time::interval(Duration::from_secs(1));
let mut reported=(false,false,false);
let deadline=tokio::time::sleep(Duration::from_secs(30));tokio::pin!(deadline);
loop {
tokio::select! {
_=tokio::signal::ctrl_c()=>return Ok(()),
result=self.step()=>result?,
_=&mut deadline,if !self.peer.observed.echo_received.load(Ordering::Acquire)=>return Err("CONTROL echo timed out".into()),
_=interval.tick()=> {
if self.peer.observed.control_open.load(Ordering::Acquire) {self.peer.send_input(&super::input::Input::heartbeat()).await?;}
let state=(self.peer.observed.control_open.load(Ordering::Acquire),self.peer.observed.echo_received.load(Ordering::Acquire),self.peer.ready(self.policy,false));
if state!=reported {log::info!("Viewer session: control_open={} echo_received={} configured_ready={} control_messages={} media_packets={}",state.0,state.1,state.2,self.peer.observed.control_messages.load(Ordering::Relaxed),self.peer.observed.media_packets.load(Ordering::Relaxed));reported=state;}
}
}
}
}
pub async fn close(&mut self) {self.peer.close().await;self.signal.close().await;}
}
+138
View File
@@ -0,0 +1,138 @@
//! Framing/ack evidence: internal viewer-evidence-20261016.md section 3.
//! Raw Engine.IO4 attachments and legacy SDK 0x04 framing are explicit alternatives.
use base64::Engine as _;
use futures_util::{SinkExt, StreamExt};
use serde_json::Value;
use tokio::net::TcpStream;
use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
use tokio_tungstenite::tungstenite::{client::IntoClientRequest, Message};
use std::{collections::VecDeque,time::Duration};
pub struct Signal {
ws: WebSocketStream<MaybeTlsStream<TcpStream>>,
next_ack:u64,
pending:VecDeque<Value>,
legacy_prefix:bool,
}
impl Signal {
pub async fn connect(urls:&[String], token:&str, timeout:Duration, legacy_prefix:bool)->Result<Self,String> {
for url in urls {
if let Ok(Ok(signal))=tokio::time::timeout(timeout,Self::one(url,token,legacy_prefix)).await {return Ok(signal)}
}
Err("Signaling connection failed (details omitted)".into())
}
async fn one(url:&str,token:&str,legacy_prefix:bool)->Result<Self,String> {
let mut request=format!("{}/socket.io/?transport=websocket&EIO=4",url.trim_end_matches('/')).into_client_request().map_err(|_|"Invalid signaling endpoint")?;
request.headers_mut().insert("X-NRD-AUTH",token.parse().map_err(|_|"Invalid room authentication header")?);
let (ws,_)=connect_async(request).await.map_err(|_|"Signaling transport failed")?;
let mut s=Self{ws,next_ack:10,pending:VecDeque::new(),legacy_prefix};
let mut opened=false;
loop {
match s.ws.next().await {
Some(Ok(Message::Text(t))) if t.starts_with('0') && !opened => {
serde_json::from_str::<Value>(&t[1..]).map_err(|_|"Invalid Engine.IO open")?;
opened=true;s.send(Message::Text("40".into())).await?;
}
Some(Ok(Message::Text(t))) if t.starts_with("40") && opened =>return Ok(s),
Some(Ok(Message::Text(t))) if t.starts_with('2')=>s.send(Message::Text(format!("3{}",&t[1..]))).await?,
Some(Ok(Message::Ping(b)))=>s.send(Message::Pong(b)).await?,
_=>return Err("Signaling handshake failed".into()),
}
}
}
async fn send(&mut self,message:Message)->Result<(),String> {self.ws.send(message).await.map_err(|_|"Signaling send failed".into())}
pub async fn control(&mut self, header:Value, app_data:Vec<u8>, timeout:Duration)->Result<Value,String> {
self.next_ack+=1;let id=self.next_ack;
self.send(Message::Text(format!("451-{id}{}",serde_json::json!(["control",header])))).await?;
let mut attachment=Vec::new();if self.legacy_prefix {attachment.push(4)} attachment.extend(app_data);
self.send(Message::Binary(attachment)).await?;
tokio::time::timeout(timeout,async {
loop {
match self.packet().await? {
Packet::Ack(ack,value) if ack==id=> {
let a=value.as_array().ok_or("Invalid control acknowledgement")?;
if a.len()!=2 || a[0].as_str()!=Some("success") || !a[1].is_object() {return Err("Control refused or malformed acknowledgement".into())}
return Ok(a[1].clone());
}
Packet::Event(value)=> {
if self.pending.len()>=64 {return Err("Too many pre-control signaling events".into())}
self.pending.push_back(value);
}
_=>{},
}
}
}).await.map_err(|_|"Control acknowledgement timed out")?
}
async fn packet(&mut self)->Result<Packet,String> {
loop {
match self.ws.next().await {
Some(Ok(Message::Text(t))) if t.starts_with('2')=>self.send(Message::Text(format!("3{}",&t[1..]))).await?,
Some(Ok(Message::Ping(b)))=>self.send(Message::Pong(b)).await?,
Some(Ok(Message::Text(t))) if t.starts_with("43")=> {
let begin=t.find('[').ok_or("Malformed signaling acknowledgement")?;
let id=t[2..begin].parse().map_err(|_|"Malformed signaling acknowledgement id")?;
let value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed signaling acknowledgement body")?;
return Ok(Packet::Ack(id,value))
}
Some(Ok(Message::Text(t))) if t.starts_with("42")=> {
let begin=t.find('[').ok_or("Malformed signaling event")?;
let value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed signaling event body")?;
return Ok(Packet::Event(value))
}
// Socket.IO binary event (45N-[...] / 46N-[...] ack) followed by N attachment frames.
// The official host sends its answer this way (binary gzip_sdp); attachments are
// substituted as base64 strings so the existing gzip_sdp decoder applies.
Some(Ok(Message::Text(t))) if t.starts_with("45") || t.starts_with("46")=> {
let dash=t.find('-').ok_or("Malformed binary signaling packet")?;
let count:usize=t[2..dash].parse().map_err(|_|"Malformed binary attachment count")?;
if count>8 {return Err("Too many signaling attachments".into())}
let begin=t.find('[').ok_or("Malformed binary signaling packet")?;
let mut value:serde_json::Value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed binary signaling body")?;
let mut attachments=Vec::with_capacity(count);
while attachments.len()<count {
match self.ws.next().await {
Some(Ok(Message::Binary(mut b)))=>{
if b.len()>2 && b[0]==4 && b[1]==0x1f {b.remove(0);}
if b.len()>4*1024*1024 {return Err("Signaling attachment too large".into())}
attachments.push(base64::engine::general_purpose::STANDARD.encode(&b));
}
Some(Ok(Message::Text(t))) if t.starts_with('2')=>self.send(Message::Text(format!("3{}",&t[1..]))).await?,
Some(Ok(_))=>{},
_=>return Err("Signaling disconnected".into()),
}
}
fn fill(v:&mut serde_json::Value,a:&[String]) {
match v {
serde_json::Value::Object(o) if o.get("_placeholder")==Some(&serde_json::Value::Bool(true))=>{
if let Some(s)=o.get("num").and_then(|n|n.as_u64()).and_then(|n|a.get(n as usize)) {*v=serde_json::Value::String(s.clone());}
}
serde_json::Value::Object(o)=>for x in o.values_mut(){fill(x,a)},
serde_json::Value::Array(l)=>for x in l{fill(x,a)},
_=>{},
}
}
fill(&mut value,&attachments);
log::info!("Viewer binary signaling event: name={} attachments={}",value.get(0).and_then(|v|v.as_str()).unwrap_or("-"),count);
if t.starts_with("46") {
let id=t[dash+1..begin].parse().map_err(|_|"Malformed binary acknowledgement id")?;
return Ok(Packet::Ack(id,value))
}
return Ok(Packet::Event(value))
}
Some(Ok(Message::Text(t))) if t=="41" || t=="1"=>return Err("Signaling room closed".into()),
Some(Ok(Message::Close(_)))|None|Some(Err(_))=>return Err("Signaling disconnected".into()),
// Type, short prefix and length only, to see what else the room delivers.
Some(Ok(Message::Text(t)))=>log::info!("Viewer signaling frame ignored: text prefix={} bytes={}",t.chars().take(3).collect::<String>(),t.len()),
Some(Ok(Message::Binary(b)))=>log::info!("Viewer signaling frame ignored: binary bytes={}",b.len()),
_=>{},
}
}
}
pub async fn event(&mut self)->Result<Value,String> {
if let Some(v)=self.pending.pop_front(){return Ok(v)}
loop {if let Packet::Event(v)=self.packet().await?{return Ok(v)}}
}
pub async fn soac(&mut self, value:Value)->Result<(),String> {self.send(Message::Text(format!("42{}",serde_json::json!(["soac",value])))).await}
pub async fn close(&mut self) {let _=self.ws.close(None).await;}
}
enum Packet { Ack(u64,Value), Event(Value) }
+289
View File
@@ -0,0 +1,289 @@
use super::{api::JoinData,session::{Session,Options},signal::Signal,rtc::{self,Peer,ReadyPolicy},wire::{self,Shape}};
use serde_json::{json,Value};
use std::{sync::{Arc,atomic::{AtomicUsize,Ordering}},time::Duration};
use tokio::{net::TcpListener,sync::{Mutex,mpsc}};
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::{accept_async,tungstenite::Message};
use webrtc::{api::{APIBuilder,media_engine::MediaEngine,setting_engine::SettingEngine},peer_connection::{configuration::RTCConfiguration,sdp::session_description::RTCSessionDescription},util::vnet::{net::{Net,NetConfig},router::{Router,RouterConfig}}};
async fn virtual_network()->(SettingEngine,SettingEngine,Arc<Mutex<Router>>) {
// RFC 5737 documentation addresses live only inside webrtc's in-memory network.
let router=Arc::new(Mutex::new(Router::new(RouterConfig{cidr:"192.0.2.0/24".into(),..Default::default()}).unwrap()));
let mut settings=Vec::new();
for address in ["192.0.2.10","192.0.2.11"] {
let net=Arc::new(Net::new(Some(NetConfig{static_ips:vec![address.into()],..Default::default()})));
let nic=net.get_nic().unwrap();router.lock().await.add_net(nic.clone()).await.unwrap();
nic.lock().await.set_router(router.clone()).await.unwrap();
let mut setting=SettingEngine::default();setting.set_vnet(Some(net));
setting.set_network_types(vec![webrtc::ice::network_type::NetworkType::Udp4]);
settings.push(setting);
}
router.lock().await.start().await.unwrap();
let b=settings.pop().unwrap();(settings.pop().unwrap(),b,router)
}
fn shape()->Shape {serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap()}
#[test]
fn ice_configuration_preserves_credentials_without_public_fallback() {
let result=json!({"iceServers":[{"urls":"turn:relay.example.invalid:3478","username":"synthetic-user","credential":"synthetic-pass"}],"force_relay":true});
let config=rtc::configuration(&result).unwrap();assert_eq!(config.ice_servers.len(),1);
assert_eq!(config.ice_servers[0].credential,"synthetic-pass");
assert_eq!(config.ice_transport_policy,webrtc::peer_connection::policy::ice_transport_policy::RTCIceTransportPolicy::Relay);
assert!(rtc::configuration(&json!({"iceServers":[]})).unwrap().ice_servers.is_empty());
for result in [json!({}),json!({"iceServers":[],"force_relay":true}),json!({"iceServers":[{"urls":"https://invalid.example"}]}),json!({"iceServers":[{"urls":[7]}]})] {assert!(rtc::configuration(&result).is_err());}
}
#[tokio::test]
async fn websocket_control_ack_framing_heartbeat_failure_and_timeout() {
for legacy in [false,true] {
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();
let url=format!("ws://{}",listener.local_addr().unwrap());
let server=tokio::spawn(async move {
let(stream,_)=listener.accept().await.unwrap();let mut ws=accept_async(stream).await.unwrap();
ws.send(Message::Text("0{}".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("40".into()));
ws.send(Message::Text("40{}".into())).await.unwrap();
let Message::Text(t)=ws.next().await.unwrap().unwrap() else{panic!()};assert!(t.starts_with("451-11["));
let Message::Binary(b)=ws.next().await.unwrap().unwrap() else{panic!()};assert_eq!(b,if legacy{vec![4,8,1]}else{vec![8,1]});
ws.send(Message::Text("2fixture".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("3fixture".into()));
ws.send(Message::Text("43999[\"success\",{}]".into())).await.unwrap();
ws.send(Message::Text("4311[\"fail\",{}]".into())).await.unwrap();
});
let mut signal=Signal::connect(&["invalid endpoint".into(),url],"synthetic-ticket",Duration::from_millis(100),legacy).await.unwrap();
assert!(signal.control(json!({}),vec![8,1],Duration::from_secs(2)).await.unwrap_err().contains("refused"));signal.close().await;server.await.unwrap();
}
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();let url=format!("ws://{}",listener.local_addr().unwrap());
let job=tokio::spawn(async move {
let(s,_)=listener.accept().await.unwrap();let mut ws=accept_async(s).await.unwrap();ws.send(Message::Text("0{}".into())).await.unwrap();let _=ws.next().await;
ws.send(Message::Text("40{}".into())).await.unwrap();while ws.next().await.is_some(){}
});
let mut signal=Signal::connect(&[url],"synthetic-ticket",Duration::from_secs(2),false).await.unwrap();
assert!(signal.control(json!({}),vec![],Duration::from_millis(20)).await.unwrap_err().contains("timed out"));signal.close().await;job.await.unwrap();
}
#[tokio::test]
async fn complete_session_uses_loopback_signaling_and_virtual_rtc_through_echo() {
tokio::time::timeout(Duration::from_secs(20),async {
let(viewer_settings,host_settings,router)=virtual_network().await;
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter};
let track=Arc::new(TrackLocalStaticRTP::new(webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability{mime_type:"video/H264".into(),clock_rate:90000,sdp_fmtp_line:"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(),..Default::default()},"synthetic-video".into(),"synthetic-stream".into()));
let sender=host.add_track(track.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
let (input_tx,mut input_rx)=mpsc::channel(8);
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
host.on_data_channel(Box::new(move |channel| {
let count=count.clone();let input_tx=input_tx.clone();Box::pin(async move {
assert!(wire::CHANNELS.contains(&channel.label()));assert!(channel.ordered());assert!(!channel.negotiated());
let c=count.clone();channel.on_open(Box::new(move ||Box::pin(async move{c.fetch_add(1,Ordering::Relaxed);} )));
if channel.label()==wire::CHANNELS[0] {
let weak=Arc::downgrade(&channel);
channel.on_message(Box::new(move |message| {let weak=weak.clone();let input_tx=input_tx.clone();Box::pin(async move {
if message.data.first()==Some(&b'{') {input_tx.send(serde_json::from_slice::<Value>(&message.data).unwrap()).await.unwrap();return}
for (action,number) in [(super::power::Action::Reboot,9),(super::power::Action::Shutdown,12)] {
if message.data.as_ref()==action.message(2).as_slice(){input_tx.send(json!({"power":number})).await.unwrap();return}
}
assert_eq!(&message.data[..],&wire::echo_request(1));
let mut action=Vec::new();wire::int(1,1,&mut action);wire::bytes(2,br#"{"seq":1}"#,&mut action);
if let Some(channel)=weak.upgrade(){channel.send(&bytes::Bytes::from(wire::envelope(100,3,&action))).await.unwrap();}
})}));
} else if [wire::CHANNELS[3],wire::CHANNELS[4]].contains(&channel.label()) {
let weak=Arc::downgrade(&channel);
channel.on_message(Box::new(move |message|{let weak=weak.clone();Box::pin(async move{
if let Some(dc)=weak.upgrade(){dc.send(&message.data).await.unwrap();}
})}));
}
})
}));
let(tx,mut candidates)=mpsc::channel(256);
host.on_ice_candidate(Box::new(move |candidate| {let tx=tx.clone();Box::pin(async move {
if let Some(candidate)=candidate {let mut c=candidate.to_json().unwrap();c.sdp_mid=Some("0".into());c.sdp_mline_index=Some(0);tx.send(c).await.unwrap();}
})}));
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();let url=format!("ws://{}",listener.local_addr().unwrap());
let server_host=host.clone();let(done_tx,mut done_rx)=mpsc::channel::<()>(1);
let server=tokio::spawn(async move {
let(stream,_)=listener.accept().await.unwrap();
let mut ws=tokio_tungstenite::accept_hdr_async(stream,|request:&tokio_tungstenite::tungstenite::handshake::server::Request,response| {
assert_eq!(request.headers()["X-NRD-AUTH"],"synthetic-room-ticket");assert_eq!(request.uri().path(),"/socket.io/");Ok(response)
}).await.unwrap();
ws.send(Message::Text("0{\"sid\":\"fixture\"}".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("40".into()));ws.send(Message::Text("40{}".into())).await.unwrap();
let Message::Text(packet)=ws.next().await.unwrap().unwrap() else{panic!()};
let begin=packet.find('[').unwrap();let ack=packet[4..begin].parse::<u64>().unwrap();let args:Value=serde_json::from_str(&packet[begin..]).unwrap();assert_eq!(args[0],"control");
let app=args[1]["app_control_id"].clone();
// As observed live: the viewer sends no ice_id and the cloud assigns one in the ack.
assert!(args[1].get("ice_id").is_none()&&args[1].get("client_id").is_none()&&args[1].get("controller_platform").is_none());
let ice=json!("synthetic-cloud-ice");
let streamer:Value=serde_json::from_str(args[1]["streamer_data"].as_str().unwrap()).unwrap();assert_eq!(streamer["control_id"],app);
let Message::Binary(b)=ws.next().await.unwrap().unwrap() else{panic!()};assert!(crate::protocol::decode_wire(&b).is_ok());
// A queued foreign candidate must not be installed into this PC.
ws.send(Message::Text(format!("42{}",json!(["soac",{"data":{"type":"candidate","ice_id":"synthetic-other-session","candidate":"invalid"}}])))).await.unwrap();
ws.send(Message::Text(format!("43{ack}{}",json!(["success",{"iceServers":[],"client_id":"synthetic-host","app_control_id":app,"ice_id":ice}])))).await.unwrap();
loop {
tokio::select! {
_=done_rx.recv()=>break,
candidate=candidates.recv()=>if let Some(candidate)=candidate {
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"candidate","candidate":candidate,"app_control_id":app,"ice_id":ice}}])))).await.unwrap();
},
message=ws.next()=> {
let Some(Ok(Message::Text(packet)))=message else{break};
let value:Value=serde_json::from_str(&packet[2..]).unwrap();let body=&value[1]["data"];
match body["type"].as_str() {
Some("offer")=> {
let offered=body["sdp"].as_str().unwrap();
assert!(offered.contains("H264/90000") && offered.contains("opus/48000"));
assert!(!offered.contains("H265") && !offered.contains("VP8"));
assert_eq!(offered.matches("a=recvonly").count(),2);
server_host.set_remote_description(RTCSessionDescription::offer(offered.into()).unwrap()).await.unwrap();
let answer=server_host.create_answer(None).await.unwrap();let sdp=answer.sdp.clone();let mut gathered=server_host.gathering_complete_promise().await;server_host.set_local_description(answer).await.unwrap();
gathered.recv().await;
// Force one real remote candidate to arrive before the answer.
let candidate=candidates.recv().await.unwrap();
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"candidate","candidate":candidate,"app_control_id":app,"ice_id":ice}}])))).await.unwrap();
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"answer","sdp":sdp,"ice_id":ice,"app_control_id":app}}])))).await.unwrap();
}
Some("candidate")=>server_host.add_ice_candidate(serde_json::from_value(body["candidate"].clone()).unwrap()).await.unwrap(),
_=>panic!("unexpected synthetic event"),
}
}
}
}
});
let room:JoinData=serde_json::from_value(json!({"token":"synthetic-room-ticket","signaling_list":[url],"report_token":"synthetic-report","report_url":""})).unwrap();
let options=Options{timeout:Duration::from_secs(3),legacy_prefix:false,ready_policy:ReadyPolicy::Explicit};
let mut session=Session::open(&room,&shape(),"synthetic-device","synthetic-client",options,viewer_settings).await.unwrap();
assert_eq!(session.peer.channels.len(),5);
let(tool_io,mut tool_rx)=super::tools::attach(&session.peer).unwrap();
assert!(super::tools::attach(&session.peer).is_err());
loop {
tokio::select! {_=tokio::time::sleep(Duration::from_millis(20))=>{},result=session.step()=>result.unwrap()}
if session.peer.ready(ReadyPolicy::EchoOnly,false) && opened.load(Ordering::Relaxed)==5 {break}
}
assert!(!session.peer.ready(ReadyPolicy::Explicit,false));assert!(session.peer.ready(ReadyPolicy::Explicit,true));
assert!(session.peer.observed.control_open.load(Ordering::Acquire));
for channel in [super::tools::FILE,super::tools::BINARY] {
let data=vec![channel as u8;32*1024];tool_io.send(channel,data.clone()).await.unwrap();
loop{let(c,b)=tool_rx.recv().await.unwrap();if c==channel{assert_eq!(b,data);break}}
}
let mut input=super::input::Input::default();
let press=input.key(4,true).unwrap();session.peer.send_input(&press).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),press);
for release in input.release_all(){session.peer.send_input(&release).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),release);}
let heartbeat=super::input::Input::heartbeat();session.peer.send_input(&heartbeat).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),heartbeat);
let packet=|seq,ts,marker,payload:&[u8]|webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:ts,marker,..Default::default()},payload:bytes::Bytes::copy_from_slice(payload)};
track.write_rtp(&packet(9,1,true,&[0x65,1])).await.unwrap();
loop {if let Some(au)=session.peer.desktop.units.pop(){assert_eq!(au,vec![0,0,0,1,0x65,1]);break}tokio::time::sleep(Duration::from_millis(10)).await;}
track.write_rtp(&packet(10,2,false,&[0x7c,0x85,1])).await.unwrap();
track.write_rtp(&packet(12,2,true,&[0x7c,0x45,3])).await.unwrap();
loop {let (packets,_)=sender.read_rtcp().await.unwrap();if packets.iter().any(|p|p.as_any().is::<webrtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication>()){break}}
assert!(session.peer.desktop.units.pop().is_none());
for (action,number) in [(super::power::Action::Reboot,9),(super::power::Action::Shutdown,12)]{
super::power::run(&mut session,action).await.unwrap();
assert_eq!(input_rx.recv().await.unwrap(),json!({"power":number}));
assert!(input_rx.try_recv().is_err());
}
done_tx.send(()).await.unwrap();server.await.unwrap();session.close().await;
assert!(tool_rx.recv().await.is_none());
host.close().await.unwrap();router.lock().await.stop().await.unwrap();
}).await.expect("offline RTC/session timed out");
}
#[tokio::test]
async fn early_candidates_and_foreign_session_messages_are_scoped() {
let(settings,_,router)=virtual_network().await;let(tx,_rx)=mpsc::channel(256);
let mut peer=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-app","synthetic-ice","synthetic-host",tx,settings).await.unwrap();
assert!(!peer.matches_route(&json!({"ice_id":"foreign"})));
assert!(!peer.matches_route(&json!({"app_control_id":"foreign"})));
peer.receive(&json!({"type":"answer","ice_id":"foreign","sdp":"invalid"})).await.unwrap();
for _ in 0..256 {peer.receive(&json!({"type":"candidate","candidate":{"candidate":""}})).await.unwrap();}
assert!(peer.receive(&json!({"type":"candidate","candidate":{"candidate":""}})).await.is_err());
peer.close().await;router.lock().await.stop().await.unwrap();
}
#[tokio::test]
async fn closing_one_peer_preserves_another_peer() {
let(a,b,router)=virtual_network().await;
let(tx1,_rx1)=mpsc::channel(256);let(tx2,_rx2)=mpsc::channel(256);
let first=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-first","synthetic-first-ice","synthetic-host",tx1,a).await.unwrap();
let second=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-second","synthetic-second-ice","synthetic-host",tx2,b).await.unwrap();
first.close().await;
assert_ne!(second.pc.connection_state(),webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed);
assert_eq!(second.channels.len(),5);
second.close().await;router.lock().await.stop().await.unwrap();
}
#[tokio::test]
async fn opus_and_video_tracks_are_received_independently_in_memory() {
tokio::time::timeout(Duration::from_secs(10),async {
let(viewer_settings,host_settings,router)=virtual_network().await;
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
use webrtc::{track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter},rtp_transceiver::rtp_codec::RTCRtpCodecCapability};
let audio=Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability{mime_type:"audio/opus".into(),clock_rate:48000,channels:2,..Default::default()},"audio".into(),"test".into()));
let video=Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability{mime_type:"video/H264".into(),clock_rate:90000,sdp_fmtp_line:"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(),..Default::default()},"video".into(),"test".into()));
host.add_track(audio.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();host.add_track(video.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
let(tx,_rx)=mpsc::channel(256);
let peer=Peer::new(RTCConfiguration::default(),&shape(),"app","ice","host",tx,viewer_settings).await.unwrap();
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
let offer=peer.pc.local_description().await.unwrap();assert!(offer.sdp.contains("m=audio") && offer.sdp.contains("opus/48000/2"));
host.set_remote_description(offer).await.unwrap();let answer=host.create_answer(None).await.unwrap();
let mut gathered=host.gathering_complete_promise().await;host.set_local_description(answer).await.unwrap();gathered.recv().await;
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while peer.pc.connection_state()!=webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected {tokio::time::sleep(Duration::from_millis(10)).await;}
let mut heard=false;let mut seen=false;
for seq in 0..200 {
let packet=|payload:&[u8]|webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:u32::from(seq)*960,marker:true,..Default::default()},payload:bytes::Bytes::copy_from_slice(payload)};
audio.write_rtp(&packet(&[0xf8,0xff,0xfe])).await.unwrap();video.write_rtp(&packet(&[0x65,1])).await.unwrap();
tokio::time::sleep(Duration::from_millis(10)).await;
if let Some(data)=peer.audio.pop(){assert_eq!(data,vec![0xf8,0xff,0xfe]);heard=true;}
if let Some(data)=peer.desktop.units.pop(){assert_eq!(data,vec![0,0,0,1,0x65,1]);seen=true;}
if heard && seen {break}
}
assert!(heard && seen);peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
}).await.expect("in-memory media timed out");
}
#[tokio::test]
async fn desktop_file_window_reattaches_without_replacing_peer(){
tokio::time::timeout(Duration::from_secs(10),async{
use super::tools::{self,files::Files};
let(viewer_settings,host_settings,router)=virtual_network().await;
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let file:Arc<std::sync::Mutex<Option<Arc<webrtc::data_channel::RTCDataChannel>>>>=Default::default();
let(tx,mut received)=mpsc::channel(32);
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
host.on_data_channel(Box::new(move|channel|{let(tx,file,count)=(tx.clone(),file.clone(),count.clone());Box::pin(async move{
count.fetch_add(1,Ordering::Relaxed);
if channel.label()==wire::CHANNELS[tools::FILE]{*file.lock().unwrap()=Some(channel.clone());}
if channel.label()==wire::CHANNELS[tools::CONTROL]{channel.on_message(Box::new(move|m|{
let(tx,file)=(tx.clone(),file.clone());Box::pin(async move{
if let Some(r)=tools::blob(&m.data,21){
if tools::blob(r,8).and_then(|b|tools::blob(b,10)).is_some(){
let id=tools::uint(tools::blob(r,1).unwrap(),1);
let reply=tools::rpc(id,true,7,&tools::ints(&[(4,1)]));
let file=file.lock().unwrap().clone().unwrap();file.send(&bytes::Bytes::from(reply)).await.unwrap();return
}
}
let _=tx.send(m.data.to_vec()).await;
})
}));}
})}));
let(tx,_rx)=mpsc::channel(256);
let peer=Peer::new(RTCConfiguration::default(),&shape(),"app","ice","host",tx,viewer_settings).await.unwrap();
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
host.set_remote_description(peer.pc.local_description().await.unwrap()).await.unwrap();
let answer=host.create_answer(None).await.unwrap();let mut gathered=host.gathering_complete_promise().await;
host.set_local_description(answer).await.unwrap();gathered.recv().await;
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while opened.load(Ordering::Relaxed)!=5 || peer.channels.iter().any(|c|c.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open){tokio::time::sleep(Duration::from_millis(10)).await;}
let pc=peer.pc.clone();
for _ in 0..2{
let(io,rx)=tools::attach(&peer).unwrap();assert!(tools::attach(&peer).is_err());
let(f,_)=Files::new(io,rx);assert!(f.list_dir(":/").await.unwrap().is_empty());drop(f);
peer.tools.lock().unwrap().take();
assert!(Arc::ptr_eq(&pc,&peer.pc));
let heartbeat=super::input::Input::heartbeat();peer.send_input(&heartbeat).await.unwrap();
loop{if serde_json::from_slice::<Value>(&received.recv().await.unwrap()).ok()==Some(heartbeat.clone()){break}}
}
assert_eq!(opened.load(Ordering::Relaxed),5);
peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
}).await.expect("desktop file reuse timed out");
}
+73
View File
@@ -0,0 +1,73 @@
//! Command-line adapters; terminal output is intentional user output, never a log.
use super::*;
use std::os::fd::AsRawFd;
use tokio::io::AsyncWriteExt;
struct Tty {fd:i32,saved:libc::termios}
impl Tty {
fn raw()->Result<Self,String>{
let fd=std::io::stdin().as_raw_fd();let mut saved=unsafe{std::mem::zeroed()};
if unsafe{libc::tcgetattr(fd,&mut saved)}!=0{return Err("Terminal command requires a local TTY".into())}
let mut raw=saved;unsafe{libc::cfmakeraw(&mut raw)};
if unsafe{libc::tcsetattr(fd,libc::TCSANOW,&raw)}!=0{return Err("Cannot set terminal raw mode".into())}Ok(Self{fd,saved})
}
}
impl Drop for Tty {fn drop(&mut self){unsafe{libc::tcsetattr(self.fd,libc::TCSANOW,&self.saved);}}}
pub fn size()->(u16,u16){let mut w:libc::winsize=unsafe{std::mem::zeroed()};if unsafe{libc::ioctl(0,libc::TIOCGWINSZ as _,&mut w)}==0{(w.ws_col.max(1),w.ws_row.max(1))}else{(80,24)}}
pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,session:Option<u32>)->Result<(),String>{
let(t,output)=terminal::Terminal::new(io,rx);t.check_env().await?;
let(c,r)=size();let id=match session{Some(id)=>t.attach(id,c,r).await?,None=>t.open(c,r).await?};
let result=terminal_loop(&t,output,id).await;let _=t.close(id).await;result
}
#[async_trait::async_trait]
pub trait TerminalInput:Sync {
async fn write(&self,id:u32,data:&[u8])->Result<(),String>;
async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>;
}
#[async_trait::async_trait]
impl TerminalInput for terminal::Terminal {
async fn write(&self,id:u32,data:&[u8])->Result<(),String>{self.write(id,data).await}
async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>{self.resize(id,cols,rows).await}
}
pub async fn terminal_loop(t:&impl TerminalInput,mut output:mpsc::Receiver<terminal::Event>,id:u32)->Result<(),String>{
async{
let _tty=Tty::raw()?;
use std::os::unix::fs::OpenOptionsExt;
let input=std::fs::OpenOptions::new().read(true).custom_flags(libc::O_NONBLOCK).open("/dev/tty").map_err(|_|"Cannot open local TTY")?;
let input=tokio::io::unix::AsyncFd::new(input).map_err(|_|"Cannot watch local TTY")?;let mut stdout=tokio::io::stdout();let mut buf=vec![0;16*1024];
let mut resize=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::window_change()).map_err(|_|"Cannot watch terminal size")?;
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
loop{tokio::select!{
_=terminate.recv()=>break,
n=async {
loop {let mut ready=input.readable().await?;
match ready.try_io(|fd|std::io::Read::read(&mut fd.get_ref(),&mut buf)){Ok(n)=>break n,Err(_)=>continue}
}
}=>{let n=n.map_err(|_|"TTY read failed")?;if n==0{break}t.write(id,&buf[..n]).await?;},
_=resize.recv()=>{let(c,r)=size();t.resize(id,c,r).await?;},
e=output.recv()=>match e{
Some(terminal::Event::Output{session,data})if session==id=>{stdout.write_all(&data).await.map_err(|_|"TTY write failed")?;stdout.flush().await.map_err(|_|"TTY flush failed")?;},
Some(terminal::Event::Exit{session,code})if session==id=>{if code!=0{return Err(format!("Remote shell exited with code {code}"))}break},
Some(terminal::Event::Error{..})|None=>return Err("Terminal session failed".into()),_=>{},
}
}}Ok(())
}.await
}
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,args:&[String])->Result<(),String>{
let(f,mut progress)=files::Files::new(io,rx);
let reporter=tokio::spawn(async move{while let Some(p)=progress.recv().await{eprintln!("{} / {} bytes",p.transferred,p.total);}});
let operation=async {match args.first().map(String::as_str){
Some("ls")if args.len()==2=>match f.list_dir(&args[1]).await{Ok(entries)=>{for e in entries{println!("{}",serde_json::json!({"kind":e.kind,"name":e.name,"size":e.size,"path":e.path}));}Ok(())},Err(e)=>Err(e)},
Some("get")if args.len()==3=>f.download(&args[1],&args[2]).await,
Some("put")if args.len()==3=>f.upload(&args[1],&args[2]).await,
_=>Err("files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE".into()),
}};
tokio::pin!(operation);
let result=tokio::select!{r=&mut operation=>r,_=tokio::signal::ctrl_c()=>{f.cancel();operation.await}};
reporter.abort();result
}
pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,local:u16,host:&str,port:u16)->Result<(),String>{
let p=portmap::PortMap::new(io,rx);let id=p.add_rule("CLI",local,host,port).await?;
eprintln!("Listening on 127.0.0.1:{}",p.status()[0].local_port);
let result=tokio::select!{r=tokio::signal::ctrl_c()=>r.map_err(|_|"Cannot watch interrupt".to_owned()),_=p.closed()=>Err("Forwarding transport closed".into())};
p.remove_rule(id).await?;result
}
+178
View File
@@ -0,0 +1,178 @@
//! FTP RPC cases and 1-based file indexes follow src/file_trans.rs.
use super::*;
use std::{collections::{BTreeMap,HashMap},io::Read,path::{Path,PathBuf},sync::atomic::{AtomicBool,AtomicU64,Ordering}};
use tokio::{io::{AsyncReadExt,AsyncWriteExt},sync::{Mutex as AsyncMutex,Notify}};
#[derive(Debug,Clone)]
pub struct Entry {pub kind:u64,pub name:String,pub size:u64,pub modified:u64,pub path:String}
#[derive(Clone,Copy,Debug)]
pub struct Progress {pub task:u64,pub transferred:u64,pub total:u64}
// Keep request/task ids unique when a desktop file window is reopened.
static NEXT:AtomicU64=AtomicU64::new(100);
pub struct Files {io:Transport,rx:AsyncMutex<mpsc::Receiver<Packet>>,next:&'static AtomicU64,canceled:AtomicBool,poisoned:AtomicBool,wake:Notify,progress:mpsc::Sender<Progress>}
fn check(code:u64)->Result<(),String>{if code==1{Ok(())}else{Err(format!("File transfer error code {code}"))}}
fn id(task:u64,index:u64)->Vec<u8>{nested(1,&ints(&[(1,task),(2,index)]))}
fn all(data:&[u8],n:u32)->Result<Vec<&[u8]>,String>{Ok(decode_wire(data).map_err(|_|"Invalid file protobuf")?.into_iter().filter_map(|f|match(f.number,f.value){(k,WireValue::Bytes(b))if k==n=>Some(b),_=>None}).collect())}
pub fn inflate(data:&[u8])->Result<Vec<u8>,String>{
let mut out=Vec::new();flate2::read::ZlibDecoder::new(data).take(16*1024*1024+1).read_to_end(&mut out).map_err(|_|"Invalid directory compression")?;
if out.len()>16*1024*1024{return Err("Directory expansion limit".into())}Ok(out)
}
fn safe(path:&str)->Result<PathBuf,String>{
let normalized=path.replace('\\',"/");let p=Path::new(&normalized);
if p.as_os_str().is_empty() || p.components().any(|c|!matches!(c,std::path::Component::Normal(_))) || normalized.contains(':') {return Err("Unsafe remote relative path".into())}Ok(p.to_owned())
}
struct Stage(PathBuf);
impl Drop for Stage {fn drop(&mut self){let _=std::fs::remove_dir_all(&self.0);}}
/// Download block ids start at 1 on the official Windows host and at 0 (sent out of order within a
/// 16-block window) on ours. `next` stays unset until block 0 arrives, 16 blocks are buffered, or the
/// file completes; the lowest buffered id is then the base.
struct Download {file:tokio::fs::File,written:u64,next:Option<u64>,blocks:BTreeMap<u64,Vec<u8>>}
impl Files {
pub fn new(io:Transport,rx:mpsc::Receiver<Packet>)->(Self,mpsc::Receiver<Progress>){let(tx,progress)=mpsc::channel(64);(Self{io,rx:AsyncMutex::new(rx),next:&NEXT,canceled:AtomicBool::new(false),poisoned:AtomicBool::new(false),wake:Notify::new(),progress:tx},progress)}
/// Cancels the active operation; subsequent operations can reuse the session.
pub fn cancel(&self){self.canceled.store(true,Ordering::Release);self.wake.notify_waiters();}
async fn recv(&self,rx:&mut mpsc::Receiver<Packet>)->Result<Vec<u8>,String>{loop{
let notified=self.wake.notified();tokio::pin!(notified);notified.as_mut().enable();
if self.canceled.load(Ordering::Acquire){return Err("File transfer canceled".into())}
let(c,b)=tokio::select!{r=receive(rx)=>r?,_=notified=>return Err("File transfer canceled".into())};if c==FILE{return Ok(b)}
}}
async fn request(&self,rx:&mut mpsc::Receiver<Packet>,case:u32,body:&[u8],expected:u32)->Result<Vec<u8>,String>{
if self.poisoned.load(Ordering::Acquire){return Err("File session requires reconnect after failed cleanup".into())}
let rid=self.next.fetch_add(1,Ordering::Relaxed);self.io.send(CONTROL,rpc(rid,false,case,body)).await?;
loop{let b=self.recv(rx).await?;
// Ids and field numbers only, to match official-host replies.
if let Some(r)=blob(&b,22){log::info!("File RPC reply: want_id={rid} got_id={} case_fields={:?}",blob(r,1).map(|h|uint(h,1)).unwrap_or(0),blob(r,4).and_then(|f|crate::protocol::decode_wire(f).ok()).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}
else {log::info!("File channel message: fields={:?}",crate::protocol::decode_wire(&b).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}
if let Some(r)=blob(&b,22){if blob(r,1).is_some_and(|h|uint(h,1)==rid){return blob(r,4).and_then(|f|blob(f,expected)).map(Vec::from).ok_or("Unexpected file response case".into())}}}
}
pub async fn list_dir(&self,path:&str)->Result<Vec<Entry>,String>{
let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
let mut body=id(self.next.fetch_add(1,Ordering::Relaxed),0);wire::bytes(2,path.as_bytes(),&mut body);
let b=self.request(&mut rx,10,&body,7).await?;check(uint(&b,4))?;
let expanded=blob(&b,5).map(inflate).transpose()?;
let rows=if let Some(ref d)=expanded {all(d,1)?}else{all(&b,3)?};
rows.into_iter().map(|r|Ok(Entry{kind:uint(r,1),name:text(r,2)?,size:uint(r,3),modified:uint(r,4),path:text(r,5)?})).collect()
}
pub async fn mkdir(&self,path:&str)->Result<(),String>{let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);let b=self.request(&mut rx,6,&nested(1,path.as_bytes()),5).await?;check(uint(&b,1))}
fn report(&self,task:u64,transferred:u64,total:u64){let _=self.progress.try_send(Progress{task,transferred,total});}
pub async fn upload(&self,local:impl AsRef<Path>,remote:&str)->Result<(),String>{
let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
let mut file=tokio::fs::File::open(local).await.map_err(|_|"Cannot open upload file")?;
let meta=file.metadata().await.map_err(|_|"Cannot stat upload file")?;if !meta.is_file(){return Err("Upload requires a regular file".into())}let size=meta.len();
let remote=Path::new(remote);let name=remote.file_name().and_then(|s|s.to_str()).ok_or("Invalid remote file name")?;safe(name)?;
let parent=remote.parent().and_then(|p|p.to_str()).filter(|p|!p.is_empty()).unwrap_or("~/");
let task=self.next.fetch_add(1,Ordering::Relaxed);
let mut info=nested(1,name.as_bytes());wire::int(2,size,&mut info);
let mut body=id(task,0);wire::bytes(2,parent.as_bytes(),&mut body);wire::bytes(3,&info,&mut body);wire::int(4,1,&mut body);
let result=async {
let r=self.request(&mut rx,1,&body,1).await?;check(uint(&r,3))?;
let mut ask=id(task,1);wire::int(3,size,&mut ask);let r=self.request(&mut rx,3,&ask,3).await?;check(uint(&r,3))?;
if uint(&r,2)!=0 || uint(&r,4)!=0{return Err("Unexpected upload skip/resume".into())}
let mut done=0;let mut block=0;let mut buf=vec![0;32*1024];
loop{let n=file.read(&mut buf).await.map_err(|_|"Upload read failed")?;if n==0{break}
let mut b=id(task,1);wire::int(2,block,&mut b);wire::bytes(3,&buf[..n],&mut b);
let r=self.request(&mut rx,4,&b,4).await?;check(uint(&r,3))?;
if uint(&r,2)!=block || uint(&r,4)!=n as u64{return Err("Invalid upload block acknowledgement".into())}
done+=n as u64;block+=1;self.report(task,done,size);
}
if done!=size{return Err("Upload size changed".into())}
let mut b=id(task,1);wire::int(2,1,&mut b);let r=self.request(&mut rx,9,&b,6).await?;check(uint(&r,2))?;self.report(task,done,size);Ok(())
}.await;
if result.is_err(){let mut b=id(task,1);wire::int(2,7,&mut b);let _=self.io.send(CONTROL,rpc(self.next.fetch_add(1,Ordering::Relaxed),false,9,&b)).await;}
result
}
pub async fn download(&self,remote:&str,local:impl AsRef<Path>)->Result<(),String>{
let local=local.as_ref();let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
let task=self.next.fetch_add(1,Ordering::Relaxed);let mut b=id(task,0);wire::bytes(2,remote.as_bytes(),&mut b);
let mut accepted=false;let mut ended=false;
let result=async {
let r=self.request(&mut rx,2,&b,2).await?;check(uint(&r,2))?;accepted=true;
let expanded=blob(&r,5).map(inflate).transpose()?;
let list=if let Some(ref e)=expanded{all(e,1)?}else{all(&r,3)?};
let files:Vec<(PathBuf,u64)>=list.iter().map(|f|Ok((safe(&text(f,1)?)?,uint(f,2)))).collect::<Result<_,String>>()?;
let folder=!text(&r,4)?.is_empty();if !folder && files.len()!=1{return Err("Invalid single file list".into())}
let stage=Stage(local.with_file_name(format!(".uu-download-{}",wire::uuid())));
tokio::fs::create_dir(&stage.0).await.map_err(|_|"Cannot create download staging directory")?;
let mut open:HashMap<u64,Download>=HashMap::new();let mut completed=std::collections::HashSet::new();let total=files.iter().try_fold(0u64,|sum,x|sum.checked_add(x.1)).ok_or("Download size overflow")?;let mut done=0;
loop {
let data=self.recv(&mut rx).await?;
let Some(rpc_body)=blob(&data,21).filter(|r|blob(r,8).is_some()) else{
// Shape only (field numbers, size): what the host sent that is not a file RPC request.
log::info!("Download skipped message: bytes={} fields={:?} inner={:?}",data.len(),decode_wire(&data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default(),
decode_wire(&data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{WireValue::Bytes(b) if x.number>2=>decode_wire(b).ok().map(|g|(x.number,g.iter().map(|y|y.number).collect::<Vec<_>>())),_=>None})));
continue};
let ftp=blob(rpc_body,8).unwrap();
let rid=blob(rpc_body,1).map(|h|uint(h,1)).unwrap_or(0);
let Some(f)=decode_wire(ftp).ok().and_then(|v|v.into_iter().find(|f|matches!(f.value,WireValue::Bytes(_))))else{return Err("Invalid download request".into())};
let WireValue::Bytes(body)=f.value else{unreachable!()};let tid=blob(body,1).unwrap_or_default();if uint(tid,1)!=task{return Err("Unexpected download task".into())}let index=uint(tid,2);
let mut reply=id(task,index);let mut code=1;
let response=match f.number {
3=>{
if let Some((path,size))=index.checked_sub(1).and_then(|i|files.get(i as usize)) {
if uint(body,3)!=*size || open.contains_key(&index)||completed.contains(&index){code=3}else{
let path=stage.0.join(path);if let Some(p)=path.parent(){tokio::fs::create_dir_all(p).await.map_err(|_|"Cannot create download directory")?;}
match tokio::fs::OpenOptions::new().write(true).create_new(true).open(&path).await {
Ok(file)=>{open.insert(index,Download{file,written:0,next:None,blocks:BTreeMap::new()});},Err(_)=>code=6,
}
}
}else{code=3}wire::int(3,code,&mut reply);3
},
4=>{
let block=uint(body,2);let chunk=blob(body,3).unwrap_or_default();
if let Some(d)=open.get_mut(&index){
let expected=files[index as usize-1].1;
if chunk.len()>32*1024 || d.next.is_some_and(|n|block<n) || d.blocks.contains_key(&block)||d.blocks.len()>=32 {code=3}else{
d.blocks.insert(block,chunk.to_vec());
if d.next.is_none() && (block==0 || d.blocks.len()>=16) {d.next=d.blocks.keys().next().copied();}
while let Some(chunk)=d.next.and_then(|n|d.blocks.remove(&n)){
if d.written+chunk.len() as u64>expected || d.file.write_all(&chunk).await.is_err(){code=6;break}
d.written+=chunk.len() as u64;done+=chunk.len() as u64;d.next=d.next.map(|n|n+1);
}
}
}else{code=3}
wire::int(2,block,&mut reply);wire::int(3,code,&mut reply);wire::int(4,chunk.len() as u64,&mut reply);self.report(task,done,total);4
},
9=>{
if index==u64::MAX {
ended=true;check(uint(body,2))?;
if completed.len()!=files.len() || !open.is_empty(){return Err("Incomplete download task".into())}
if folder {tokio::fs::rename(&stage.0,local).await.map_err(|_|"Cannot finalize download directory")?;}else{tokio::fs::rename(stage.0.join(&files[0].0),local).await.map_err(|_|"Cannot finalize download file")?;}
self.report(task,done,total);return Ok(())
}
if let Some(mut d)=open.remove(&index){
if d.next.is_none(){d.next=d.blocks.keys().next().copied();}
while let Some(chunk)=d.next.and_then(|n|d.blocks.remove(&n)){
if d.written+chunk.len() as u64>files[index as usize-1].1 || d.file.write_all(&chunk).await.is_err(){break}
d.written+=chunk.len() as u64;done+=chunk.len() as u64;d.next=d.next.map(|n|n+1);
}
if uint(body,2)!=1 || d.written!=files[index as usize-1].1 || !d.blocks.is_empty() || d.file.flush().await.is_err(){code=6}else{completed.insert(index);}
}else{code=3}wire::int(2,code,&mut reply);6
},_=>return Err("Unexpected download request case".into()),
};
// Numbers only: request case, file index, expected/declared sizes, our result code.
if code!=1 || f.number!=4 {log::info!("Download step: case={} index={} files={} declared={} expected={} status={} code={code}",f.number,index,files.len(),uint(body,3),index.checked_sub(1).and_then(|i|files.get(i as usize)).map_or(0,|x|x.1),uint(body,2));}
self.io.send(CONTROL,rpc(rid,true,response,&reply)).await?;
if code!=1{return Err(format!("Download rejected with code {code}"))}
}
}.await;
if result.is_err() && !ended && (accepted || self.canceled.load(Ordering::Acquire)) {
// Reject outstanding host requests so cancellation releases its transfer window.
let cleanup=async {
loop {
let Some((channel,data))=rx.recv().await else{return};if channel!=FILE{continue}
let Some(r)=blob(&data,21)else{continue};let Some(ftp)=blob(r,8)else{continue};
let rid=blob(r,1).map(|h|uint(h,1)).unwrap_or(0);
for (request,response,error_field) in [(3,3,3),(4,4,3),(9,6,2)] {
let Some(body)=blob(ftp,request)else{continue};let tid=blob(body,1).unwrap_or_default();
if uint(tid,1)!=task{continue}
if request==9 && uint(tid,2)==u64::MAX{return}
let mut reply=nested(1,tid);wire::int(error_field,7,&mut reply);
if request==4{wire::int(2,uint(body,2),&mut reply);}
let _=self.io.send(CONTROL,rpc(rid,true,response,&reply)).await;
}
}
};
if tokio::time::timeout(Duration::from_secs(3),cleanup).await.is_err(){self.poisoned.store(true,Ordering::Release);}
}
result
}
}
+58
View File
@@ -0,0 +1,58 @@
//! Tool transports use only this peer's ordered channels; payloads are never logged.
pub mod terminal;
pub mod files;
pub mod portmap;
pub mod cli;
pub mod terminal_ipc;
use std::{sync::{Arc,Mutex},time::Duration};
use tokio::sync::mpsc;
use crate::protocol::{decode_wire,WireValue};
use super::wire;
pub const CONTROL:usize=0;
pub const FILE:usize=3;
pub const BINARY:usize=4;
pub type Packet=(usize,Vec<u8>);
pub type Inbox=Arc<Mutex<Option<mpsc::Sender<Packet>>>>;
pub const TIMEOUT:Duration=Duration::from_secs(30);
#[async_trait::async_trait]
pub trait Send:std::marker::Send+Sync {async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String>;}
#[derive(Clone)]
pub struct Transport(pub Arc<dyn Send>);
impl Transport {
pub async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String> {
tokio::time::timeout(TIMEOUT,self.0.send(channel,data)).await.map_err(|_|"Tool send timeout")?
}
}
struct Rtc(Vec<Arc<webrtc::data_channel::RTCDataChannel>>);
#[async_trait::async_trait]
impl Send for Rtc {
async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String> {
let dc=self.0.get(channel).ok_or("Unknown tool channel")?;
while dc.buffered_amount().await>1024*1024 {tokio::time::sleep(Duration::from_millis(5)).await;}
dc.send(&bytes::Bytes::from(data)).await.map_err(|_|"Tool data channel send failed")?;Ok(())
}
}
pub fn attach(peer:&super::rtc::Peer)->Result<(Transport,mpsc::Receiver<Packet>),String> {
let(tx,rx)=mpsc::channel(256);
let mut slot=peer.tools.lock().unwrap();
if slot.is_some(){return Err("Tool transport already attached".into())}
*slot=Some(tx);Ok((Transport(Arc::new(Rtc(peer.channels.clone()))),rx))
}
pub fn uint(data:&[u8],n:u32)->u64 {decode_wire(data).ok().and_then(|f|f.into_iter().find_map(|f|match(f.number,f.value){(k,WireValue::Varint(v))if k==n=>Some(v),_=>None})).unwrap_or(0)}
pub fn blob(data:&[u8],n:u32)->Option<&[u8]> {decode_wire(data).ok()?.into_iter().find_map(|f|match(f.number,f.value){(k,WireValue::Bytes(v))if k==n=>Some(v),_=>None})}
pub fn text(data:&[u8],n:u32)->Result<String,String> {String::from_utf8(blob(data,n).unwrap_or_default().to_vec()).map_err(|_|"Invalid UTF-8 field".into())}
pub fn ints(fields:&[(u32,u64)])->Vec<u8>{let mut b=Vec::new();for &(n,v) in fields{wire::int(n,v,&mut b)}b}
pub fn nested(n:u32,b:&[u8])->Vec<u8>{let mut out=Vec::new();wire::bytes(n,b,&mut out);out}
pub fn rpc(id:u64,response:bool,case:u32,body:&[u8])->Vec<u8>{
let mut b=nested(1,&ints(&[(1,id)]));wire::bytes(if response{4}else{8},&nested(case,body),&mut b);
wire::envelope(id,if response{22}else{21},&b)
}
pub async fn receive(rx:&mut mpsc::Receiver<Packet>)->Result<Packet,String>{tokio::time::timeout(TIMEOUT,rx.recv()).await.map_err(|_|"Tool response timeout")?.ok_or("Tool transport closed".into())}
#[cfg(test)]
pub mod tests;
pub struct Abort<T>(pub tokio::task::JoinHandle<T>);
impl<T> Drop for Abort<T>{fn drop(&mut self){self.0.abort();}}
pub struct Cancel(pub tokio::task::AbortHandle);
impl Drop for Cancel{fn drop(&mut self){self.0.abort();}}
+80
View File
@@ -0,0 +1,80 @@
//! Message27/SYN JSON follows src/port_mapping.rs; TCP half-close is unsupported.
use super::*;
use std::{collections::HashMap,sync::atomic::{AtomicU64,Ordering}};
use tokio::{net::{TcpListener,TcpStream},io::{AsyncReadExt,AsyncWriteExt},sync::watch};
#[derive(Clone,Debug)]
pub struct Status {pub id:u64,pub name:String,pub local_port:u16,pub streams:usize,pub failures:u64}
struct Rule {status:Arc<Mutex<Status>>,stop:watch::Sender<bool>,task:tokio::task::JoinHandle<()>}
type Routes=Arc<Mutex<HashMap<(u64,u64),mpsc::Sender<(u64,Vec<u8>)>>>>;
pub struct PortMap {io:Transport,session:u64,next:Arc<AtomicU64>,routes:Routes,rules:Mutex<HashMap<u64,Rule>>,alive:watch::Receiver<()>,worker:tokio::task::JoinHandle<()>}
pub fn frame(session:u64,rule:u64,stream:u64,kind:u64,payload:&[u8])->Vec<u8>{let mut b=ints(&[(1,session),(2,rule),(3,stream),(4,kind)]);wire::bytes(5,payload,&mut b);wire::envelope(0,27,&b)}
struct Route {routes:Routes,key:(u64,u64),status:Arc<Mutex<Status>>}
impl Drop for Route {fn drop(&mut self){self.routes.lock().unwrap().remove(&self.key);self.status.lock().unwrap().streams-=1;}}
impl Drop for PortMap {fn drop(&mut self){self.worker.abort();for(_,r)in self.rules.lock().unwrap().drain(){let _=r.stop.send(true);}self.routes.lock().unwrap().clear();}}
impl PortMap {
pub fn new(io:Transport,mut rx:mpsc::Receiver<Packet>)->Self{
let session=rand::random::<u64>();let routes:Routes=Arc::new(Mutex::new(HashMap::new()));let route=routes.clone();
let(life,alive)=watch::channel(());
let worker=tokio::spawn(async move{
let _life=life;
while let Some((channel,b))=rx.recv().await {
if channel!=FILE{continue}let Some(f)=blob(&b,27)else{continue};if uint(f,1)!=session{continue}
let key=(uint(f,2),uint(f,3));let sender=route.lock().unwrap().get(&key).cloned();
if let Some(tx)=sender {if tx.try_send((uint(f,4),blob(f,5).unwrap_or_default().to_vec())).is_err(){route.lock().unwrap().remove(&key);}}
}
route.lock().unwrap().clear();
});
Self{io,session,next:Arc::new(AtomicU64::new(1)),routes,rules:Mutex::new(HashMap::new()),alive,worker}
}
pub async fn closed(&self){let mut alive=self.alive.clone();let _=alive.changed().await;}
pub fn status(&self)->Vec<Status>{self.rules.lock().unwrap().values().map(|r|r.status.lock().unwrap().clone()).collect()}
pub async fn add_rule(&self,name:impl Into<String>,local_port:u16,target_host:impl Into<String>,target_port:u16)->Result<u64,String>{
if self.worker.is_finished(){return Err("Forwarding transport closed".into())}
let host=target_host.into();if host.trim().is_empty() || target_port==0 {return Err("Invalid forwarding target".into())}
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,local_port)).await.map_err(|_|"Cannot bind local forwarding port")?;
let port=listener.local_addr().map_err(|_|"Cannot inspect local forwarding port")?.port();
let id=self.next.fetch_add(1,Ordering::Relaxed);let status=Arc::new(Mutex::new(Status{id,name:name.into(),local_port:port,streams:0,failures:0}));
let(stopper,mut stop)=watch::channel(false);let st=status.clone();let io=self.io.clone();let routes=self.routes.clone();let next=self.next.clone();let session=self.session;
let mut disconnected=self.alive.clone();
let task=tokio::spawn(async move {
let mut streams=tokio::task::JoinSet::new();
loop {tokio::select!{
_=stop.changed()=>break,
_=disconnected.changed()=>break,
_=streams.join_next(),if !streams.is_empty()=>{},
accepted=listener.accept()=>{
let Ok((socket,_))=accepted else{break};
if st.lock().unwrap().streams>=128 {continue}
let stream=next.fetch_add(1,Ordering::Relaxed);let(tx,rx)=mpsc::channel(64);
routes.lock().unwrap().insert((id,stream),tx);st.lock().unwrap().streams+=1;
let guard=Route{routes:routes.clone(),key:(id,stream),status:st.clone()};
let io=io.clone();let host=host.clone();let mut cancel=stop.clone();let mut transport_closed=disconnected.clone();
streams.spawn(async move {
let result=tokio::select!{r=forward(&io,session,id,stream,socket,rx,&host,target_port)=>r,_=cancel.changed()=>Ok(()),_=transport_closed.changed()=>Err("Forwarding transport closed".into())};
if result.is_err(){guard.status.lock().unwrap().failures+=1;}
let _=io.send(FILE,frame(session,id,stream,1,&[])).await;drop(guard);
});
}
}}
drop(listener);
while streams.join_next().await.is_some(){}
});
self.rules.lock().unwrap().insert(id,Rule{status,stop:stopper,task});Ok(id)
}
pub async fn remove_rule(&self,id:u64)->Result<(),String>{
let rule=self.rules.lock().unwrap().remove(&id).ok_or("Unknown forwarding rule")?;
let _=rule.stop.send(true);let mut task=rule.task;
if tokio::time::timeout(TIMEOUT+Duration::from_secs(1),&mut task).await.is_err(){task.abort();return Err("Forwarding shutdown timed out".into())}Ok(())
}
}
async fn forward(io:&Transport,session:u64,rule:u64,stream:u64,mut socket:TcpStream,mut rx:mpsc::Receiver<(u64,Vec<u8>)>,host:&str,port:u16)->Result<(),String>{
let syn=serde_json::json!({"version":1,"target_host":host,"target_port":port}).to_string();
io.send(FILE,frame(session,rule,stream,0,syn.as_bytes())).await?;
let ack=tokio::time::timeout(Duration::from_secs(12),rx.recv()).await.map_err(|_|"Forwarding SYN timeout")?.ok_or("Forwarding channel closed")?;
if ack.0!=3 || serde_json::from_slice::<serde_json::Value>(&ack.1).ok().and_then(|v|v["ok"].as_bool())!=Some(true){return Err("Forwarding target rejected".into())}
let mut buf=vec![0;16*1024];
loop {tokio::select!{
r=socket.read(&mut buf)=>{let n=r.map_err(|_|"Forwarding read failed")?;if n==0{break}io.send(FILE,frame(session,rule,stream,2,&buf[..n])).await?;},
f=rx.recv()=>match f {Some((2,b))=>if socket.write_all(&b).await.is_err(){break}/* local client hung up: a normal close */,Some((1,_))|None=>break,Some((4,_))=>{},_=>return Err("Unexpected forwarding frame".into())},
}}let _=socket.shutdown().await;Ok(())
}
+148
View File
@@ -0,0 +1,148 @@
//! TERM types and JSON shapes follow src/terminal.rs (including bare LIST_RESP arrays).
use super::*;
use std::{collections::HashMap,sync::atomic::{AtomicU32,AtomicU64,Ordering}};
use tokio::sync::oneshot;
use serde_json::{json,Value};
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 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 struct Frame {pub kind:u8,pub session:u32,pub payload:Vec<u8>}
pub fn encode(kind:u8,session:u32,payload:&[u8])->Vec<u8>{
let mut b=b"TERM\x01".to_vec();b.extend([kind,0,0]);b.extend(session.to_le_bytes());b.extend((payload.len() as u32).to_le_bytes());b.extend(payload);b
}
#[derive(Default)]
pub struct Decoder {buffer:Vec<u8>}
impl Decoder {
pub fn push(&mut self,data:&[u8])->Result<Vec<Frame>,String>{
if self.buffer.len()+data.len()>2*1024*1024 {return Err("Terminal buffer limit".into())}
self.buffer.extend(data);let mut out=Vec::new();let mut at=0;
while self.buffer.len()-at>=16 {
let b=&self.buffer[at..];
if &b[..5]!=b"TERM\x01" || !(1..=16).contains(&b[5]) {return Err("Invalid TERM header".into())}
let len=u32::from_le_bytes(b[12..16].try_into().unwrap()) as usize;
if len>1024*1024{return Err("TERM payload limit".into())}
if b.len()<16+len {break}
out.push(Frame{kind:b[5],session:u32::from_le_bytes(b[8..12].try_into().unwrap()),payload:b[16..16+len].to_vec()});at+=16+len;
}
self.buffer.drain(..at);Ok(out)
}
}
#[derive(Clone)]
pub enum Event {Output{session:u32,data:Vec<u8>},Exit{session:u32,code:i64},Error{session:u32}}
type Pending=Arc<Mutex<HashMap<(u8,u64),oneshot::Sender<Result<Vec<u8>,String>>>>>;
struct Request {pending:Pending,key:(u8,u64)}
impl Drop for Request {fn drop(&mut self){self.pending.lock().unwrap().remove(&self.key);}}
pub struct Terminal {io:Transport,pending:Pending,next:AtomicU32,rpc:AtomicU64,worker:tokio::task::JoinHandle<()>}
impl Drop for Terminal {fn drop(&mut self){self.worker.abort();}}
impl Terminal {
pub fn new(io:Transport,mut rx:mpsc::Receiver<Packet>)->(Self,mpsc::Receiver<Event>){
let pending:Pending=Arc::new(Mutex::new(HashMap::new()));let p=pending.clone();let(tx,events)=mpsc::channel(256);
let worker=tokio::spawn(async move {
let mut decoder=Decoder::default();
while let Some((channel,data))=rx.recv().await {
if channel==CONTROL {
if let Some(r)=blob(&data,22) {if let (Some(h),Some(body))=(blob(r,1),blob(r,24)) {
if let Some(t)=p.lock().unwrap().remove(&(24,uint(h,1))) {let _=t.send(Ok(body.to_vec()));}
}}continue
}
if channel!=BINARY {continue}
let Ok(frames)=decoder.push(&data) else {break};
let mut overflow=false;
for f in frames {
let event=match f.kind {
STDOUT=>Some(Event::Output{session:f.session,data:f.payload.clone()}),
EXIT=>Some(Event::Exit{session:f.session,code:serde_json::from_slice::<Value>(&f.payload).ok().and_then(|v|v["exit_code"].as_i64()).unwrap_or(-1)}),
ERROR=>Some(Event::Error{session:f.session}),_=>None,
};
if let Some(event)=event {if tx.try_send(event).is_err(){overflow=true;break}}
let key=if f.kind==OPEN_RESP {(OPEN_RESP,0)}else{(f.kind,f.session as u64)};
let payload=if f.kind==OPEN_RESP {
serde_json::from_slice::<Value>(&f.payload).ok().filter(Value::is_object).map(|mut v|{v["session_id"]=json!(f.session);v.to_string().into_bytes()}).unwrap_or(f.payload)
}else{f.payload};
if let Some(t)=p.lock().unwrap().remove(&key){let _=t.send(Ok(payload));}
}
if overflow {break}
}
for (_,t) in p.lock().unwrap().drain(){let _=t.send(Err("Terminal channel closed or output overflow".into()));}
});
(Self{io,pending,next:AtomicU32::new(1),rpc:AtomicU64::new(10),worker},events)
}
async fn request(&self,key:(u8,u64),channel:usize,data:Vec<u8>)->Result<Vec<u8>,String>{
if self.worker.is_finished(){return Err("Terminal channel closed".into())}
let(tx,rx)=oneshot::channel();{
let mut pending=self.pending.lock().unwrap();
if pending.contains_key(&key){return Err("Terminal request already pending".into())}pending.insert(key,tx);
}
let _request=Request{pending:self.pending.clone(),key};
let result=async {self.io.send(channel,data).await?;tokio::time::timeout(TIMEOUT,rx).await.map_err(|_|"Terminal request timeout")?.map_err(|_|"Terminal closed")?}.await;
result
}
pub async fn check_env(&self)->Result<(),String>{
let id=self.rpc.fetch_add(1,Ordering::Relaxed);let mut r=nested(1,&ints(&[(1,id)]));wire::bytes(28,&[],&mut r);
let b=self.request((24,id),CONTROL,wire::envelope(id,21,&r)).await?;
if uint(&b,1)!=0 {return Err("Terminal environment unavailable".into())}Ok(())
}
pub async fn list_sessions(&self)->Result<Vec<Value>,String>{
let id=self.next.fetch_add(1,Ordering::Relaxed);
serde_json::from_slice(&self.request((LIST_RESP,id as u64),BINARY,encode(LIST_REQ,id,&[])).await?).map_err(|_|"Invalid terminal session list".into())
}
pub async fn open(&self,cols:u16,rows:u16)->Result<u32,String>{
self.open_session(0,cols,rows).await
}
pub async fn attach(&self,id:u32,cols:u16,rows:u16)->Result<u32,String>{
if id==0 || !self.list_sessions().await?.iter().any(|s|s["session_id"].as_u64()==Some(id as u64)){return Err("Terminal session no longer exists".into())}
self.open_session(id,cols,rows).await
}
async fn open_session(&self,id:u32,cols:u16,rows:u16)->Result<u32,String>{
// Host TerminalConn handles OPEN(nonzero) as reattachment.
let b=self.request((OPEN_RESP,0),BINARY,encode(OPEN,id,json!({"cols":cols.max(1),"rows":rows.max(1)}).to_string().as_bytes())).await?;
let v:Value=serde_json::from_slice(&b).map_err(|_|"Invalid terminal open response")?;
if v["code"].as_i64()!=Some(0){return Err("Terminal open rejected".into())}v["session_id"].as_u64().and_then(|n|u32::try_from(n).ok()).filter(|n|*n!=0).ok_or("Invalid terminal session id".into())
}
pub async fn write(&self,id:u32,data:&[u8])->Result<(),String>{for b in data.chunks(16*1024){self.io.send(BINARY,encode(STDIN,id,b)).await?}Ok(())}
pub async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>{self.io.send(BINARY,encode(RESIZE,id,json!({"cols":cols.max(1),"rows":rows.max(1)}).to_string().as_bytes())).await}
pub async fn close(&self,id:u32)->Result<(),String>{self.io.send(BINARY,encode(CLOSE,id,&[])).await}
pub async fn kill(&self,id:u32)->Result<(),String>{
let b=self.request((KILL_RESP,id as u64),BINARY,encode(KILL_REQ,id,&[])).await?;
if serde_json::from_slice::<Value>(&b).ok().and_then(|v|v["code"].as_u64())!=Some(0){return Err("Terminal kill rejected".into())}Ok(())
}
}
/// The remote shell needs a real terminal emulator: `$TERMINAL`, else the first installed common one.
/// On failure the window stays open so the error is readable.
pub fn terminal_command(exe: &std::path::Path, id: &str, session: Option<u32>) -> Option<std::process::Command> {
terminal_launcher(exe,"terminal",id,session)
}
pub fn local_terminal_command(exe:&std::path::Path,path:&std::path::Path,session:Option<u32>)->Option<std::process::Command>{
terminal_launcher(exe,"terminal-local",path.to_str()?,session)
}
fn terminal_launcher(exe:&std::path::Path,mode:&str,id:&str,session:Option<u32>)->Option<std::process::Command>{
let script = r#""$0" "$1" "$2" ${3:+"$3"} || { printf '\n终端连接失败,按回车关闭'; read _; }"#;
let inner = ["sh", "-c", script, &exe.to_string_lossy(), mode, id].map(str::to_owned);
let mut inner = inner.to_vec();
if let Some(id) = session { inner.push(id.to_string()); }
let found = |name: &str| std::env::var_os("PATH").is_some_and(|p| std::env::split_paths(&p).any(|d| d.join(name).is_file()));
let custom = std::env::var("TERMINAL").ok().filter(|t| !t.is_empty() && found(t));
let candidates = ["xdg-terminal-exec", "x-terminal-emulator", "kitty", "foot", "alacritty", "wezterm", "ghostty", "gnome-terminal", "konsole", "xfce4-terminal", "xterm"];
let program = custom.or_else(|| candidates.iter().find(|c| found(c)).map(|c| c.to_string()))?;
let prefix: &[&str] = match program.as_str() {
"xdg-terminal-exec" | "kitty" | "foot" => &[],
"wezterm" => &["start", "--"],
"gnome-terminal" => &["--"],
"xfce4-terminal" => &["-x"],
_ => &["-e"],
};
let mut command = std::process::Command::new(program);
command.args(prefix).args(inner).stdin(std::process::Stdio::null()).stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null());
Some(command)
}
/// Only known metadata is allowed across the GTK boundary; never serialize the full host object.
pub fn session_rows(sessions:&[Value])->String{
let mut rows:Vec<_>=sessions.iter().filter_map(|s|{
let id=u32::try_from(s["session_id"].as_u64()?).ok().filter(|n|*n!=0)?;
let shell=s["shell"].as_str().unwrap_or("--").chars().take(256).collect::<String>().replace(['\t','\n','\r','\0']," ");
let state=match s["state"].as_str(){Some("running")=>"运行中",Some("detached")=>"已分离",_=>"--"};
Some((id,format!("{id}\t{shell}\t{}\t{state}\n",s["created_at_ms"].as_u64().unwrap_or(0))))
}).collect();rows.sort_by_key(|r|r.0);rows.into_iter().map(|r|r.1).collect()
}
+152
View File
@@ -0,0 +1,152 @@
//! Local TTY clients share the list process's Terminal; no cloud credentials cross IPC.
use super::{terminal::{Terminal,Event},cli};
use std::{path::{Path,PathBuf},sync::Arc};
use tokio::{io::{AsyncRead,AsyncReadExt,AsyncWrite,AsyncWriteExt},net::{UnixListener,UnixStream},sync::{broadcast,mpsc,Mutex},task::JoinSet};
use serde::{Serialize,Deserialize};
const MAX:usize=4*1024*1024+1024;
#[derive(Serialize,Deserialize)]
enum Message {Open{session:Option<u32>,cols:u16,rows:u16},Ready(u32),Input(Vec<u8>),Resize(u16,u16),Output(Vec<u8>),Exit(i64),Close,Error}
async fn read(r:&mut (impl AsyncRead+Unpin))->Result<Message,String>{
let n=r.read_u32().await.map_err(|_|"Local terminal closed")? as usize;
if n>MAX{return Err("Local terminal frame limit".into())}
let mut b=vec![0;n];r.read_exact(&mut b).await.map_err(|_|"Local terminal closed")?;
serde_json::from_slice(&b).map_err(|_|"Invalid local terminal frame".into())
}
async fn write(w:&mut (impl AsyncWrite+Unpin),m:&Message)->Result<(),String>{
let b=serde_json::to_vec(m).map_err(|_|"Invalid local terminal frame")?;
if b.len()>MAX{return Err("Local terminal frame limit".into())}
w.write_u32(b.len() as u32).await.map_err(|_|"Local terminal closed")?;
w.write_all(&b).await.map_err(|_|"Local terminal closed".into())
}
pub struct Server {dir:PathBuf,pub path:PathBuf,listener:UnixListener}
impl Drop for Server {fn drop(&mut self){let _=std::fs::remove_file(&self.path);let _=std::fs::remove_dir(&self.dir);}}
impl Server {
pub fn new()->Result<Self,String>{
use std::os::unix::fs::DirBuilderExt;
let dir=std::env::temp_dir().join(format!("uu-tty-{}",super::super::wire::uuid()));
std::fs::DirBuilder::new().mode(0o700).create(&dir).map_err(|_|"Cannot create private terminal directory")?;
let path=dir.join("tty");
match UnixListener::bind(&path){Ok(listener)=>Ok(Self{dir,path,listener}),Err(_)=>{let _=std::fs::remove_dir(dir);Err("Cannot bind local terminal socket".into())}}
}
pub async fn run(self,t:Arc<Terminal>,events:broadcast::Sender<Event>){
let opening=Arc::new(Mutex::new(()));let active=Arc::new(std::sync::Mutex::new(std::collections::HashSet::new()));let mut clients=JoinSet::new();
loop{tokio::select!{
accepted=self.listener.accept(),if clients.len()<16=>match accepted{
Ok((socket,_))=>{let(t,opening,active,output)=(t.clone(),opening.clone(),active.clone(),events.subscribe());clients.spawn(async move{let _=serve(socket,t,opening,active,output).await;});},
Err(_)=>break,
},
_=clients.join_next(),if !clients.is_empty()=>{},
}}
}
}
type Sessions=Arc<std::sync::Mutex<std::collections::HashSet<u32>>>;
struct Active {id:u32,sessions:Sessions}
impl Drop for Active {fn drop(&mut self){self.sessions.lock().unwrap().remove(&self.id);}}
async fn serve<S:AsyncRead+AsyncWrite+Unpin+Send+'static>(mut socket:S,t:Arc<Terminal>,opening:Arc<Mutex<()>>,active:Sessions,mut output:broadcast::Receiver<Event>)->Result<(),String>{
let first=tokio::time::timeout(super::TIMEOUT,read(&mut socket)).await.map_err(|_|"Local terminal open timeout")??;
let Message::Open{session,cols,rows}=first else{return Err("Expected local terminal open".into())};
let id={let _guard=opening.lock().await;
if session.is_some_and(|id|active.lock().unwrap().contains(&id)){return Err("Terminal session already attached locally".into())}
let id=match session{Some(id)=>t.attach(id,cols,rows).await?,None=>t.open(cols,rows).await?};
active.lock().unwrap().insert(id);id
};
let _active=Active{id,sessions:active};
let result=async{
write(&mut socket,&Message::Ready(id)).await?;
let(mut r,mut w)=tokio::io::split(socket);let(tx,mut commands)=mpsc::channel(32);
let _reader=super::Abort(tokio::spawn(async move{loop{
let message=read(&mut r).await;let failed=message.is_err();
if tx.send(message).await.is_err() || failed{break}
}}));
loop{tokio::select!{
m=commands.recv()=>match m.ok_or("Local terminal closed")??{
Message::Input(b)=>t.write(id,&b).await?,Message::Resize(c,r)=>t.resize(id,c,r).await?,Message::Close=>break,
_=>return Err("Invalid local terminal command".into()),
},
e=output.recv()=>match e{
Ok(Event::Output{session,data})if session==id=>write(&mut w,&Message::Output(data)).await?,
Ok(Event::Exit{session,code})if session==id=>{write(&mut w,&Message::Exit(code)).await?;break},
Ok(Event::Error{session})if session==id=>{write(&mut w,&Message::Error).await?;break},
Err(_)=>return Err("Local terminal output closed or overflowed".into()),_=>{},
},
}}Ok(())
}.await;
let _=t.close(id).await;result
}
struct Input(Mutex<tokio::net::unix::OwnedWriteHalf>);
#[async_trait::async_trait]
impl cli::TerminalInput for Input {
async fn write(&self,_:u32,b:&[u8])->Result<(),String>{write(&mut *self.0.lock().await,&Message::Input(b.to_vec())).await}
async fn resize(&self,_:u32,c:u16,r:u16)->Result<(),String>{write(&mut *self.0.lock().await,&Message::Resize(c,r)).await}
}
pub async fn client(path:&Path,session:Option<u32>)->Result<(),String>{
let mut socket=UnixStream::connect(path).await.map_err(|_|"Terminal list is no longer available")?;
let(c,r)=cli::size();write(&mut socket,&Message::Open{session,cols:c,rows:r}).await?;
let Message::Ready(id)=read(&mut socket).await? else{return Err("Local terminal open failed".into())};
let(mut r,w)=socket.into_split();let input=Input(Mutex::new(w));let(tx,rx)=mpsc::channel(256);
let worker=tokio::spawn(async move{loop{
let event=match read(&mut r).await{Ok(Message::Output(data))=>Event::Output{session:id,data},Ok(Message::Exit(code))=>Event::Exit{session:id,code},_=>break};
if tx.send(event).await.is_err(){break}
}});
let result=cli::terminal_loop(&input,rx,id).await;
worker.abort();let _=worker.await;let _=write(&mut *input.0.lock().await,&Message::Close).await;result
}
#[cfg(test)] mod tests {
use super::*;
struct Mock(mpsc::Sender<super::super::Packet>);
#[async_trait::async_trait]
impl super::super::Send for Mock {
async fn send(&self,c:usize,b:Vec<u8>)->Result<(),String>{self.0.send((c,b)).await.map_err(|_|"Mock closed".into())}
}
#[tokio::test] async fn two_local_ttys_share_one_terminal_and_close_independently(){
tokio::time::timeout(std::time::Duration::from_secs(3),async{
use super::super::{terminal as term,BINARY};
let(tx,mut requests)=mpsc::channel(256);let(input,rx)=mpsc::channel(256);
let(t,mut events)=Terminal::new(super::super::Transport(Arc::new(Mock(tx))),rx);let t=Arc::new(t);
let(output,_)=broadcast::channel(256);let sender=output.clone();
let _relay=super::super::Abort(tokio::spawn(async move{while let Some(e)=events.recv().await{let _=sender.send(e);}}));
let(closed,mut closes)=mpsc::channel(8);
let _host=super::super::Abort(tokio::spawn(async move{
let mut next=40;
while let Some((channel,b))=requests.recv().await{
assert_eq!(channel,BINARY);let f=term::Decoder::default().push(&b).unwrap().remove(0);
let reply=match f.kind{
term::OPEN=>{next+=1;term::encode(term::OPEN_RESP,next,br#"{"code":0}"#)},
term::STDIN=>term::encode(term::STDOUT,f.session,&f.payload),
term::CLOSE=>{closed.send(f.session).await.unwrap();continue},_=>panic!("Unexpected remote request"),
};input.send((BINARY,reply)).await.unwrap();
}
}));
let opening=Arc::new(Mutex::new(()));let active:Sessions=Default::default();let mut clients=Vec::new();let mut tasks=Vec::new();
for _ in 0..2{
let(mut client,server)=tokio::io::duplex(4096);
let(t,opening,active,events)=(t.clone(),opening.clone(),active.clone(),output.subscribe());
tasks.push(tokio::spawn(serve(server,t,opening,active,events)));
write(&mut client,&Message::Open{session:None,cols:80,rows:24}).await.unwrap();
let Message::Ready(id)=read(&mut client).await.unwrap()else{panic!()};clients.push((client,id));
}
let(mut first,id)=clients.remove(0);write(&mut first,&Message::Close).await.unwrap();
assert_eq!(closes.recv().await.unwrap(),id);tasks.remove(0).await.unwrap().unwrap();
let(mut second,id)=clients.remove(0);
// Split an incoming frame while remote output is ready: the reader must retain framing.
let b=serde_json::to_vec(&Message::Input(vec![0,255,27])).unwrap();second.write_u32(b.len() as u32).await.unwrap();second.write_all(&b[..2]).await.unwrap();
assert!(output.send(Event::Output{session:id,data:b"synthetic".to_vec()}).is_ok());
assert!(matches!(read(&mut second).await,Ok(Message::Output(b))if b==b"synthetic"));
second.write_all(&b[2..]).await.unwrap();
assert!(matches!(read(&mut second).await,Ok(Message::Output(b))if b==[0,255,27]));
drop(second);assert_eq!(closes.recv().await.unwrap(),id);tasks.remove(0).await.unwrap().unwrap_err();
assert!(active.lock().unwrap().is_empty());
}).await.unwrap();
}
#[tokio::test] async fn framing_rejects_oversize_before_payload(){
let(mut a,mut b)=tokio::io::duplex(64);a.write_u32(MAX as u32+1).await.unwrap();
assert!(read(&mut b).await.err().unwrap().contains("limit"));
}
#[tokio::test] async fn framing_roundtrips_binary_and_detects_truncation(){
let(mut a,mut b)=tokio::io::duplex(256);
write(&mut a,&Message::Input(vec![0,255,27])).await.unwrap();
assert!(matches!(read(&mut b).await,Ok(Message::Input(v))if v==[0,255,27]));
a.write_u32(30).await.unwrap();drop(a);assert!(read(&mut b).await.is_err());
}
}
+194
View File
@@ -0,0 +1,194 @@
use super::*;
use tokio::io::{AsyncReadExt,AsyncWriteExt};
struct Mock(mpsc::Sender<Packet>);
#[async_trait::async_trait]
impl Send for Mock {async fn send(&self,c:usize,b:Vec<u8>)->Result<(),String>{self.0.send((c,b)).await.map_err(|_|"Mock closed".into())}}
fn pair()->(Transport,mpsc::Receiver<Packet>,mpsc::Sender<Packet>,mpsc::Receiver<Packet>){let(tx,out)=mpsc::channel(256);let(input,rx)=mpsc::channel(256);(Transport(Arc::new(Mock(tx))),rx,input,out)}
struct Temp(std::path::PathBuf);
impl Temp {fn new()->Self{let p=std::env::temp_dir().join(format!("uu-tools-test-{}",wire::uuid()));std::fs::create_dir(&p).unwrap();Self(p)}}
impl Drop for Temp {fn drop(&mut self){let _=std::fs::remove_dir_all(&self.0);}}
fn host_files()->(files::Files,mpsc::Receiver<files::Progress>,tokio::task::JoinHandle<()>,tokio::task::JoinHandle<()>){
let(io,rx,input,mut out)=pair();let(tx,mut host)=mpsc::unbounded_channel();
let session=crate::file_trans::FileSession::new(tx,Arc::new(std::sync::atomic::AtomicU64::new(1)));
let server=tokio::spawn(async move{while let Some((c,b))=out.recv().await{assert_eq!(c,CONTROL);assert!(session.handle(&decode_wire(&b).unwrap()));}});
let pump=tokio::spawn(async move{while let Some(b)=host.recv().await{if input.send((FILE,b)).await.is_err(){break}}});
let(f,p)=files::Files::new(io,rx);(f,p,server,pump)
}
#[test]
fn terminal_frames_match_host_and_incremental_decoder(){
let a=terminal::encode(terminal::OPEN,7,br#"{"cols":80,"rows":24}"#);
assert_eq!(a,crate::terminal::encode(crate::terminal::OPEN,7,br#"{"cols":80,"rows":24}"#));
let mut d=terminal::Decoder::default();let b=[a.clone(),terminal::encode(terminal::STDOUT,7,b"synthetic")].concat();let mut frames=Vec::new();
for part in b.chunks(3){frames.extend(d.push(part).unwrap());}assert_eq!(frames.len(),2);assert_eq!(frames[1].payload,b"synthetic");
assert!(terminal::Decoder::default().push(b"TERM\x02\x01\0\0\0\0\0\0\0\0\0\0").is_err());
let mut bad=a;bad[12..16].copy_from_slice(&u32::MAX.to_le_bytes());assert!(terminal::Decoder::default().push(&bad).is_err());
}
#[tokio::test]
async fn terminal_rpc_list_open_io_and_errors(){
let(io,rx,input,mut out)=pair();let(t,mut events)=terminal::Terminal::new(io,rx);
let server=tokio::spawn(async move{
let(tx,mut replies)=mpsc::unbounded_channel();let host=crate::terminal::TerminalConn::new(tx);
while let Some((c,b))=out.recv().await{
if c==CONTROL{let r=crate::terminal::rpc_response(&decode_wire(blob(&b,21).unwrap()).unwrap()).unwrap();input.send((CONTROL,wire::envelope(1,22,&r))).await.unwrap();continue}
assert_eq!(c,BINARY);let f=crate::terminal::decode(&b).unwrap();
match f.kind{
terminal::LIST_REQ=>{host.handle(&b);input.send((BINARY,replies.recv().await.unwrap())).await.unwrap();},
terminal::OPEN=>{let v:serde_json::Value=serde_json::from_slice(&f.payload).unwrap();assert_eq!(v["cols"],91);input.send((BINARY,terminal::encode(terminal::OPEN_RESP,37,br#"{"code":0}"#))).await.unwrap();},
terminal::STDIN=>input.send((BINARY,terminal::encode(terminal::STDOUT,f.session,&f.payload))).await.unwrap(),
terminal::RESIZE=>assert_eq!(serde_json::from_slice::<serde_json::Value>(&f.payload).unwrap()["rows"],40),
terminal::KILL_REQ=>input.send((BINARY,terminal::encode(terminal::KILL_RESP,f.session,br#"{"code":1}"#))).await.unwrap(),
terminal::CLOSE=>break,_=>panic!(),
}
}
});
t.check_env().await.unwrap();let _sessions=t.list_sessions().await.unwrap();let id=t.open(91,30).await.unwrap();
let data=vec![42;50_000];t.write(id,&data).await.unwrap();let mut received=Vec::new();
while received.len()<data.len(){match tokio::time::timeout(TIMEOUT,events.recv()).await.unwrap().unwrap(){terminal::Event::Output{data,..}=>{assert!(data.len()<=16*1024);received.extend(data)},_=>panic!()}}
assert_eq!(received,data);t.resize(id,100,40).await.unwrap();assert!(t.kill(id).await.is_err());t.close(id).await.unwrap();server.await.unwrap();
}
#[tokio::test]
async fn file_host_roundtrip_multiblock_empty_mkdir_and_errors(){
let tmp=Temp::new();let(f,mut progress,server,pump)=host_files();
let remote=tmp.0.join("remote");f.mkdir(remote.to_str().unwrap()).await.unwrap();
let source=tmp.0.join("source");let data:Vec<u8>=(0..130_111).map(|i|(i%251)as u8).collect();std::fs::write(&source,&data).unwrap();
let dest=remote.join("uploaded");f.upload(&source,dest.to_str().unwrap()).await.unwrap();assert_eq!(std::fs::read(&dest).unwrap(),data);
let entries=f.list_dir(remote.to_str().unwrap()).await.unwrap();assert_eq!(entries.len(),1);assert_eq!(entries[0].size,data.len()as u64);
let downloaded=tmp.0.join("downloaded");f.download(dest.to_str().unwrap(),&downloaded).await.unwrap();assert_eq!(std::fs::read(downloaded).unwrap(),data);
let empty=tmp.0.join("empty");std::fs::write(&empty,[]).unwrap();f.upload(&empty,remote.join("empty").to_str().unwrap()).await.unwrap();
let copy=tmp.0.join("empty-copy");f.download(empty.to_str().unwrap(),&copy).await.unwrap();assert_eq!(std::fs::metadata(copy).unwrap().len(),0);
let folder_copy=tmp.0.join("folder-copy");f.download(remote.to_str().unwrap(),&folder_copy).await.unwrap();assert_eq!(std::fs::read(folder_copy.join("uploaded")).unwrap(),data);
assert!(f.list_dir(tmp.0.join("missing").to_str().unwrap()).await.unwrap_err().contains("9"));
assert!(f.download(tmp.0.join("missing").to_str().unwrap(),tmp.0.join("absent")).await.unwrap_err().contains("9"));
assert!(progress.try_recv().is_ok());server.abort();pump.abort();
}
#[test]
fn directory_expansion_and_invalid_compression(){
use std::io::Write;let mut z=flate2::write::ZlibEncoder::new(Vec::new(),flate2::Compression::fast());z.write_all(&nested(1,b"synthetic")).unwrap();let data=z.finish().unwrap();assert_eq!(files::inflate(&data).unwrap(),nested(1,b"synthetic"));assert!(files::inflate(b"invalid").is_err());
}
#[tokio::test]
async fn files_cancel_wakes_pending_request(){
let(io,rx,_input,mut out)=pair();let(f,_)=files::Files::new(io,rx);
let op=f.list_dir("synthetic");tokio::pin!(op);
tokio::select!{r=&mut op=>panic!("unexpected {r:?}"),_=out.recv()=>{}};
f.cancel();assert!(tokio::time::timeout(Duration::from_secs(1),op).await.unwrap().unwrap_err().contains("canceled"));
}
#[tokio::test]
async fn forwarding_mock_loopback_echo_fragmentation_remove_and_reject(){
let target=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();let port=target.local_addr().unwrap().port();
let echo=tokio::spawn(async move{let(mut s,_)=target.accept().await.unwrap();let mut b=vec![0;4096];loop{let n=s.read(&mut b).await.unwrap();if n==0{break}s.write_all(&b[..n]).await.unwrap();}});
let(io,rx,input,mut out)=pair();let p=portmap::PortMap::new(io,rx);
let host=tokio::spawn(async move{
let mut tcp:Option<tokio::net::TcpStream>=None;
while let Some((c,b))=out.recv().await{
assert_eq!(c,FILE);let f=blob(&b,27).unwrap();let(s,r,t)=(uint(f,1),uint(f,2),uint(f,3));
match uint(f,4){
0=>{let v:serde_json::Value=serde_json::from_slice(blob(f,5).unwrap()).unwrap();assert_eq!(v["version"],1);let target=v["target_port"].as_u64().unwrap()as u16;
let connected=if target==port {tokio::net::TcpStream::connect(("127.0.0.1",target)).await.ok()}else{None};let ok=connected.is_some();tcp=connected;
input.send((FILE,portmap::frame(s,r,t,3,if ok{br#"{"version":1,"ok":true}"#}else{br#"{"version":1,"ok":false}"#}))).await.unwrap();},
2=>{let payload=blob(f,5).unwrap();assert!(payload.len()<=16*1024);let socket=tcp.as_mut().unwrap();socket.write_all(payload).await.unwrap();let mut b=vec![0;payload.len()];socket.read_exact(&mut b).await.unwrap();input.send((FILE,portmap::frame(s,r,t,2,&b))).await.unwrap();},
1=>{tcp.take();},_=>panic!(),
}
}
});
let id=p.add_rule("echo",0,"127.0.0.1",port).await.unwrap();let local=p.status()[0].local_port;
let mut socket=tokio::net::TcpStream::connect(("127.0.0.1",local)).await.unwrap();let bytes=vec![91;100_000];socket.write_all(&bytes).await.unwrap();let mut received=vec![0;bytes.len()];tokio::time::timeout(TIMEOUT,socket.read_exact(&mut received)).await.unwrap().unwrap();assert_eq!(received,bytes);
p.remove_rule(id).await.unwrap();assert!(p.status().is_empty());assert!(tokio::net::TcpStream::connect(("127.0.0.1",local)).await.is_err());
let id=p.add_rule("reject",0,"127.0.0.1",1).await.unwrap();let mut socket=tokio::net::TcpStream::connect(("127.0.0.1",p.status()[0].local_port)).await.unwrap();assert_eq!(tokio::time::timeout(TIMEOUT,socket.read(&mut [0])).await.unwrap().unwrap(),0);
assert_eq!(p.status()[0].failures,1);p.remove_rule(id).await.unwrap();host.abort();echo.await.unwrap();
}
#[tokio::test]
async fn file_download_reorders_blocks_and_rejects_traversal(){
for (unsafe_name,one_based) in [(false,true),(false,false),(true,false)]{
let tmp=Temp::new();let(io,rx,input,mut out)=pair();let(f,_)=files::Files::new(io,rx);
let host=tokio::spawn(async move{
let(_,b)=out.recv().await.unwrap();let r=blob(&b,21).unwrap();let rid=uint(blob(r,1).unwrap(),1);let req=blob(blob(r,8).unwrap(),2).unwrap();let task=uint(blob(req,1).unwrap(),1);
let mut info=nested(1,if unsafe_name{b"../escape"}else{b"file"});wire::int(2,6,&mut info);
let mut response=nested(1,&ints(&[(1,task)]));wire::int(2,1,&mut response);wire::bytes(3,&info,&mut response);
input.send((FILE,rpc(rid,true,2,&response))).await.unwrap();
if unsafe_name{
// Let the client reject an ask, then close the host task normally.
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,6,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();
let(_,reply)=out.recv().await.unwrap();assert_eq!(uint(blob(blob(blob(&reply,22).unwrap(),4).unwrap(),3).unwrap(),3),7);
}else{
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,6,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();out.recv().await.unwrap();
// Official Windows host numbering starts at 1 (base fixed at completion); our host sends 0-based out of order.
let blocks:&[(u64,&[u8;2])]=if one_based {&[(1,b"ab"),(3,b"ef"),(2,b"cd")]} else {&[(2,b"ef"),(0,b"ab"),(1,b"cd")]};
for &(block,data) in blocks {let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,block,&mut b);wire::bytes(3,data,&mut b);input.send((FILE,rpc(901+block,false,4,&b))).await.unwrap();out.recv().await.unwrap();}
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,1,&mut b);input.send((FILE,rpc(903,false,9,&b))).await.unwrap();out.recv().await.unwrap();
}
let mut b=nested(1,&ints(&[(1,task),(2,u64::MAX)]));wire::int(2,1,&mut b);input.send((FILE,rpc(904,false,9,&b))).await.unwrap();
});
let target=tmp.0.join("received");let result=f.download("synthetic",&target).await;
if unsafe_name{assert!(result.unwrap_err().contains("Unsafe"));assert!(!tmp.0.join("escape").exists());assert!(!target.exists());}else{result.unwrap();assert_eq!(std::fs::read(target).unwrap(),b"abcdef");}
host.await.unwrap();
}
}
#[tokio::test]
async fn cancel_download_rejects_host_and_removes_staging(){
let tmp=Temp::new();let(io,rx,input,mut out)=pair();let(f,_)=files::Files::new(io,rx);let(asked,ready)=tokio::sync::oneshot::channel();
let host=tokio::spawn(async move{
let(_,b)=out.recv().await.unwrap();let r=blob(&b,21).unwrap();let rid=uint(blob(r,1).unwrap(),1);let req=blob(blob(r,8).unwrap(),2).unwrap();let task=uint(blob(req,1).unwrap(),1);
let mut info=nested(1,b"file");wire::int(2,10,&mut info);let mut b=nested(1,&ints(&[(1,task)]));wire::int(2,1,&mut b);wire::bytes(3,&info,&mut b);
input.send((FILE,rpc(rid,true,2,&b))).await.unwrap();let _=asked.send(());
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,10,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();
let(_,reply)=out.recv().await.unwrap();let code=uint(blob(blob(blob(&reply,22).unwrap(),4).unwrap(),3).unwrap(),3);
if code==1{
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,0,&mut b);wire::bytes(3,b"synthetic!",&mut b);input.send((FILE,rpc(901,false,4,&b))).await.unwrap();let(_,r)=out.recv().await.unwrap();assert_eq!(uint(blob(blob(blob(&r,22).unwrap(),4).unwrap(),4).unwrap(),3),7);
}else{assert_eq!(code,7);}
let mut b=nested(1,&ints(&[(1,task),(2,u64::MAX)]));wire::int(2,7,&mut b);input.send((FILE,rpc(902,false,9,&b))).await.unwrap();
});
let target=tmp.0.join("received");let op=f.download("synthetic",&target);tokio::pin!(op);
tokio::select!{r=&mut op=>panic!("unexpected {r:?}"),_=ready=>{}}f.cancel();
assert!(tokio::time::timeout(Duration::from_secs(4),op).await.unwrap().unwrap_err().contains("canceled"));host.await.unwrap();assert!(!target.exists());assert_eq!(std::fs::read_dir(&tmp.0).unwrap().count(),0);
}
#[tokio::test]
async fn forwarding_transport_close_stops_listener(){
let(io,rx,input,_out)=pair();let p=portmap::PortMap::new(io,rx);let id=p.add_rule("closed",0,"127.0.0.1",1).await.unwrap();let port=p.status()[0].local_port;
drop(input);tokio::time::timeout(Duration::from_secs(1),p.closed()).await.unwrap();
p.remove_rule(id).await.unwrap();assert!(tokio::net::TcpStream::connect(("127.0.0.1",port)).await.is_err());
assert!(p.add_rule("unavailable",0,"127.0.0.1",1).await.is_err());
}
#[test]
fn terminal_metadata_is_allowlisted_and_sorted(){
let rows=terminal::session_rows(&[
serde_json::json!({"session_id":9,"shell":"/bin/sh\tX\nY\0","state":"detached","created_at_ms":123,"output":"PRIVATE","name":"PRIVATE"}),
serde_json::json!({"session_id":2,"shell":"/bin/bash","state":"running"}),
serde_json::json!({"session_id":0}),serde_json::json!({"session_id":4294967296u64}),
]);
assert_eq!(rows,"2\t/bin/bash\t0\t运行中\n9\t/bin/sh X Y \t123\t已分离\n");
assert!(!rows.contains("PRIVATE"));assert!(terminal::session_rows(&[]).is_empty());
}
#[tokio::test]
async fn terminal_attach_uses_existing_id_and_rejects_absent_session(){
let(io,rx,input,mut out)=pair();let(t,_events)=terminal::Terminal::new(io,rx);
let host=tokio::spawn(async move{
for id in [37,99]{
let(c,b)=out.recv().await.unwrap();assert_eq!(c,BINARY);
let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::LIST_REQ);
input.send((BINARY,terminal::encode(terminal::LIST_RESP,f.session,br#"[{"session_id":37}]"#))).await.unwrap();
if id==37{
let(_,b)=out.recv().await.unwrap();let f=crate::terminal::decode(&b).unwrap();
assert_eq!(f.kind,terminal::OPEN);assert_eq!(f.session,37);
let v:serde_json::Value=serde_json::from_slice(&f.payload).unwrap();assert_eq!(v["cols"],90);assert_eq!(v["rows"],30);
input.send((BINARY,terminal::encode(terminal::OPEN_RESP,37,br#"{"code":0}"#))).await.unwrap();
}
}
assert!(out.try_recv().is_err());
});
assert_eq!(t.attach(37,90,30).await.unwrap(),37);
assert!(t.attach(99,90,30).await.is_err());assert!(t.attach(0,90,30).await.is_err());host.await.unwrap();
}
#[tokio::test]
async fn terminal_kill_acknowledgement_and_empty_refresh(){
let(io,rx,input,mut out)=pair();let(t,_events)=terminal::Terminal::new(io,rx);
let host=tokio::spawn(async move{
let(c,b)=out.recv().await.unwrap();assert_eq!(c,BINARY);
let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::KILL_REQ);assert_eq!(f.session,42);
input.send((BINARY,terminal::encode(terminal::KILL_RESP,42,br#"{"code":0}"#))).await.unwrap();
let(_,b)=out.recv().await.unwrap();let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::LIST_REQ);
input.send((BINARY,terminal::encode(terminal::LIST_RESP,f.session,b"[]"))).await.unwrap();
});
t.kill(42).await.unwrap();assert!(t.list_sessions().await.unwrap().is_empty());host.await.unwrap();
}
+240
View File
@@ -0,0 +1,240 @@
//! GTK windows for file transfer, port mapping and terminal sessions. Paths, names and
//! ports are shown only in the local window; logs keep to the existing id/field diagnostics.
use super::tools::{files::{Entry,Files},portmap::PortMap,Packet,Transport};
use std::ffi::{CStr,CString};
use std::os::raw::{c_char,c_int,c_ulonglong};
use std::sync::{Arc,Mutex,atomic::{AtomicU64,AtomicBool,Ordering}};
use std::time::{Duration,Instant};
use tokio::sync::mpsc;
extern "C" {
fn uu_tools_ui_start(kind:*const c_char,name:*const c_char)->c_int;
fn uu_tools_ui_take(out:*mut c_char,len:usize)->c_int;
fn uu_tools_ui_closed()->c_int;
fn uu_tools_ui_hide();
fn uu_tools_ui_present();
fn uu_tools_ui_toast(text:*const c_char);
fn uu_files_ui_set_remote(path:*const c_char,rows:*const c_char);
fn uu_files_ui_task(id:c_int,name:*const c_char,status:*const c_char,transferred:c_ulonglong,total:c_ulonglong,from:*const c_char,to:*const c_char,done:c_int);
fn uu_files_ui_refresh_local();
fn uu_terminal_ui_set(rows:*const c_char,connected:c_int);
fn uu_portmap_ui_set_rules(rows:*const c_char);
}
fn c(text:&str)->CString{CString::new(text.replace('\0',"")).unwrap_or_default()}
fn toast(text:&str){let t=c(text);unsafe{uu_tools_ui_toast(t.as_ptr())}}
fn take()->Option<String>{
let mut buf=vec![0 as c_char;4096];
(unsafe{uu_tools_ui_take(buf.as_mut_ptr(),buf.len())}!=0).then(||unsafe{CStr::from_ptr(buf.as_ptr())}.to_string_lossy().into_owned())
}
pub fn hide(){unsafe{uu_tools_ui_hide()}}
pub fn present(){unsafe{uu_tools_ui_present()}}
pub fn closed()->bool{(unsafe{uu_tools_ui_closed()})!=0}
fn start(kind:&str,name:&str)->Result<(),String>{
let(k,n)=(c(kind),c(name));
if unsafe{uu_tools_ui_start(k.as_ptr(),n.as_ptr())}!=0{return Err("Cannot open the window (GTK3 and a graphical session are required)".into())}Ok(())
}
/// Last path component for either separator; hosts may be Windows (`C:\x`) or Unix.
pub fn base_name(path:&str)->&str{path.trim_end_matches(['/','\\']).rsplit(['/','\\']).next().filter(|s|!s.is_empty()).unwrap_or(path)}
pub fn remote_join(dir:&str,name:&str)->String{
let sep=if dir.contains('\\') && !dir.contains('/'){'\\'}else{'/'};
if dir.ends_with(['/','\\']){format!("{dir}{name}")}else{format!("{dir}{sep}{name}")}
}
/// First free `name`, `name (1)`, ... in `dir` so a download never replaces a local file.
pub fn free_local(dir:&std::path::Path,name:&str)->std::path::PathBuf{
let(stem,ext)=match name.rfind('.'){Some(i) if i>0=>(&name[..i],&name[i..]),_=>(name,"")};
(0..).map(|n|dir.join(if n==0{name.to_owned()}else{format!("{stem} ({n}){ext}")})).find(|p|!p.exists()).unwrap()
}
pub fn entry_rows(entries:&[Entry])->String{
let clean=|s:&str|s.replace(['\t','\n','\r']," ");
entries.iter().map(|e|format!("{}\t{}\t{}\t{}\t{}\n",e.kind,clean(&e.name),e.size,e.modified,clean(&e.path))).collect()
}
enum Job {List(String),Mkdir(String,String),Transfer{id:i32,upload:bool,from:String,dir:String,generation:u64}}
struct Active {id:i32,name:String,from:String,to:String,last:Instant}
fn task(id:i32,name:&str,status:&str,done:u64,total:u64,from:&str,to:&str,state:i32){
let(n,s,f,t)=(c(name),c(status),c(from),c(to));
unsafe{uu_files_ui_task(id,n.as_ptr(),s.as_ptr(),done,total,f.as_ptr(),t.as_ptr(),state)}
}
fn reason(error:&str)->String{if error.contains("canceled"){"已取消".into()}else{format!("失败:{error}")}}
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
start("files",name)?;
let(f,mut progress)=Files::new(io,rx);let f=Arc::new(f);
let generation=Arc::new(AtomicU64::new(0));
let active:Arc<Mutex<Option<Active>>>=Arc::new(Mutex::new(None));
let shown=active.clone();
let reporter=tokio::spawn(async move{
while let Some(p)=progress.recv().await{
let mut guard=shown.lock().unwrap();let Some(a)=guard.as_mut() else{continue};
if a.last.elapsed()<Duration::from_millis(200) && p.transferred<p.total{continue}a.last=Instant::now();
let percent=if p.total>0{p.transferred*100/p.total}else{0};
task(a.id,&a.name,&format!("传输中 {percent}%"),p.transferred,p.total,&a.from,&a.to,0);
}
});
let _reporter=super::tools::Cancel(reporter.abort_handle());
let(jobs,mut queue)=mpsc::unbounded_channel::<Job>();
let closing=Arc::new(AtomicBool::new(false));let worker_closing=closing.clone();
let(worker_f,worker_gen,worker_active)=(f.clone(),generation.clone(),active.clone());
let mut worker=tokio::spawn(async move{
let mut remote=":/".to_owned();
while let Some(job)=queue.recv().await{if worker_closing.load(Ordering::Acquire){break}match job{
Job::List(path)=>match worker_f.list_dir(&path).await{
Ok(entries)=>{remote=path.clone();let(p,r)=(c(&path),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}
Err(e)=>toast(&format!("无法读取远端目录:{e}")),
},
Job::Mkdir(path,parent)=>match worker_f.mkdir(&path).await{
Ok(())=>if parent==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}},
Err(e)=>toast(&format!("无法创建远端文件夹:{e}")),
},
Job::Transfer{id,upload,from,dir,generation}=>{
let name=base_name(&from).to_owned();
let to=if upload{remote_join(&dir,&name)}else{free_local(std::path::Path::new(&dir),&name).to_string_lossy().into_owned()};
if generation!=worker_gen.load(Ordering::Acquire){task(id,&name,"已取消",0,0,&from,&to,2);continue}
*worker_active.lock().unwrap()=Some(Active{id,name:name.clone(),from:from.clone(),to:to.clone(),last:Instant::now()});
task(id,&name,"传输中",0,0,&from,&to,0);
let result=if upload{worker_f.upload(&from,&to).await}else{worker_f.download(&from,&to).await};
*worker_active.lock().unwrap()=None;
match result{
Ok(())=>{
let size=std::fs::metadata(if upload{&from}else{&to}).map(|m|if m.is_file(){m.len()}else{0}).unwrap_or(0);
task(id,&name,"已完成",size,size,&from,&to,1);
if upload{if dir==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}}}
else{unsafe{uu_files_ui_refresh_local()}}
}
Err(e)=>task(id,&name,&reason(&e),0,0,&from,&to,2),
}
}
}}
});
let _worker=super::tools::Cancel(worker.abort_handle());
let _=jobs.send(Job::List(":/".into()));
static NEXT_TASK:std::sync::atomic::AtomicI32=std::sync::atomic::AtomicI32::new(1);
let result=loop{
if closed(){break Ok(())}
if worker.is_finished(){break Err("File transfer worker stopped".into())}
while let Some(cmd)=take(){
let parts:Vec<&str>=cmd.split('\t').collect();
match parts.as_slice(){
["ls",path]=>{let _=jobs.send(Job::List((*path).into()));}
["mkdir",path]=>{let parent=path.rfind(['/','\\']).map(|i|path[..i.max(1)].to_owned()).unwrap_or_default();let _=jobs.send(Job::Mkdir((*path).into(),parent));}
[kind@("put"|"get"),from,dir]=>{
let(id,upload)=(NEXT_TASK.fetch_add(1,Ordering::Relaxed),*kind=="put");
let name=base_name(from);task(id,name,"等待中",0,0,from,dir,0);
let _=jobs.send(Job::Transfer{id,upload,from:(*from).into(),dir:(*dir).into(),generation:generation.load(Ordering::Acquire)});
}
["cancel"]=>{generation.fetch_add(1,Ordering::AcqRel);f.cancel();}
_=>{}
}
}
tokio::time::sleep(Duration::from_millis(100)).await;
};
closing.store(true,Ordering::Release);drop(jobs);f.cancel();
// Allow the existing transfer cancellation handshake to release the host's window.
if tokio::time::timeout(Duration::from_secs(5),&mut worker).await.is_err(){worker.abort();let _=worker.await;}
reporter.abort();let _=reporter.await;result
}
pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
start("portmap",name)?;
let p=PortMap::new(io,rx);
let mut targets:std::collections::HashMap<u64,String>=Default::default();
let mut last=String::from("-");
let closed_transport=p.closed();tokio::pin!(closed_transport);
let result=loop{
if closed(){break Ok(())}
while let Some(cmd)=take(){
let parts:Vec<&str>=cmd.split('\t').collect();
match parts.as_slice(){
["add",rule,local,host,port]=>match(local.parse::<u16>(),port.parse::<u16>()){
(Ok(local),Ok(port))=>match p.add_rule(*rule,local,*host,port).await{
Ok(id)=>{targets.insert(id,format!("{host}:{port}"));}
Err(e)=>toast(&format!("添加失败:{}",if e.contains("bind"){"本地端口已被占用".to_owned()}else{e})),
},
_=>toast("端口无效"),
},
["remove",id]=>if let Ok(id)=id.parse::<u64>(){
if let Err(e)=p.remove_rule(id).await{toast(&format!("删除失败:{e}"))}targets.remove(&id);
},
_=>{}
}
}
let mut status=p.status();status.sort_by_key(|s|s.id);
let rows:String=status.iter().map(|s|format!("{}\t{}\t127.0.0.1:{}\t{}\t{}\n",s.id,s.name.replace(['\t','\n']," "),s.local_port,
targets.get(&s.id).map(String::as_str).unwrap_or("-"),
if s.failures>0{format!("已启用 · {} 个连接 · {} 次失败",s.streams,s.failures)}else{format!("已启用 · {} 个连接",s.streams)})).collect();
if rows!=last{let r=c(&rows);unsafe{uu_portmap_ui_set_rules(r.as_ptr())};last=rows;}
tokio::select!{_=&mut closed_transport=>{toast("连接已断开");tokio::time::sleep(Duration::from_secs(3)).await;break Err("Forwarding transport closed".into())},_=tokio::time::sleep(Duration::from_millis(200))=>{}}
};
let ids:Vec<u64>=p.status().iter().map(|s|s.id).collect();for id in ids{let _=p.remove_rule(id).await;}
result
}
// The worker serializes LIST/KILL requests; GTK commands remain responsive during network waits.
pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&str)->Result<(),String>{
use super::tools::terminal::{Terminal,session_rows,local_terminal_command};
let exe=std::env::current_exe().map_err(|_|"Cannot locate executable")?;
start("terminal",name)?;
let(t,mut events)=Terminal::new(io,rx);let t=Arc::new(t);
let server=super::tools::terminal_ipc::Server::new()?;let path=server.path.clone();
let(output,_)=tokio::sync::broadcast::channel(256);
let ipc=super::tools::Abort(tokio::spawn(server.run(t.clone(),output.clone())));
let relay=super::tools::Abort(tokio::spawn(async move{while let Some(e)=events.recv().await{let _=output.send(e);}}));
let(jobs,mut queue)=mpsc::unbounded_channel::<u32>();
let worker=tokio::spawn(async move{
let operation=async{
t.check_env().await?;
let mut refresh=tokio::time::interval(Duration::from_secs(2));
refresh.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop{tokio::select!{
_=refresh.tick()=>{
let rows=c(&session_rows(&t.list_sessions().await?));
unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}
},
id=queue.recv()=>match id{
Some(id)=>{if t.kill(id).await.is_err(){toast("结束会话失败,会话可能已退出")}
let rows=c(&session_rows(&t.list_sessions().await?));unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}},
None=>return Ok::<(),String>(()),
},
_=tokio::time::sleep(Duration::from_millis(100)),if relay.0.is_finished()=>return Err("Terminal channel closed".into()),
}}
}.await;
if operation.is_err(){unsafe{uu_terminal_ui_set(c("").as_ptr(),0)};toast("终端连接已断开,请关闭窗口后重试")}
});
let _worker=super::tools::Cancel(worker.abort_handle());
let mut children:Vec<std::process::Child>=Vec::new();
while !closed(){
if worker.is_finished(){ipc.0.abort();}
children.retain_mut(|child|matches!(child.try_wait(),Ok(None)));
while let Some(cmd)=take(){
if worker.is_finished(){toast("连接已断开");continue}
let parts:Vec<_>=cmd.split('\t').collect();
let session=match parts.as_slice(){
["create"]=>None,
["open",id]=>match id.parse::<u32>().ok().filter(|n|*n!=0){Some(id)=>Some(id),None=>continue},
["kill",id]=>{if let Ok(id)=id.parse::<u32>(){let _=jobs.send(id);}continue},
_=>continue,
};
match local_terminal_command(&exe,&path,session){
Some(mut command)=>match command.spawn(){Ok(child)=>children.push(child),Err(_)=>toast("无法启动本机终端程序")},
None=>toast("没有找到本机终端程序(可设置 TERMINAL 环境变量)"),
}
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
worker.abort();let _=worker.await;
drop(ipc);
// Closing the list drops all local IPC clients; reap emulator launchers off-thread.
std::thread::spawn(move||{for mut child in children{let _=child.wait();}});
Ok(())
}
#[cfg(test)] mod tests {
use super::*;
#[test] fn path_helpers_handle_both_separators() {
assert_eq!(base_name("/home/u/a.txt"),"a.txt");assert_eq!(base_name("C:\\Users\\x\\"),"x");assert_eq!(base_name("/"),"/");
assert_eq!(remote_join("/home/u","a"),"/home/u/a");assert_eq!(remote_join("/","a"),"/a");assert_eq!(remote_join("C:\\Users","a"),"C:\\Users\\a");
let dir=std::env::temp_dir().join(format!("uu-free-{}",super::super::wire::uuid()));std::fs::create_dir(&dir).unwrap();
std::fs::write(dir.join("a.txt"),b"").unwrap();
assert_eq!(free_local(&dir,"a.txt"),dir.join("a (1).txt"));assert_eq!(free_local(&dir,"b"),dir.join("b"));
std::fs::remove_file(dir.join("a.txt")).unwrap();std::fs::remove_dir(&dir).unwrap();
}
}
+217
View File
@@ -0,0 +1,217 @@
//! Launcher window (`uuremote-viewer ui`): QR sign-in, device list, and one child process per
//! remote session so each SDL window is isolated. Account data never reaches the logs.
use serde_json::Value;
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int};
use std::time::{Duration, Instant, SystemTime};
extern "C" {
fn uu_viewer_ui_start() -> c_int;
fn uu_viewer_ui_set_devices(tsv: *const c_char);
fn uu_viewer_ui_set_login(signed_in: c_int, qr_png: *const c_char, status: *const c_char, user: *const c_char);
fn uu_viewer_ui_take_command(out: *mut c_char, len: usize) -> c_int;
fn uu_viewer_ui_closed() -> c_int;
fn uu_viewer_ui_confirm_replace() -> c_int;
fn uu_viewer_ui_toast(text: *const c_char);
}
fn toast(text: &str) { let t = c(text); unsafe { uu_viewer_ui_toast(t.as_ptr()) } }
/// Runs one session child; on failure shows its last error line (log lines start with '[').
fn watch_session(mut child: tokio::process::Child, mut cancel: tokio::sync::oneshot::Receiver<()>, success: Option<&'static str>) -> tokio::task::JoinHandle<()> {
use tokio::io::AsyncBufReadExt;
let stderr = child.stderr.take();
tokio::spawn(async move {
let mut last = String::new();
let mut lines = stderr.map(|e| tokio::io::BufReader::new(e).lines());
let status = loop {
tokio::select! {
_ = &mut cancel => {
if let Some(id)=child.id(){unsafe{libc::kill(id as i32,libc::SIGTERM);}}
if tokio::time::timeout(Duration::from_secs(6),child.wait()).await.is_err(){let _=child.kill().await;}return;
}
status = child.wait() => break status,
line = async { match lines.as_mut() { Some(l) => l.next_line().await, None => std::future::pending().await } } => match line {
Ok(Some(l)) => { if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); } }
_ => lines = None,
},
}
};
// wait() may win before the final stderr line is read.
let _ = tokio::time::timeout(Duration::from_millis(200), async {
if let Some(lines) = lines.as_mut() {
while let Ok(Some(l)) = lines.next_line().await {
if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); }
}
}
}).await;
if !status.is_ok_and(|s| s.success()) {
let reason = match last.as_str() {
"" => "连接已断开".to_owned(),
"CONTROL echo timed out" => "连接超时:被控端没有响应(官方主机互通尚未完成)".to_owned(),
"Remote session released" => "被控端结束了本次连接".to_owned(),
other => other.to_owned(),
};
toast(&format!("连接失败:{reason}"));
} else if let Some(message) = success { toast(message); }
})
}
struct Running { cancel:tokio::sync::oneshot::Sender<()>, task:tokio::task::JoinHandle<()>, input:Option<tokio::process::ChildStdin> }
impl Running { async fn stop(self){let _=self.cancel.send(());let _=self.task.await;} }
async fn replace(sessions:&mut std::collections::HashMap<String,Running>,id:&str)->bool{
if sessions.get(id).is_some_and(|s|!s.task.is_finished()) && unsafe{uu_viewer_ui_confirm_replace()}!=1{return false}
if let Some(old)=sessions.remove(id){old.stop().await;}true
}
fn c(text: &str) -> CString { CString::new(text.replace('\0', "")).unwrap_or_default() }
fn set_login(signed_in: bool, qr: &str, status: &str, user: &str) {
let (q, s, u) = (c(qr), c(status), c(user));
unsafe { uu_viewer_ui_set_login(signed_in as c_int, q.as_ptr(), s.as_ptr(), u.as_ptr()) }
}
fn take() -> Option<String> {
let mut buf = [0 as c_char; 200];
(unsafe { uu_viewer_ui_take_command(buf.as_mut_ptr(), buf.len()) } != 0)
.then(|| unsafe { CStr::from_ptr(buf.as_ptr()) }.to_string_lossy().into_owned())
}
/// "id\tname\tplatform\tonline\tcurrent" lines; tabs and newlines in names are flattened.
pub fn device_rows(devices: &[Value], current: Option<&str>) -> String {
let clean = |s: &str| s.replace(['\t', '\n', '\r'], " ");
devices.iter().filter_map(|d| {
let id = d.get("device_id")?.as_str()?;
let name = d.get("alias").and_then(Value::as_str).unwrap_or(id);
let platform = d.get("platform").and_then(Value::as_i64).unwrap_or(0);
let online = d.get("status").and_then(Value::as_str) == Some("CONNECTED");
Some(format!("{}\t{}\t{}\t{}\t{}\n", clean(id), clean(name), platform, online as u8, (current == Some(id)) as u8))
}).collect()
}
pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, String>) -> Result<(), String> {
if unsafe { uu_viewer_ui_start() } != 0 { return Err("Cannot open the window (GTK3 and a graphical session are required)".into()); }
let exe = std::env::current_exe().map_err(|_| "Cannot locate executable")?;
let qr = std::env::temp_dir().join(format!("uu-viewer-qr-{}.png", std::process::id()));
let mut login: Option<tokio::process::Child> = None;
let mut qr_seen: Option<SystemTime> = None;
let mut next_refresh = Instant::now();
let mut sessions:std::collections::HashMap<String,Running>=Default::default();
let mut names: std::collections::HashMap<String, String> = Default::default();
let refresh = |creds: &crate::auth::Credentials| {
let api = super::api::Api::new(crate::auth::UUAuthClient::new(creds.clone()), crate::auth::BASE_URL);
async move { api.device_list().await }
};
loop {
if unsafe { uu_viewer_ui_closed() } != 0 { break; }
sessions.retain(|_,s| !s.task.is_finished());
if let Some(child) = login.as_mut() {
if let Ok(meta) = std::fs::metadata(&qr) {
if meta.modified().ok() != qr_seen { qr_seen = meta.modified().ok(); set_login(false, &qr.to_string_lossy(), "请用手机扫码并确认", ""); }
}
if let Ok(Some(_)) = child.try_wait() { login = None; let _ = std::fs::remove_file(&qr); next_refresh = Instant::now(); }
} else if Instant::now() >= next_refresh {
next_refresh = Instant::now() + Duration::from_secs(30);
match credentials() {
Ok(creds) => {
set_login(true, "", "", "已登录");
match refresh(&creds).await {
Ok(data) => {
let list = data.get("my_binded_devices").and_then(Value::as_array).cloned().unwrap_or_default();
let current = data.pointer("/current_device/device_id").and_then(Value::as_str);
names = list.iter().filter_map(|d| Some((d.get("device_id")?.as_str()?.to_owned(),
d.get("alias").and_then(Value::as_str).unwrap_or("远端设备").to_owned()))).collect();
let rows = c(&device_rows(&list, current)); unsafe { uu_viewer_ui_set_devices(rows.as_ptr()) }
}
Err(super::api::Error::AuthenticationExpired) => set_login(false, "", "登录已过期,请重新登录", ""),
Err(_) => {}
}
}
Err(_) => set_login(false, "", "尚未登录", ""),
}
}
while let Some(cmd) = take() {
let parts: Vec<&str> = cmd.split('\t').collect();
match parts.as_slice() {
["quit"] => break,
["refresh"] => next_refresh = Instant::now(),
["logout"] => {
// Sign out locally: drop the account token, keep the device identity.
let path = crate::config::path();
if let Ok(mut v) = std::fs::read_to_string(&path).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()).ok_or(()) {
if let Some(o) = v.as_object_mut() { o.remove("token"); o.remove("csrf"); }
let _ = std::fs::write(&path, v.to_string());
}
for (_,s) in sessions.drain() { s.stop().await; }
unsafe { uu_viewer_ui_set_devices(c("").as_ptr()) }
set_login(false, "", "已退出登录", "");
next_refresh = Instant::now() + Duration::from_secs(3600);
}
["login"] if login.is_none() => {
let server = exe.with_file_name("uuremote-server");
login = tokio::process::Command::new(server).args(["login", "--no-gui"])
.env("UU_LOGIN_QR_PNG", &qr).stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null())
.kill_on_drop(true).spawn().ok();
if login.is_none() { set_login(false, "", "找不到配套的 uuremote-server", ""); }
}
["connect", id, kind] if matches!(*kind, "desktop" | "watch") => {
if !replace(&mut sessions,id).await{continue}
// One process per session; "-" selects the built-in desktop connection shape.
let mut command=tokio::process::Command::new(&exe);
command.args(["connect", id, "false", "-", "echo", "legacy"]);
command.env("UU_VIEWER_DEVICE_NAME", super::device_label(names.get(*id).map(String::as_str)));
if *kind=="watch" {command.arg("--view-only");}
match command.env("UU_VIEWER_COMMANDS","1").stdin(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
Ok(mut child) => { let input=child.stdin.take();let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input}); }
Err(_) => toast("连接失败:无法启动会话进程"),
}
}
["assist", id, code] => {
match super::assist::command(&exe, id).spawn() {
Ok(mut child) => match super::assist::send_code(&mut child, code).await {
Ok(()) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert(format!("assist:{id}"),Running{cancel,task,input:None}); }
Err(reason) => toast(&format!("连接失败:{reason}")),
},
Err(_) => toast("连接失败:无法启动协助会话进程"),
}
}
["connect", id, kind @ ("file" | "portmap" | "terminal")] => {
if *kind=="file" {if let Some(s)=sessions.get_mut(*id){if let Some(input)=s.input.as_mut(){
use tokio::io::AsyncWriteExt;
if input.write_all(b"files\n").await.is_err(){toast("桌面会话命令发送失败,请重试")}continue
}}}
if !replace(&mut sessions,id).await{continue}
let name = names.get(*id).cloned().unwrap_or_else(|| "远端设备".into());
let tool = if *kind == "file" { "files-ui" } else if *kind == "terminal" { "terminal-ui" } else { "portmap-ui" };
match tokio::process::Command::new(&exe).args([tool, id, &name])
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input:None}); }
Err(_) => toast("连接失败:无法启动工具进程"),
}
}
["connect", id, kind @ ("reboot" | "shutdown")] => {
if !replace(&mut sessions,id).await{continue}
match tokio::process::Command::new(&exe).args(["power", id, kind])
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,Some("电源指令已发送,未确认远端执行结果"));sessions.insert((*id).into(),Running{cancel,task,input:None}); }
Err(_) => toast("电源指令失败:无法启动会话进程"),
}
}
["connect", _, kind] => log::info!("Viewer UI: {kind} is not supported yet"),
_ => {}
}
}
tokio::time::sleep(Duration::from_millis(200)).await;
}
for (_,s) in sessions {s.stop().await;}
Ok(())
}
#[cfg(test)] mod tests {
#[test] fn device_rows_flatten_names_and_mark_online() {
let rows = super::device_rows(&[
serde_json::json!({"device_id":"d1","alias":"a\tb","platform":4,"status":"CONNECTED"}),
serde_json::json!({"device_id":"d2","platform":1,"status":"DISCONNECTED"}),
serde_json::json!({"alias":"no id"}),
], Some("d2"));
assert_eq!(rows, "d1\ta b\t4\t1\t0\nd2\td2\t1\t0\t1\n");
}
}
+183
View File
@@ -0,0 +1,183 @@
//! Shapes from viewer-connect-shape-20261016.md; values describe caller capabilities.
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use crate::protocol::{decode_wire, WireValue};
pub const CHANNELS: [&str; 5] = ["CONTROL_DATA_CHANNEL", "TEXT_DATA_CHANNEL", "STREAMER_DATA_CHANNEL", "FILE_DATA_CHANNEL", "BINARY_DATA_CHANNEL"];
pub fn uuid() -> String {
let mut b: [u8;16] = rand::random(); b[6] = (b[6] & 15) | 64; b[8] = (b[8] & 63) | 128;
let s = hex::encode(b);
format!("{}-{}-{}-{}-{}", &s[..8], &s[8..12], &s[12..16], &s[16..20], &s[20..])
}
pub fn varint(mut n: u64, out: &mut Vec<u8>) { while n >= 128 { out.push(n as u8 | 128); n >>= 7; } out.push(n as u8); }
pub fn int(field: u32, value: u64, out: &mut Vec<u8>) { varint(u64::from(field) << 3,out); varint(value,out); }
pub fn bytes(field: u32, value: &[u8], out: &mut Vec<u8>) { varint((u64::from(field)<<3)|2,out); varint(value.len() as u64,out); out.extend(value); }
pub fn envelope(seq:u64, kind:u32, payload:&[u8]) -> Vec<u8> {
let mut out=Vec::new(); int(1,seq,&mut out); bytes(kind,payload,&mut out); out
}
#[derive(Clone, Deserialize)]
pub struct Decoder { pub fps:u32, pub codec:u32, pub width:u32, pub height:u32, pub chroma:u32 }
#[derive(Clone, Deserialize, Serialize)]
pub struct Display { pub id:u32, pub fps:u32, pub r#type:u32, pub hdr:u32 }
#[derive(Clone, Deserialize, Serialize)]
pub struct Codec { pub video_codec:u32, pub chroma_sampling:u32, pub codec_impl:u32, pub bit_depth:u32, pub width:u32, pub height:u32 }
#[derive(Clone, Deserialize)]
pub struct Shape {
pub capture_type:u32,
pub platform:u32,
pub client_version:String,
pub width:u32,
pub height:u32,
pub fps:u32,
pub chroma:u32,
pub decoders:Vec<Decoder>,
pub display_modes:Vec<[u32;3]>,
pub displays:Vec<Display>,
pub codecs:Vec<Codec>,
/// FeatureFlag {field: version} pairs (ConnectOptions 11). Empty by default; official hosts may
/// require it (live: official Mac/Windows hosts did not answer an empty flag set).
#[serde(default)]
pub feature_flag:Vec<[u32;2]>,
}
impl Shape {
pub fn validate(&self) -> Result<(),String> {
if ![1,5,8,9].contains(&self.capture_type) || ![3,4].contains(&self.platform)
|| self.width==0 || self.height==0 || self.fps==0 || ![1,3].contains(&self.chroma) {
return Err("Invalid explicit viewer shape".into());
}
if self.decoders.iter().any(|d| ![1,2].contains(&d.codec) || ![1,3].contains(&d.chroma) || d.width==0 || d.height==0 || d.fps==0) {
return Err("Invalid decoder capability".into());
}
Ok(())
}
pub fn validate_session(&self)->Result<(),String> {
self.validate()?;
// H264/420 receive only. streamer_data video_codec_capability is sent by the official Mac
// viewer (8 entries observed live), so H264/420 entries are allowed there too.
if self.decoders.iter().any(|d|d.codec!=1 || d.chroma!=1) || self.codecs.iter().any(|c|c.video_codec!=1 || c.chroma_sampling!=1)
|| (self.capture_type==1 && (self.chroma!=1 || self.decoders.is_empty())) {
return Err("Sessions require H264/420 decoder and codec capabilities".into());
}
Ok(())
}
pub fn connect_options(&self, device:&str) -> Result<Vec<u8>,String> {
self.validate()?;
let mut out=Vec::new(); int(1,self.capture_type.into(),&mut out);
if [1,8].contains(&self.capture_type) { int(2,u64::MAX,&mut out); }
if [1,5].contains(&self.capture_type) {
let mut params=Vec::new(); int(1,2,&mut params); int(2,4,&mut params); int(4,2,&mut params);
let mut size=Vec::new(); int(1,self.width.into(),&mut size); int(2,self.height.into(),&mut size);
bytes(5,&size,&mut params); bytes(6,&[],&mut params);
if self.capture_type==1 { int(7,self.chroma.into(),&mut params); int(9,1,&mut params); int(11,self.fps.into(),&mut params); }
bytes(3,&params,&mut out);
for d in &self.decoders {
let mut cap=Vec::new();
for (f,v) in [(1,d.fps),(2,d.codec),(3,d.width),(4,d.height)] { int(f,v.into(),&mut cap); }
if self.capture_type==1 { int(5,d.chroma.into(),&mut cap); }
bytes(4,&cap,&mut out);
}
for mode in &self.display_modes {
let mut value=Vec::new(); for (f,v) in mode.iter().enumerate() { int(f as u32+1,(*v).into(),&mut value); }
bytes(6,&value,&mut out);
}
bytes(7,&size,&mut out);
}
int(8,self.platform.into(),&mut out); bytes(9,device.as_bytes(),&mut out); int(10,1,&mut out);
if self.capture_type==1 {
let mut flags=Vec::new(); for [field,version] in &self.feature_flag { if *field!=8 {int((*field).into(),(*version).into(),&mut flags);} }
if super::clipboard::available(){int(8,3,&mut flags);}
bytes(11,&flags,&mut out);
}
if self.capture_type!=5 { bytes(12,self.client_version.as_bytes(),&mut out); }
Ok(out)
}
pub fn control(&self, client:&str, id:&str, ice:&str) -> Result<Value,String> {
self.validate()?;
let streamer=json!({"control_id":id,"device_capability":{"display_info":self.displays,"ice_id":"","video_codec_capability":self.codecs}});
// Official Control::SerializeSioMsg (libstreamer 0x107bf8) sends only these three keys. A
// viewer-chosen ice_id reaches the host via be-controlled while the ack assigns another, and the
// official host drops the offer ("drop the soac event ... not in current ice connections").
let _=(client,ice);
Ok(json!({"app_control_id":id,"app_data":{"_placeholder":true,"num":0},"streamer_data":streamer.to_string()}))
}
}
/// Existing viewer FeatureFlag pairs; clipboard uses the host text protocol version (3).
/// Session encoders omit clipboard when its local backend is disabled or unavailable.
pub const VIEWER_FEATURES:[[u32;2];8]=[[1,6],[2,2],[3,1],[4,2],[6,2],[7,2],[8,3],[9,1]];
pub fn feature_flag(flags:&[[u32;2]]) -> Vec<u8> { let mut out=Vec::new(); for [f,v] in flags { int(*f,(*v).into(),&mut out); } out }
pub fn echo_request(seq:u64) -> Vec<u8> {echo_request_with_clipboard(seq,false)}
fn session_features(clipboard:bool)->Vec<u8>{
let mut flags:Vec<_>=VIEWER_FEATURES.iter().copied().filter(|p|p[0]!=8).collect();
if clipboard{flags.push([8,3]);}feature_flag(&flags)
}
pub fn echo_request_with_clipboard(seq:u64,clipboard:bool)->Vec<u8>{
let mut action=Vec::new();int(1,0,&mut action);bytes(4,&session_features(clipboard),&mut action);envelope(seq,3,&action)
}
pub fn echo_clipboard_supported(data:&[u8])->bool{
let Ok(fields)=decode_wire(data) else{return false};
fields.iter().any(|f|match (f.number,&f.value){
(3,WireValue::Bytes(action))=>decode_wire(action).is_ok_and(|fields|fields.iter().any(|f|match (f.number,&f.value){
(4,WireValue::Bytes(flags))=>decode_wire(flags).is_ok_and(|flags|flags.iter().any(|f|matches!((f.number,&f.value),(8,WireValue::Varint(3..))))),_=>false,
})),_=>false,
})
}
/// Official hosts also send an echo request (SimpleAction action 0) and repeat it until answered.
/// Returns the request's Message seq when `data` is such a request.
pub fn echo_request_seq(data:&[u8]) -> Option<u64> {
let fields=decode_wire(data).ok()?;
let seq=fields.iter().find_map(|f|match (f.number,&f.value){(1,WireValue::Varint(v))=>Some(*v),_=>None})?;
fields.iter().find_map(|f|match (f.number,&f.value) {
(3,WireValue::Bytes(action))=>decode_wire(action).ok()?.iter().any(|f|f.number==1 && f.value==WireValue::Varint(0)).then_some(seq),
_=>None,
})
}
/// Answer like the host side does: action 1, args {"seq": request seq}, our FeatureFlag.
pub fn echo_response(seq:u64,request_seq:u64)->Vec<u8>{echo_response_with_clipboard(seq,request_seq,false)}
pub fn echo_response_with_clipboard(seq:u64, request_seq:u64,clipboard:bool) -> Vec<u8> {
let mut action=Vec::new(); int(1,1,&mut action);
bytes(2,format!("{{\"seq\":{request_seq}}}").as_bytes(),&mut action);
bytes(4,&session_features(clipboard),&mut action); envelope(seq,3,&action)
}
pub fn echo_matches(data:&[u8], seq:u64) -> bool {
let Ok(fields)=decode_wire(data) else {return false};
fields.iter().any(|f| match (f.number,&f.value) {
(3,WireValue::Bytes(action))=> {
let Ok(fields)=decode_wire(action) else {return false};
let response=fields.iter().any(|f|f.number==1 && f.value==WireValue::Varint(1));
response && fields.iter().any(|f|match (f.number,&f.value) {
(2,WireValue::Bytes(args))=>serde_json::from_slice::<Value>(args).ok().and_then(|v|v.get("seq").and_then(Value::as_u64))==Some(seq), _=>false,
})
}, _=>false,
})
}
#[cfg(test)]
mod tests {
use super::*;
pub fn shape()->Shape { serde_json::from_str(include_str!("../../tests/fixtures/viewer/shape.json")).unwrap() }
#[test]
fn session_shape_uses_observed_field_presence_and_nested_values() {
let mut s=shape();
for capture in [1,5,8,9] {
s.capture_type=capture;
let b=s.connect_options("synthetic-device").unwrap(); let f=decode_wire(&b).unwrap();
let numbers:Vec<u32>=f.iter().map(|f|f.number).collect();
let expected=match capture {1=>vec![1,2,3,4,4,4,4,6,6,7,8,9,10,11,12],5=>vec![1,3,4,4,4,4,6,6,7,8,9,10],8=>vec![1,2,8,9,10,12],_=>vec![1,8,9,10,12]};
assert_eq!(numbers,expected);
for f in f.iter().filter(|f|f.number==4) {
let WireValue::Bytes(b)=f.value else {panic!()}; let cap=decode_wire(b).unwrap();
assert_eq!(cap.len(),if capture==1 {5}else{4});
}
if [1,8].contains(&capture) { assert!(f.iter().any(|f| f.number==2 && f.value==WireValue::Varint(u64::MAX))); }
}
}
#[test]
fn streamer_identity_and_echo_correlation_are_separate_from_socket_ack() {
let s=shape();let id=uuid(); let v=s.control("synthetic-client",&id,"synthetic-ice").unwrap();
let streamer:Value=serde_json::from_str(v["streamer_data"].as_str().unwrap()).unwrap();
assert_eq!(streamer["control_id"],v["app_control_id"]); assert_eq!(id.len(),36); assert_ne!(id,uuid()); assert_eq!(&id[14..15],"4");
let mut action=Vec::new();int(1,1,&mut action);bytes(2,br#"{"seq":7}"#,&mut action);
let reply=envelope(99,3,&action); assert!(echo_matches(&reply,7)); assert!(!echo_matches(&reply,99));
assert!(!echo_matches(&echo_request(7),7)); assert!(!echo_matches(&[255],7));
}
}
+177
View File
@@ -0,0 +1,177 @@
//! Experimental controller session, built only with --features native-viewer.
#![allow(dead_code)]
#[path = "auth.rs"] mod auth;
#[path = "config.rs"] mod config;
#[path = "protocol.rs"] mod protocol;
mod viewer;
use viewer::clipboard;
#[path="clipboard_protocol.rs"] mod clipboard_protocol;
#[path="clipboard_rich.rs"] mod clipboard_rich;
#[cfg(test)] #[path="terminal.rs"] mod terminal;
#[cfg(test)] #[path="file_trans.rs"] mod file_trans;
#[cfg(test)] #[path="initialization.rs"] mod initialization;
use viewer::{api::Api,rtc::ReadyPolicy,session::{Options,Session},wire::Shape};
use std::time::Duration;
const HELP:&str="Experimental native viewer.\n uuremote-viewer ui (GTK window: sign-in, devices, sessions) Desktop UI requires viewer-sdl (decodes with the ffmpeg CLI, or FFmpeg 6.x libraries with viewer-ffmpeg).\n uuremote-viewer power DEVICE reboot|shutdown\n uuremote-viewer terminal DEVICE [SESSION]\n uuremote-viewer files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE\n uuremote-viewer portmap DEVICE LOCAL_PORT HOST PORT\n uuremote-viewer files-ui|portmap-ui|terminal-ui DEVICE NAME (GTK tool windows)\n uuremote-viewer login [--no-gui]\n uuremote-viewer devices METHOD ARRAY_POINTER ID_POINTER NAME_POINTER\n uuremote-viewer assist CONNECT_ID (验证码从 stdin 读取一行)\n uuremote-viewer connect DEVICE true|false SHAPE_JSON echo|manual raw|legacy [--view-only]\nAudio: UU_VIEWER_AUDIO=0 disables playback. UU_VIEWER_VIEW_ONLY=1 disables desktop input.\nDevice-list method/JSON pointers and compatibility shape require verified operator configuration.\nQR login reuses the sibling uuremote-server login command. Never run login in a captured log.\nEcho readiness is transport observation only; no sendVideoTrack RPC is emitted.";
const DEFAULT_SHAPE:&str=r#"{"capture_type":1,"platform":3,"client_version":"4.42.0","width":1920,"height":1080,"fps":60,"chroma":1,
"decoders":[{"fps":60,"codec":1,"width":3840,"height":2160,"chroma":1}],"display_modes":[[1920,1080,60]],
"displays":[{"id":1,"fps":60,"type":0,"hdr":0}],
"codecs":[{"video_codec":1,"chroma_sampling":1,"codec_impl":34,"bit_depth":8,"width":3840,"height":2160}],
"feature_flag":[[1,6],[2,2],[3,1],[4,2],[6,2],[7,2],[8,3],[9,1]]}"#;
#[tokio::main]
async fn main() {
// Do not inherit broad RUST_LOG filters that could expose third-party wire diagnostics.
let args:Vec<String>=std::env::args().skip(1).collect();
// The terminal tool owns the TTY: diagnostics would interleave with the remote shell's screen.
let level=if args.first().is_some_and(|m|matches!(m.as_str(),"terminal"|"terminal-local")){log::LevelFilter::Off}else{log::LevelFilter::Info};
env_logger::Builder::new().filter_level(log::LevelFilter::Off).filter_module("uuremote_viewer",level).init();
match run(&args).await {Ok(())=>{},Err(error)=>{eprintln!("{error}");std::process::exit(2)}}
}
async fn run(args:&[String])->Result<(),String> {
match args.first().map(String::as_str) {
None|Some("--help"|"help")=>{println!("{HELP}");Ok(())},
Some("login") if args.len()==1 || (args.len()==2 && args[1]=="--no-gui")=> {
let executable=std::env::current_exe().map_err(|_|"Cannot locate companion login binary")?.with_file_name("uuremote-server");
login_command(&executable,&args[1..]).await
}
#[cfg(uu_gtk)]
Some("ui") if args.len()==1=> viewer::ui::run(credentials).await,
Some("devices-shape") if args.len()==2=> {
let method=match args[1].as_str(){"GET"=>reqwest::Method::GET,"POST"=>reqwest::Method::POST,_=>return Err("Device list method must be GET or POST".into())};
println!("{}",api()?.devices_shape(method).await.map_err(|e|e.to_string())?);
Ok(())
}
Some("devices") if args.len()==5=> {
let method=match args[1].as_str(){"GET"=>reqwest::Method::GET,"POST"=>reqwest::Method::POST,_=>return Err("Device list method must be GET or POST".into())};
let api=api()?;
let devices=api.devices(method,&args[2]).await.map_err(|e|e.to_string())?;
for device in devices {
// Deliberate UI output, restricted to selected identity/display fields.
// Strings verbatim; numbers/booleans (platform, status flags) as their JSON text.
let id=device.pointer(&args[3]).map(|v|v.as_str().map(str::to_owned).unwrap_or_else(||v.to_string())).unwrap_or_default();
let name=device.pointer(&args[4]).and_then(serde_json::Value::as_str).unwrap_or("");
println!("{}",serde_json::json!({"device":id,"name":name}));
}
Ok(())
}
Some("power")=>power_command(args).await,
Some("terminal-local") if args.len()==2 || args.len()==3=>{
let session=if args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
viewer::tools::terminal_ipc::client(std::path::Path::new(&args[1]),session).await
},
Some("terminal"|"files"|"portmap"|"files-ui"|"portmap-ui"|"terminal-ui")=>tool_command(args).await,
Some("assist") if args.len()==2=> {
let code=viewer::assist::read_code(std::io::stdin().lock())?;
desktop_command(&["connect".into(),args[1].clone(),"false".into(),"-".into(),"echo".into(),"legacy".into()],Some(code)).await.map_err(|e|format!("协助连接失败:{e}"))
}
Some("connect") if args.len()==6 || args.len()==7=> desktop_command(args,None).await,
_=>Err(HELP.into()),
}
}
async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String> {
let view_only=viewer::input::view_only(args.get(6).map(String::as_str),std::env::var("UU_VIEWER_VIEW_ONLY").ok().as_deref())?;
let force=match args[2].as_str(){"true"=>true,"false"=>false,_=>return Err("force_join must be explicit true or false".into())};
let policy=match args[4].as_str(){"echo"=>ReadyPolicy::EchoOnly,"manual"=>ReadyPolicy::Explicit,_=>return Err("Ready policy must be echo or manual".into())};
let legacy=match args[5].as_str(){"raw"=>false,"legacy"=>true,_=>return Err("Attachment framing must be raw or legacy".into())};
// "-" selects the built-in desktop shape (mirrors the official Mac viewer's observed request).
let text=if args[3]=="-" {DEFAULT_SHAPE.to_owned()} else {std::fs::read_to_string(&args[3]).map_err(|_|"Cannot read explicit viewer shape")?};
let shape:Shape=serde_json::from_str(&text).map_err(|_|"Invalid explicit viewer shape JSON")?;shape.validate_session()?;
#[cfg(feature="viewer-sdl")]
let mut desktop=if shape.capture_type==1 {
if matches!(policy,ReadyPolicy::Explicit) {return Err("Desktop manual readiness has no verified activation protocol".into())}
// Library decoding with viewer-ffmpeg (FFmpeg 6.x headers); otherwise an ffmpeg CLI process.
#[cfg(feature="viewer-ffmpeg")]
let decoder:Box<dyn viewer::desktop::Decoder>=Box::new(viewer::decoder::Ffmpeg::new()?);
#[cfg(not(feature="viewer-ffmpeg"))]
let decoder:Box<dyn viewer::desktop::Decoder>=Box::new(viewer::decoder_cli::Cli::new()?);
Some((viewer::sdl::Window::new()?,decoder))
}else{None};
let creds=credentials()?;
let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let room=match code {
Some(code)=>api.join_share(&args[1],&code).await,
None=>api.join(&args[1],force,true).await,
}.map_err(|e|e.to_string())?;
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
#[cfg(feature="viewer-sdl")]
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only).await}else{session.run().await};
#[cfg(not(feature="viewer-sdl"))]
let result=session.run().await;
session.close().await;result
}
fn credentials()->Result<auth::Credentials,String> {auth::Credentials::load(config::read_fresh().map_err(|_|"Cannot read credential configuration")?.as_ref())}
fn api()->Result<Api,String> {Ok(Api::new(auth::UUAuthClient::new(credentials()?),auth::BASE_URL))}
async fn login_command(executable:&std::path::Path,options:&[String])->Result<(),String> {
let status=tokio::process::Command::new(executable).arg("login").args(options).status().await.map_err(|_|"Build sibling uuremote-server to reuse QR login")?;
if status.success(){Ok(())}else{Err("QR login did not complete".into())}
}
#[cfg(test)]
mod cli_tests {
use super::*;
#[tokio::test]
async fn invalid_commands_never_fall_through_to_login_or_host_service() {
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["login","--invalid"],vec!["connect"],vec!["assist"],vec!["assist","id","forbidden-code-argument"],vec!["terminal"],vec!["terminal","device","extra"],vec!["terminal","device","0"],vec!["terminal","device","4294967296"],vec!["terminal-ui","device"],vec!["files","device","bad","path"],vec!["portmap","device","bad","host","80"],vec!["portmap","device","8000","host","0"],vec!["devices","DELETE","/data","/id","/name"]] {
assert!(run(&args.into_iter().map(str::to_owned).collect::<Vec<_>>()).await.is_err());
}
}
#[tokio::test]
async fn login_reuses_companion_subcommand_with_a_local_process_mock() {
use std::os::unix::fs::PermissionsExt;
let path=std::env::temp_dir().join(format!("uu-viewer-login-mock-{}",viewer::wire::uuid()));
std::fs::write(&path,b"#!/bin/sh\n[ \"$#\" -eq 2 ] && [ \"$1\" = login ] && [ \"$2\" = --no-gui ]\n".as_slice()).unwrap();
std::fs::set_permissions(&path,std::fs::Permissions::from_mode(0o700)).unwrap();
let result=login_command(&path,&["--no-gui".into()]).await;
std::fs::remove_file(path).unwrap();assert!(result.is_ok());
}
}
async fn tool_command(args:&[String])->Result<(),String>{
let capture=match args[0].as_str(){"terminal" if args.len()==2 || args.len()==3=>8,"terminal-ui" if args.len()==3=>8,"files" if (args.len()==4 && args[2]=="ls") || (args.len()==5 && ["get","put"].contains(&args[2].as_str()))=>5,"portmap" if args.len()==5=>9,"files-ui" if args.len()==3=>5,"portmap-ui" if args.len()==3=>9,_=>return Err(HELP.into())};
let terminal_session=if args[0]=="terminal" && args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
#[cfg(not(uu_gtk))] if args[0].ends_with("-ui"){return Err("Tool windows require the GTK build".into())}
let ports=if args[0]=="portmap"{Some((args[2].parse::<u16>().map_err(|_|"Invalid local port")?,args[4].parse::<u16>().map_err(|_|"Invalid target port")?))}else{None};
if ports.is_some_and(|(_,port)|port==0) || (args[0]=="portmap" && args[3].trim().is_empty()){return Err("Invalid forwarding target".into())}
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in tool shape")?;
shape.capture_type=capture;shape.feature_flag.clear();
if capture!=5{shape.decoders.clear();shape.display_modes.clear();shape.displays.clear();shape.codecs.clear();}
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
// Match the existing UI connection framing (9bb42d5); the host tolerates this prefix.
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
let result=async{
let(io,rx)=viewer::tools::attach(&session.peer)?;
let ready=async{
loop{if session.peer.channels.iter().enumerate().filter(|(i,_)|[0,if capture==8{4}else{3}].contains(i)).all(|(_,c)|c.ready_state()==webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) && session.peer.observed.echo_received.load(std::sync::atomic::Ordering::Acquire){break}tokio::select!{r=session.step()=>r?,_=tokio::time::sleep(Duration::from_millis(20))=>{}}}Ok::<_,String>(())
};
tokio::time::timeout(Duration::from_secs(30),ready).await.map_err(|_|"Tool connection timed out")??;
let operation=async{match args[0].as_str(){"terminal"=>viewer::tools::cli::terminal(io,rx,terminal_session).await,"files"=>viewer::tools::cli::files(io,rx,&args[2..]).await,
#[cfg(uu_gtk)] "terminal-ui"=>viewer::tools_ui::terminal(io,rx,&args[1],&args[2]).await,
#[cfg(uu_gtk)] "files-ui"=>viewer::tools_ui::files(io,rx,&args[2]).await,
#[cfg(uu_gtk)] "portmap-ui"=>viewer::tools_ui::portmap(io,rx,&args[2]).await,
"portmap"=>{let(local,port)=ports.unwrap();viewer::tools::cli::portmap(io,rx,local,&args[3],port).await}
_=>Err("Tool windows require the GTK build".into())}};
tokio::pin!(operation);
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
loop{tokio::select!{r=&mut operation=>break r,r=session.step()=>r?,_=terminate.recv()=>break Ok(()),_=tokio::signal::ctrl_c()=>break Ok(())}}
}.await;
session.close().await;result
}
async fn power_command(args:&[String])->Result<(),String>{
if args.len()!=3 || args[1].trim().is_empty(){return Err(HELP.into())}
let action=viewer::power::Action::parse(&args[2])?;
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in power shape")?;
// File-tool peers carry CONTROL without starting desktop capture or clipboard.
shape.capture_type=5;shape.feature_flag.clear();
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
let result=viewer::power::run(&mut session,action).await;
session.close().await;
if result.is_ok(){println!("电源指令已发送;未确认远端执行结果。");}
result
}