diff --git a/src/bridge.rs b/src/bridge.rs index 3b25a9e..915f02e 100644 --- a/src/bridge.rs +++ b/src/bridge.rs @@ -1,12 +1,122 @@ use anyhow::{Context, Result}; +use std::collections::{HashMap, HashSet}; use std::io::Read; use std::net::{TcpListener, TcpStream}; +use std::sync::{Arc, Mutex}; use std::thread; use crate::config::Config; use crate::input; use crate::protocol::{self, RECORD_BYTES, RECORD_HELLO}; +struct SharedInput { + backend: Box, + keys: HashMap, + buttons: HashMap, +} + +struct ConnectionInput { + shared: Arc>, + name: &'static str, + keys: HashSet, + buttons: HashSet, +} + +impl ConnectionInput { + fn press(&mut self, code: u16, down: bool, keyboard: bool) -> Result<()> { + let mut shared = self.shared.lock().unwrap(); + let held = if keyboard { + &mut self.keys + } else { + &mut self.buttons + }; + let owners = if keyboard { + &shared.keys + } else { + &shared.buttons + }; + let count = owners.get(&code).copied().unwrap_or(0); + if !down && !held.contains(&code) { + return Ok(()); + } + if down || count <= 1 { + if keyboard { + shared.backend.key(code, down)?; + } else { + shared.backend.button(code, down)?; + } + } + let owners = if keyboard { + &mut shared.keys + } else { + &mut shared.buttons + }; + if down { + if held.insert(code) { + *owners.entry(code).or_default() += 1; + } + } else { + held.remove(&code); + if count <= 1 { + owners.remove(&code); + } else { + owners.insert(code, count - 1); + } + } + Ok(()) + } +} + +impl input::InputBackend for ConnectionInput { + fn name(&self) -> &'static str { + self.name + } + fn key(&mut self, code: u16, down: bool) -> Result<()> { + self.press(code, down, true) + } + fn button(&mut self, code: u16, down: bool) -> Result<()> { + self.press(code, down, false) + } + fn motion(&mut self, absolute: bool, x: i32, y: i32) -> Result<()> { + self.shared.lock().unwrap().backend.motion(absolute, x, y) + } + fn wheel(&mut self, horizontal: bool, delta: i32) -> Result<()> { + self.shared.lock().unwrap().backend.wheel(horizontal, delta) + } + fn release_all(&mut self) -> Result<()> { + let mut error = None; + for code in self.keys.clone() { + if let Err(e) = self.key(code, false) { + error = Some(e); + } + } + for code in self.buttons.clone() { + if let Err(e) = self.button(code, false) { + error = Some(e); + } + } + // A disconnected client must not retain ownership if a release fails. + let mut shared = self.shared.lock().unwrap(); + for code in self.keys.drain() { + if let Some(count) = shared.keys.get_mut(&code) { + *count -= 1; + if *count == 0 { + shared.keys.remove(&code); + } + } + } + for code in self.buttons.drain() { + if let Some(count) = shared.buttons.get_mut(&code) { + *count -= 1; + if *count == 0 { + shared.buttons.remove(&code); + } + } + } + error.map_or(Ok(()), Err) + } +} + /// Print the X11 pointer position — the before/after observable for hook /// verification. pub fn print_pointer() -> Result<()> { @@ -19,8 +129,8 @@ pub fn print_pointer() -> Result<()> { Ok(()) } -/// Serve the in-client hook: one authenticated loopback connection at a -/// time, records dispatched to the selected input backend. +/// Serve authenticated loopback hook connections, serializing individual +/// input events without holding the backend lock while waiting for records. pub fn serve() -> Result<()> { let config = Config::load()?; let preferred = @@ -29,7 +139,12 @@ pub fn serve() -> Result<()> { if let Some(path) = std::env::var_os("UUR_BACKEND_STATUS") { std::fs::write(path, selected.name()).context("writing backend status")?; } - let backend = std::sync::Arc::new(std::sync::Mutex::new(selected)); + let backend_name = selected.name(); + let backend = Arc::new(Mutex::new(SharedInput { + backend: selected, + keys: HashMap::new(), + buttons: HashMap::new(), + })); let backend_handle = backend.clone(); let addr = format!("127.0.0.1:{}", config.bridge_port); let listener = TcpListener::bind(&addr).with_context(|| format!("binding {addr}"))?; @@ -52,9 +167,16 @@ pub fn serve() -> Result<()> { Ok(false) => return, Err(_) => return, } - let mut guard = backend_handle.lock().unwrap(); - println!("{}", t!("bridge.connected", backend = guard.name())); - match pump(&mut stream, guard.as_mut()) { + use input::InputBackend; + // Read sockets without holding the shared desktop input lock. + let mut connection = ConnectionInput { + shared: backend_handle, + name: backend_name, + keys: HashSet::new(), + buttons: HashSet::new(), + }; + println!("{}", t!("bridge.connected", backend = connection.name())); + match pump(&mut stream, &mut connection) { Ok(count) => { println!("{}", t!("bridge.session_summary", count = count)); println!("{}", t!("bridge.disconnected_clean")); @@ -66,7 +188,7 @@ pub fn serve() -> Result<()> { ); } } - let _ = guard.release_all(); + let _ = connection.release_all(); }); } Ok(()) @@ -165,3 +287,151 @@ fn tokens_differ(a: &[u8; 32], b: &[u8; 32]) -> bool { } diff != 0 } + +#[cfg(test)] +mod tests { + use super::*; + use crate::input::InputBackend; + use std::io::Write; + use std::sync::mpsc; + use std::time::Duration; + + struct Recorder(mpsc::Sender); + impl InputBackend for Recorder { + fn name(&self) -> &'static str { + "test" + } + fn key(&mut self, code: u16, down: bool) -> Result<()> { + self.0.send(format!("key {code} {down}"))?; + Ok(()) + } + fn button(&mut self, code: u16, down: bool) -> Result<()> { + self.0.send(format!("button {code} {down}"))?; + Ok(()) + } + fn motion(&mut self, _: bool, _: i32, _: i32) -> Result<()> { + self.0.send("motion".into())?; + Ok(()) + } + fn wheel(&mut self, _: bool, _: i32) -> Result<()> { + Ok(()) + } + fn release_all(&mut self) -> Result<()> { + panic!("must release only owned inputs") + } + } + + fn connection(shared: &Arc>) -> ConnectionInput { + ConnectionInput { + shared: shared.clone(), + name: "test", + keys: HashSet::new(), + buttons: HashSet::new(), + } + } + + fn shared() -> (Arc>, mpsc::Receiver) { + let (tx, rx) = mpsc::channel(); + ( + Arc::new(Mutex::new(SharedInput { + backend: Box::new(Recorder(tx)), + keys: HashMap::new(), + buttons: HashMap::new(), + })), + rx, + ) + } + + #[test] + fn idle_connection_does_not_block_another_connections_motion() { + let (shared, events) = shared(); + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let mut client = TcpStream::connect(listener.local_addr().unwrap()).unwrap(); + let (mut server, _) = listener.accept().unwrap(); + let mut idle = connection(&shared); + let thread = thread::spawn(move || pump(&mut server, &mut idle).unwrap()); + let mut packet = Vec::new(); + for value in [ + protocol::MAGIC, + 1, + protocol::RECORD_MOUSE, + 16, + protocol::RECORD_MOUSE, + ] { + packet.extend_from_slice(&value.to_le_bytes()); + } + packet.extend_from_slice(&0xffffu16.to_le_bytes()); + packet.extend_from_slice(&0u16.to_le_bytes()); + packet.extend_from_slice(&1i32.to_le_bytes()); + packet.extend_from_slice(&0i32.to_le_bytes()); + client.write_all(&packet).unwrap(); + assert_eq!( + events.recv_timeout(Duration::from_secs(2)).unwrap(), + "motion" + ); + let mut other = connection(&shared); + let other_thread = thread::spawn(move || other.motion(false, 1, 0).unwrap()); + let delivered = events.recv_timeout(Duration::from_secs(2)); + drop(client); + thread.join().unwrap(); + other_thread.join().unwrap(); + assert_eq!(delivered.unwrap(), "motion"); + } + + #[test] + fn disconnect_preserves_keys_and_buttons_held_by_another_connection() { + let (shared, events) = shared(); + let mut first = connection(&shared); + let mut second = connection(&shared); + first.key(65, true).unwrap(); + second.key(65, true).unwrap(); + first.button(1, true).unwrap(); + second.button(1, true).unwrap(); + first.release_all().unwrap(); + assert_eq!( + events.try_iter().collect::>(), + [ + "key 65 true", + "key 65 true", + "button 1 true", + "button 1 true" + ] + ); + second.release_all().unwrap(); + assert_eq!( + events.try_iter().collect::>(), + ["key 65 false", "button 1 false"] + ); + } + + #[test] + fn disconnect_forgets_ownership_when_backend_release_fails() { + let (shared, events) = shared(); + let mut client = connection(&shared); + client.key(65, true).unwrap(); + client.button(1, true).unwrap(); + drop(events); + assert!(client.release_all().is_err()); + assert!(client.keys.is_empty()); + assert!(client.buttons.is_empty()); + let shared = shared.lock().unwrap(); + assert!(shared.keys.is_empty()); + assert!(shared.buttons.is_empty()); + } + + #[test] + fn repeated_press_is_released_once_and_unowned_release_is_ignored() { + let (shared, events) = shared(); + let mut first = connection(&shared); + let mut second = connection(&shared); + first.key(65, true).unwrap(); + first.key(65, true).unwrap(); + second.key(65, false).unwrap(); + first.release_all().unwrap(); + assert_eq!( + events.try_iter().collect::>(), + ["key 65 true", "key 65 true", "key 65 false"] + ); + assert!(shared.lock().unwrap().keys.is_empty()); + } +}