release stuck keys (#53)

Keys are now released when
- A client disconnects and still has pressed keys
- A client disconnects through CTLR+ALT+SHIFT+WIN
- Lan Mouse terminates with keys still being pressed through a remote client

This is also fixes an issue caused by KDE's implementation of the remote desktop portal backend:
Keys are not correctly released when a remote desktop session is closed while keys are still pressed,
causing them to be permanently stuck until kwin is restarted.

This workaround remembers all pressed keys and releases them when lan-mouse exits or a device disconnects.

closes #15

src/backend/producer/wayland.rs

@@ -568,6 +568,7 @@ impl EventProducer for WaylandEventProducer {
     }
 
     fn release(&mut self) {
+        log::debug!("releasing pointer");
         let inner = self.0.get_mut();
         inner.state.ungrab();
         inner.flush_events();

src/client.rs

@@ -2,7 +2,6 @@ use std::{
     collections::HashSet,
     fmt::Display,
     net::{IpAddr, SocketAddr},
-    time::Instant,
 };
 
 use serde::{Deserialize, Serialize};
@@ -57,10 +56,6 @@ pub struct Client {
     /// This way any event consumer / producer backend does not
     /// need to know anything about a client other than its handle.
     pub handle: ClientHandle,
-    /// `active` address of the client, used to send data to.
-    /// This should generally be the socket address where data
-    /// was last received from.
-    pub active_addr: Option<SocketAddr>,
     /// all socket addresses associated with a particular client
     /// e.g. Laptops usually have at least an ethernet and a wifi port
     /// which have different ip addresses
@@ -71,7 +66,7 @@ pub struct Client {
     pub pos: Position,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug)]
 pub enum ClientEvent {
     Create(ClientHandle, Position),
     Destroy(ClientHandle),
@@ -81,11 +76,18 @@ pub type ClientHandle = u32;
 
 #[derive(Debug, Clone)]
 pub struct ClientState {
+    /// information about the client
     pub client: Client,
+    /// events should be sent to and received from the client
     pub active: bool,
-    pub last_ping: Option<Instant>,
-    pub last_seen: Option<Instant>,
-    pub last_replied: Option<Instant>,
+    /// `active` address of the client, used to send data to.
+    /// This should generally be the socket address where data
+    /// was last received from.
+    pub active_addr: Option<SocketAddr>,
+    /// tracks whether or not the client is responding to pings
+    pub alive: bool,
+    /// keys currently pressed by this client
+    pub pressed_keys: HashSet<u32>,
 }
 
 pub struct ClientManager {
@@ -114,9 +116,6 @@ impl ClientManager {
         // get a new client_handle
         let handle = self.free_id();
 
-        // we dont know, which IP is initially active
-        let active_addr = None;
-
         // store fix ip addresses
         let fix_ips = ips.iter().cloned().collect();
 
@@ -128,7 +127,6 @@ impl ClientManager {
             hostname,
             fix_ips,
             handle,
-            active_addr,
             addrs,
             port,
             pos,
@@ -137,10 +135,10 @@ impl ClientManager {
         // client was never seen, nor pinged
         let client_state = ClientState {
             client,
-            last_ping: None,
-            last_seen: None,
-            last_replied: None,
             active: false,
+            active_addr: None,
+            alive: false,
+            pressed_keys: HashSet::new(),
         };
 
         if handle as usize >= self.clients.len() {

src/event.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, Result};
 use std::{
     error::Error,
     fmt::{self, Display},
@@ -65,6 +66,9 @@ pub enum Event {
     /// response to a ping event: this event signals that a client
     /// is still alive but must otherwise be ignored
     Pong(),
+    /// explicit disconnect request. The client will no longer
+    /// send events until the next Enter event. All of its keys should be released.
+    Disconnect(),
 }
 
 impl Display for PointerEvent {
@@ -120,6 +124,7 @@ impl Display for Event {
             Event::Leave() => write!(f, "leave"),
             Event::Ping() => write!(f, "ping"),
             Event::Pong() => write!(f, "pong"),
+            Event::Disconnect() => write!(f, "disconnect"),
         }
     }
 }
@@ -133,6 +138,7 @@ impl Event {
             Self::Leave() => EventType::Leave,
             Self::Ping() => EventType::Ping,
             Self::Pong() => EventType::Pong,
+            Self::Disconnect() => EventType::Disconnect,
         }
     }
 }
@@ -174,32 +180,33 @@ enum EventType {
     Leave,
     Ping,
     Pong,
+    Disconnect,
 }
 
 impl TryFrom<u8> for PointerEventType {
-    type Error = Box<dyn Error>;
+    type Error = anyhow::Error;
 
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
+    fn try_from(value: u8) -> Result<Self> {
         match value {
             x if x == Self::Motion as u8 => Ok(Self::Motion),
             x if x == Self::Button as u8 => Ok(Self::Button),
             x if x == Self::Axis as u8 => Ok(Self::Axis),
             x if x == Self::Frame as u8 => Ok(Self::Frame),
-            _ => Err(Box::new(ProtocolError {
+            _ => Err(anyhow!(ProtocolError {
                 msg: format!("invalid pointer event type {}", value),
             })),
         }
     }
 }
 
 impl TryFrom<u8> for KeyboardEventType {
-    type Error = Box<dyn Error>;
+    type Error = anyhow::Error;
 
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
+    fn try_from(value: u8) -> Result<Self> {
         match value {
             x if x == Self::Key as u8 => Ok(Self::Key),
             x if x == Self::Modifiers as u8 => Ok(Self::Modifiers),
-            _ => Err(Box::new(ProtocolError {
+            _ => Err(anyhow!(ProtocolError {
                 msg: format!("invalid keyboard event type {}", value),
             })),
         }
@@ -216,6 +223,7 @@ impl From<&Event> for Vec<u8> {
             Event::Leave() => vec![],
             Event::Ping() => vec![],
             Event::Pong() => vec![],
+            Event::Disconnect() => vec![],
         };
         [event_id, event_data].concat()
     }
@@ -234,9 +242,9 @@ impl fmt::Display for ProtocolError {
 impl Error for ProtocolError {}
 
 impl TryFrom<Vec<u8>> for Event {
-    type Error = Box<dyn Error>;
+    type Error = anyhow::Error;
 
-    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+    fn try_from(value: Vec<u8>) -> Result<Self> {
         let event_id = u8::from_be_bytes(value[..1].try_into()?);
         match event_id {
             i if i == (EventType::Pointer as u8) => Ok(Event::Pointer(value.try_into()?)),
@@ -245,7 +253,8 @@ impl TryFrom<Vec<u8>> for Event {
             i if i == (EventType::Leave as u8) => Ok(Event::Leave()),
             i if i == (EventType::Ping as u8) => Ok(Event::Ping()),
             i if i == (EventType::Pong as u8) => Ok(Event::Pong()),
-            _ => Err(Box::new(ProtocolError {
+            i if i == (EventType::Disconnect as u8) => Ok(Event::Disconnect()),
+            _ => Err(anyhow!(ProtocolError {
                 msg: format!("invalid event_id {}", event_id),
             })),
         }
@@ -291,9 +300,9 @@ impl From<&PointerEvent> for Vec<u8> {
 }
 
 impl TryFrom<Vec<u8>> for PointerEvent {
-    type Error = Box<dyn Error>;
+    type Error = anyhow::Error;
 
-    fn try_from(data: Vec<u8>) -> Result<Self, Self::Error> {
+    fn try_from(data: Vec<u8>) -> Result<Self> {
         match data.get(1) {
             Some(id) => {
                 let event_type = match id.to_owned().try_into() {
@@ -305,23 +314,23 @@ impl TryFrom<Vec<u8>> for PointerEvent {
                         let time = match data.get(2..6) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 2".into(),
                                 }))
                             }
                         };
                         let relative_x = match data.get(6..14) {
                             Some(d) => f64::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 8 Bytes at index 6".into(),
                                 }))
                             }
                         };
                         let relative_y = match data.get(14..22) {
                             Some(d) => f64::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 8 Bytes at index 14".into(),
                                 }))
                             }
@@ -336,23 +345,23 @@ impl TryFrom<Vec<u8>> for PointerEvent {
                         let time = match data.get(2..6) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 2".into(),
                                 }))
                             }
                         };
                         let button = match data.get(6..10) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 10".into(),
                                 }))
                             }
                         };
                         let state = match data.get(10..14) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 14".into(),
                                 }))
                             }
@@ -367,23 +376,23 @@ impl TryFrom<Vec<u8>> for PointerEvent {
                         let time = match data.get(2..6) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 2".into(),
                                 }))
                             }
                         };
                         let axis = match data.get(6) {
                             Some(d) => *d,
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 1 Byte at index 6".into(),
                                 }));
                             }
                         };
                         let value = match data.get(7..15) {
                             Some(d) => f64::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 8 Bytes at index 7".into(),
                                 }));
                             }
@@ -393,7 +402,7 @@ impl TryFrom<Vec<u8>> for PointerEvent {
                     PointerEventType::Frame => Ok(Self::Frame {}),
                 }
             }
-            None => Err(Box::new(ProtocolError {
+            None => Err(anyhow!(ProtocolError {
                 msg: "Expected an element at index 0".into(),
             })),
         }
@@ -434,9 +443,9 @@ impl From<&KeyboardEvent> for Vec<u8> {
 }
 
 impl TryFrom<Vec<u8>> for KeyboardEvent {
-    type Error = Box<dyn Error>;
+    type Error = anyhow::Error;
 
-    fn try_from(data: Vec<u8>) -> Result<Self, Self::Error> {
+    fn try_from(data: Vec<u8>) -> Result<Self> {
         match data.get(1) {
             Some(id) => {
                 let event_type = match id.to_owned().try_into() {
@@ -448,23 +457,23 @@ impl TryFrom<Vec<u8>> for KeyboardEvent {
                         let time = match data.get(2..6) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 6".into(),
                                 }))
                             }
                         };
                         let key = match data.get(6..10) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 10".into(),
                                 }))
                             }
                         };
                         let state = match data.get(10) {
                             Some(d) => *d,
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 1 Bytes at index 14".into(),
                                 }))
                             }
@@ -475,31 +484,31 @@ impl TryFrom<Vec<u8>> for KeyboardEvent {
                         let mods_depressed = match data.get(2..6) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 6".into(),
                                 }))
                             }
                         };
                         let mods_latched = match data.get(6..10) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 10".into(),
                                 }))
                             }
                         };
                         let mods_locked = match data.get(10..14) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 14".into(),
                                 }))
                             }
                         };
                         let group = match data.get(14..18) {
                             Some(d) => u32::from_be_bytes(d.try_into()?),
                             None => {
-                                return Err(Box::new(ProtocolError {
+                                return Err(anyhow!(ProtocolError {
                                     msg: "Expected 4 Bytes at index 18".into(),
                                 }))
                             }
@@ -513,7 +522,7 @@ impl TryFrom<Vec<u8>> for KeyboardEvent {
                     }
                 }
             }
-            None => Err(Box::new(ProtocolError {
+            None => Err(anyhow!(ProtocolError {
                 msg: "Expected an element at index 0".into(),
             })),
         }

src/frontend.rs

@@ -108,6 +108,7 @@ pub enum FrontendNotify {
     NotifyClientDelete(ClientHandle),
     /// new port, reason of failure (if failed)
     NotifyPortChange(u16, Option<String>),
+    /// Client State, active
     Enumerate(Vec<(Client, bool)>),
     NotifyError(String),
 }

src/main.rs

@@ -65,7 +65,9 @@ fn run_service(config: &Config) -> Result<()> {
     runtime.block_on(LocalSet::new().run_until(async {
         // run main loop
         log::info!("Press Ctrl+Alt+Shift+Super to release the mouse");
-        Server::run(config).await?;
+
+        let server = Server::new(config);
+        server.run().await?;
 
         log::debug!("service exiting");
         anyhow::Ok(())