derive barrier_id from cursor position

this should fix #140

Cargo.lock

@@ -1192,7 +1192,7 @@ dependencies = [
 
 [[package]]
 name = "input-capture"
-version = "0.2.0"
+version = "0.1.0"
 dependencies = [
  "ashpd",
  "async-trait",
@@ -1217,7 +1217,7 @@ dependencies = [
 
 [[package]]
 name = "input-emulation"
-version = "0.2.1"
+version = "0.1.0"
 dependencies = [
  "ashpd",
  "async-trait",
@@ -1240,7 +1240,7 @@ dependencies = [
 
 [[package]]
 name = "input-event"
-version = "0.2.1"
+version = "0.1.0"
 dependencies = [
  "futures-core",
  "log",
@@ -1306,7 +1306,7 @@ dependencies = [
 
 [[package]]
 name = "lan-mouse"
-version = "0.9.1"
+version = "0.8.0"
 dependencies = [
  "anyhow",
  "async-channel",

Cargo.toml

@@ -4,19 +4,19 @@ members = ["input-capture", "input-emulation", "input-event"]
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.9.1"
+version = "0.8.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 
 [profile.release]
 strip = true
 lto = "fat"
 
 [dependencies]
-input-event = { path = "input-event", version = "0.2.1" }
-input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
-input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
+input-event = { path = "input-event", version = "0.1.0" }
+input-emulation = { path = "input-emulation", version = "0.1.0", default-features = false }
+input-capture = { path = "input-capture", version = "0.1.0", default-features = false }
 
 hickory-resolver = "0.24.1"
 toml = "0.8"

input-capture/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "input-capture"
 description = "cross-platform input-capture library used by lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 
 [dependencies]
 futures = "0.3.28"
 futures-core = "0.3.30"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.1.0" }
 memmap = "0.7"
 tempfile = "3.8"
 thiserror = "1.0.61"

input-capture/src/dummy.rs

@@ -8,7 +8,7 @@ use input_event::Event;
 
 use crate::CaptureError;
 
-use super::{Capture, CaptureHandle, Position};
+use super::{CaptureHandle, InputCapture, Position};
 
 pub struct DummyInputCapture {}
 
@@ -25,7 +25,7 @@ impl Default for DummyInputCapture {
 }
 
 #[async_trait]
-impl Capture for DummyInputCapture {
+impl InputCapture for DummyInputCapture {
     async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
         Ok(())
     }

input-capture/src/lib.rs

@@ -1,32 +1,31 @@
-use std::{collections::HashSet, fmt::Display, task::Poll};
+use std::fmt::Display;
 
 use async_trait::async_trait;
-use futures::StreamExt;
 use futures_core::Stream;
 
-use input_event::{scancode, Event, KeyboardEvent};
+use input_event::Event;
 
 pub use error::{CaptureCreationError, CaptureError, InputCaptureError};
 
 pub mod error;
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-mod libei;
+pub mod libei;
 
 #[cfg(target_os = "macos")]
-mod macos;
+pub mod macos;
 
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-mod wayland;
+pub mod wayland;
 
 #[cfg(windows)]
-mod windows;
+pub mod windows;
 
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-mod x11;
+pub mod x11;
 
 /// fallback input capture (does not produce events)
-mod dummy;
+pub mod dummy;
 
 pub type CaptureHandle = u64;
 
@@ -94,79 +93,10 @@ impl Display for Backend {
     }
 }
 
-pub struct InputCapture {
-    capture: Box<dyn Capture>,
-    pressed_keys: HashSet<scancode::Linux>,
-}
-
-impl InputCapture {
-    /// create a new client with the given id
-    pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
-        self.capture.create(id, pos).await
-    }
-
-    /// destroy the client with the given id, if it exists
-    pub async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
-        self.capture.destroy(id).await
-    }
-
-    /// release mouse
-    pub async fn release(&mut self) -> Result<(), CaptureError> {
-        self.pressed_keys.clear();
-        self.capture.release().await
-    }
-
-    /// destroy the input capture
-    pub async fn terminate(&mut self) -> Result<(), CaptureError> {
-        self.capture.terminate().await
-    }
-
-    /// creates a new [`InputCapture`]
-    pub async fn new(backend: Option<Backend>) -> Result<Self, CaptureCreationError> {
-        let capture = create(backend).await?;
-        Ok(Self {
-            capture,
-            pressed_keys: HashSet::new(),
-        })
-    }
-
-    /// check whether the given keys are pressed
-    pub fn keys_pressed(&self, keys: &[scancode::Linux]) -> bool {
-        keys.iter().all(|k| self.pressed_keys.contains(k))
-    }
-
-    fn update_pressed_keys(&mut self, key: u32, state: u8) {
-        if let Ok(scancode) = scancode::Linux::try_from(key) {
-            log::debug!("key: {key}, state: {state}, scancode: {scancode:?}");
-            match state {
-                1 => self.pressed_keys.insert(scancode),
-                _ => self.pressed_keys.remove(&scancode),
-            };
-        }
-    }
-}
-
-impl Stream for InputCapture {
-    type Item = Result<(CaptureHandle, Event), CaptureError>;
-
-    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        match self.capture.poll_next_unpin(cx) {
-            Poll::Ready(e) => {
-                if let Some(Ok((_, Event::Keyboard(KeyboardEvent::Key { key, state, .. })))) = e {
-                    self.update_pressed_keys(key, state);
-                }
-                Poll::Ready(e)
-            }
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
 #[async_trait]
-trait Capture: Stream<Item = Result<(CaptureHandle, Event), CaptureError>> + Unpin {
+pub trait InputCapture:
+    Stream<Item = Result<(CaptureHandle, Event), CaptureError>> + Unpin
+{
     /// create a new client with the given id
     async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;
 
@@ -180,10 +110,10 @@ trait Capture: Stream<Item = Result<(CaptureHandle, Event), CaptureError>> + Unp
     async fn terminate(&mut self) -> Result<(), CaptureError>;
 }
 
-async fn create_backend(
+pub async fn create_backend(
     backend: Backend,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
+    Box<dyn InputCapture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
     CaptureCreationError,
 > {
     match backend {
@@ -201,10 +131,10 @@ async fn create_backend(
     }
 }
 
-async fn create(
+pub async fn create(
     backend: Option<Backend>,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
+    Box<dyn InputCapture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
     CaptureCreationError,
 > {
     if let Some(backend) = backend {

input-capture/src/libei.rs

@@ -38,7 +38,7 @@ use input_event::Event;
 
 use super::{
     error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
-    Capture as LanMouseInputCapture, CaptureHandle, Position,
+    CaptureHandle, InputCapture as LanMouseInputCapture, Position,
 };
 
 /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that

input-capture/src/macos.rs

@@ -1,5 +1,5 @@
 use crate::{
-    error::MacOSInputCaptureCreationError, Capture, CaptureError, CaptureHandle, Position,
+    error::MacOSInputCaptureCreationError, CaptureError, CaptureHandle, InputCapture, Position,
 };
 use async_trait::async_trait;
 use futures_core::Stream;
@@ -24,7 +24,7 @@ impl Stream for MacOSInputCapture {
 }
 
 #[async_trait]
-impl Capture for MacOSInputCapture {
+impl InputCapture for MacOSInputCapture {
     async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
         Ok(())
     }

input-capture/src/wayland.rs

@@ -1,10 +1,11 @@
 use async_trait::async_trait;
 use futures_core::Stream;
+use memmap::MmapOptions;
 use std::{
     collections::VecDeque,
     env,
     io::{self, ErrorKind},
-    os::fd::{AsFd, RawFd},
+    os::fd::{AsFd, OwnedFd, RawFd},
     pin::Pin,
     task::{ready, Context, Poll},
 };
@@ -13,7 +14,7 @@ use tokio::io::unix::AsyncFd;
 use std::{
     fs::File,
     io::{BufWriter, Write},
-    os::unix::prelude::AsRawFd,
+    os::unix::prelude::{AsRawFd, FromRawFd},
     sync::Arc,
 };
 
@@ -58,13 +59,15 @@ use wayland_client::{
     Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
 };
 
+use tempfile;
+
 use input_event::{Event, KeyboardEvent, PointerEvent};
 
 use crate::CaptureError;
 
 use super::{
     error::{LayerShellCaptureCreationError, WaylandBindError},
-    Capture, CaptureHandle, Position,
+    CaptureHandle, InputCapture, Position,
 };
 
 struct Globals {
@@ -105,7 +108,7 @@ struct State {
     client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
     focused: Option<(Arc<Window>, CaptureHandle)>,
     g: Globals,
-    wayland_fd: RawFd,
+    wayland_fd: OwnedFd,
     read_guard: Option<ReadEventsGuard>,
     qh: QueueHandle<Self>,
     pending_events: VecDeque<(CaptureHandle, Event)>,
@@ -120,7 +123,7 @@ struct Inner {
 
 impl AsRawFd for Inner {
     fn as_raw_fd(&self) -> RawFd {
-        self.state.wayland_fd
+        self.state.wayland_fd.as_raw_fd()
     }
 }
 
@@ -305,7 +308,10 @@ impl WaylandInputCapture {
         // flush outgoing events
         queue.flush()?;
 
-        let wayland_fd = queue.as_fd().as_raw_fd();
+        // prepare reading wayland events
+        let read_guard = queue.prepare_read().unwrap(); // there can not yet be events to dispatch
+        let wayland_fd = read_guard.connection_fd().try_clone_to_owned().unwrap();
+        std::mem::drop(read_guard);
 
         let mut state = State {
             pointer: None,
@@ -559,7 +565,7 @@ impl Inner {
 }
 
 #[async_trait]
-impl Capture for WaylandInputCapture {
+impl InputCapture for WaylandInputCapture {
     async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
         self.add_client(handle, pos);
         let inner = self.0.get_mut();
@@ -814,6 +820,15 @@ impl Dispatch<WlKeyboard, ()> for State {
                     ));
                 }
             }
+            wl_keyboard::Event::Keymap {
+                format: _,
+                fd,
+                size: _,
+            } => {
+                let fd = unsafe { &File::from_raw_fd(fd.as_raw_fd()) };
+                let _mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
+                // TODO keymap
+            }
             _ => (),
         }
     }

input-capture/src/windows.rs

@@ -37,7 +37,7 @@ use input_event::{
     Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
 
-use super::{Capture, CaptureError, CaptureHandle, Position};
+use super::{CaptureError, CaptureHandle, InputCapture, Position};
 
 enum Request {
     Create(CaptureHandle, Position),
@@ -64,7 +64,7 @@ unsafe fn signal_message_thread(event_type: EventType) {
 }
 
 #[async_trait]
-impl Capture for WindowsInputCapture {
+impl InputCapture for WindowsInputCapture {
     async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
         unsafe {
             {

input-capture/src/x11.rs

@@ -5,7 +5,7 @@ use futures_core::Stream;
 
 use crate::CaptureError;
 
-use super::Capture;
+use super::InputCapture;
 use input_event::Event;
 
 use super::error::X11InputCaptureCreationError;
@@ -20,7 +20,7 @@ impl X11InputCapture {
 }
 
 #[async_trait]
-impl Capture for X11InputCapture {
+impl InputCapture for X11InputCapture {
     async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
         Ok(())
     }

input-emulation/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "input-emulation"
 description = "cross-platform input emulation library used by lan-mouse"
-version = "0.2.1"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 
 [dependencies]
 async-trait = "0.1.80"
 futures = "0.3.28"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.1.0" }
 thiserror = "1.0.61"
 tokio = { version = "1.32.0", features = [
     "io-util",

input-emulation/src/dummy.rs

@@ -3,19 +3,19 @@ use input_event::Event;
 
 use crate::error::EmulationError;
 
-use super::{Emulation, EmulationHandle};
+use super::{EmulationHandle, InputEmulation};
 
 #[derive(Default)]
-pub(crate) struct DummyEmulation;
+pub struct DummyEmulation;
 
 impl DummyEmulation {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {}
     }
 }
 
 #[async_trait]
-impl Emulation for DummyEmulation {
+impl InputEmulation for DummyEmulation {
     async fn consume(
         &mut self,
         event: Event,

input-emulation/src/error.rs

@@ -87,25 +87,19 @@ pub enum EmulationCreationError {
 
 impl EmulationCreationError {
     /// request was intentionally denied by the user
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
     pub(crate) fn cancelled_by_user(&self) -> bool {
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        if matches!(
+        matches!(
             self,
             EmulationCreationError::Libei(LibeiEmulationCreationError::Ashpd(Response(
                 ResponseError::Cancelled,
-            )))
-        ) {
-            return true;
-        }
-        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-        if matches!(
-            self,
-            EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
+            ))) | EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
                 ResponseError::Cancelled,
             )))
-        ) {
-            return true;
-        }
+        )
+    }
+    #[cfg(not(all(unix, feature = "libei", not(target_os = "macos"))))]
+    pub(crate) fn cancelled_by_user(&self) -> bool {
         false
     }
 }

input-emulation/src/lib.rs

@@ -1,34 +1,31 @@
 use async_trait::async_trait;
-use std::{
-    collections::{HashMap, HashSet},
-    fmt::Display,
-};
+use std::fmt::Display;
 
-use input_event::{Event, KeyboardEvent};
+use input_event::Event;
 
 pub use self::error::{EmulationCreationError, EmulationError, InputEmulationError};
 
 #[cfg(windows)]
-mod windows;
+pub mod windows;
 
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-mod x11;
+pub mod x11;
 
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-mod wlroots;
+pub mod wlroots;
 
 #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-mod xdg_desktop_portal;
+pub mod xdg_desktop_portal;
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-mod libei;
+pub mod libei;
 
 #[cfg(target_os = "macos")]
-mod macos;
+pub mod macos;
 
 /// fallback input emulation (logs events)
-mod dummy;
-mod error;
+pub mod dummy;
+pub mod error;
 
 pub type EmulationHandle = u64;
 
@@ -69,166 +66,8 @@ impl Display for Backend {
     }
 }
 
-pub struct InputEmulation {
-    emulation: Box<dyn Emulation>,
-    handles: HashSet<EmulationHandle>,
-    pressed_keys: HashMap<EmulationHandle, HashSet<u32>>,
-}
-
-impl InputEmulation {
-    async fn with_backend(backend: Backend) -> Result<InputEmulation, EmulationCreationError> {
-        let emulation: Box<dyn Emulation> = match backend {
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            Backend::Wlroots => Box::new(wlroots::WlrootsEmulation::new()?),
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            Backend::Libei => Box::new(libei::LibeiEmulation::new().await?),
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            Backend::X11 => Box::new(x11::X11Emulation::new()?),
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-            Backend::Xdp => Box::new(xdg_desktop_portal::DesktopPortalEmulation::new().await?),
-            #[cfg(windows)]
-            Backend::Windows => Box::new(windows::WindowsEmulation::new()?),
-            #[cfg(target_os = "macos")]
-            Backend::MacOs => Box::new(macos::MacOSEmulation::new()?),
-            Backend::Dummy => Box::new(dummy::DummyEmulation::new()),
-        };
-        Ok(Self {
-            emulation,
-            handles: HashSet::new(),
-            pressed_keys: HashMap::new(),
-        })
-    }
-
-    pub async fn new(backend: Option<Backend>) -> Result<InputEmulation, EmulationCreationError> {
-        if let Some(backend) = backend {
-            let b = Self::with_backend(backend).await;
-            if b.is_ok() {
-                log::info!("using emulation backend: {backend}");
-            }
-            return b;
-        }
-
-        for backend in [
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            Backend::Wlroots,
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            Backend::Libei,
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-            Backend::Xdp,
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            Backend::X11,
-            #[cfg(windows)]
-            Backend::Windows,
-            #[cfg(target_os = "macos")]
-            Backend::MacOs,
-            Backend::Dummy,
-        ] {
-            match Self::with_backend(backend).await {
-                Ok(b) => {
-                    log::info!("using emulation backend: {backend}");
-                    return Ok(b);
-                }
-                Err(e) if e.cancelled_by_user() => return Err(e),
-                Err(e) => log::warn!("{e}"),
-            }
-        }
-
-        Err(EmulationCreationError::NoAvailableBackend)
-    }
-
-    pub async fn consume(
-        &mut self,
-        event: Event,
-        handle: EmulationHandle,
-    ) -> Result<(), EmulationError> {
-        match event {
-            Event::Keyboard(KeyboardEvent::Key { key, state, .. }) => {
-                // prevent double pressed / released keys
-                if self.update_pressed_keys(handle, key, state) {
-                    self.emulation.consume(event, handle).await?;
-                }
-                Ok(())
-            }
-            _ => self.emulation.consume(event, handle).await,
-        }
-    }
-
-    pub async fn create(&mut self, handle: EmulationHandle) -> bool {
-        if self.handles.insert(handle) {
-            self.pressed_keys.insert(handle, HashSet::new());
-            self.emulation.create(handle).await;
-            true
-        } else {
-            false
-        }
-    }
-
-    pub async fn destroy(&mut self, handle: EmulationHandle) {
-        let _ = self.release_keys(handle).await;
-        if self.handles.remove(&handle) {
-            self.pressed_keys.remove(&handle);
-            self.emulation.destroy(handle).await
-        }
-    }
-
-    pub async fn terminate(&mut self) {
-        for handle in self.handles.iter().cloned().collect::<Vec<_>>() {
-            self.destroy(handle).await
-        }
-        self.emulation.terminate().await
-    }
-
-    pub async fn release_keys(&mut self, handle: EmulationHandle) -> Result<(), EmulationError> {
-        if let Some(keys) = self.pressed_keys.get_mut(&handle) {
-            let keys = keys.drain().collect::<Vec<_>>();
-            for key in keys {
-                let event = Event::Keyboard(KeyboardEvent::Key {
-                    time: 0,
-                    key,
-                    state: 0,
-                });
-                self.emulation.consume(event, handle).await?;
-                if let Ok(key) = input_event::scancode::Linux::try_from(key) {
-                    log::warn!("releasing stuck key: {key:?}");
-                }
-            }
-        }
-
-        let event = Event::Keyboard(KeyboardEvent::Modifiers {
-            mods_depressed: 0,
-            mods_latched: 0,
-            mods_locked: 0,
-            group: 0,
-        });
-        self.emulation.consume(event, handle).await?;
-        Ok(())
-    }
-
-    pub fn has_pressed_keys(&self, handle: EmulationHandle) -> bool {
-        self.pressed_keys
-            .get(&handle)
-            .is_some_and(|p| !p.is_empty())
-    }
-
-    /// update the pressed_keys for the given handle
-    /// returns whether the event should be processed
-    fn update_pressed_keys(&mut self, handle: EmulationHandle, key: u32, state: u8) -> bool {
-        let Some(pressed_keys) = self.pressed_keys.get_mut(&handle) else {
-            return false;
-        };
-
-        if state == 0 {
-            // currently pressed => can release
-            pressed_keys.remove(&key)
-        } else {
-            // currently not pressed => can press
-            pressed_keys.insert(key)
-        }
-    }
-}
-
 #[async_trait]
-trait Emulation: Send {
+pub trait InputEmulation: Send {
     async fn consume(
         &mut self,
         event: Event,
@@ -238,3 +77,64 @@ trait Emulation: Send {
     async fn destroy(&mut self, handle: EmulationHandle);
     async fn terminate(&mut self);
 }
+
+pub async fn create_backend(
+    backend: Backend,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    match backend {
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::Wlroots => Ok(Box::new(wlroots::WlrootsEmulation::new()?)),
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::Libei => Ok(Box::new(libei::LibeiEmulation::new().await?)),
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11 => Ok(Box::new(x11::X11Emulation::new()?)),
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        Backend::Xdp => Ok(Box::new(
+            xdg_desktop_portal::DesktopPortalEmulation::new().await?,
+        )),
+        #[cfg(windows)]
+        Backend::Windows => Ok(Box::new(windows::WindowsEmulation::new()?)),
+        #[cfg(target_os = "macos")]
+        Backend::MacOs => Ok(Box::new(macos::MacOSEmulation::new()?)),
+        Backend::Dummy => Ok(Box::new(dummy::DummyEmulation::new())),
+    }
+}
+
+pub async fn create(
+    backend: Option<Backend>,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    if let Some(backend) = backend {
+        let b = create_backend(backend).await;
+        if b.is_ok() {
+            log::info!("using emulation backend: {backend}");
+        }
+        return b;
+    }
+
+    for backend in [
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::Wlroots,
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::Libei,
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        Backend::Xdp,
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11,
+        #[cfg(windows)]
+        Backend::Windows,
+        #[cfg(target_os = "macos")]
+        Backend::MacOs,
+        Backend::Dummy,
+    ] {
+        match create_backend(backend).await {
+            Ok(b) => {
+                log::info!("using emulation backend: {backend}");
+                return Ok(b);
+            }
+            Err(e) if e.cancelled_by_user() => return Err(e),
+            Err(e) => log::warn!("{e}"),
+        }
+    }
+
+    Err(EmulationCreationError::NoAvailableBackend)
+}

input-emulation/src/libei.rs

@@ -34,7 +34,7 @@ use input_event::{Event, KeyboardEvent, PointerEvent};
 
 use crate::error::{EmulationError, ReisConvertStreamError};
 
-use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};
+use super::{error::LibeiEmulationCreationError, EmulationHandle, InputEmulation};
 
 static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
     let mut m = HashMap::new();
@@ -60,7 +60,7 @@ struct Devices {
     keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
 }
 
-pub(crate) struct LibeiEmulation<'a> {
+pub struct LibeiEmulation<'a> {
     context: ei::Context,
     devices: Devices,
     ei_task: JoinHandle<()>,
@@ -99,7 +99,7 @@ async fn get_ei_fd<'a>(
 }
 
 impl<'a> LibeiEmulation<'a> {
-    pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
+    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
         let (_remote_desktop, session, eifd) = get_ei_fd().await?;
         let stream = UnixStream::from(eifd);
         stream.set_nonblocking(true)?;
@@ -147,7 +147,7 @@ impl<'a> Drop for LibeiEmulation<'a> {
 }
 
 #[async_trait]
-impl<'a> Emulation for LibeiEmulation<'a> {
+impl<'a> InputEmulation for LibeiEmulation<'a> {
     async fn consume(
         &mut self,
         event: Event,

input-emulation/src/macos.rs

@@ -1,4 +1,4 @@
-use super::{error::EmulationError, Emulation, EmulationHandle};
+use super::{error::EmulationError, EmulationHandle, InputEmulation};
 use async_trait::async_trait;
 use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
 use core_graphics::event::{
@@ -16,8 +16,8 @@ use super::error::MacOSEmulationCreationError;
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
 
-pub(crate) struct MacOSEmulation {
-    event_source: CGEventSource,
+pub struct MacOSEmulation {
+    pub event_source: CGEventSource,
     repeat_task: Option<AbortHandle>,
     button_state: ButtonState,
 }
@@ -53,7 +53,7 @@ impl IndexMut<CGMouseButton> for ButtonState {
 unsafe impl Send for MacOSEmulation {}
 
 impl MacOSEmulation {
-    pub(crate) fn new() -> Result<Self, MacOSEmulationCreationError> {
+    pub fn new() -> Result<Self, MacOSEmulationCreationError> {
         let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
             .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
         let button_state = ButtonState {
@@ -106,7 +106,7 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8) {
 }
 
 #[async_trait]
-impl Emulation for MacOSEmulation {
+impl InputEmulation for MacOSEmulation {
     async fn consume(
         &mut self,
         event: Event,

input-emulation/src/windows.rs

@@ -19,23 +19,23 @@ use windows::Win32::UI::Input::KeyboardAndMouse::{
 };
 use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};
 
-use super::{Emulation, EmulationHandle};
+use super::{EmulationHandle, InputEmulation};
 
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
 
-pub(crate) struct WindowsEmulation {
+pub struct WindowsEmulation {
     repeat_task: Option<AbortHandle>,
 }
 
 impl WindowsEmulation {
-    pub(crate) fn new() -> Result<Self, WindowsEmulationCreationError> {
+    pub fn new() -> Result<Self, WindowsEmulationCreationError> {
         Ok(Self { repeat_task: None })
     }
 }
 
 #[async_trait]
-impl Emulation for WindowsEmulation {
+impl InputEmulation for WindowsEmulation {
     async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {

input-emulation/src/wlroots.rs

@@ -1,6 +1,6 @@
 use crate::error::EmulationError;
 
-use super::{error::WlrootsEmulationCreationError, Emulation};
+use super::{error::WlrootsEmulationCreationError, InputEmulation};
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -50,7 +50,7 @@ pub(crate) struct WlrootsEmulation {
 }
 
 impl WlrootsEmulation {
-    pub(crate) fn new() -> Result<Self, WlrootsEmulationCreationError> {
+    pub fn new() -> Result<Self, WlrootsEmulationCreationError> {
         let conn = Connection::connect_to_env()?;
         let (globals, queue) = registry_queue_init::<State>(&conn)?;
         let qh = queue.handle();
@@ -116,7 +116,7 @@ impl State {
 }
 
 #[async_trait]
-impl Emulation for WlrootsEmulation {
+impl InputEmulation for WlrootsEmulation {
     async fn consume(
         &mut self,
         event: Event,

input-emulation/src/x11.rs

@@ -11,16 +11,16 @@ use input_event::{
 
 use crate::error::EmulationError;
 
-use super::{error::X11EmulationCreationError, Emulation, EmulationHandle};
+use super::{error::X11EmulationCreationError, EmulationHandle, InputEmulation};
 
-pub(crate) struct X11Emulation {
+pub struct X11Emulation {
     display: *mut xlib::Display,
 }
 
 unsafe impl Send for X11Emulation {}
 
 impl X11Emulation {
-    pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
+    pub fn new() -> Result<Self, X11EmulationCreationError> {
         let display = unsafe {
             match xlib::XOpenDisplay(ptr::null()) {
                 d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
@@ -99,7 +99,7 @@ impl Drop for X11Emulation {
 }
 
 #[async_trait]
-impl Emulation for X11Emulation {
+impl InputEmulation for X11Emulation {
     async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {

input-emulation/src/xdg_desktop_portal.rs

@@ -16,15 +16,15 @@ use input_event::{
 
 use crate::error::EmulationError;
 
-use super::{error::XdpEmulationCreationError, Emulation, EmulationHandle};
+use super::{error::XdpEmulationCreationError, EmulationHandle, InputEmulation};
 
-pub(crate) struct DesktopPortalEmulation<'a> {
+pub struct DesktopPortalEmulation<'a> {
     proxy: RemoteDesktop<'a>,
     session: Session<'a, RemoteDesktop<'a>>,
 }
 
 impl<'a> DesktopPortalEmulation<'a> {
-    pub(crate) async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
+    pub async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
         log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
         let proxy = RemoteDesktop::new().await?;
 
@@ -56,7 +56,7 @@ impl<'a> DesktopPortalEmulation<'a> {
 }
 
 #[async_trait]
-impl<'a> Emulation for DesktopPortalEmulation<'a> {
+impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
     async fn consume(
         &mut self,
         event: input_event::Event,

input-event/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "input-event"
 description = "cross-platform input-event types for input-capture / input-emulation"
-version = "0.2.1"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"
 
 [dependencies]
 futures-core = "0.3.30"

src/capture_test.rs

@@ -20,7 +20,7 @@ async fn input_capture_test(config: Config) -> Result<(), InputCaptureError> {
     log::info!("creating input capture");
     let backend = config.capture_backend.map(|b| b.into());
     loop {
-        let mut input_capture = InputCapture::new(backend).await?;
+        let mut input_capture = input_capture::create(backend).await?;
         log::info!("creating clients");
         input_capture.create(0, Position::Left).await?;
         input_capture.create(1, Position::Right).await?;
@@ -33,7 +33,7 @@ async fn input_capture_test(config: Config) -> Result<(), InputCaptureError> {
     }
 }
 
-async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError> {
+async fn do_capture(input_capture: &mut Box<dyn InputCapture>) -> Result<(), CaptureError> {
     loop {
         let (client, event) = input_capture
             .next()

src/client.rs

@@ -125,8 +125,8 @@ pub struct ClientState {
     /// e.g. Laptops usually have at least an ethernet and a wifi port
     /// which have different ip addresses
     pub ips: HashSet<IpAddr>,
-    /// client has pressed keys
-    pub has_pressed_keys: bool,
+    /// keys currently pressed by this client
+    pub pressed_keys: HashSet<u32>,
     /// dns resolving in progress
     pub resolving: bool,
 }

src/emulation_test.rs

@@ -1,6 +1,5 @@
 use crate::config::Config;
 use anyhow::Result;
-use input_emulation::InputEmulation;
 use input_event::{Event, PointerEvent};
 use std::f64::consts::PI;
 use std::time::{Duration, Instant};
@@ -23,7 +22,7 @@ const RADIUS: f64 = 100.0;
 
 async fn input_emulation_test(config: Config) -> Result<()> {
     let backend = config.emulation_backend.map(|b| b.into());
-    let mut emulation = InputEmulation::new(backend).await?;
+    let mut emulation = input_emulation::create(backend).await?;
     emulation.create(0).await;
     let start = Instant::now();
     let mut offset = (0, 0);

src/server.rs

@@ -1,5 +1,5 @@
-use capture_task::CaptureRequest;
-use emulation_task::EmulationRequest;
+use capture_task::CaptureEvent;
+use emulation_task::EmulationEvent;
 use log;
 use std::{
     cell::{Cell, RefCell},
@@ -253,7 +253,7 @@ impl Server {
         self.notifies.capture.notify_waiters()
     }
 
-    async fn capture_enabled(&self) {
+    async fn capture_notified(&self) {
         self.notifies.capture.notified().await
     }
 
@@ -306,8 +306,8 @@ impl Server {
 
     async fn handle_request(
         &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
+        capture: &Sender<CaptureEvent>,
+        emulate: &Sender<EmulationEvent>,
         event: FrontendRequest,
     ) -> bool {
         log::debug!("frontend: {event:?}");
@@ -372,8 +372,8 @@ impl Server {
 
     async fn deactivate_client(
         &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
+        capture: &Sender<CaptureEvent>,
+        emulate: &Sender<EmulationEvent>,
         handle: ClientHandle,
     ) {
         log::debug!("deactivating client {handle}");
@@ -382,15 +382,15 @@ impl Server {
             None => return,
         };
 
-        let _ = capture.send(CaptureRequest::Destroy(handle)).await;
-        let _ = emulate.send(EmulationRequest::Destroy(handle)).await;
+        let _ = capture.send(CaptureEvent::Destroy(handle)).await;
+        let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
         log::debug!("deactivating client {handle} done");
     }
 
     async fn activate_client(
         &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
+        capture: &Sender<CaptureEvent>,
+        emulate: &Sender<EmulationEvent>,
         handle: ClientHandle,
     ) {
         log::debug!("activating client");
@@ -415,17 +415,15 @@ impl Server {
         };
 
         /* notify emulation, capture and frontends */
-        let _ = capture
-            .send(CaptureRequest::Create(handle, pos.into()))
-            .await;
-        let _ = emulate.send(EmulationRequest::Create(handle)).await;
+        let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
+        let _ = emulate.send(EmulationEvent::Create(handle)).await;
         log::debug!("activating client {handle} done");
     }
 
     async fn remove_client(
         &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
+        capture: &Sender<CaptureEvent>,
+        emulate: &Sender<EmulationEvent>,
         handle: ClientHandle,
     ) {
         let Some(active) = self
@@ -438,14 +436,8 @@ impl Server {
         };
 
         if active {
-            let _ = capture.send(CaptureRequest::Destroy(handle)).await;
-            let _ = emulate.send(EmulationRequest::Destroy(handle)).await;
-        }
-    }
-
-    fn update_pressed_keys(&self, handle: ClientHandle, has_pressed_keys: bool) {
-        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
-            s.has_pressed_keys = has_pressed_keys;
+            let _ = capture.send(CaptureEvent::Destroy(handle)).await;
+            let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
         }
     }
 
@@ -504,8 +496,8 @@ impl Server {
     async fn update_pos(
         &self,
         handle: ClientHandle,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
+        capture: &Sender<CaptureEvent>,
+        emulate: &Sender<EmulationEvent>,
         pos: Position,
     ) {
         let (changed, active) = {
@@ -522,13 +514,11 @@ impl Server {
         // update state in event input emulator & input capture
         if changed {
             if active {
-                let _ = capture.send(CaptureRequest::Destroy(handle)).await;
-                let _ = emulate.send(EmulationRequest::Destroy(handle)).await;
+                let _ = capture.send(CaptureEvent::Destroy(handle)).await;
+                let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
             }
-            let _ = capture
-                .send(CaptureRequest::Create(handle, pos.into()))
-                .await;
-            let _ = emulate.send(EmulationRequest::Create(handle)).await;
+            let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
+            let _ = emulate.send(EmulationEvent::Create(handle)).await;
         }
     }
 
@@ -567,27 +557,6 @@ impl Server {
             .get_mut(handle)
             .and_then(|(c, _)| c.hostname.clone())
     }
-
-    fn get_state(&self) -> State {
-        self.state.get()
-    }
-
-    fn set_state(&self, state: State) {
-        log::debug!("state => {state:?}");
-        self.state.replace(state);
-    }
-
-    fn set_active(&self, handle: Option<u64>) {
-        log::debug!("active client => {handle:?}");
-        self.active_client.replace(handle);
-    }
-
-    fn active_addr(&self, handle: u64) -> Option<SocketAddr> {
-        self.client_manager
-            .borrow()
-            .get(handle)
-            .and_then(|(_, s)| s.active_addr)
-    }
 }
 
 async fn listen_frontend(

src/server/capture_task.rs

@@ -1,5 +1,5 @@
 use futures::StreamExt;
-use std::net::SocketAddr;
+use std::{collections::HashSet, net::SocketAddr};
 
 use tokio::{
     process::Command,
@@ -9,14 +9,14 @@ use tokio::{
 
 use input_capture::{self, CaptureError, CaptureHandle, InputCapture, InputCaptureError, Position};
 
-use input_event::Event;
+use input_event::{scancode, Event, KeyboardEvent};
 
 use crate::{client::ClientHandle, frontend::Status, server::State};
 
 use super::Server;
 
 #[derive(Clone, Copy, Debug)]
-pub(crate) enum CaptureRequest {
+pub(crate) enum CaptureEvent {
     /// capture must release the mouse
     Release,
     /// add a capture client
@@ -27,7 +27,7 @@ pub(crate) enum CaptureRequest {
 
 pub(crate) fn new(
     server: Server,
-    capture_rx: Receiver<CaptureRequest>,
+    capture_rx: Receiver<CaptureEvent>,
     udp_send: Sender<(Event, SocketAddr)>,
 ) -> JoinHandle<()> {
     let backend = server.config.capture_backend.map(|b| b.into());
@@ -38,7 +38,7 @@ async fn capture_task(
     server: Server,
     backend: Option<input_capture::Backend>,
     sender_tx: Sender<(Event, SocketAddr)>,
-    mut notify_rx: Receiver<CaptureRequest>,
+    mut notify_rx: Receiver<CaptureEvent>,
 ) {
     loop {
         if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await {
@@ -53,7 +53,7 @@ async fn capture_task(
         loop {
             tokio::select! {
                 _ = notify_rx.recv() => continue, /* need to ignore requests here! */
-                _ = server.capture_enabled() => break,
+                _ = server.capture_notified() => break,
                 _ = server.cancelled() => return,
             }
         }
@@ -64,48 +64,50 @@ async fn do_capture(
     backend: Option<input_capture::Backend>,
     server: &Server,
     sender_tx: &Sender<(Event, SocketAddr)>,
-    notify_rx: &mut Receiver<CaptureRequest>,
+    notify_rx: &mut Receiver<CaptureEvent>,
 ) -> Result<(), InputCaptureError> {
     /* allow cancelling capture request */
     let mut capture = tokio::select! {
-        r = InputCapture::new(backend) => r?,
+        r = input_capture::create(backend) => {
+            r?
+        },
         _ = server.cancelled() => return Ok(()),
     };
 
     server.set_capture_status(Status::Enabled);
 
-    let clients = server.active_clients();
-    let clients = clients.iter().copied().map(|handle| {
-        (
-            handle,
-            server
-                .client_manager
-                .borrow()
-                .get(handle)
-                .map(|(c, _)| c.pos)
-                .expect("no such client"),
-        )
-    });
-    for (handle, pos) in clients {
-        capture.create(handle, pos.into()).await?;
+    // FIXME DUPLICATES
+    let clients = server
+        .client_manager
+        .borrow()
+        .get_client_states()
+        .map(|(h, s)| (h, s.clone()))
+        .collect::<Vec<_>>();
+    log::info!("{clients:?}");
+    for (handle, (config, _state)) in clients {
+        capture.create(handle, config.pos.into()).await?;
     }
 
+    let mut pressed_keys = HashSet::new();
     loop {
         tokio::select! {
-            event = capture.next() => match event {
-                Some(event) => handle_capture_event(server, &mut capture, sender_tx, event?).await?,
-                None => return Ok(()),
-            },
+            event = capture.next() => {
+                match event {
+                    Some(Ok(event)) => handle_capture_event(server, &mut capture, sender_tx, event, &mut pressed_keys).await?,
+                    Some(Err(e)) => return Err(e.into()),
+                    None => return Ok(()),
+                }
+            }
             e = notify_rx.recv() => {
                 log::debug!("input capture notify rx: {e:?}");
                 match e {
                     Some(e) => match e {
-                        CaptureRequest::Release => {
+                        CaptureEvent::Release => {
                             capture.release().await?;
                             server.state.replace(State::Receiving);
                         }
-                        CaptureRequest::Create(h, p) => capture.create(h, p).await?,
-                        CaptureRequest::Destroy(h) => capture.destroy(h).await?,
+                        CaptureEvent::Create(h, p) => capture.create(h, p).await?,
+                        CaptureEvent::Destroy(h) => capture.destroy(h).await?,
                     },
                     None => break,
                 }
@@ -117,44 +119,92 @@ async fn do_capture(
     Ok(())
 }
 
+fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {
+    if let Ok(scancode) = scancode::Linux::try_from(key) {
+        log::debug!("key: {key}, state: {state}, scancode: {scancode:?}");
+        match state {
+            1 => pressed_keys.insert(scancode),
+            _ => pressed_keys.remove(&scancode),
+        };
+    }
+}
+
 async fn handle_capture_event(
     server: &Server,
-    capture: &mut InputCapture,
+    capture: &mut Box<dyn InputCapture>,
     sender_tx: &Sender<(Event, SocketAddr)>,
     event: (CaptureHandle, Event),
+    pressed_keys: &mut HashSet<scancode::Linux>,
 ) -> Result<(), CaptureError> {
-    let (handle, event) = event;
-    log::trace!("({handle}) {event:?}");
+    let (handle, mut e) = event;
+    log::trace!("({handle}) {e:?}");
 
-    // capture started
-    if event == Event::Enter() {
-        server.set_state(State::AwaitingLeave);
-        server.set_active(Some(handle));
+    if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = e {
+        update_pressed_keys(pressed_keys, key, state);
+        log::debug!("{pressed_keys:?}");
+        if server.release_bind.iter().all(|k| pressed_keys.contains(k)) {
+            pressed_keys.clear();
+            log::info!("releasing pointer");
+            capture.release().await?;
+            server.state.replace(State::Receiving);
+            log::trace!("STATE ===> Receiving");
+            // send an event to release all the modifiers
+            e = Event::Disconnect();
+        }
+    }
+
+    let info = {
+        let mut enter = false;
+        let mut start_timer = false;
+
+        // get client state for handle
+        let mut client_manager = server.client_manager.borrow_mut();
+        let client_state = client_manager.get_mut(handle).map(|(_, s)| s);
+        if let Some(client_state) = client_state {
+            // if we just entered the client we want to send additional enter events until
+            // we get a leave event
+            if let Event::Enter() = e {
+                server.state.replace(State::AwaitingLeave);
+                server.active_client.replace(Some(handle));
+                log::trace!("Active client => {}", handle);
+                start_timer = true;
+                log::trace!("STATE ===> AwaitingLeave");
+                enter = true;
+            } else {
+                // ignore any potential events in receiving mode
+                if server.state.get() == State::Receiving && e != Event::Disconnect() {
+                    return Ok(());
+                }
+            }
+            Some((client_state.active_addr, enter, start_timer))
+        } else {
+            None
+        }
+    };
+
+    let (addr, enter, start_timer) = match info {
+        Some(i) => i,
+        None => {
+            // should not happen
+            log::warn!("unknown client!");
+            capture.release().await?;
+            server.state.replace(State::Receiving);
+            log::trace!("STATE ===> Receiving");
+            return Ok(());
+        }
+    };
+
+    if start_timer {
         server.restart_ping_timer();
+    }
+    if enter {
         spawn_hook_command(server, handle);
     }
-
-    // release capture if emulation set state to Receiveing
-    if server.get_state() == State::Receiving {
-        capture.release().await?;
-        return Ok(());
-    }
-
-    // check release bind
-    if capture.keys_pressed(&server.release_bind) {
-        capture.release().await?;
-        server.set_state(State::Receiving);
-    }
-
-    if let Some(addr) = server.active_addr(handle) {
-        let event = match server.get_state() {
-            State::Sending => event,
-            /* send additional enter events until acknowleged */
-            State::AwaitingLeave => Event::Enter(),
-            /* released capture */
-            State::Receiving => Event::Disconnect(),
-        };
-        sender_tx.send((event, addr)).await.expect("sender closed");
+    if let Some(addr) = addr {
+        if enter {
+            let _ = sender_tx.send((Event::Enter(), addr)).await;
+        }
+        let _ = sender_tx.send((e, addr)).await;
     }
     Ok(())
 }

src/server/emulation_task.rs

@@ -11,12 +11,12 @@ use crate::{
     server::State,
 };
 use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
-use input_event::Event;
+use input_event::{Event, KeyboardEvent};
 
-use super::{network_task::NetworkError, CaptureRequest, Server};
+use super::{network_task::NetworkError, CaptureEvent, Server};
 
 #[derive(Clone, Debug)]
-pub(crate) enum EmulationRequest {
+pub(crate) enum EmulationEvent {
     /// create a new client
     Create(EmulationHandle),
     /// destroy a client
@@ -27,10 +27,10 @@ pub(crate) enum EmulationRequest {
 
 pub(crate) fn new(
     server: Server,
-    emulation_rx: Receiver<EmulationRequest>,
+    emulation_rx: Receiver<EmulationEvent>,
     udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: Sender<(Event, SocketAddr)>,
-    capture_tx: Sender<CaptureRequest>,
+    capture_tx: Sender<CaptureEvent>,
 ) -> JoinHandle<()> {
     let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx, capture_tx);
     tokio::task::spawn_local(emulation_task)
@@ -38,10 +38,10 @@ pub(crate) fn new(
 
 async fn emulation_task(
     server: Server,
-    mut rx: Receiver<EmulationRequest>,
+    mut rx: Receiver<EmulationEvent>,
     mut udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: Sender<(Event, SocketAddr)>,
-    capture_tx: Sender<CaptureRequest>,
+    capture_tx: Sender<CaptureEvent>,
 ) {
     loop {
         if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_tx, &capture_tx).await {
@@ -65,15 +65,17 @@ async fn emulation_task(
 
 async fn do_emulation(
     server: &Server,
-    rx: &mut Receiver<EmulationRequest>,
+    rx: &mut Receiver<EmulationEvent>,
     udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: &Sender<(Event, SocketAddr)>,
-    capture_tx: &Sender<CaptureRequest>,
+    capture_tx: &Sender<CaptureEvent>,
 ) -> Result<(), InputEmulationError> {
     let backend = server.config.emulation_backend.map(|b| b.into());
     log::info!("creating input emulation...");
     let mut emulation = tokio::select! {
-        r = InputEmulation::new(backend) => r?,
+        r = input_emulation::create(backend) => {
+            r?
+        }
         _ = server.cancelled() => return Ok(()),
     };
 
@@ -85,17 +87,23 @@ async fn do_emulation(
     }
 
     let res = do_emulation_session(server, &mut emulation, rx, udp_rx, sender_tx, capture_tx).await;
-    emulation.terminate().await; // manual drop
-    res
+
+    // release potentially still pressed keys
+    release_all_keys(server, &mut emulation).await?;
+
+    emulation.terminate().await;
+    res?;
+
+    Ok(())
 }
 
 async fn do_emulation_session(
     server: &Server,
-    emulation: &mut InputEmulation,
-    rx: &mut Receiver<EmulationRequest>,
+    emulation: &mut Box<dyn InputEmulation>,
+    rx: &mut Receiver<EmulationEvent>,
     udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: &Sender<(Event, SocketAddr)>,
-    capture_tx: &Sender<CaptureRequest>,
+    capture_tx: &Sender<CaptureEvent>,
 ) -> Result<(), InputEmulationError> {
     let mut last_ignored = None;
 
@@ -113,9 +121,9 @@ async fn do_emulation_session(
             }
             emulate_event = rx.recv() => {
                 match emulate_event.expect("channel closed") {
-                    EmulationRequest::Create(h) => { let _ = emulation.create(h).await; },
-                    EmulationRequest::Destroy(h) => emulation.destroy(h).await,
-                    EmulationRequest::ReleaseKeys(c) => emulation.release_keys(c).await?,
+                    EmulationEvent::Create(h) => emulation.create(h).await,
+                    EmulationEvent::Destroy(h) => emulation.destroy(h).await,
+                    EmulationEvent::ReleaseKeys(c) => release_keys(server, emulation, c).await?,
                 }
             }
             _ = server.notifies.cancel.cancelled() => break Ok(()),
@@ -125,8 +133,8 @@ async fn do_emulation_session(
 
 async fn handle_udp_rx(
     server: &Server,
-    capture_tx: &Sender<CaptureRequest>,
-    emulate: &mut InputEmulation,
+    capture_tx: &Sender<CaptureEvent>,
+    emulate: &mut Box<dyn InputEmulation>,
     sender_tx: &Sender<(Event, SocketAddr)>,
     last_ignored: &mut Option<SocketAddr>,
     event: (Event, SocketAddr),
@@ -147,7 +155,9 @@ async fn handle_udp_rx(
         (Event::Ping(), addr) => {
             let _ = sender_tx.send((Event::Pong(), addr)).await;
         }
-        (Event::Disconnect(), _) => emulate.release_keys(handle).await?,
+        (Event::Disconnect(), _) => {
+            release_keys(server, emulate, handle).await?;
+        }
         (event, addr) => {
             // tell clients that we are ready to receive events
             if let Event::Enter() = event {
@@ -162,17 +172,32 @@ async fn handle_udp_rx(
                     } else {
                         // upon receiving any event, we go back to receiving mode
                         server.state.replace(State::Receiving);
-                        let _ = capture_tx.send(CaptureRequest::Release).await;
+                        let _ = capture_tx.send(CaptureEvent::Release).await;
                         log::trace!("STATE ===> Receiving");
                     }
                 }
                 State::Receiving => {
-                    log::trace!("{event} => emulate");
-                    emulate.consume(event, handle).await?;
-                    let has_pressed_keys = emulate.has_pressed_keys(handle);
-                    server.update_pressed_keys(handle, has_pressed_keys);
-                    if has_pressed_keys {
-                        server.restart_ping_timer();
+                    let ignore_event =
+                        if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = event {
+                            let (ignore_event, restart_timer) = update_client_keys(
+                                &mut server.client_manager.borrow_mut(),
+                                handle,
+                                key,
+                                state,
+                            );
+                            // restart timer if necessary
+                            if restart_timer {
+                                server.restart_ping_timer();
+                            }
+                            ignore_event
+                        } else {
+                            false
+                        };
+                    // workaround buggy rdp backend.
+                    if !ignore_event {
+                        // consume event
+                        emulate.consume(event, handle).await?;
+                        log::trace!("{event} => emulate");
                     }
                 }
                 State::AwaitingLeave => {
@@ -189,7 +214,7 @@ async fn handle_udp_rx(
                     // event should still be possible
                     if let Event::Enter() = event {
                         server.state.replace(State::Receiving);
-                        let _ = capture_tx.send(CaptureRequest::Release).await;
+                        let _ = capture_tx.send(CaptureEvent::Release).await;
                         log::trace!("STATE ===> Receiving");
                     }
                 }
@@ -199,6 +224,57 @@ async fn handle_udp_rx(
     Ok(())
 }
 
+async fn release_all_keys(
+    server: &Server,
+    emulation: &mut Box<dyn InputEmulation>,
+) -> Result<(), EmulationError> {
+    let clients = server
+        .client_manager
+        .borrow()
+        .get_client_states()
+        .map(|(h, _)| h)
+        .collect::<Vec<_>>();
+    for client in clients {
+        release_keys(server, emulation, client).await?;
+    }
+    Ok(())
+}
+
+async fn release_keys(
+    server: &Server,
+    emulate: &mut Box<dyn InputEmulation>,
+    client: ClientHandle,
+) -> Result<(), EmulationError> {
+    let keys = server
+        .client_manager
+        .borrow_mut()
+        .get_mut(client)
+        .iter_mut()
+        .flat_map(|(_, s)| s.pressed_keys.drain())
+        .collect::<Vec<_>>();
+
+    for key in keys {
+        let event = Event::Keyboard(KeyboardEvent::Key {
+            time: 0,
+            key,
+            state: 0,
+        });
+        emulate.consume(event, client).await?;
+        if let Ok(key) = input_event::scancode::Linux::try_from(key) {
+            log::warn!("releasing stuck key: {key:?}");
+        }
+    }
+
+    let event = Event::Keyboard(KeyboardEvent::Modifiers {
+        mods_depressed: 0,
+        mods_latched: 0,
+        mods_locked: 0,
+        group: 0,
+    });
+    emulate.consume(event, client).await?;
+    Ok(())
+}
+
 fn activate_client_if_exists(
     client_manager: &mut ClientManager,
     addr: SocketAddr,
@@ -223,3 +299,25 @@ fn activate_client_if_exists(
     client_state.active_addr = Some(addr);
     Some(handle)
 }
+
+fn update_client_keys(
+    client_manager: &mut ClientManager,
+    handle: ClientHandle,
+    key: u32,
+    state: u8,
+) -> (bool, bool) {
+    let Some(client_state) = client_manager.get_mut(handle).map(|(_, s)| s) else {
+        return (true, false);
+    };
+
+    // ignore double press / release events
+    let ignore_event = if state == 0 {
+        // ignore release event if key not pressed
+        !client_state.pressed_keys.remove(&key)
+    } else {
+        // ignore press event if key not released
+        !client_state.pressed_keys.insert(key)
+    };
+    let restart_timer = !client_state.pressed_keys.is_empty();
+    (ignore_event, restart_timer)
+}

src/server/ping_task.rs

@@ -6,15 +6,15 @@ use input_event::Event;
 
 use crate::client::ClientHandle;
 
-use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State};
+use super::{capture_task::CaptureEvent, emulation_task::EmulationEvent, Server, State};
 
 const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);
 
 pub(crate) fn new(
     server: Server,
     sender_ch: Sender<(Event, SocketAddr)>,
-    emulate_notify: Sender<EmulationRequest>,
-    capture_notify: Sender<CaptureRequest>,
+    emulate_notify: Sender<EmulationEvent>,
+    capture_notify: Sender<CaptureEvent>,
 ) -> JoinHandle<()> {
     // timer task
     tokio::task::spawn_local(async move {
@@ -28,8 +28,8 @@ pub(crate) fn new(
 async fn ping_task(
     server: &Server,
     sender_ch: Sender<(Event, SocketAddr)>,
-    emulate_notify: Sender<EmulationRequest>,
-    capture_notify: Sender<CaptureRequest>,
+    emulate_notify: Sender<EmulationEvent>,
+    capture_notify: Sender<CaptureEvent>,
 ) {
     loop {
         // wait for wake up signal
@@ -42,8 +42,8 @@ async fn ping_task(
                 let ping_clients: Vec<ClientHandle> = if receiving {
                     // if receiving we care about clients with pressed keys
                     client_manager
-                        .get_client_states()
-                        .filter(|(_, (_, s))| s.has_pressed_keys)
+                        .get_client_states_mut()
+                        .filter(|(_, (_, s))| !s.pressed_keys.is_empty())
                         .map(|(h, _)| h)
                         .collect()
                 } else {
@@ -123,14 +123,14 @@ async fn ping_task(
             if receiving {
                 for h in unresponsive_clients {
                     log::warn!("device not responding, releasing keys!");
-                    let _ = emulate_notify.send(EmulationRequest::ReleaseKeys(h)).await;
+                    let _ = emulate_notify.send(EmulationEvent::ReleaseKeys(h)).await;
                 }
             } else {
                 // release pointer if the active client has not responded
                 if !unresponsive_clients.is_empty() {
                     log::warn!("client not responding, releasing pointer!");
                     server.state.replace(State::Receiving);
-                    let _ = capture_notify.send(CaptureRequest::Release).await;
+                    let _ = capture_notify.send(CaptureEvent::Release).await;
                 }
             }
         }