use base64::engine::general_purpose::STANDARD;
use base64::Engine as _;
use serde::{Deserialize, Serialize};
pub const VERSION: u32 = 1;
pub const TOKEN_PROTOCOL: &str = "sbx.v1.";
pub const CHANNELS: [&str; 4] = ["control", "input", "pointer", "clipboard"];
pub const MAX_CLIP_TEXT_BYTES: usize = 1 << 20;
pub const MAX_CLIP_IMAGE_BYTES: usize = 8 << 20;
pub const MAX_FRAME_BYTES: usize = 16 << 10;
pub const CHUNK_SLICE_BYTES: usize = 12_000;
pub const MAX_CHUNKS: u32 = 2048;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "t", rename_all = "snake_case")]
pub enum SignalClient {
Hello(Hello),
Answer { sdp: String },
Ice { candidate: IceCandidate },
Restart,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "t", rename_all = "snake_case")]
pub enum SignalServer {
Offer { sdp: String },
Ice { candidate: IceCandidate },
Bye { reason: ByeReason },
Error(ErrorFrame),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Hello {
pub v: u32,
pub client: ClientInfo,
#[serde(default)]
pub monitors: MonitorSelection,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ClientInfo {
pub dpr: f64,
pub w: u32,
pub h: u32,
pub touch: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum MonitorSelection {
All(AllMonitors),
Ids(Vec<String>),
}
impl Default for MonitorSelection {
fn default() -> Self {
MonitorSelection::All(AllMonitors::All)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AllMonitors {
All,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct IceCandidate {
pub candidate: String,
#[serde(rename = "sdpMid", default, skip_serializing_if = "Option::is_none")]
pub sdp_mid: Option<String>,
#[serde(
rename = "sdpMLineIndex",
default,
skip_serializing_if = "Option::is_none"
)]
pub sdp_m_line_index: Option<u16>,
#[serde(
rename = "usernameFragment",
default,
skip_serializing_if = "Option::is_none"
)]
pub username_fragment: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ByeReason {
GenerationChanged,
Revoked,
LeaseGone,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ErrorFrame {
pub code: ErrorCode,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
impl ErrorFrame {
pub fn new(code: ErrorCode) -> Self {
ErrorFrame {
code,
message: None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ErrorCode {
InvalidMessage,
UnsupportedVersion,
OutOfOrder,
Unauthenticated,
StaleGeneration,
ControlHeld,
NotController,
TooLarge,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum AdmitError {
Unauthenticated,
NotFound,
StaleGeneration,
ControlHeld,
}
impl AdmitError {
pub fn status(self) -> u16 {
match self {
AdmitError::Unauthenticated => 401,
AdmitError::NotFound => 404,
AdmitError::StaleGeneration | AdmitError::ControlHeld => 409,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "t", rename_all = "snake_case")]
pub enum ControlClient {
Upgrade { token: String },
Downgrade,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "t", rename_all = "snake_case")]
pub enum ControlServer {
Role { role: PeerRole, epoch: i64 },
Control {
holder: Holder,
epoch: i64,
label: String,
},
Monitors { list: Vec<Monitor> },
Cursor {
png: String,
hx: u32,
hy: u32,
visible: bool,
},
Stats {
rtt_ms: u32,
fps: u32,
kbps: u32,
encoder: String,
},
Error(ErrorFrame),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PeerRole {
Viewer,
Controller,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Holder {
Human,
Agent,
None,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Monitor {
pub id: String,
pub name: String,
pub x: i32,
pub y: i32,
pub w: u32,
pub h: u32,
pub scale: f64,
pub primary: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "t", rename_all = "snake_case")]
pub enum Input {
Pd(ButtonEvent),
Pu(ButtonEvent),
Wh(Wheel),
Kd(KeyEvent),
Ku(KeyEvent),
Tx { text: String },
Ime(Ime),
Tc(Touch),
Combo { keys: Vec<ComboKey> },
ReleaseAll,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "t", rename_all = "snake_case")]
pub enum Pointer {
Pm {
m: String,
x: i32,
y: i32,
b: u8,
#[serde(default, skip_serializing_if = "Option::is_none")]
ts: Option<u64>,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ButtonEvent {
pub m: String,
pub x: i32,
pub y: i32,
pub button: Button,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ts: Option<u64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(try_from = "u8", into = "u8")]
pub struct Button(u8);
impl Button {
pub const LEFT: Button = Button(0);
pub fn get(self) -> u8 {
self.0
}
}
impl TryFrom<u8> for Button {
type Error = String;
fn try_from(v: u8) -> Result<Self, String> {
if v <= 4 {
Ok(Button(v))
} else {
Err(format!("button {v} is not 0-4"))
}
}
}
impl From<Button> for u8 {
fn from(b: Button) -> u8 {
b.0
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Wheel {
pub dx: f64,
pub dy: f64,
pub unit: WheelUnit,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ts: Option<u64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum WheelUnit {
Pixel,
Line,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct KeyEvent {
pub code: String,
pub key: String,
pub mods: Vec<Modifier>,
pub repeat: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ts: Option<u64>,
}
impl KeyEvent {
pub fn types_unicode(&self) -> bool {
self.key.chars().count() == 1 && self.mods.iter().all(|m| *m == Modifier::Shift)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Modifier {
Ctrl,
Alt,
Shift,
Meta,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Ime {
pub phase: ImePhase,
pub text: String,
pub caret: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ImePhase {
Start,
Update,
End,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Touch {
pub id: u32,
pub phase: TouchPhase,
pub m: String,
pub x: i32,
pub y: i32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TouchPhase {
Start,
Move,
End,
Cancel,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ComboKey {
Ctrl,
Alt,
Shift,
Meta,
Delete,
Tab,
Escape,
Enter,
Backspace,
Space,
Printscreen,
F1,
F2,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
F10,
F11,
F12,
}
impl ComboKey {
pub fn name(self) -> String {
match serde_json::to_value(self) {
Ok(serde_json::Value::String(s)) => s,
_ => String::new(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "t", rename_all = "snake_case")]
pub enum Clipboard {
Clip(Clip),
ClipChunk(ClipChunk),
Error(ErrorFrame),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Clip {
pub seq: u64,
pub items: Vec<ClipItem>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ClipItem {
pub mime: ClipMime,
pub data: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ClipMime {
#[serde(rename = "text/plain")]
TextPlain,
#[serde(rename = "image/png")]
ImagePng,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ClipChunk {
pub seq: u64,
pub i: u32,
pub n: u32,
pub data: String,
}
impl Clip {
pub fn check(&self) -> Result<(), ErrorCode> {
let mut seen = Vec::new();
for item in &self.items {
if seen.contains(&item.mime) {
return Err(ErrorCode::InvalidMessage);
}
seen.push(item.mime);
match item.mime {
ClipMime::TextPlain => {
if item.data.len() > MAX_CLIP_TEXT_BYTES {
return Err(ErrorCode::TooLarge);
}
}
ClipMime::ImagePng => {
if item.data.len() > (MAX_CLIP_IMAGE_BYTES / 3 + 1) * 4 {
return Err(ErrorCode::TooLarge);
}
let bytes = STANDARD
.decode(item.data.as_bytes())
.map_err(|_| ErrorCode::InvalidMessage)?;
if bytes.len() > MAX_CLIP_IMAGE_BYTES {
return Err(ErrorCode::TooLarge);
}
}
}
}
Ok(())
}
pub fn frames(&self) -> Vec<Clipboard> {
let frame = Clipboard::Clip(self.clone());
if serde_json::to_vec(&frame).map_or(0, |b| b.len()) <= MAX_FRAME_BYTES {
return vec![frame];
}
self.chunks(CHUNK_SLICE_BYTES)
}
pub fn chunks(&self, slice_bytes: usize) -> Vec<Clipboard> {
let bytes = serde_json::to_vec(&Clipboard::Clip(self.clone())).unwrap_or_default();
let slices: Vec<&[u8]> = bytes.chunks(slice_bytes.max(1)).collect();
let n = slices.len() as u32;
slices
.into_iter()
.enumerate()
.map(|(i, s)| {
Clipboard::ClipChunk(ClipChunk {
seq: self.seq,
i: i as u32,
n,
data: STANDARD.encode(s),
})
})
.collect()
}
}
#[derive(Debug, Default, Clone)]
pub struct ChunkJoiner {
seq: Option<u64>,
parts: Vec<Option<Vec<u8>>>,
}
impl ChunkJoiner {
pub fn push(&mut self, c: &ClipChunk) -> Result<Option<Clip>, ErrorCode> {
if c.n == 0 || c.n > MAX_CHUNKS || c.i >= c.n {
return Err(ErrorCode::InvalidMessage);
}
if self.seq != Some(c.seq) || self.parts.len() != c.n as usize {
self.seq = Some(c.seq);
self.parts = vec![None; c.n as usize];
}
let bytes = STANDARD
.decode(c.data.as_bytes())
.map_err(|_| ErrorCode::InvalidMessage)?;
if bytes.len() > CHUNK_SLICE_BYTES {
return Err(ErrorCode::TooLarge);
}
self.parts[c.i as usize] = Some(bytes);
if self.parts.iter().any(Option::is_none) {
return Ok(None);
}
let joined: Vec<u8> = self.parts.drain(..).flatten().flatten().collect();
self.seq = None;
match serde_json::from_slice::<Clipboard>(&joined) {
Ok(Clipboard::Clip(clip)) => Ok(Some(clip)),
_ => Err(ErrorCode::InvalidMessage),
}
}
}
pub fn parse_signal_client(s: &str) -> Result<SignalClient, ErrorCode> {
parse(s)
}
pub fn parse_signal_server(s: &str) -> Result<SignalServer, ErrorCode> {
parse(s)
}
pub fn parse_control_client(s: &str) -> Result<ControlClient, ErrorCode> {
parse(s)
}
pub fn parse_control_server(s: &str) -> Result<ControlServer, ErrorCode> {
parse(s)
}
pub fn parse_input(s: &str) -> Result<Input, ErrorCode> {
parse(s)
}
pub fn parse_pointer(s: &str) -> Result<Pointer, ErrorCode> {
parse(s)
}
pub fn parse_clipboard(s: &str) -> Result<Clipboard, ErrorCode> {
parse(s)
}
fn parse<T: serde::de::DeserializeOwned>(s: &str) -> Result<T, ErrorCode> {
serde_json::from_str(s).map_err(|_| ErrorCode::InvalidMessage)
}
pub fn to_json<T: Serialize>(frame: &T) -> String {
serde_json::to_string(frame).unwrap_or_default()
}