use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::stream::*;
pub type SessionId = u32;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Channel {
Signal,
Control,
Input,
Pointer,
Clipboard,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Out {
pub session: SessionId,
pub channel: Channel,
pub frame: Value,
}
#[derive(Debug, Clone)]
pub struct MockLeaseSpec {
pub uid: String,
pub org: String,
pub project: String,
pub generation: i64,
pub holder: Holder,
pub epoch: i64,
pub label: String,
pub monitors: Vec<Monitor>,
}
impl MockLeaseSpec {
pub fn desktop(uid: &str, org: &str, project: &str, generation: i64) -> Self {
MockLeaseSpec {
uid: uid.into(),
org: org.into(),
project: project.into(),
generation,
holder: Holder::None,
epoch: 0,
label: String::new(),
monitors: vec![Monitor {
id: "m0".into(),
name: "Display 1".into(),
x: 0,
y: 0,
w: 1920,
h: 1080,
scale: 1.0,
primary: true,
}],
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MockClaims {
pub lease: String,
pub org: String,
pub project: String,
pub generation: i64,
pub role: PeerRole,
pub epoch: i64,
#[serde(default)]
pub expired: bool,
}
impl MockClaims {
pub fn viewer(lease: &str, org: &str, project: &str, generation: i64) -> Self {
MockClaims {
lease: lease.into(),
org: org.into(),
project: project.into(),
generation,
role: PeerRole::Viewer,
epoch: 0,
expired: false,
}
}
pub fn controller(lease: &str, org: &str, project: &str, generation: i64, epoch: i64) -> Self {
MockClaims {
role: PeerRole::Controller,
epoch,
..MockClaims::viewer(lease, org, project, generation)
}
}
}
#[derive(Debug, Clone)]
pub struct MockLease {
pub spec: MockLeaseSpec,
pub ready: bool,
pub controller: Option<SessionId>,
pub held_keys: Vec<String>,
pub held_buttons: Vec<u8>,
pub typed: String,
pub pointer: Option<(String, i32, i32)>,
pub clipboard: Vec<ClipItem>,
pub combos: Vec<String>,
pub probe_white: bool,
touch: Option<u32>,
machine_seq: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Phase {
Admitted,
Offered,
Connected,
}
#[derive(Debug)]
struct Session {
id: SessionId,
lease: usize,
token: String,
upgrade_token: Option<String>,
phase: Phase,
open: bool,
closed: bool,
offers: u32,
mids: Vec<String>,
last_clip_seq: Option<u64>,
joiner: ChunkJoiner,
}
#[derive(Debug, Default)]
pub struct MockStreamHub {
leases: Vec<MockLease>,
tokens: Vec<(String, MockClaims, bool)>,
sessions: Vec<Session>,
outbox: Vec<Out>,
}
impl MockStreamHub {
pub fn new() -> Self {
Self::default()
}
pub fn add_lease(&mut self, spec: MockLeaseSpec) {
self.leases.push(MockLease {
spec,
ready: true,
controller: None,
held_keys: Vec::new(),
held_buttons: Vec::new(),
typed: String::new(),
pointer: None,
clipboard: Vec::new(),
combos: Vec::new(),
probe_white: false,
touch: None,
machine_seq: 0,
});
}
pub fn lease(&self, uid: &str) -> Option<&MockLease> {
self.leases.iter().find(|l| l.spec.uid == uid)
}
pub fn mint_token(&mut self, claims: MockClaims) -> String {
let token = format!("mock-token-{}", self.tokens.len() + 1);
self.tokens.push((token.clone(), claims, false));
token
}
pub fn drain(&mut self) -> Vec<Out> {
std::mem::take(&mut self.outbox)
}
pub fn admit(&mut self, token: &str) -> Result<SessionId, AdmitError> {
let (claims, revoked) = match self.tokens.iter().find(|t| t.0 == token) {
Some((_, c, r)) => (c.clone(), *r),
None => return Err(AdmitError::Unauthenticated),
};
if claims.expired {
return Err(AdmitError::Unauthenticated);
}
let li = self
.leases
.iter()
.position(|l| {
l.spec.uid == claims.lease
&& l.spec.org == claims.org
&& l.spec.project == claims.project
})
.ok_or(AdmitError::NotFound)?;
let lease = &self.leases[li];
if lease.spec.generation != claims.generation || !lease.ready {
return Err(AdmitError::StaleGeneration);
}
if revoked {
return Err(AdmitError::Unauthenticated);
}
if claims.role == PeerRole::Controller
&& !(lease.spec.holder == Holder::Human && lease.spec.epoch == claims.epoch)
{
return Err(AdmitError::ControlHeld);
}
let id = self.sessions.len() as SessionId + 1;
self.sessions.push(Session {
id,
lease: li,
token: token.to_string(),
upgrade_token: None,
phase: Phase::Admitted,
open: false,
closed: false,
offers: 0,
mids: Vec::new(),
last_clip_seq: None,
joiner: ChunkJoiner::default(),
});
if claims.role == PeerRole::Controller {
self.make_controller(li, id);
}
Ok(id)
}
pub fn send(&mut self, session: SessionId, channel: Channel, text: &str) {
let Some(si) = self.session_index(session) else {
return;
};
if self.sessions[si].closed {
return;
}
match channel {
Channel::Signal => self.on_signal(si, text),
_ if !self.sessions[si].open => {}
Channel::Control => match parse_control_client(text) {
Ok(f) => self.on_control(si, f),
Err(code) => self.error(si, Channel::Control, code),
},
Channel::Input => match parse_input(text) {
Ok(f) => {
if self.is_controller(si) {
let li = self.sessions[si].lease;
apply_input(&mut self.leases[li], f);
}
}
Err(code) => self.error(si, Channel::Control, code),
},
Channel::Pointer => match parse_pointer(text) {
Ok(Pointer::Pm { m, x, y, .. }) => {
if self.is_controller(si) {
let li = self.sessions[si].lease;
self.leases[li].pointer = Some((m, x, y));
}
}
Err(code) => self.error(si, Channel::Control, code),
},
Channel::Clipboard => match parse_clipboard(text) {
Ok(Clipboard::Clip(clip)) => self.on_clip(si, clip),
Ok(Clipboard::ClipChunk(chunk)) => match self.sessions[si].joiner.push(&chunk) {
Ok(Some(clip)) => self.on_clip(si, clip),
Ok(None) => {}
Err(code) => self.error(si, Channel::Clipboard, code),
},
Ok(Clipboard::Error(_)) => {}
Err(code) => self.error(si, Channel::Clipboard, code),
},
}
}
pub fn acquire(&mut self, lease: &str, holder: Holder, label: &str) -> i64 {
let Some(li) = self.lease_index(lease) else {
return 0;
};
self.leases[li].spec.epoch += 1;
self.leases[li].spec.holder = holder;
self.leases[li].spec.label = label.to_string();
self.demote_controller(li);
self.broadcast_control(li);
self.leases[li].spec.epoch
}
pub fn release(&mut self, lease: &str) {
let Some(li) = self.lease_index(lease) else {
return;
};
self.leases[li].spec.holder = Holder::None;
self.leases[li].spec.label.clear();
self.demote_controller(li);
self.broadcast_control(li);
}
pub fn bump_generation(&mut self, lease: &str) {
if let Some(li) = self.lease_index(lease) {
self.leases[li].spec.generation += 1;
self.end_sessions(li, ByeReason::GenerationChanged);
}
}
pub fn end_lease(&mut self, lease: &str) {
if let Some(li) = self.lease_index(lease) {
self.leases[li].ready = false;
self.end_sessions(li, ByeReason::LeaseGone);
}
}
pub fn revoke(&mut self, token: &str) {
for t in self.tokens.iter_mut().filter(|t| t.0 == token) {
t.2 = true;
}
for si in 0..self.sessions.len() {
let s = &self.sessions[si];
if s.closed {
continue;
}
if s.token == token {
self.close(si, Some(ByeReason::Revoked));
} else if s.upgrade_token.as_deref() == Some(token) && self.is_controller(si) {
let li = s.lease;
self.demote_controller(li);
}
}
}
pub fn set_machine_clipboard(&mut self, lease: &str, items: Vec<ClipItem>) {
if let Some(li) = self.lease_index(lease) {
self.leases[li].clipboard = items.clone();
self.send_clip(li, None, items);
}
}
fn session_index(&self, id: SessionId) -> Option<usize> {
self.sessions.iter().position(|s| s.id == id)
}
fn lease_index(&self, uid: &str) -> Option<usize> {
self.leases.iter().position(|l| l.spec.uid == uid)
}
fn is_controller(&self, si: usize) -> bool {
let s = &self.sessions[si];
self.leases[s.lease].controller == Some(s.id)
}
fn push(&mut self, si: usize, channel: Channel, frame: Value) {
self.outbox.push(Out {
session: self.sessions[si].id,
channel,
frame,
});
}
fn emit<T: Serialize>(&mut self, si: usize, channel: Channel, frame: &T) {
let v = serde_json::to_value(frame).unwrap_or(Value::Null);
self.push(si, channel, v);
}
fn error(&mut self, si: usize, channel: Channel, code: ErrorCode) {
let f = ErrorFrame::new(code);
match channel {
Channel::Signal => self.emit(si, channel, &SignalServer::Error(f)),
Channel::Clipboard => self.emit(si, channel, &Clipboard::Error(f)),
_ => self.emit(si, Channel::Control, &ControlServer::Error(f)),
}
}
fn open_sessions(&self, li: usize) -> Vec<usize> {
(0..self.sessions.len())
.filter(|&i| {
let s = &self.sessions[i];
s.lease == li && s.open && !s.closed
})
.collect()
}
fn broadcast_control(&mut self, li: usize) {
let spec = &self.leases[li].spec;
let frame = ControlServer::Control {
holder: spec.holder,
epoch: spec.epoch,
label: spec.label.clone(),
};
for si in self.open_sessions(li) {
self.emit(si, Channel::Control, &frame);
}
}
fn make_controller(&mut self, li: usize, id: SessionId) {
if self.leases[li].controller.is_some_and(|c| c != id) {
self.demote_controller(li);
}
self.leases[li].controller = Some(id);
}
fn demote_controller(&mut self, li: usize) {
let Some(id) = self.leases[li].controller.take() else {
return;
};
release_all(&mut self.leases[li]);
if let Some(si) = self.session_index(id) {
if self.sessions[si].open && !self.sessions[si].closed {
self.emit(
si,
Channel::Control,
&ControlServer::Role {
role: PeerRole::Viewer,
epoch: 0,
},
);
}
}
}
fn close(&mut self, si: usize, bye: Option<ByeReason>) {
if let Some(reason) = bye {
self.emit(si, Channel::Signal, &SignalServer::Bye { reason });
}
self.sessions[si].closed = true;
let li = self.sessions[si].lease;
if self.leases[li].controller == Some(self.sessions[si].id) {
self.leases[li].controller = None;
release_all(&mut self.leases[li]);
}
}
fn end_sessions(&mut self, li: usize, reason: ByeReason) {
for si in 0..self.sessions.len() {
if self.sessions[si].lease == li && !self.sessions[si].closed {
self.close(si, Some(reason));
}
}
}
fn offer(&mut self, si: usize) {
let s = &mut self.sessions[si];
s.offers += 1;
s.phase = Phase::Offered;
let sdp = mock_sdp(&s.mids, s.offers);
let first = s.mids.first().cloned();
self.emit(si, Channel::Signal, &SignalServer::Offer { sdp });
self.emit(
si,
Channel::Signal,
&SignalServer::Ice {
candidate: IceCandidate {
candidate: "candidate:1 1 udp 2130706431 127.0.0.1 9 typ host".into(),
sdp_mid: first,
sdp_m_line_index: Some(0),
username_fragment: None,
},
},
);
}
fn on_signal(&mut self, si: usize, text: &str) {
let frame = match parse_signal_client(text) {
Ok(f) => f,
Err(code) => return self.error(si, Channel::Signal, code),
};
let phase = self.sessions[si].phase;
match frame {
SignalClient::Hello(hello) => {
if phase != Phase::Admitted {
return self.error(si, Channel::Signal, ErrorCode::OutOfOrder);
}
if hello.v != VERSION {
self.error(si, Channel::Signal, ErrorCode::UnsupportedVersion);
return self.close(si, None);
}
let li = self.sessions[si].lease;
let mids: Vec<String> = self.leases[li]
.spec
.monitors
.iter()
.filter(|m| match &hello.monitors {
MonitorSelection::All(_) => true,
MonitorSelection::Ids(ids) => ids.contains(&m.id),
})
.map(|m| m.id.clone())
.collect();
if mids.is_empty() {
return self.error(si, Channel::Signal, ErrorCode::InvalidMessage);
}
self.sessions[si].mids = mids;
self.offer(si);
}
SignalClient::Answer { .. } => {
if phase != Phase::Offered {
return self.error(si, Channel::Signal, ErrorCode::OutOfOrder);
}
self.sessions[si].phase = Phase::Connected;
if !self.sessions[si].open {
self.sessions[si].open = true;
let li = self.sessions[si].lease;
let spec = self.leases[li].spec.clone();
let role = if self.is_controller(si) {
ControlServer::Role {
role: PeerRole::Controller,
epoch: spec.epoch,
}
} else {
ControlServer::Role {
role: PeerRole::Viewer,
epoch: 0,
}
};
self.emit(si, Channel::Control, &role);
self.emit(
si,
Channel::Control,
&ControlServer::Control {
holder: spec.holder,
epoch: spec.epoch,
label: spec.label,
},
);
self.emit(
si,
Channel::Control,
&ControlServer::Monitors {
list: spec.monitors,
},
);
}
}
SignalClient::Ice { .. } => {
if phase == Phase::Admitted {
self.error(si, Channel::Signal, ErrorCode::OutOfOrder);
}
}
SignalClient::Restart => {
if phase != Phase::Connected {
return self.error(si, Channel::Signal, ErrorCode::OutOfOrder);
}
self.offer(si);
}
}
}
fn on_control(&mut self, si: usize, frame: ControlClient) {
let li = self.sessions[si].lease;
match frame {
ControlClient::Upgrade { token } => {
if let Err(code) = self.check_upgrade(li, &token) {
return self.error(si, Channel::Control, code);
}
let id = self.sessions[si].id;
self.make_controller(li, id);
self.sessions[si].upgrade_token = Some(token);
let epoch = self.leases[li].spec.epoch;
self.emit(
si,
Channel::Control,
&ControlServer::Role {
role: PeerRole::Controller,
epoch,
},
);
}
ControlClient::Downgrade => {
if self.is_controller(si) {
self.leases[li].controller = None;
release_all(&mut self.leases[li]);
}
self.emit(
si,
Channel::Control,
&ControlServer::Role {
role: PeerRole::Viewer,
epoch: 0,
},
);
}
}
}
fn check_upgrade(&self, li: usize, token: &str) -> Result<(), ErrorCode> {
let spec = &self.leases[li].spec;
let Some((_, c, revoked)) = self.tokens.iter().find(|t| t.0 == token) else {
return Err(ErrorCode::Unauthenticated);
};
if c.expired
|| *revoked
|| c.role != PeerRole::Controller
|| c.lease != spec.uid
|| c.org != spec.org
|| c.project != spec.project
{
return Err(ErrorCode::Unauthenticated);
}
if c.generation != spec.generation {
return Err(ErrorCode::StaleGeneration);
}
if spec.holder != Holder::Human || c.epoch != spec.epoch {
return Err(ErrorCode::ControlHeld);
}
Ok(())
}
fn on_clip(&mut self, si: usize, clip: Clip) {
if !self.is_controller(si) {
return self.error(si, Channel::Clipboard, ErrorCode::NotController);
}
if self.sessions[si]
.last_clip_seq
.is_some_and(|l| clip.seq <= l)
{
return;
}
if let Err(code) = clip.check() {
return self.error(si, Channel::Clipboard, code);
}
self.sessions[si].last_clip_seq = Some(clip.seq);
let li = self.sessions[si].lease;
self.leases[li].clipboard = clip.items.clone();
self.send_clip(li, Some(si), clip.items);
}
fn send_clip(&mut self, li: usize, except: Option<usize>, items: Vec<ClipItem>) {
self.leases[li].machine_seq += 1;
let clip = Clip {
seq: self.leases[li].machine_seq,
items,
};
for si in self.open_sessions(li) {
if Some(si) == except {
continue;
}
for frame in clip.frames() {
self.emit(si, Channel::Clipboard, &frame);
}
}
}
}
fn release_all(l: &mut MockLease) {
l.held_keys.clear();
l.held_buttons.clear();
l.touch = None;
}
fn apply_input(l: &mut MockLease, f: Input) {
match f {
Input::Pd(b) => {
if !l.held_buttons.contains(&b.button.get()) {
l.held_buttons.push(b.button.get());
}
l.pointer = Some((b.m, b.x, b.y));
}
Input::Pu(b) => {
l.held_buttons.retain(|x| *x != b.button.get());
l.pointer = Some((b.m, b.x, b.y));
}
Input::Wh(_) | Input::Ime(_) => {}
Input::Kd(k) => {
if !l.held_keys.contains(&k.code) {
l.held_keys.push(k.code.clone());
}
l.probe_white = true;
if k.types_unicode() {
l.typed.push_str(&k.key);
}
}
Input::Ku(k) => {
l.held_keys.retain(|c| *c != k.code);
l.probe_white = false;
}
Input::Tx { text } => l.typed.push_str(&text),
Input::Tc(t) => match t.phase {
TouchPhase::Start => {
if l.touch.is_none() {
l.touch = Some(t.id);
if !l.held_buttons.contains(&0) {
l.held_buttons.push(0);
}
l.pointer = Some((t.m, t.x, t.y));
}
}
TouchPhase::Move => {
if l.touch == Some(t.id) {
l.pointer = Some((t.m, t.x, t.y));
}
}
TouchPhase::End | TouchPhase::Cancel => {
if l.touch == Some(t.id) {
l.touch = None;
l.held_buttons.retain(|b| *b != 0);
l.pointer = Some((t.m, t.x, t.y));
}
}
},
Input::Combo { keys } => l
.combos
.push(keys.iter().map(|k| k.name()).collect::<Vec<_>>().join("+")),
Input::ReleaseAll => release_all(l),
}
}
pub fn mock_sdp(mids: &[String], offer: u32) -> String {
let mut s = format!(
"v=0\r\no=- 0 {offer} IN IP4 127.0.0.1\r\ns=sylphx-sandboxes-mock\r\nt=0 0\r\na=group:BUNDLE {} data\r\na=ice-ufrag:mock{offer}\r\na=ice-pwd:mockmockmockmockmockmock\r\n",
mids.join(" ")
);
for mid in mids {
s.push_str(&format!(
"m=video 9 UDP/TLS/RTP/SAVPF 102\r\nc=IN IP4 0.0.0.0\r\na=mid:{mid}\r\na=sendonly\r\na=rtpmap:102 H264/90000\r\na=fmtp:102 packetization-mode=1;profile-level-id=42e01f\r\n"
));
}
s.push_str("m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\nc=IN IP4 0.0.0.0\r\na=mid:data\r\na=sctp-port:5000\r\na=max-message-size:262144\r\n");
s
}