Files
uu-remote-linux/src/clipboard_protocol.rs
T
VallierDevandClaude Opus 5.5 502635b156 Initial import of uu-remote-linux
Unofficial Linux host for NetEase UU Remote: X11 (production-tested on
GNOME/Ubuntu 24.04), experimental Wayland (Hyprland) and portal
(GNOME/KDE) backends; video, input, clipboard, file transfer, terminal,
sound, quality/fps/resolution settings, lock/unlock and system actions.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-14 23:53:16 +08:00

146 lines
7.1 KiB
Rust

//! Official GvPb_Message field 17 / ClipboardChange (UInt32, String, Bool).
//! Source-bound field/type evidence is retained in control/CLIPBOARD.md.
use crate::protocol::{decode_wire, WireValue};
use crate::clipboard::MAX_TEXT;
use std::time::{Duration, Instant};
#[derive(Default)]
pub struct Assembly {
pending: Option<(u32, String, Instant)>,
}
impl Assembly {
pub fn accept(&mut self, message: &[u8]) -> Result<Option<String>, &'static str> {
let result = self.decode(message);
if result.is_err() { self.pending = None; }
result
}
fn decode(&mut self, message: &[u8]) -> Result<Option<String>, &'static str> {
if message.len() > MAX_TEXT + 256 { return Err("clipboard message exceeds limit"); }
let fields = decode_wire(message).map_err(|_| "invalid clipboard wire")?;
let mut id = 0;
let mut text = "";
let mut more = false;
let mut seen = [false; 3];
for field in fields {
if !(1..=3).contains(&field.number) { continue; }
let index = field.number as usize - 1;
if seen[index] { return Err("duplicate clipboard field"); }
seen[index] = true;
match (field.number, field.value) {
(1, WireValue::Varint(value)) => id = u32::try_from(value).map_err(|_| "invalid clipboard content id")?,
(2, WireValue::Bytes(value)) => text = std::str::from_utf8(value).map_err(|_| "invalid clipboard UTF-8")?,
(3, WireValue::Varint(value @ 0..=1)) => more = value != 0,
_ => return Err("invalid clipboard field type"),
}
}
let now = Instant::now();
let mut combined = match self.pending.take() {
Some((previous, text, started)) if previous == id && now.duration_since(started) < Duration::from_secs(5) => (text, started),
_ => (String::new(), now),
};
if combined.0.len() + text.len() > MAX_TEXT { return Err("clipboard text exceeds limit"); }
combined.0.push_str(text);
if more { self.pending = Some((id, combined.0, combined.1)); Ok(None) }
else { Ok(Some(combined.0)) }
}
}
pub(crate) fn varint(mut value: u64, out: &mut Vec<u8>) {
while value >= 128 { out.push(value as u8 & 127 | 128); value >>= 7; }
out.push(value as u8);
}
pub(crate) fn nested(field: u32, payload: &[u8], out: &mut Vec<u8>) {
varint(u64::from(field) << 3 | 2, out);
varint(payload.len() as u64, out); out.extend_from_slice(payload);
}
pub fn text_request(request_id: u64, text: &str) -> Vec<u8> {
let mut header=vec![8];varint(request_id,&mut header);
// Official ClipboardMobileManager uses format_id=1 for text.
let data=encode(1,text,false);
let mut request=Vec::new();nested(1,&header,&mut request);nested(10,&data,&mut request);request
}
pub fn read_text_request(request: &[u8]) -> Result<Option<(Vec<u8>,String)>, &'static str> {
if request.len()>MAX_TEXT+256 {return Err("clipboard RPC exceeds limit");}
let fields=decode_wire(request).map_err(|_|"invalid clipboard RPC")?;
let data=fields.iter().find(|f|f.number==10);
let Some(data)=data else {return Ok(None);};
let header=fields.iter().find(|f|f.number==1).ok_or("missing clipboard RPC header")?;
let WireValue::Bytes(header)=header.value else {return Err("invalid clipboard RPC header");};
if header.len()>32 {return Err("invalid clipboard RPC header length");}
let header_fields=decode_wire(header).map_err(|_|"invalid clipboard RPC request id")?;
if header_fields.iter().any(|f|f.number!=1 || !matches!(f.value,WireValue::Varint(_))) {return Err("invalid clipboard RPC request id");}
let WireValue::Bytes(data)=data.value else {return Err("invalid clipboard RPC text");};
let parts=decode_wire(data).map_err(|_|"invalid clipboard RPC text")?;
if !parts.iter().any(|f|f.number==1 && f.value==WireValue::Varint(1)) || parts.iter().any(|f|f.number==1 && f.value!=WireValue::Varint(1)) {return Err("unsupported clipboard RPC format");}
let text=Assembly::default().accept(data)?.ok_or("incomplete clipboard RPC text")?;
Ok(Some((header.to_vec(),text)))
}
pub fn text_response(header: &[u8]) -> Vec<u8> {
let mut response=Vec::new();nested(1,header,&mut response);
nested(6,&[8,1],&mut response); // TextChangeResponse.err=CB_SUCCEEDED
response
}
pub fn encode(id: u32, text: &str, more: bool) -> Vec<u8> {
let mut out = vec![8]; varint(u64::from(id), &mut out);
out.push(18); varint(text.len() as u64, &mut out); out.extend_from_slice(text.as_bytes());
if more { out.extend_from_slice(&[24, 1]); }
out
}
pub fn chunks(text: &str) -> Result<Vec<&str>, &'static str> {
if text.len() > MAX_TEXT { return Err("clipboard text exceeds limit"); }
if text.is_empty() { return Ok(vec![""]); }
let mut chunks = Vec::new();
let mut remaining = text;
while !remaining.is_empty() {
let mut end = remaining.len().min(8192);
while !remaining.is_char_boundary(end) { end -= 1; }
chunks.push(&remaining[..end]); remaining = &remaining[end..];
}
Ok(chunks)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rpc_text_roundtrip_preserves_request_id_and_returns_official_success() {
let text="UU-test-中文🙂\n";
let request=text_request(0x12345678,text);
let (header,received)=read_text_request(&request).unwrap().unwrap();
assert_eq!(received,text);
assert_eq!(header,vec![8,0xf8,0xac,0xd1,0x91,1]);
let response=text_response(&header);
assert_eq!(&response[response.len()-4..],&[50,2,8,1]);
assert_eq!(&response[2..2+header.len()],header.as_slice());
assert!(read_text_request(&[10,1,255,82,0]).is_err());
assert!(read_text_request(&[10,0,82,2,8,2]).is_err());
assert!(read_text_request(&[10,0,74,0]).unwrap().is_none());
}
#[test]
fn unicode_chunk_roundtrip_and_empty_copy() {
let text = "中文🙂\n".repeat(1600);
let parts = chunks(&text).unwrap(); assert!(parts.len() > 1);
let mut assembly = Assembly::default();
for (i, part) in parts.iter().enumerate() {
let result = assembly.accept(&encode(u32::MAX, part, i + 1 < parts.len())).unwrap();
if i + 1 == parts.len() { assert_eq!(result.as_deref(), Some(text.as_str())); }
else { assert!(result.is_none()); }
}
assert_eq!(assembly.accept(&encode(0,"",false)).unwrap(),Some(String::new()));
}
#[test]
fn resets_for_new_id_and_rejects_malformed_and_oversized_text() {
let mut assembly = Assembly::default();
assembly.accept(&encode(1,"stale",true)).unwrap();
assert_eq!(assembly.accept(&encode(2,"new",false)).unwrap(),Some("new".into()));
assert!(assembly.accept(&[18,1,255]).is_err());
assert!(assembly.accept(&[8,1,8,2]).is_err());
assert!(assembly.accept(&[24,2]).is_err());
assert!(chunks(&"a".repeat(MAX_TEXT+1)).is_err());
assembly.accept(&encode(1,&"a".repeat(MAX_TEXT),true)).unwrap();
assert!(assembly.accept(&encode(1,"b",false)).is_err());
assert_eq!(assembly.accept(&encode(1,"fresh",false)).unwrap(),Some("fresh".into()));
}
}