mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
147 lines
7.2 KiB
Rust
147 lines
7.2 KiB
Rust
//! Official protobuf maps: RpcRequest 7 {1 enable, 2 privacy_type, 3 setting_source};
|
|
//! RpcResponse 3 {1 error_code, 2 req_privacy_type, 3 cur_privacy_type}. Types: see `Mode`.
|
|
//! Field numbers and enums verified against the Mac UURemote SwiftProtobuf name maps.
|
|
use super::Mode;
|
|
|
|
pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 }
|
|
|
|
impl Request {
|
|
/// iOS viewers encode "turn off the display" as `enable=0, privacy_type=3`: their enable bit is
|
|
/// the picture-mode switch, and the explicit screen-off type carries the intent. iOS "off" is
|
|
/// `enable=0, type=1` (seen live), so rewrite only this exact combination. Android 4.43.0 was
|
|
/// verified with the field-1 semantics, so the rewrite is iOS-only.
|
|
pub fn normalize_ios_screen_off(&mut self, ios: bool) -> bool {
|
|
if ios && !self.enable && self.mode == Some(Mode::ScreenOff) {
|
|
self.enable = true;
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
/// Windows viewers send every privacy request with `enable=0` and carry the intent in
|
|
/// `privacy_type`: `0/0` is off, `0/2` picture and `0/3` screen-off (verified live on the
|
|
/// Windows client). Android 4.43.0 and macOS keep field 1 as the master switch.
|
|
pub fn normalize_windows(&mut self, windows: bool) -> bool {
|
|
if windows && !self.enable && self.mode.is_some() {
|
|
self.enable = true;
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
}
|
|
|
|
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
|
|
use crate::protocol::{decode_wire, WireValue};
|
|
let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None });
|
|
let header = body(1)?.to_vec();
|
|
let req = decode_wire(body(7)?).ok()?;
|
|
let value = |n| req.iter().find_map(|f| match f.value { WireValue::Varint(v) if f.number == n => Some(v), _ => None }).unwrap_or(0);
|
|
log::info!("Privacy request: enable_value={} requested_type={} source={}", value(1), value(2), value(3));
|
|
Some((header, Request { enable: value(1) != 0, mode: Mode::from_type(value(2)), requested: value(2) }))
|
|
}
|
|
|
|
/// RpcResponse with the request's header, error_code 1 on failure, and the type now in effect.
|
|
pub fn response(header: &[u8], request: &Request, failed: bool, current: u8) -> Vec<u8> {
|
|
let mut payload = Vec::new();
|
|
if failed { payload.extend([8, 1]); }
|
|
if request.requested != 0 { payload.push(16); varint(request.requested, &mut payload); }
|
|
payload.extend([24, current]);
|
|
let mut out = vec![10];
|
|
varint(header.len() as u64, &mut out);
|
|
out.extend(header);
|
|
out.push(26);
|
|
varint(payload.len() as u64, &mut out);
|
|
out.extend(payload);
|
|
out
|
|
}
|
|
/// RpcRequest 25 update_screen_saver_req → RpcResponse 21 update_screen_saver_rsp (Mac UURemote
|
|
/// name maps). The viewer sends it before enabling picture mode (notifyScreensaverUpdate) and aborts
|
|
/// with error 9998 when it times out. The picture itself is the host's: answer an empty (success) one.
|
|
pub fn screensaver_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
|
|
use crate::protocol::WireValue;
|
|
if !rpc.iter().any(|f| f.number == 25) { return None; }
|
|
let header = rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == 1 => Some(*b), _ => None })?;
|
|
let mut out = vec![10];
|
|
varint(header.len() as u64, &mut out);
|
|
out.extend(header);
|
|
out.extend([0xaa, 1, 0]); // field 21, length-delimited, empty
|
|
log::info!("Privacy screensaver update answered");
|
|
Some(out)
|
|
}
|
|
/// SystemStateChange { 5 PrivateScreenState { 1 error_code, 2 req_privacy_type, 3 cur_privacy_type } }
|
|
/// (field numbers from the Mac UURemote name map); the host pushes it when the state changes.
|
|
pub fn state_change(current: u8) -> Vec<u8> {
|
|
let state = [16, current, 24, current];
|
|
let mut out = vec![42, state.len() as u8];
|
|
out.extend(state);
|
|
out
|
|
}
|
|
fn varint(mut n: u64, out: &mut Vec<u8>) {
|
|
while n >= 128 { out.push((n as u8 & 127) | 128); n >>= 7; }
|
|
out.push(n as u8);
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn parses_request_and_echoes_header() {
|
|
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
|
|
let (header, request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
|
assert!(request.enable);
|
|
assert_eq!(request.mode, Some(Mode::ScreenOff));
|
|
assert_eq!(response(&header, &request, true, 1), [10, 2, 8, 42, 26, 6, 8, 1, 16, 3, 24, 1]);
|
|
assert_eq!(response(&header, &request, false, 3), [10, 2, 8, 42, 26, 4, 16, 3, 24, 3]);
|
|
assert_eq!(state_change(2), [42, 4, 16, 2, 24, 2]);
|
|
let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap();
|
|
assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]);
|
|
}
|
|
#[test]
|
|
fn normalizes_ios_screen_off_only() {
|
|
let screen_off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 3]).unwrap();
|
|
let (_, mut request) = parse(&screen_off).unwrap();
|
|
assert!(request.normalize_ios_screen_off(true));
|
|
assert!(request.enable);
|
|
assert_eq!(request.mode, Some(Mode::ScreenOff));
|
|
let (_, mut request) = parse(&screen_off).unwrap();
|
|
assert!(!request.normalize_ios_screen_off(false));
|
|
assert!(!request.enable);
|
|
|
|
// An iOS "off" (type 1) and a Mac-style enable (1,3) must stay untouched.
|
|
let off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 1]).unwrap();
|
|
let (_, mut request) = parse(&off).unwrap();
|
|
assert!(!request.normalize_ios_screen_off(true));
|
|
assert!(!request.enable);
|
|
let mac = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 3]).unwrap();
|
|
let (_, mut request) = parse(&mac).unwrap();
|
|
assert!(!request.normalize_ios_screen_off(true));
|
|
assert!(request.enable);
|
|
}
|
|
#[test]
|
|
fn normalizes_windows_encoding_only() {
|
|
// Windows: enable is always 0, the type carries the intent.
|
|
for (wire, mode) in [(2u8, Mode::Picture), (3u8, Mode::ScreenOff)] {
|
|
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
|
|
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
|
assert!(request.normalize_windows(true));
|
|
assert!(request.enable);
|
|
assert_eq!(request.mode, Some(mode));
|
|
}
|
|
// Off stays off: type 0 (seen when the Windows switch is turned off) and type 1.
|
|
for wire in [0u8, 1] {
|
|
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
|
|
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
|
assert!(!request.normalize_windows(true));
|
|
assert!(!request.enable);
|
|
}
|
|
// Other platforms and explicit enables are untouched.
|
|
let picture = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 2]).unwrap();
|
|
let (_, mut request) = parse(&picture).unwrap();
|
|
assert!(!request.normalize_windows(false));
|
|
assert!(!request.enable);
|
|
let explicit = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 2]).unwrap();
|
|
let (_, mut request) = parse(&explicit).unwrap();
|
|
assert!(!request.normalize_windows(true));
|
|
assert!(request.enable);
|
|
}
|
|
}
|