rename {Capture,Emulation}Event to %Request

move pressed key tracking to input capture

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: [feschber]
+ko_fi: feschber

.github/workflows/cachix.yml

@@ -3,8 +3,14 @@ name: Binary Cache
 on: [push, pull_request, workflow_dispatch]
 jobs:
   nix:
+    strategy:
+      matrix:
+       os: 
+        - ubuntu-latest
+        - macos-13
+        - macos-14
     name: "Build"
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }} 
     steps:
     - name: Checkout
       uses: actions/checkout@v4
@@ -20,5 +26,15 @@ jobs:
         name: lan-mouse
         authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
 
-    - name: Build lan-mouse
-      run: nix build --print-build-logs
+    - name: Build lan-mouse (x86_64-linux)
+      if: matrix.os == 'ubuntu-latest'
+      run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
+
+    - name: Build lan-mouse (x86_64-darwin)
+      if: matrix.os == 'macos-13'
+      run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
+
+    - name: Build lan-mouse (aarch64-darwin)
+      if: matrix.os == 'macos-14'
+      run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse
+

.github/workflows/pre-release.yml

@@ -78,7 +78,7 @@ jobs:
         path: lan-mouse-windows.zip
 
   macos-release-build:
-    runs-on: macos-latest
+    runs-on: macos-13
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
@@ -90,9 +90,25 @@ jobs:
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos
+        name: lan-mouse-macos-intel
         path: lan-mouse-macos-intel
 
+  macos-aarch64-release-build:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Release Build
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-macos-aarch64
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-aarch64
+        path: lan-mouse-macos-aarch64
+
   pre-release:
     name: "Pre Release"
     needs: [windows-release-build, linux-release-build, macos-release-build]
@@ -109,5 +125,6 @@ jobs:
         title: "Development Build"
         files: |
           lan-mouse-linux/lan-mouse
-          lan-mouse-macos/lan-mouse-macos-intel
+          lan-mouse-macos-intel/lan-mouse-macos-intel
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
           lan-mouse-windows/lan-mouse-windows.zip

.github/workflows/rust.yml

@@ -92,7 +92,7 @@ jobs:
           target/debug/*.dll
 
   build-macos:
-    runs-on: macos-latest
+    runs-on: macos-13
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
@@ -110,3 +110,23 @@ jobs:
       with:
         name: lan-mouse-macos
         path: target/debug/lan-mouse
+
+  build-macos-aarch64:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-aarch64
+        path: target/debug/lan-mouse

.github/workflows/tagged-release.yml

@@ -74,7 +74,7 @@ jobs:
         path: lan-mouse-windows.zip
 
   macos-release-build:
-    runs-on: macos-latest
+    runs-on: macos-13
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
@@ -86,9 +86,25 @@ jobs:
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos
+        name: lan-mouse-macos-intel
         path: lan-mouse-macos-intel
 
+  macos-aarch64-release-build:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Release Build
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-macos-aarch64
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-aarch64
+        path: lan-mouse-macos-aarch64
+
   tagged-release:
     name: "Tagged Release"
     needs: [windows-release-build, linux-release-build, macos-release-build]
@@ -103,5 +119,6 @@ jobs:
         prerelease: false
         files: |
           lan-mouse-linux/lan-mouse
-          lan-mouse-macos/lan-mouse-macos-intel
+          lan-mouse-macos-intel/lan-mouse-macos-intel
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
           lan-mouse-windows/lan-mouse-windows.zip

Cargo.toml

@@ -1,63 +1,65 @@
+[workspace]
+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.7.2"
+version = "0.9.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/ferdinandschober/lan-mouse"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+repository = "https://github.com/feschber/lan-mouse"
 
 [profile.release]
 strip = true
 lto = "fat"
 
 [dependencies]
-tempfile = "3.8"
-trust-dns-resolver = "0.23"
-memmap = "0.7"
+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 }
+
+hickory-resolver = "0.24.1"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 anyhow = "1.0.71"
 log = "0.4.20"
 env_logger = "0.11.3"
 serde_json = "1.0.107"
-tokio = {version = "1.32.0", features = ["io-util", "macros", "net", "rt", "sync", "signal"] }
-async-trait = "0.1.73"
-futures-core = "0.3.28"
+tokio = { version = "1.32.0", features = [
+    "io-util",
+    "io-std",
+    "macros",
+    "net",
+    "process",
+    "rt",
+    "sync",
+    "signal",
+] }
 futures = "0.3.28"
-clap = { version="4.4.11", features = ["derive"] }
-gtk = { package = "gtk4", version = "0.8.1", features = ["v4_2"], optional = true }
-adw = { package = "libadwaita", version = "0.6.0", features = ["v1_1"], optional = true }
+clap = { version = "4.4.11", features = ["derive"] }
+gtk = { package = "gtk4", version = "0.9.0", features = [
+    "v4_2",
+], optional = true }
+adw = { package = "libadwaita", version = "0.7.0", features = [
+    "v1_1",
+], optional = true }
 async-channel = { version = "2.1.1", optional = true }
-keycode = "0.4.0"
-once_cell = "1.19.0"
+hostname = "0.4.0"
+slab = "0.4.9"
+endi = "1.1.0"
+thiserror = "1.0.61"
+tokio-util = "0.7.11"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
 
-[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-wayland-client = { version="0.31.1", optional = true }
-wayland-protocols = { version="0.31.0", features=["client", "staging", "unstable"], optional = true }
-wayland-protocols-wlr = { version="0.2.0", features=["client"], optional = true }
-wayland-protocols-misc = { version="0.2.0", features=["client"], optional = true }
-x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
-reis = { version = "0.2", features = [ "tokio" ], optional = true }
-
-[target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.23", features = ["highsierra"] }
-
-[target.'cfg(windows)'.dependencies]
-winapi = { version = "0.3.9", features = ["winuser"] }
-
 [build-dependencies]
-glib-build-tools = "0.19.0"
+glib-build-tools = { version = "0.20.0", optional = true }
 
 [features]
 default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
-wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc" ]
-x11 = ["dep:x11"]
-xdg_desktop_portal = ["dep:ashpd"]
-libei = ["dep:reis", "dep:ashpd"]
-gtk = ["dep:gtk", "dep:adw", "dep:async-channel"]
+wayland = ["input-capture/wayland", "input-emulation/wayland"]
+x11 = ["input-capture/x11", "input-emulation/x11"]
+xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
+libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
+gtk = ["dep:gtk", "dep:adw", "dep:async-channel", "dep:glib-build-tools"]

README.md

@@ -39,13 +39,13 @@ For an alternative (with slightly different goals) you may check out [Input Leap
 The following table shows support for input emulation (to emulate events received from other clients) and
 input capture (to send events *to* other clients) on different operating systems:
 
-| Backend                   | input emulation          | input capture                        |
+| OS / Desktop Environment  | input emulation          | input capture                        |
 |---------------------------|--------------------------|--------------------------------------|
 | Wayland (wlroots)         | :heavy_check_mark:       | :heavy_check_mark:                   |
 | Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:                   |
-| Wayland (Gnome)           | :heavy_check_mark:       | :heavy_check_mark:                   |
+| Wayland (Gnome)           | :heavy_check_mark:       | :heavy_check_mark: (starting at GNOME 45) |
+| Windows                   | :heavy_check_mark:       | :heavy_check_mark:                   |
 | X11                       | :heavy_check_mark:       | WIP                                  |
-| Windows                   | :heavy_check_mark:       | WIP                                  |
 | MacOS                     | :heavy_check_mark:       | WIP                                  |
 
 > [!Important]
@@ -57,15 +57,31 @@ input capture (to send events *to* other clients) on different operating systems
 > If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
 > Otherwise input capture will not work.
 
+> [!Important]
+> The mouse cursor will be invisible when sending input to a Windows system if
+> there is no real mouse connected to the machine.
+
 ## Installation
+### Install via cargo
+```sh
+cargo install lan-mouse
+```
 
 ### Download from Releases
-The easiest way to install Lan Mouse is to download precompiled release binaries from the [releases section](https://github.com/feschber/lan-mouse/releases).
+Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
 
 For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
 
 ### Arch Linux
-Lan Mouse is available on the AUR:
+
+Lan Mouse can be installed from the [official repositories](https://archlinux.org/packages/extra/x86_64/lan-mouse/):
+
+```sh
+pacman -S lan-mouse
+```
+
+It is also available on the AUR:
+
 ```sh
 # git version (includes latest changes)
 paru -S lan-mouse-git
@@ -79,7 +95,9 @@ paru -S lan-mouse-bin
 - flake: [README.md](./nix/README.md)
 
 
-### Building from Source
+### Manual Installation
+
+First make sure to [install the necessary dependencies](#installing-dependencies).
 
 Build in release mode:
 ```sh
@@ -134,56 +152,61 @@ For a detailed list of available features, checkout the [Cargo.toml](./Cargo.tom
 
 
 ## Installing Dependencies
+<details>
+    <summary>MacOS</summary>
 
-#### Macos
 ```sh
 brew install libadwaita
 ```
+</details>
+
+<details>
+    <summary>Ubuntu and derivatives</summary>
 
-#### Ubuntu and derivatives
 ```sh
 sudo apt install libadwaita-1-dev libgtk-4-dev libx11-dev libxtst-dev
 ```
+</details>
+
+<details>
+    <summary>Arch and derivatives</summary>
 
-#### Arch and derivatives
 ```sh
 sudo pacman -S libadwaita gtk libx11 libxtst
 ```
+</details>
+
+<details>
+    <summary>Fedora and derivatives</summary>
 
-#### Fedora and derivatives
 ```sh
 sudo dnf install libadwaita-devel libXtst-devel libX11-devel
 ```
+</details>
+<details>
+    <summary>Windows</summary>
 
-#### Windows
 > [!NOTE]
 > This is only necessary when building lan-mouse from source. The windows release comes with precompiled gtk dlls.
 
-Follow the instructions at [gtk-rs.org](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation_windows.html)
+- First install [Rust](https://www.rust-lang.org/tools/install).
+
+- Then follow the instructions at [gtk-rs.org](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation_windows.html)
 
 *TLDR:*
 
 Build gtk from source
 
-- The following commands should be run in an admin power shell instance:
+- The following commands should be run in an **admin power shell** instance:
 ```sh
 # install chocolatey
 Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
 
-# install python 3.11 (Version is important, as 3.12 does not work currently) -> Has been fixed recently
-choco install python --version=3.11.0
-
-# install git
-choco install git
-
-# install msys2
-choco install msys2
-
-# install Visual Studio 2022
-choco install visualstudio2022-workload-vctools
+# install gvsbuild dependencies
+choco install python git msys2 visualstudio2022-workload-vctools
 ```
 
-- The following commands should be run in a regular power shell instance:
+- The following commands should be run in a **regular power shell** instance:
 
 ```sh
 # install gvsbuild with python
@@ -199,11 +222,12 @@ pipx install gvsbuild
 gvsbuild build gtk4 libadwaita librsvg
 ```
 
-Make sure to add the directory `C:\gtk-build\gtk\x64\release\bin`
-[to the `PATH` environment variable]((https://learn.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14))). Otherwise the project will fail to build.
+- **Make sure to add the directory** `C:\gtk-build\gtk\x64\release\bin`
+[**to the `PATH` environment variable**]((https://learn.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14))). Otherwise the project will fail to build.
 
 To avoid building GTK from source, it is possible to disable
 the gtk frontend (see conditional compilation below).
+</details>
 
 ## Usage
 ### Gtk Frontend

build.rs

@@ -1,5 +1,6 @@
 fn main() {
     // composite_templates
+    #[cfg(feature = "gtk")]
     glib_build_tools::compile_resources(
         &["resources"],
         "resources/resources.gresource.xml",

config.toml

@@ -1,5 +1,7 @@
 # example configuration
 
+# capture_backend = "LayerShell"
+
 # release bind
 release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
 

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1710806803,
-        "narHash": "sha256-qrxvLS888pNJFwJdK+hf1wpRCSQcqA6W5+Ox202NDa0=",
+        "lastModified": 1716293225,
+        "narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "b06025f1533a1e07b6db3e75151caa155d1c7eb3",
+        "rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
         "type": "github"
       },
       "original": {
@@ -48,11 +48,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1710987136,
-        "narHash": "sha256-Q8GRdlAIKZ8tJUXrbcRO1pA33AdoPfTUirsSnmGQnOU=",
+        "lastModified": 1716257780,
+        "narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "97596b54ac34ad8184ca1eef44b1ec2e5c2b5f9e",
+        "rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
         "type": "github"
       },
       "original": {

flake.nix

@@ -15,6 +15,9 @@
   }: let
     inherit (nixpkgs) lib;
     genSystems = lib.genAttrs [
+      "aarch64-darwin"
+      "aarch64-linux"
+      "x86_64-darwin"
       "x86_64-linux"
     ];
     pkgsFor = system:
@@ -48,7 +51,10 @@
           xorg.libX11
           gtk4
           libadwaita
+          librsvg
           xorg.libXtst
+        ] ++ lib.optionals stdenv.isDarwin [
+          darwin.apple_sdk_11_0.frameworks.CoreGraphics
         ];
 
         RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";

input-capture/Cargo.toml

@@ -0,0 +1,70 @@
+[package]
+name = "input-capture"
+description = "cross-platform input-capture library used by lan-mouse"
+version = "0.2.0"
+edition = "2021"
+license = "GPL-3.0-or-later"
+repository = "https://github.com/feschber/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" }
+memmap = "0.7"
+tempfile = "3.8"
+thiserror = "1.0.61"
+tokio = { version = "1.32.0", features = [
+    "io-util",
+    "io-std",
+    "macros",
+    "net",
+    "process",
+    "rt",
+    "sync",
+    "signal",
+] }
+once_cell = "1.19.0"
+async-trait = "0.1.81"
+tokio-util = "0.7.11"
+
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+wayland-client = { version = "0.31.1", optional = true }
+wayland-protocols = { version = "0.32.1", features = [
+    "client",
+    "staging",
+    "unstable",
+], optional = true }
+wayland-protocols-wlr = { version = "0.3.1", features = [
+    "client",
+], optional = true }
+x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
+ashpd = { version = "0.9", default-features = false, features = [
+    "tokio",
+], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }
+
+[target.'cfg(target_os="macos")'.dependencies]
+core-graphics = { version = "0.23", features = ["highsierra"] }
+
+[target.'cfg(windows)'.dependencies]
+windows = { version = "0.58.0", features = [
+    "Win32_System_LibraryLoader",
+    "Win32_System_Threading",
+    "Win32_Foundation",
+    "Win32_Graphics",
+    "Win32_Graphics_Gdi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_WindowsAndMessaging",
+] }
+
+[features]
+default = ["wayland", "x11", "libei"]
+wayland = [
+    "dep:wayland-client",
+    "dep:wayland-protocols",
+    "dep:wayland-protocols-wlr",
+]
+x11 = ["dep:x11"]
+libei = ["dep:reis", "dep:ashpd"]

input-capture/src/dummy.rs

@@ -0,0 +1,52 @@
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use async_trait::async_trait;
+use futures_core::Stream;
+
+use input_event::Event;
+
+use crate::CaptureError;
+
+use super::{Capture, CaptureHandle, Position};
+
+pub struct DummyInputCapture {}
+
+impl DummyInputCapture {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for DummyInputCapture {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Capture for DummyInputCapture {
+    async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn destroy(&mut self, _handle: CaptureHandle) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+}
+
+impl Stream for DummyInputCapture {
+    type Item = Result<(CaptureHandle, Event), CaptureError>;
+
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}

input-capture/src/error.rs

@@ -0,0 +1,150 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum InputCaptureError {
+    #[error("error creating input-capture: `{0}`")]
+    Create(#[from] CaptureCreationError),
+    #[error("error while capturing input: `{0}`")]
+    Capture(#[from] CaptureError),
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use std::io;
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use wayland_client::{
+    backend::WaylandError,
+    globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
+};
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use ashpd::desktop::ResponseError;
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::{EiConvertEventStreamError, HandshakeError};
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("error in libei stream: {inner:?}")]
+pub struct ReisConvertEventStreamError {
+    inner: EiConvertEventStreamError,
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl From<EiConvertEventStreamError> for ReisConvertEventStreamError {
+    fn from(e: EiConvertEventStreamError) -> Self {
+        Self { inner: e }
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum CaptureError {
+    #[error("activation stream closed unexpectedly")]
+    ActivationClosed,
+    #[error("libei stream was closed")]
+    EndOfStream,
+    #[error("io error: `{0}`")]
+    Io(#[from] std::io::Error),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("error in libei stream: `{0}`")]
+    Reis(#[from] ReisConvertEventStreamError),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei handshake failed: `{0}`")]
+    Handshake(#[from] HandshakeError),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error(transparent)]
+    Portal(#[from] ashpd::Error),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei disconnected - reason: `{0}`")]
+    Disconnected(String),
+}
+
+#[derive(Debug, Error)]
+pub enum CaptureCreationError {
+    #[error("no backend available")]
+    NoAvailableBackend,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("error creating input-capture-portal backend: `{0}`")]
+    Libei(#[from] LibeiCaptureCreationError),
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[error("error creating layer-shell capture backend: `{0}`")]
+    LayerShell(#[from] LayerShellCaptureCreationError),
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    #[error("error creating x11 capture backend: `{0}`")]
+    X11(#[from] X11InputCaptureCreationError),
+    #[cfg(target_os = "macos")]
+    #[error("error creating macos capture backend: `{0}`")]
+    Macos(#[from] MacOSInputCaptureCreationError),
+    #[cfg(windows)]
+    #[error("error creating windows capture backend")]
+    Windows,
+}
+
+impl CaptureCreationError {
+    /// request was intentionally denied by the user
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    pub(crate) fn cancelled_by_user(&self) -> bool {
+        matches!(
+            self,
+            CaptureCreationError::Libei(LibeiCaptureCreationError::Ashpd(ashpd::Error::Response(
+                ResponseError::Cancelled
+            )))
+        )
+    }
+    #[cfg(not(all(unix, feature = "libei", not(target_os = "macos"))))]
+    pub(crate) fn cancelled_by_user(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LibeiCaptureCreationError {
+    #[error("xdg-desktop-portal: `{0}`")]
+    Ashpd(#[from] ashpd::Error),
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("{protocol} protocol not supported: {inner}")]
+pub struct WaylandBindError {
+    inner: BindError,
+    protocol: &'static str,
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl WaylandBindError {
+    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
+        Self { inner, protocol }
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LayerShellCaptureCreationError {
+    #[error(transparent)]
+    Connect(#[from] ConnectError),
+    #[error(transparent)]
+    Global(#[from] GlobalError),
+    #[error(transparent)]
+    Wayland(#[from] WaylandError),
+    #[error(transparent)]
+    Bind(#[from] WaylandBindError),
+    #[error(transparent)]
+    Dispatch(#[from] DispatchError),
+    #[error(transparent)]
+    Io(#[from] io::Error),
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum X11InputCaptureCreationError {
+    #[error("X11 input capture is not yet implemented :(")]
+    NotImplemented,
+}
+
+#[cfg(target_os = "macos")]
+#[derive(Debug, Error)]
+pub enum MacOSInputCaptureCreationError {
+    #[error("MacOS input capture is not yet implemented :(")]
+    NotImplemented,
+}

input-capture/src/lib.rs

@@ -0,0 +1,240 @@
+use std::{collections::HashSet, fmt::Display, task::Poll};
+
+use async_trait::async_trait;
+use futures::StreamExt;
+use futures_core::Stream;
+
+use input_event::{scancode, Event, KeyboardEvent};
+
+pub use error::{CaptureCreationError, CaptureError, InputCaptureError};
+
+pub mod error;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+mod libei;
+
+#[cfg(target_os = "macos")]
+mod macos;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+mod wayland;
+
+#[cfg(windows)]
+mod windows;
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+mod x11;
+
+/// fallback input capture (does not produce events)
+mod dummy;
+
+pub type CaptureHandle = u64;
+
+#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
+pub enum Position {
+    Left,
+    Right,
+    Top,
+    Bottom,
+}
+
+impl Position {
+    pub fn opposite(&self) -> Self {
+        match self {
+            Position::Left => Self::Right,
+            Position::Right => Self::Left,
+            Position::Top => Self::Bottom,
+            Position::Bottom => Self::Top,
+        }
+    }
+}
+
+impl Display for Position {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let pos = match self {
+            Position::Left => "left",
+            Position::Right => "right",
+            Position::Top => "top",
+            Position::Bottom => "bottom",
+        };
+        write!(f, "{}", pos)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Backend {
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    InputCapturePortal,
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    LayerShell,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl Display for Backend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            Backend::InputCapturePortal => write!(f, "input-capture-portal"),
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            Backend::LayerShell => write!(f, "layer-shell"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            Backend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            Backend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            Backend::MacOs => write!(f, "MacOS"),
+            Backend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+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 {
+    /// create a new client with the given id
+    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;
+
+    /// destroy the client with the given id, if it exists
+    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError>;
+
+    /// release mouse
+    async fn release(&mut self) -> Result<(), CaptureError>;
+
+    /// destroy the input capture
+    async fn terminate(&mut self) -> Result<(), CaptureError>;
+}
+
+async fn create_backend(
+    backend: Backend,
+) -> Result<
+    Box<dyn Capture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
+    CaptureCreationError,
+> {
+    match backend {
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
+        #[cfg(windows)]
+        Backend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
+        #[cfg(target_os = "macos")]
+        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
+        Backend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
+    }
+}
+
+async fn create(
+    backend: Option<Backend>,
+) -> Result<
+    Box<dyn Capture<Item = Result<(CaptureHandle, Event), CaptureError>>>,
+    CaptureCreationError,
+> {
+    if let Some(backend) = backend {
+        let b = create_backend(backend).await;
+        if b.is_ok() {
+            log::info!("using capture backend: {backend}");
+        }
+        return b;
+    }
+
+    for backend in [
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::InputCapturePortal,
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::LayerShell,
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11,
+        #[cfg(windows)]
+        Backend::Windows,
+        #[cfg(target_os = "macos")]
+        Backend::MacOs,
+    ] {
+        match create_backend(backend).await {
+            Ok(b) => {
+                log::info!("using capture backend: {backend}");
+                return Ok(b);
+            }
+            Err(e) if e.cancelled_by_user() => return Err(e),
+            Err(e) => log::warn!("{backend} input capture backend unavailable: {e}"),
+        }
+    }
+    Err(CaptureCreationError::NoAvailableBackend)
+}

input-capture/src/libei.rs

@@ -0,0 +1,641 @@
+use ashpd::{
+    desktop::{
+        input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
+        Session,
+    },
+    enumflags2::BitFlags,
+};
+use async_trait::async_trait;
+use futures::{FutureExt, StreamExt};
+use reis::{
+    ei,
+    event::{DeviceCapability, EiEvent},
+    tokio::{EiConvertEventStream, EiEventStream},
+};
+use std::{
+    cell::Cell,
+    collections::HashMap,
+    io,
+    os::unix::net::UnixStream,
+    pin::Pin,
+    rc::Rc,
+    sync::Arc,
+    task::{Context, Poll},
+};
+use tokio::{
+    sync::{
+        mpsc::{self, Receiver, Sender},
+        Notify,
+    },
+    task::JoinHandle,
+};
+use tokio_util::sync::CancellationToken;
+
+use futures_core::Stream;
+use once_cell::sync::Lazy;
+
+use input_event::Event;
+
+use super::{
+    error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
+    Capture as LanMouseInputCapture, CaptureHandle, Position,
+};
+
+/* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
+ * prevents receiving further events after a session has been disabled once.
+ * Therefore the session needs to be recreated when the barriers are updated */
+
+/// events that necessitate restarting the capture session
+#[derive(Clone, Copy, Debug)]
+enum LibeiNotifyEvent {
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+}
+
+#[allow(dead_code)]
+pub struct LibeiInputCapture<'a> {
+    input_capture: Pin<Box<InputCapture<'a>>>,
+    capture_task: JoinHandle<Result<(), CaptureError>>,
+    event_rx: Receiver<(CaptureHandle, Event)>,
+    notify_capture: Sender<LibeiNotifyEvent>,
+    notify_release: Arc<Notify>,
+    cancellation_token: CancellationToken,
+    terminated: bool,
+}
+
+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
+/// returns (start pos, end pos), inclusive
+fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
+    let (x, y) = (r.x_offset(), r.y_offset());
+    let (w, h) = (r.width() as i32, r.height() as i32);
+    match pos {
+        Position::Left => (x, y, x, y + h - 1),
+        Position::Right => (x + w, y, x + w, y + h - 1),
+        Position::Top => (x, y, x + w - 1, y),
+        Position::Bottom => (x, y + h, x + w - 1, y + h),
+    }
+}
+
+/// Ashpd does not expose fields
+#[derive(Clone, Copy, Debug)]
+struct ICBarrier {
+    barrier_id: BarrierID,
+    position: (i32, i32, i32, i32),
+}
+
+impl ICBarrier {
+    fn new(barrier_id: BarrierID, position: (i32, i32, i32, i32)) -> Self {
+        Self {
+            barrier_id,
+            position,
+        }
+    }
+}
+
+impl From<ICBarrier> for Barrier {
+    fn from(barrier: ICBarrier) -> Self {
+        Barrier::new(barrier.barrier_id, barrier.position)
+    }
+}
+
+fn select_barriers(
+    zones: &Zones,
+    clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+) -> (Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>) {
+    let mut client_for_barrier = HashMap::new();
+    let mut barriers: Vec<ICBarrier> = vec![];
+
+    for (handle, pos) in clients {
+        let mut client_barriers = zones
+            .regions()
+            .iter()
+            .map(|r| {
+                let id = *next_barrier_id;
+                *next_barrier_id = id + 1;
+                let position = pos_to_barrier(r, *pos);
+                client_for_barrier.insert(id, *handle);
+                ICBarrier::new(id, position)
+            })
+            .collect();
+        barriers.append(&mut client_barriers);
+    }
+    (barriers, client_for_barrier)
+}
+
+async fn update_barriers(
+    input_capture: &InputCapture<'_>,
+    session: &Session<'_, InputCapture<'_>>,
+    active_clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>), ashpd::Error> {
+    let zones = input_capture.zones(session).await?.response()?;
+    log::debug!("zones: {zones:?}");
+
+    let (barriers, id_map) = select_barriers(&zones, active_clients, next_barrier_id);
+    log::debug!("barriers: {barriers:?}");
+    log::debug!("client for barrier id: {id_map:?}");
+
+    let ashpd_barriers: Vec<Barrier> = barriers.iter().copied().map(|b| b.into()).collect();
+    let response = input_capture
+        .set_pointer_barriers(session, &ashpd_barriers, zones.zone_set())
+        .await?;
+    let response = response.response()?;
+    log::debug!("{response:?}");
+    Ok((barriers, id_map))
+}
+
+async fn create_session<'a>(
+    input_capture: &'a InputCapture<'a>,
+) -> std::result::Result<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>), ashpd::Error> {
+    log::debug!("creating input capture session");
+    input_capture
+        .create_session(
+            &ashpd::WindowIdentifier::default(),
+            Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
+        )
+        .await
+}
+
+async fn connect_to_eis(
+    input_capture: &InputCapture<'_>,
+    session: &Session<'_, InputCapture<'_>>,
+) -> Result<(ei::Context, EiConvertEventStream), CaptureError> {
+    log::debug!("connect_to_eis");
+    let fd = input_capture.connect_to_eis(session).await?;
+
+    // create unix stream from fd
+    let stream = UnixStream::from(fd);
+    stream.set_nonblocking(true)?;
+
+    // create ei context
+    let context = ei::Context::new(stream)?;
+    let mut event_stream = EiEventStream::new(context.clone())?;
+    let response = reis::tokio::ei_handshake(
+        &mut event_stream,
+        "de.feschber.LanMouse",
+        ei::handshake::ContextType::Receiver,
+        &INTERFACES,
+    )
+    .await?;
+    let event_stream = EiConvertEventStream::new(event_stream, response.serial);
+
+    Ok((context, event_stream))
+}
+
+async fn libei_event_handler(
+    mut ei_event_stream: EiConvertEventStream,
+    context: ei::Context,
+    event_tx: Sender<(CaptureHandle, Event)>,
+    release_session: Arc<Notify>,
+    current_client: Rc<Cell<Option<CaptureHandle>>>,
+) -> Result<(), CaptureError> {
+    loop {
+        let ei_event = ei_event_stream
+            .next()
+            .await
+            .ok_or(CaptureError::EndOfStream)?
+            .map_err(ReisConvertEventStreamError::from)?;
+        log::trace!("from ei: {ei_event:?}");
+        let client = current_client.get();
+        handle_ei_event(ei_event, client, &context, &event_tx, &release_session).await?;
+    }
+}
+
+impl<'a> LibeiInputCapture<'a> {
+    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
+        let input_capture = Box::pin(InputCapture::new().await?);
+        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
+        let first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
+
+        let (event_tx, event_rx) = mpsc::channel(1);
+        let (notify_capture, notify_rx) = mpsc::channel(1);
+        let notify_release = Arc::new(Notify::new());
+
+        let cancellation_token = CancellationToken::new();
+
+        let capture = do_capture(
+            input_capture_ptr,
+            notify_rx,
+            notify_release.clone(),
+            first_session,
+            event_tx,
+            cancellation_token.clone(),
+        );
+        let capture_task = tokio::task::spawn_local(capture);
+
+        let producer = Self {
+            input_capture,
+            event_rx,
+            capture_task,
+            notify_capture,
+            notify_release,
+            cancellation_token,
+            terminated: false,
+        };
+
+        Ok(producer)
+    }
+}
+
+async fn do_capture(
+    input_capture: *const InputCapture<'static>,
+    mut capture_event: Receiver<LibeiNotifyEvent>,
+    notify_release: Arc<Notify>,
+    session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
+    event_tx: Sender<(CaptureHandle, Event)>,
+    cancellation_token: CancellationToken,
+) -> Result<(), CaptureError> {
+    let mut session = session.map(|s| s.0);
+
+    /* safety: libei_task does not outlive Self */
+    let input_capture = unsafe { &*input_capture };
+    let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
+    let mut next_barrier_id = 1u32;
+
+    let mut zones_changed = input_capture.receive_zones_changed().await?;
+
+    loop {
+        // do capture session
+        let cancel_session = CancellationToken::new();
+        let cancel_update = CancellationToken::new();
+
+        let mut capture_event_occured: Option<LibeiNotifyEvent> = None;
+        let mut zones_have_changed = false;
+
+        // kill session if clients need to be updated
+        let handle_session_update_request = async {
+            tokio::select! {
+                _ = cancellation_token.cancelled() => {
+                    log::debug!("cancelled")
+                }, /* exit requested */
+                _ = cancel_update.cancelled() => {
+                    log::debug!("update task cancelled");
+                }, /* session exited */
+                _ = zones_changed.next() => {
+                    log::debug!("zones changed!");
+                    zones_have_changed = true
+                }, /* zones have changed */
+                e = capture_event.recv() => if let Some(e) = e { /* clients changed */
+                    log::debug!("capture event: {e:?}");
+                    capture_event_occured.replace(e);
+                },
+            }
+            // kill session (might already be dead!)
+            log::debug!("=> cancelling session");
+            cancel_session.cancel();
+        };
+
+        if !active_clients.is_empty() {
+            // create session
+            let mut session = match session.take() {
+                Some(s) => s,
+                None => create_session(input_capture).await?.0,
+            };
+
+            let capture_session = do_capture_session(
+                input_capture,
+                &mut session,
+                &event_tx,
+                &active_clients,
+                &mut next_barrier_id,
+                &notify_release,
+                (cancel_session.clone(), cancel_update.clone()),
+            );
+
+            let (capture_result, ()) = tokio::join!(capture_session, handle_session_update_request);
+            log::debug!("capture session + session_update task done!");
+
+            // disable capture
+            log::debug!("disabling input capture");
+            if let Err(e) = input_capture.disable(&session).await {
+                log::warn!("input_capture.disable(&session) {e}");
+            }
+            if let Err(e) = session.close().await {
+                log::warn!("session.close(): {e}");
+            }
+
+            // propagate error from capture session
+            capture_result?;
+        } else {
+            handle_session_update_request.await;
+        }
+
+        // update clients if requested
+        if let Some(event) = capture_event_occured.take() {
+            match event {
+                LibeiNotifyEvent::Create(c, p) => active_clients.push((c, p)),
+                LibeiNotifyEvent::Destroy(c) => active_clients.retain(|(h, _)| *h != c),
+            }
+        }
+
+        // break
+        if cancellation_token.is_cancelled() {
+            break Ok(());
+        }
+    }
+}
+
+async fn do_capture_session(
+    input_capture: &InputCapture<'_>,
+    session: &mut Session<'_, InputCapture<'_>>,
+    event_tx: &Sender<(CaptureHandle, Event)>,
+    active_clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+    notify_release: &Notify,
+    cancel: (CancellationToken, CancellationToken),
+) -> Result<(), CaptureError> {
+    let (cancel_session, cancel_update) = cancel;
+    // current client
+    let current_client = Rc::new(Cell::new(None));
+
+    // connect to eis server
+    let (context, ei_event_stream) = connect_to_eis(input_capture, session).await?;
+
+    // set barriers
+    let (barriers, client_for_barrier_id) =
+        update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
+
+    log::debug!("enabling session");
+    input_capture.enable(session).await?;
+
+    // cancellation token to release session
+    let release_session = Arc::new(Notify::new());
+
+    // async event task
+    let cancel_ei_handler = CancellationToken::new();
+    let event_chan = event_tx.clone();
+    let client = current_client.clone();
+    let cancel_session_clone = cancel_session.clone();
+    let release_session_clone = release_session.clone();
+    let cancel_ei_handler_clone = cancel_ei_handler.clone();
+    let ei_task = async move {
+        tokio::select! {
+            r = libei_event_handler(
+                ei_event_stream,
+                context,
+                event_chan,
+                release_session_clone,
+                client,
+            ) => {
+                log::debug!("libei exited: {r:?} cancelling session task");
+                cancel_session_clone.cancel();
+            }
+            _ = cancel_ei_handler_clone.cancelled() => {},
+        }
+        Ok::<(), CaptureError>(())
+    };
+
+    let capture_session_task = async {
+        // receiver for activation tokens
+        let mut activated = input_capture.receive_activated().await?;
+        let mut ei_devices_changed = false;
+        loop {
+            tokio::select! {
+                activated = activated.next() => {
+                    let activated = activated.ok_or(CaptureError::ActivationClosed)?;
+                    log::debug!("activated: {activated:?}");
+
+                    // get barrier id from activation
+                    let barrier_id = match activated.barrier_id() {
+                        Some(bid) => bid,
+                        // workaround for KDE plasma not reporting barrier ids
+                        None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
+                    };
+
+                    // find client corresponding to barrier
+                    let client = *client_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
+                    current_client.replace(Some(client));
+
+                    // client entered => send event
+                    event_tx.send((client, Event::Enter())).await.expect("no channel");
+
+                    tokio::select! {
+                        _ = notify_release.notified() => { /* capture release */
+                            log::debug!("release session requested");
+                        },
+                        _ = release_session.notified() => { /* release session */
+                            log::debug!("ei devices changed");
+                            ei_devices_changed = true;
+                        },
+                        _ = cancel_session.cancelled() => { /* kill session notify */
+                            log::debug!("session cancel requested");
+                            break
+                        },
+                    }
+
+                    release_capture(input_capture, session, activated, client, active_clients).await?;
+
+                }
+                _ = notify_release.notified() => { /* capture release -> we are not capturing anyway, so ignore */
+                    log::debug!("release session requested");
+                },
+                _ = release_session.notified() => { /* release session */
+                    log::debug!("ei devices changed");
+                    ei_devices_changed = true;
+                },
+                _ = cancel_session.cancelled() => { /* kill session notify */
+                    log::debug!("session cancel requested");
+                    break
+                },
+            }
+            if ei_devices_changed {
+                /* for whatever reason, GNOME seems to kill the session
+                 * as soon as devices are added or removed, so we need
+                 * to cancel */
+                break;
+            }
+        }
+        // cancel libei task
+        log::debug!("session exited: killing libei task");
+        cancel_ei_handler.cancel();
+        Ok::<(), CaptureError>(())
+    };
+
+    let (a, b) = tokio::join!(ei_task, capture_session_task);
+
+    cancel_update.cancel();
+
+    log::debug!("both session and ei task finished!");
+    a?;
+    b?;
+
+    Ok(())
+}
+
+async fn release_capture<'a>(
+    input_capture: &InputCapture<'a>,
+    session: &Session<'a, InputCapture<'a>>,
+    activated: Activated,
+    current_client: CaptureHandle,
+    active_clients: &[(CaptureHandle, Position)],
+) -> Result<(), CaptureError> {
+    if let Some(activation_id) = activated.activation_id() {
+        log::debug!("releasing input capture {activation_id}");
+    }
+    let (x, y) = activated
+        .cursor_position()
+        .expect("compositor did not report cursor position!");
+    log::debug!("client entered @ ({x}, {y})");
+    let pos = active_clients
+        .iter()
+        .filter(|(c, _)| *c == current_client)
+        .map(|(_, p)| p)
+        .next()
+        .unwrap(); // FIXME
+    let (dx, dy) = match pos {
+        // offset cursor position to not enter again immediately
+        Position::Left => (1., 0.),
+        Position::Right => (-1., 0.),
+        Position::Top => (0., 1.),
+        Position::Bottom => (0., -1.),
+    };
+    // release 1px to the right of the entered zone
+    let cursor_position = (x as f64 + dx, y as f64 + dy);
+    input_capture
+        .release(session, activated.activation_id(), Some(cursor_position))
+        .await?;
+    Ok(())
+}
+
+fn find_corresponding_client(barriers: &[ICBarrier], pos: (f32, f32)) -> BarrierID {
+    barriers
+        .iter()
+        .copied()
+        .min_by_key(|b| {
+            let (x1, y1, x2, y2) = b.position;
+            let (x1, y1, x2, y2) = (x1 as f32, y1 as f32, x2 as f32, y2 as f32);
+            distance_to_line(((x1, y1), (x2, y2)), pos) as i32
+        })
+        .expect("could not find barrier corresponding to client")
+        .barrier_id
+}
+
+fn distance_to_line(line: ((f32, f32), (f32, f32)), p: (f32, f32)) -> f32 {
+    let ((x1, y1), (x2, y2)) = line;
+    let (x0, y0) = p;
+    /*
+     * we use the fact that for the triangle spanned by the line and p,
+     * the height of the triangle is the desired distance and can be calculated by
+     * h = 2A / b with b being the line_length and
+     */
+    let double_triangle_area = ((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1).abs();
+    let line_length = ((y2 - y1).powf(2.0) + (x2 - x1).powf(2.0)).sqrt();
+    let distance = double_triangle_area / line_length;
+    log::debug!("distance to line({line:?}, {p:?}) = {distance}");
+    distance
+}
+
+static ALL_CAPABILITIES: &[DeviceCapability] = &[
+    DeviceCapability::Pointer,
+    DeviceCapability::PointerAbsolute,
+    DeviceCapability::Keyboard,
+    DeviceCapability::Touch,
+    DeviceCapability::Scroll,
+    DeviceCapability::Button,
+];
+
+async fn handle_ei_event(
+    ei_event: EiEvent,
+    current_client: Option<CaptureHandle>,
+    context: &ei::Context,
+    event_tx: &Sender<(CaptureHandle, Event)>,
+    release_session: &Notify,
+) -> Result<(), CaptureError> {
+    match ei_event {
+        EiEvent::SeatAdded(s) => {
+            s.seat.bind_capabilities(ALL_CAPABILITIES);
+            context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
+        }
+        EiEvent::SeatRemoved(_) | /* EiEvent::DeviceAdded(_) | */ EiEvent::DeviceRemoved(_) => {
+            log::debug!("releasing session: {ei_event:?}");
+            release_session.notify_waiters();
+        }
+        EiEvent::DevicePaused(_) | EiEvent::DeviceResumed(_) => {}
+        EiEvent::DeviceStartEmulating(_) => log::debug!("START EMULATING"),
+        EiEvent::DeviceStopEmulating(_) => log::debug!("STOP EMULATING"),
+        EiEvent::Disconnected(d) => {
+            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
+        }
+        _ => {
+            if let Some(handle) = current_client {
+                for event in Event::from_ei_event(ei_event) {
+                    event_tx.send((handle, event)).await.expect("no channel");
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[async_trait]
+impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        let _ = self
+            .notify_capture
+            .send(LibeiNotifyEvent::Create(handle, pos))
+            .await;
+        Ok(())
+    }
+
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        let _ = self
+            .notify_capture
+            .send(LibeiNotifyEvent::Destroy(handle))
+            .await;
+        Ok(())
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        self.notify_release.notify_waiters();
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        self.cancellation_token.cancel();
+        let task = &mut self.capture_task;
+        log::debug!("waiting for capture to terminate...");
+        let res = task.await.expect("libei task panic");
+        log::debug!("done!");
+        self.terminated = true;
+        res
+    }
+}
+
+impl<'a> Drop for LibeiInputCapture<'a> {
+    fn drop(&mut self) {
+        if !self.terminated {
+            /* this workaround is needed until async drop is stabilized */
+            panic!("LibeiInputCapture dropped without being terminated!");
+        }
+    }
+}
+
+impl<'a> Stream for LibeiInputCapture<'a> {
+    type Item = Result<(CaptureHandle, Event), CaptureError>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        match self.capture_task.poll_unpin(cx) {
+            Poll::Ready(r) => match r.expect("failed to join") {
+                Ok(()) => Poll::Ready(None),
+                Err(e) => Poll::Ready(Some(Err(e))),
+            },
+            Poll::Pending => self.event_rx.poll_recv(cx).map(|e| e.map(Result::Ok)),
+        }
+    }
+}

input-capture/src/macos.rs

@@ -0,0 +1,43 @@
+use crate::{
+    error::MacOSInputCaptureCreationError, Capture, CaptureError, CaptureHandle, Position,
+};
+use async_trait::async_trait;
+use futures_core::Stream;
+use input_event::Event;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+pub struct MacOSInputCapture;
+
+impl MacOSInputCapture {
+    pub fn new() -> std::result::Result<Self, MacOSInputCaptureCreationError> {
+        Err(MacOSInputCaptureCreationError::NotImplemented)
+    }
+}
+
+impl Stream for MacOSInputCapture {
+    type Item = Result<(CaptureHandle, Event), CaptureError>;
+
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}
+
+#[async_trait]
+impl Capture for MacOSInputCapture {
+    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+}

input-capture/src/wayland.rs

@@ -1,16 +1,10 @@
-use crate::{
-    client::{ClientEvent, ClientHandle, Position},
-    producer::EventProducer,
-};
-
-use anyhow::{anyhow, Result};
+use async_trait::async_trait;
 use futures_core::Stream;
-use memmap::MmapOptions;
 use std::{
     collections::VecDeque,
     env,
     io::{self, ErrorKind},
-    os::fd::{AsFd, OwnedFd, RawFd},
+    os::fd::{AsFd, RawFd},
     pin::Pin,
     task::{ready, Context, Poll},
 };
@@ -19,8 +13,8 @@ use tokio::io::unix::AsyncFd;
 use std::{
     fs::File,
     io::{BufWriter, Write},
-    os::unix::prelude::{AsRawFd, FromRawFd},
-    rc::Rc,
+    os::unix::prelude::AsRawFd,
+    sync::Arc,
 };
 
 use wayland_protocols::{
@@ -64,9 +58,14 @@ use wayland_client::{
     Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
 };
 
-use tempfile;
+use input_event::{Event, KeyboardEvent, PointerEvent};
 
-use crate::event::{Event, KeyboardEvent, PointerEvent};
+use crate::CaptureError;
+
+use super::{
+    error::{LayerShellCaptureCreationError, WaylandBindError},
+    Capture, CaptureHandle, Position,
+};
 
 struct Globals {
     compositor: wl_compositor::WlCompositor,
@@ -103,14 +102,15 @@ struct State {
     pointer_lock: Option<ZwpLockedPointerV1>,
     rel_pointer: Option<ZwpRelativePointerV1>,
     shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    client_for_window: Vec<(Rc<Window>, ClientHandle)>,
-    focused: Option<(Rc<Window>, ClientHandle)>,
+    client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
+    focused: Option<(Arc<Window>, CaptureHandle)>,
     g: Globals,
-    wayland_fd: OwnedFd,
+    wayland_fd: RawFd,
     read_guard: Option<ReadEventsGuard>,
     qh: QueueHandle<Self>,
-    pending_events: VecDeque<(ClientHandle, Event)>,
+    pending_events: VecDeque<(CaptureHandle, Event)>,
     output_info: Vec<(WlOutput, OutputInfo)>,
+    scroll_discrete_pending: bool,
 }
 
 struct Inner {
@@ -120,11 +120,11 @@ struct Inner {
 
 impl AsRawFd for Inner {
     fn as_raw_fd(&self) -> RawFd {
-        self.state.wayland_fd.as_raw_fd()
+        self.state.wayland_fd
     }
 }
 
-pub struct WaylandEventProducer(AsyncFd<Inner>);
+pub struct WaylandInputCapture(AsyncFd<Inner>);
 
 struct Window {
     buffer: wl_buffer::WlBuffer,
@@ -256,65 +256,38 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
     }
 }
 
-impl WaylandEventProducer {
-    pub fn new() -> Result<Self> {
-        let conn = match Connection::connect_to_env() {
-            Ok(c) => c,
-            Err(e) => return Err(anyhow!("could not connect to wayland compositor: {e:?}")),
-        };
-
-        let (g, mut queue) = match registry_queue_init::<State>(&conn) {
-            Ok(q) => q,
-            Err(e) => return Err(anyhow!("failed to initialize wl_registry: {e:?}")),
-        };
+impl WaylandInputCapture {
+    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
+        let conn = Connection::connect_to_env()?;
+        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
 
         let qh = queue.handle();
 
-        let compositor: wl_compositor::WlCompositor = match g.bind(&qh, 4..=5, ()) {
-            Ok(compositor) => compositor,
-            Err(_) => return Err(anyhow!("wl_compositor >= v4 not supported")),
-        };
-
-        let xdg_output_manager: ZxdgOutputManagerV1 = match g.bind(&qh, 1..=3, ()) {
-            Ok(xdg_output_manager) => xdg_output_manager,
-            Err(_) => return Err(anyhow!("xdg_output not supported!")),
-        };
-
-        let shm: wl_shm::WlShm = match g.bind(&qh, 1..=1, ()) {
-            Ok(wl_shm) => wl_shm,
-            Err(_) => return Err(anyhow!("wl_shm v1 not supported")),
-        };
-
-        let layer_shell: ZwlrLayerShellV1 = match g.bind(&qh, 3..=4, ()) {
-            Ok(layer_shell) => layer_shell,
-            Err(_) => return Err(anyhow!("zwlr_layer_shell_v1 >= v3 not supported - required to display a surface at the edge of the screen")),
-        };
-
-        let seat: wl_seat::WlSeat = match g.bind(&qh, 7..=8, ()) {
-            Ok(wl_seat) => wl_seat,
-            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
-        };
-
-        let pointer_constraints: ZwpPointerConstraintsV1 = match g.bind(&qh, 1..=1, ()) {
-            Ok(pointer_constraints) => pointer_constraints,
-            Err(_) => return Err(anyhow!("zwp_pointer_constraints_v1 not supported")),
-        };
-
-        let relative_pointer_manager: ZwpRelativePointerManagerV1 = match g.bind(&qh, 1..=1, ()) {
-            Ok(relative_pointer_manager) => relative_pointer_manager,
-            Err(_) => return Err(anyhow!("zwp_relative_pointer_manager_v1 not supported")),
-        };
-
-        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 =
-            match g.bind(&qh, 1..=1, ()) {
-                Ok(shortcut_inhibit_manager) => shortcut_inhibit_manager,
-                Err(_) => {
-                    return Err(anyhow!(
-                        "zwp_keyboard_shortcuts_inhibit_manager_v1 not supported"
-                    ))
-                }
-            };
+        let compositor: wl_compositor::WlCompositor = g
+            .bind(&qh, 4..=5, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_compositor 4..=5"))?;
+        let xdg_output_manager: ZxdgOutputManagerV1 = g
+            .bind(&qh, 1..=3, ())
+            .map_err(|e| WaylandBindError::new(e, "xdg_output_manager 1..=3"))?;
+        let shm: wl_shm::WlShm = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_shm"))?;
+        let layer_shell: ZwlrLayerShellV1 = g
+            .bind(&qh, 3..=4, ())
+            .map_err(|e| WaylandBindError::new(e, "wlr_layer_shell 3..=4"))?;
+        let seat: wl_seat::WlSeat = g
+            .bind(&qh, 7..=8, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
 
+        let pointer_constraints: ZwpPointerConstraintsV1 = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_pointer_constraints_v1"))?;
+        let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
+        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 = g
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"))?;
         let outputs = vec![];
 
         let g = Globals {
@@ -332,10 +305,7 @@ impl WaylandEventProducer {
         // flush outgoing events
         queue.flush()?;
 
-        // 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 wayland_fd = queue.as_fd().as_raw_fd();
 
         let mut state = State {
             pointer: None,
@@ -351,6 +321,7 @@ impl WaylandEventProducer {
             read_guard: None,
             pending_events: VecDeque::new(),
             output_info: vec![],
+            scroll_discrete_pending: false,
         };
 
         // dispatch registry to () again, in order to read all wl_outputs
@@ -390,14 +361,14 @@ impl WaylandEventProducer {
 
         let inner = AsyncFd::new(Inner { queue, state })?;
 
-        Ok(WaylandEventProducer(inner))
+        Ok(WaylandInputCapture(inner))
     }
 
-    fn add_client(&mut self, handle: ClientHandle, pos: Position) {
+    fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
         self.0.get_mut().state.add_client(handle, pos);
     }
 
-    fn delete_client(&mut self, handle: ClientHandle) {
+    fn delete_client(&mut self, handle: CaptureHandle) {
         let inner = self.0.get_mut();
         // remove all windows corresponding to this client
         while let Some(i) = inner
@@ -495,13 +466,13 @@ impl State {
         }
     }
 
-    fn add_client(&mut self, client: ClientHandle, pos: Position) {
+    fn add_client(&mut self, client: CaptureHandle, pos: Position) {
         let outputs = get_output_configuration(self, pos);
 
         log::debug!("outputs: {outputs:?}");
         outputs.iter().for_each(|(o, i)| {
             let window = Window::new(self, &self.qh, o, pos, i.size);
-            let window = Rc::new(window);
+            let window = Arc::new(window);
             self.client_for_window.push((window, client));
         });
     }
@@ -587,30 +558,34 @@ impl Inner {
     }
 }
 
-impl EventProducer for WaylandEventProducer {
-    fn notify(&mut self, client_event: ClientEvent) -> io::Result<()> {
-        match client_event {
-            ClientEvent::Create(handle, pos) => {
-                self.add_client(handle, pos);
-            }
-            ClientEvent::Destroy(handle) => {
-                self.delete_client(handle);
-            }
-        }
+#[async_trait]
+impl Capture for WaylandInputCapture {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        self.add_client(handle, pos);
         let inner = self.0.get_mut();
-        inner.flush_events()
+        Ok(inner.flush_events()?)
     }
 
-    fn release(&mut self) -> io::Result<()> {
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        self.delete_client(handle);
+        let inner = self.0.get_mut();
+        Ok(inner.flush_events()?)
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
         log::debug!("releasing pointer");
         let inner = self.0.get_mut();
         inner.state.ungrab();
-        inner.flush_events()
+        Ok(inner.flush_events()?)
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
     }
 }
 
-impl Stream for WaylandEventProducer {
-    type Item = io::Result<(ClientHandle, Event)>;
+impl Stream for WaylandInputCapture {
+    type Item = Result<(CaptureHandle, Event), CaptureError>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
@@ -628,7 +603,7 @@ impl Stream for WaylandEventProducer {
                     // prepare next read
                     match inner.prepare_read() {
                         Ok(_) => {}
-                        Err(e) => return Poll::Ready(Some(Err(e))),
+                        Err(e) => return Poll::Ready(Some(Err(e.into()))),
                     }
                 }
 
@@ -638,14 +613,14 @@ impl Stream for WaylandEventProducer {
                 // flush outgoing events
                 if let Err(e) = inner.flush_events() {
                     if e.kind() != ErrorKind::WouldBlock {
-                        return Poll::Ready(Some(Err(e)));
+                        return Poll::Ready(Some(Err(e.into())));
                     }
                 }
 
                 // prepare for the next read
                 match inner.prepare_read() {
                     Ok(_) => {}
-                    Err(e) => return Poll::Ready(Some(Err(e))),
+                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
                 }
             }
 
@@ -752,12 +727,30 @@ impl Dispatch<WlPointer, ()> for State {
             }
             wl_pointer::Event::Axis { time, axis, value } => {
                 let (_, client) = app.focused.as_ref().unwrap();
+                if app.scroll_discrete_pending {
+                    // each axisvalue120 event is coupled with
+                    // a corresponding axis event, which needs to
+                    // be ignored to not duplicate the scrolling
+                    app.scroll_discrete_pending = false;
+                } else {
+                    app.pending_events.push_back((
+                        *client,
+                        Event::Pointer(PointerEvent::Axis {
+                            time,
+                            axis: u32::from(axis) as u8,
+                            value,
+                        }),
+                    ));
+                }
+            }
+            wl_pointer::Event::AxisValue120 { axis, value120 } => {
+                let (_, client) = app.focused.as_ref().unwrap();
+                app.scroll_discrete_pending = true;
                 app.pending_events.push_back((
                     *client,
-                    Event::Pointer(PointerEvent::Axis {
-                        time,
+                    Event::Pointer(PointerEvent::AxisDiscrete120 {
                         axis: u32::from(axis) as u8,
-                        value,
+                        value: value120,
                     }),
                 ));
             }
@@ -821,15 +814,6 @@ 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
-            }
             _ => (),
         }
     }
@@ -847,21 +831,16 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
         if let zwp_relative_pointer_v1::Event::RelativeMotion {
             utime_hi,
             utime_lo,
-            dx: _,
-            dy: _,
-            dx_unaccel: surface_x,
-            dy_unaccel: surface_y,
+            dx_unaccel: dx,
+            dy_unaccel: dy,
+            ..
         } = event
         {
             if let Some((_window, client)) = &app.focused {
                 let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
                 app.pending_events.push_back((
                     *client,
-                    Event::Pointer(PointerEvent::Motion {
-                        time,
-                        relative_x: surface_x,
-                        relative_y: surface_y,
-                    }),
+                    Event::Pointer(PointerEvent::Motion { time, dx, dy }),
                 ));
             }
         }

input-capture/src/windows.rs

@@ -0,0 +1,631 @@
+use async_trait::async_trait;
+use core::task::{Context, Poll};
+use futures::Stream;
+use once_cell::unsync::Lazy;
+
+use std::collections::HashMap;
+use std::ptr::{addr_of, addr_of_mut};
+
+use futures::executor::block_on;
+use std::default::Default;
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::{mpsc, Mutex};
+use std::task::ready;
+use std::{pin::Pin, thread};
+use tokio::sync::mpsc::{channel, Receiver, Sender};
+use windows::core::{w, PCWSTR};
+use windows::Win32::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
+use windows::Win32::Graphics::Gdi::{
+    EnumDisplayDevicesW, EnumDisplaySettingsW, DEVMODEW, DISPLAY_DEVICEW,
+    DISPLAY_DEVICE_ATTACHED_TO_DESKTOP, ENUM_CURRENT_SETTINGS,
+};
+use windows::Win32::System::LibraryLoader::GetModuleHandleW;
+use windows::Win32::System::Threading::GetCurrentThreadId;
+
+use windows::Win32::UI::WindowsAndMessaging::{
+    CallNextHookEx, CreateWindowExW, DispatchMessageW, GetMessageW, PostThreadMessageW,
+    RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HHOOK,
+    HMENU, HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL,
+    WH_MOUSE_LL, WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN,
+    WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
+    WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW,
+    WNDPROC,
+};
+
+use input_event::{
+    scancode::{self, Linux},
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+};
+
+use super::{Capture, CaptureError, CaptureHandle, Position};
+
+enum Request {
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+}
+
+pub struct WindowsInputCapture {
+    event_rx: Receiver<(CaptureHandle, Event)>,
+    msg_thread: Option<std::thread::JoinHandle<()>>,
+}
+
+enum EventType {
+    Request = 0,
+    Release = 1,
+    Exit = 2,
+}
+
+unsafe fn signal_message_thread(event_type: EventType) {
+    if let Some(event_tid) = get_event_tid() {
+        PostThreadMessageW(event_tid, WM_USER, WPARAM(event_type as usize), LPARAM(0)).unwrap();
+    } else {
+        panic!();
+    }
+}
+
+#[async_trait]
+impl Capture for WindowsInputCapture {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        unsafe {
+            {
+                let mut requests = REQUEST_BUFFER.lock().unwrap();
+                requests.push(Request::Create(handle, pos));
+            }
+            signal_message_thread(EventType::Request);
+        }
+        Ok(())
+    }
+
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        unsafe {
+            {
+                let mut requests = REQUEST_BUFFER.lock().unwrap();
+                requests.push(Request::Destroy(handle));
+            }
+            signal_message_thread(EventType::Request);
+        }
+        Ok(())
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        unsafe { signal_message_thread(EventType::Release) };
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+}
+
+static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
+static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
+static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
+static mut EVENT_TX: Option<Sender<(CaptureHandle, Event)>> = None;
+static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
+unsafe fn set_event_tid(tid: u32) {
+    EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
+}
+unsafe fn get_event_tid() -> Option<u32> {
+    match EVENT_THREAD_ID.load(Ordering::SeqCst) {
+        0 => None,
+        id => Some(id),
+    }
+}
+
+static mut ENTRY_POINT: (i32, i32) = (0, 0);
+
+fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
+    let mouse_low_level: MSLLHOOKSTRUCT = unsafe { *(lparam.0 as *const MSLLHOOKSTRUCT) };
+    match wparam {
+        WPARAM(p) if p == WM_LBUTTONDOWN as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_LEFT,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_MBUTTONDOWN as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_MIDDLE,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_RBUTTONDOWN as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_RIGHT,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_LBUTTONUP as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_LEFT,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_MBUTTONUP as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_MIDDLE,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_RBUTTONUP as usize => Some(PointerEvent::Button {
+            time: 0,
+            button: BTN_RIGHT,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_MOUSEMOVE as usize => unsafe {
+            let (x, y) = (mouse_low_level.pt.x, mouse_low_level.pt.y);
+            let (ex, ey) = ENTRY_POINT;
+            let (dx, dy) = (x - ex, y - ey);
+            let (dx, dy) = (dx as f64, dy as f64);
+            Some(PointerEvent::Motion { time: 0, dx, dy })
+        },
+        WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
+            axis: 0,
+            value: -(mouse_low_level.mouseData as i32 >> 16),
+        }),
+        WPARAM(p) if p == WM_XBUTTONDOWN as usize || p == WM_XBUTTONUP as usize => {
+            let hb = mouse_low_level.mouseData >> 16;
+            let button = match hb {
+                1 => BTN_BACK,
+                2 => BTN_FORWARD,
+                _ => {
+                    log::warn!("unknown mouse button");
+                    return None;
+                }
+            };
+            Some(PointerEvent::Button {
+                time: 0,
+                button,
+                state: if p == WM_XBUTTONDOWN as usize { 1 } else { 0 },
+            })
+        }
+        w => {
+            log::warn!("unknown mouse event: {w:?}");
+            None
+        }
+    }
+}
+
+unsafe fn to_key_event(wparam: WPARAM, lparam: LPARAM) -> Option<KeyboardEvent> {
+    let kybrdllhookstruct: KBDLLHOOKSTRUCT = *(lparam.0 as *const KBDLLHOOKSTRUCT);
+    let mut scan_code = kybrdllhookstruct.scanCode;
+    log::trace!("scan_code: {scan_code}");
+    if kybrdllhookstruct.flags.contains(LLKHF_EXTENDED) {
+        scan_code |= 0xE000;
+    }
+    let Ok(win_scan_code) = scancode::Windows::try_from(scan_code) else {
+        log::warn!("failed to translate to windows scancode: {scan_code}");
+        return None;
+    };
+    log::trace!("windows_scan: {win_scan_code:?}");
+    let Ok(linux_scan_code): Result<Linux, ()> = win_scan_code.try_into() else {
+        log::warn!("failed to translate into linux scancode: {win_scan_code:?}");
+        return None;
+    };
+    log::trace!("windows_scan: {linux_scan_code:?}");
+    let scan_code = linux_scan_code as u32;
+    match wparam {
+        WPARAM(p) if p == WM_KEYDOWN as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_KEYUP as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 0,
+        }),
+        WPARAM(p) if p == WM_SYSKEYDOWN as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 1,
+        }),
+        WPARAM(p) if p == WM_SYSKEYUP as usize => Some(KeyboardEvent::Key {
+            time: 0,
+            key: scan_code,
+            state: 1,
+        }),
+        _ => None,
+    }
+}
+
+///
+/// clamp point to display bounds
+///
+/// # Arguments
+///
+/// * `prev_point`: coordinates, the cursor was before entering, within bounds of a display
+/// * `entry_point`: point to clamp
+///
+/// returns: (i32, i32), the corrected entry point
+///
+fn clamp_to_display_bounds(prev_point: (i32, i32), point: (i32, i32)) -> (i32, i32) {
+    /* find display where movement came from */
+    let display_regions = unsafe { get_display_regions() };
+    let display = display_regions
+        .iter()
+        .find(|&d| is_within_dp_region(prev_point, d))
+        .unwrap();
+
+    /* clamp to bounds (inclusive) */
+    let (x, y) = point;
+    let (min_x, max_x) = (display.left, display.right - 1);
+    let (min_y, max_y) = (display.top, display.bottom - 1);
+    (x.clamp(min_x, max_x), y.clamp(min_y, max_y))
+}
+
+unsafe fn send_blocking(event: Event) {
+    if let Some(active) = ACTIVE_CLIENT {
+        block_on(async move {
+            let _ = EVENT_TX.as_ref().unwrap().send((active, event)).await;
+        });
+    }
+}
+
+unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
+    if wparam.0 != WM_MOUSEMOVE as usize {
+        return ACTIVE_CLIENT.is_some();
+    }
+    let mouse_low_level: MSLLHOOKSTRUCT = *(lparam.0 as *const MSLLHOOKSTRUCT);
+    static mut PREV_POS: Option<(i32, i32)> = None;
+    let curr_pos = (mouse_low_level.pt.x, mouse_low_level.pt.y);
+    let prev_pos = PREV_POS.unwrap_or(curr_pos);
+    PREV_POS.replace(curr_pos);
+
+    /* next event is the first actual event */
+    let ret = ACTIVE_CLIENT.is_some();
+
+    /* client already active, no need to check */
+    if ACTIVE_CLIENT.is_some() {
+        return ret;
+    }
+
+    /* check if a client was activated */
+    let Some(pos) = entered_barrier(prev_pos, curr_pos, get_display_regions()) else {
+        return ret;
+    };
+
+    /* check if a client is registered for the barrier */
+    let Some(client) = CLIENT_FOR_POS.get(&pos) else {
+        return ret;
+    };
+
+    /* update active client and entry point */
+    ACTIVE_CLIENT.replace(*client);
+    ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);
+
+    /* notify main thread */
+    log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
+    send_blocking(Event::Enter());
+
+    ret
+}
+
+unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+    let active = check_client_activation(wparam, lparam);
+
+    /* no client was active */
+    if !active {
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
+    }
+
+    /* get active client if any */
+    let Some(client) = ACTIVE_CLIENT else {
+        return LRESULT(1);
+    };
+
+    /* convert to lan-mouse event */
+    let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
+        return LRESULT(1);
+    };
+    let event = (client, Event::Pointer(pointer_event));
+
+    /* notify mainthread (drop events if sending too fast) */
+    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
+        log::warn!("e: {e}");
+    }
+
+    /* don't pass event to applications */
+    LRESULT(1)
+}
+
+unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+    /* get active client if any */
+    let Some(client) = ACTIVE_CLIENT else {
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
+    };
+
+    /* convert to key event */
+    let Some(key_event) = to_key_event(wparam, lparam) else {
+        return LRESULT(1);
+    };
+    let event = (client, Event::Keyboard(key_event));
+
+    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
+        log::warn!("e: {e}");
+    }
+
+    /* don't pass event to applications */
+    LRESULT(1)
+}
+
+unsafe extern "system" fn window_proc(
+    _hwnd: HWND,
+    uint: u32,
+    _wparam: WPARAM,
+    _lparam: LPARAM,
+) -> LRESULT {
+    match uint {
+        x if x == WM_DISPLAYCHANGE => {
+            log::debug!("display resolution changed");
+            DISPLAY_RESOLUTION_CHANGED = true;
+        }
+        _ => {}
+    }
+    LRESULT(1)
+}
+
+fn enumerate_displays() -> Vec<RECT> {
+    unsafe {
+        let mut display_rects = vec![];
+        let mut devices = vec![];
+        for i in 0.. {
+            let mut device: DISPLAY_DEVICEW = std::mem::zeroed();
+            device.cb = std::mem::size_of::<DISPLAY_DEVICEW>() as u32;
+            let ret = EnumDisplayDevicesW(None, i, &mut device, EDD_GET_DEVICE_INTERFACE_NAME);
+            if ret == FALSE {
+                break;
+            }
+            if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
+                devices.push(device.DeviceName);
+            }
+        }
+        for device in devices {
+            let mut dev_mode: DEVMODEW = std::mem::zeroed();
+            dev_mode.dmSize = std::mem::size_of::<DEVMODEW>() as u16;
+            let ret = EnumDisplaySettingsW(
+                PCWSTR::from_raw(&device as *const _),
+                ENUM_CURRENT_SETTINGS,
+                &mut dev_mode,
+            );
+            if ret == FALSE {
+                log::warn!("no display mode");
+            }
+
+            let pos = dev_mode.Anonymous1.Anonymous2.dmPosition;
+            let (x, y) = (pos.x, pos.y);
+            let (width, height) = (dev_mode.dmPelsWidth, dev_mode.dmPelsHeight);
+
+            display_rects.push(RECT {
+                left: x,
+                right: x + width as i32,
+                top: y,
+                bottom: y + height as i32,
+            });
+        }
+        display_rects
+    }
+}
+
+static mut DISPLAY_RESOLUTION_CHANGED: bool = true;
+
+unsafe fn get_display_regions() -> &'static Vec<RECT> {
+    static mut DISPLAYS: Vec<RECT> = vec![];
+    if DISPLAY_RESOLUTION_CHANGED {
+        DISPLAYS = enumerate_displays();
+        DISPLAY_RESOLUTION_CHANGED = false;
+        log::debug!("displays: {DISPLAYS:?}");
+    }
+    &*addr_of!(DISPLAYS)
+}
+
+fn is_within_dp_region(point: (i32, i32), display: &RECT) -> bool {
+    [
+        Position::Left,
+        Position::Right,
+        Position::Top,
+        Position::Bottom,
+    ]
+    .iter()
+    .all(|&pos| is_within_dp_boundary(point, display, pos))
+}
+fn is_within_dp_boundary(point: (i32, i32), display: &RECT, pos: Position) -> bool {
+    let (x, y) = point;
+    match pos {
+        Position::Left => display.left <= x,
+        Position::Right => display.right > x,
+        Position::Top => display.top <= y,
+        Position::Bottom => display.bottom > y,
+    }
+}
+
+/// returns whether the given position is within the display bounds with respect to the given
+/// barrier position
+///
+/// # Arguments
+///
+/// * `x`:
+/// * `y`:
+/// * `displays`:
+/// * `pos`:
+///
+/// returns: bool
+///
+fn in_bounds(point: (i32, i32), displays: &[RECT], pos: Position) -> bool {
+    displays
+        .iter()
+        .any(|d| is_within_dp_boundary(point, d, pos))
+}
+
+fn in_display_region(point: (i32, i32), displays: &[RECT]) -> bool {
+    displays.iter().any(|d| is_within_dp_region(point, d))
+}
+
+fn moved_across_boundary(
+    prev_pos: (i32, i32),
+    curr_pos: (i32, i32),
+    displays: &[RECT],
+    pos: Position,
+) -> bool {
+    /* was within bounds, but is not anymore */
+    in_display_region(prev_pos, displays) && !in_bounds(curr_pos, displays, pos)
+}
+
+fn entered_barrier(
+    prev_pos: (i32, i32),
+    curr_pos: (i32, i32),
+    displays: &[RECT],
+) -> Option<Position> {
+    [
+        Position::Left,
+        Position::Right,
+        Position::Top,
+        Position::Bottom,
+    ]
+    .into_iter()
+    .find(|&pos| moved_across_boundary(prev_pos, curr_pos, displays, pos))
+}
+
+fn get_msg() -> Option<MSG> {
+    unsafe {
+        let mut msg = std::mem::zeroed();
+        let ret = GetMessageW(addr_of_mut!(msg), HWND::default(), 0, 0);
+        match ret.0 {
+            0 => None,
+            x if x > 0 => Some(msg),
+            _ => panic!("error in GetMessageW"),
+        }
+    }
+}
+
+fn message_thread(ready_tx: mpsc::Sender<()>) {
+    unsafe {
+        set_event_tid(GetCurrentThreadId());
+        ready_tx.send(()).expect("channel closed");
+        let mouse_proc: HOOKPROC = Some(mouse_proc);
+        let kybrd_proc: HOOKPROC = Some(kybrd_proc);
+        let window_proc: WNDPROC = Some(window_proc);
+
+        /* register hooks */
+        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
+        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
+
+        let instance = GetModuleHandleW(None).unwrap();
+        let window_class: WNDCLASSW = WNDCLASSW {
+            lpfnWndProc: window_proc,
+            hInstance: instance.into(),
+            lpszClassName: w!("lan-mouse-message-window-class"),
+            ..Default::default()
+        };
+
+        let ret = RegisterClassW(&window_class);
+        if ret == 0 {
+            panic!("RegisterClassW");
+        }
+
+        /* window is used ro receive WM_DISPLAYCHANGE messages */
+        CreateWindowExW(
+            Default::default(),
+            w!("lan-mouse-message-window-class"),
+            w!("lan-mouse-msg-window"),
+            WINDOW_STYLE::default(),
+            0,
+            0,
+            0,
+            0,
+            HWND::default(),
+            HMENU::default(),
+            instance,
+            None,
+        )
+        .expect("CreateWindowExW");
+
+        /* run message loop */
+        loop {
+            // mouse / keybrd proc do not actually return a message
+            let Some(msg) = get_msg() else {
+                break;
+            };
+            if msg.hwnd.0.is_null() {
+                /* messages sent via PostThreadMessage */
+                match msg.wParam.0 {
+                    x if x == EventType::Exit as usize => break,
+                    x if x == EventType::Release as usize => {
+                        ACTIVE_CLIENT.take();
+                    }
+                    x if x == EventType::Request as usize => {
+                        let requests = {
+                            let mut res = vec![];
+                            let mut requests = REQUEST_BUFFER.lock().unwrap();
+                            for request in requests.drain(..) {
+                                res.push(request);
+                            }
+                            res
+                        };
+
+                        for request in requests {
+                            update_clients(request)
+                        }
+                    }
+                    _ => {}
+                }
+            } else {
+                /* other messages for window_procs */
+                let _ = TranslateMessage(&msg);
+                DispatchMessageW(&msg);
+            }
+        }
+    }
+}
+
+fn update_clients(request: Request) {
+    match request {
+        Request::Create(handle, pos) => {
+            unsafe { CLIENT_FOR_POS.insert(pos, handle) };
+        }
+        Request::Destroy(handle) => unsafe {
+            for pos in [
+                Position::Left,
+                Position::Right,
+                Position::Top,
+                Position::Bottom,
+            ] {
+                if ACTIVE_CLIENT == Some(handle) {
+                    ACTIVE_CLIENT.take();
+                }
+                if CLIENT_FOR_POS.get(&pos).copied() == Some(handle) {
+                    CLIENT_FOR_POS.remove(&pos);
+                }
+            }
+        },
+    }
+}
+
+impl WindowsInputCapture {
+    pub(crate) fn new() -> Self {
+        unsafe {
+            let (tx, rx) = channel(10);
+            EVENT_TX.replace(tx);
+            let (ready_tx, ready_rx) = mpsc::channel();
+            let msg_thread = Some(thread::spawn(|| message_thread(ready_tx)));
+            /* wait for thread to set its id */
+            ready_rx.recv().expect("channel closed");
+            Self {
+                msg_thread,
+                event_rx: rx,
+            }
+        }
+    }
+}
+
+impl Stream for WindowsInputCapture {
+    type Item = Result<(CaptureHandle, Event), CaptureError>;
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        match ready!(self.event_rx.poll_recv(cx)) {
+            None => Poll::Ready(None),
+            Some(e) => Poll::Ready(Some(Ok(e))),
+        }
+    }
+}
+
+impl Drop for WindowsInputCapture {
+    fn drop(&mut self) {
+        unsafe { signal_message_thread(EventType::Exit) };
+        let _ = self.msg_thread.take().unwrap().join();
+    }
+}

input-capture/src/x11.rs

@@ -0,0 +1,50 @@
+use std::task::Poll;
+
+use async_trait::async_trait;
+use futures_core::Stream;
+
+use crate::CaptureError;
+
+use super::Capture;
+use input_event::Event;
+
+use super::error::X11InputCaptureCreationError;
+use super::{CaptureHandle, Position};
+
+pub struct X11InputCapture {}
+
+impl X11InputCapture {
+    pub fn new() -> std::result::Result<Self, X11InputCaptureCreationError> {
+        Err(X11InputCaptureCreationError::NotImplemented)
+    }
+}
+
+#[async_trait]
+impl Capture for X11InputCapture {
+    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+}
+
+impl Stream for X11InputCapture {
+    type Item = Result<(CaptureHandle, Event), CaptureError>;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}

input-emulation/Cargo.toml

@@ -0,0 +1,71 @@
+[package]
+name = "input-emulation"
+description = "cross-platform input emulation library used by lan-mouse"
+version = "0.2.1"
+edition = "2021"
+license = "GPL-3.0-or-later"
+repository = "https://github.com/feschber/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" }
+thiserror = "1.0.61"
+tokio = { version = "1.32.0", features = [
+    "io-util",
+    "io-std",
+    "macros",
+    "net",
+    "process",
+    "rt",
+    "sync",
+    "signal",
+] }
+once_cell = "1.19.0"
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+wayland-client = { version = "0.31.1", optional = true }
+wayland-protocols = { version = "0.32.1", features = [
+    "client",
+    "staging",
+    "unstable",
+], optional = true }
+wayland-protocols-wlr = { version = "0.3.1", features = [
+    "client",
+], optional = true }
+wayland-protocols-misc = { version = "0.3.1", features = [
+    "client",
+], optional = true }
+x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
+ashpd = { version = "0.9", default-features = false, features = [
+    "tokio",
+], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }
+
+[target.'cfg(target_os="macos")'.dependencies]
+core-graphics = { version = "0.23", features = ["highsierra"] }
+keycode = "0.4.0"
+
+[target.'cfg(windows)'.dependencies]
+windows = { version = "0.58.0", features = [
+    "Win32_System_LibraryLoader",
+    "Win32_System_Threading",
+    "Win32_Foundation",
+    "Win32_Graphics",
+    "Win32_Graphics_Gdi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_WindowsAndMessaging",
+] }
+
+[features]
+default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
+wayland = [
+    "dep:wayland-client",
+    "dep:wayland-protocols",
+    "dep:wayland-protocols-wlr",
+    "dep:wayland-protocols-misc",
+]
+x11 = ["dep:x11"]
+xdg_desktop_portal = ["dep:ashpd"]
+libei = ["dep:reis", "dep:ashpd"]

input-emulation/src/dummy.rs

@@ -0,0 +1,32 @@
+use async_trait::async_trait;
+use input_event::Event;
+
+use crate::error::EmulationError;
+
+use super::{Emulation, EmulationHandle};
+
+#[derive(Default)]
+pub(crate) struct DummyEmulation;
+
+impl DummyEmulation {
+    pub(crate) fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl Emulation for DummyEmulation {
+    async fn consume(
+        &mut self,
+        event: Event,
+        client_handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
+        log::info!("received event: ({client_handle}) {event}");
+        Ok(())
+    }
+    async fn create(&mut self, _: EmulationHandle) {}
+    async fn destroy(&mut self, _: EmulationHandle) {}
+    async fn terminate(&mut self) {
+        /* nothing to do */
+    }
+}

input-emulation/src/error.rs

@@ -0,0 +1,179 @@
+#[derive(Debug, Error)]
+pub enum InputEmulationError {
+    #[error("error creating input-emulation: `{0}`")]
+    Create(#[from] EmulationCreationError),
+    #[error("error emulating input: `{0}`")]
+    Emulate(#[from] EmulationError),
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use ashpd::{desktop::ResponseError, Error::Response};
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::EiConvertEventStreamError;
+use std::io;
+use thiserror::Error;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use wayland_client::{
+    backend::WaylandError,
+    globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
+};
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::HandshakeError;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("error in libei stream: {inner:?}")]
+pub struct ReisConvertStreamError {
+    inner: EiConvertEventStreamError,
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl From<EiConvertEventStreamError> for ReisConvertStreamError {
+    fn from(e: EiConvertEventStreamError) -> Self {
+        Self { inner: e }
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum EmulationError {
+    #[error("event stream closed")]
+    EndOfStream,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei error flushing events: `{0}`")]
+    Libei(#[from] reis::event::Error),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("")]
+    LibeiConvertStream(#[from] ReisConvertStreamError),
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[error("wayland error: `{0}`")]
+    Wayland(#[from] wayland_client::backend::WaylandError),
+    #[cfg(all(
+        unix,
+        any(feature = "xdg_desktop_portal", feature = "libei"),
+        not(target_os = "macos")
+    ))]
+    #[error("xdg-desktop-portal: `{0}`")]
+    Ashpd(#[from] ashpd::Error),
+    #[error("io error: `{0}`")]
+    Io(#[from] io::Error),
+}
+
+#[derive(Debug, Error)]
+pub enum EmulationCreationError {
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[error("wlroots backend: `{0}`")]
+    Wlroots(#[from] WlrootsEmulationCreationError),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei backend: `{0}`")]
+    Libei(#[from] LibeiEmulationCreationError),
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    #[error("xdg-desktop-portal: `{0}`")]
+    Xdp(#[from] XdpEmulationCreationError),
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    #[error("x11: `{0}`")]
+    X11(#[from] X11EmulationCreationError),
+    #[cfg(target_os = "macos")]
+    #[error("macos: `{0}`")]
+    MacOs(#[from] MacOSEmulationCreationError),
+    #[cfg(windows)]
+    #[error("windows: `{0}`")]
+    Windows(#[from] WindowsEmulationCreationError),
+    #[error("capture error")]
+    NoAvailableBackend,
+}
+
+impl EmulationCreationError {
+    /// request was intentionally denied by the user
+    pub(crate) fn cancelled_by_user(&self) -> bool {
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        if 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(
+                ResponseError::Cancelled,
+            )))
+        ) {
+            return true;
+        }
+        false
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum WlrootsEmulationCreationError {
+    #[error(transparent)]
+    Connect(#[from] ConnectError),
+    #[error(transparent)]
+    Global(#[from] GlobalError),
+    #[error(transparent)]
+    Wayland(#[from] WaylandError),
+    #[error(transparent)]
+    Bind(#[from] WaylandBindError),
+    #[error(transparent)]
+    Dispatch(#[from] DispatchError),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("wayland protocol \"{protocol}\" not supported: {inner}")]
+pub struct WaylandBindError {
+    inner: BindError,
+    protocol: &'static str,
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl WaylandBindError {
+    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
+        Self { inner, protocol }
+    }
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LibeiEmulationCreationError {
+    #[error(transparent)]
+    Ashpd(#[from] ashpd::Error),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error(transparent)]
+    Handshake(#[from] HandshakeError),
+}
+
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum XdpEmulationCreationError {
+    #[error(transparent)]
+    Ashpd(#[from] ashpd::Error),
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum X11EmulationCreationError {
+    #[error("could not open display")]
+    OpenDisplay,
+}
+
+#[cfg(target_os = "macos")]
+#[derive(Debug, Error)]
+pub enum MacOSEmulationCreationError {
+    #[error("could not create event source")]
+    EventSourceCreation,
+}
+
+#[cfg(windows)]
+#[derive(Debug, Error)]
+pub enum WindowsEmulationCreationError {}

input-emulation/src/lib.rs

@@ -0,0 +1,240 @@
+use async_trait::async_trait;
+use std::{
+    collections::{HashMap, HashSet},
+    fmt::Display,
+};
+
+use input_event::{Event, KeyboardEvent};
+
+pub use self::error::{EmulationCreationError, EmulationError, InputEmulationError};
+
+#[cfg(windows)]
+mod windows;
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+mod x11;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+mod wlroots;
+
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+mod xdg_desktop_portal;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+mod libei;
+
+#[cfg(target_os = "macos")]
+mod macos;
+
+/// fallback input emulation (logs events)
+mod dummy;
+mod error;
+
+pub type EmulationHandle = u64;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Backend {
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    Wlroots,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei,
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    Xdp,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl Display for Backend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            Backend::Wlroots => write!(f, "wlroots"),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            Backend::Libei => write!(f, "libei"),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            Backend::Xdp => write!(f, "xdg-desktop-portal"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            Backend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            Backend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            Backend::MacOs => write!(f, "macos"),
+            Backend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+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 {
+    async fn consume(
+        &mut self,
+        event: Event,
+        handle: EmulationHandle,
+    ) -> Result<(), EmulationError>;
+    async fn create(&mut self, handle: EmulationHandle);
+    async fn destroy(&mut self, handle: EmulationHandle);
+    async fn terminate(&mut self);
+}

input-emulation/src/libei.rs

@@ -0,0 +1,372 @@
+use futures::{future, StreamExt};
+use once_cell::sync::Lazy;
+use std::{
+    collections::HashMap,
+    io,
+    os::{fd::OwnedFd, unix::net::UnixStream},
+    sync::{
+        atomic::{AtomicBool, AtomicU32, Ordering},
+        Arc, Mutex, RwLock,
+    },
+    time::{SystemTime, UNIX_EPOCH},
+};
+use tokio::task::JoinHandle;
+
+use ashpd::{
+    desktop::{
+        remote_desktop::{DeviceType, RemoteDesktop},
+        PersistMode, Session,
+    },
+    WindowIdentifier,
+};
+use async_trait::async_trait;
+
+use reis::{
+    ei::{
+        self, button::ButtonState, handshake::ContextType, keyboard::KeyState, Button, Keyboard,
+        Pointer, Scroll,
+    },
+    event::{DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
+    tokio::{ei_handshake, EiConvertEventStream, EiEventStream},
+};
+
+use input_event::{Event, KeyboardEvent, PointerEvent};
+
+use crate::error::{EmulationError, ReisConvertStreamError};
+
+use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};
+
+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
+#[derive(Clone, Default)]
+struct Devices {
+    pointer: Arc<RwLock<Option<(ei::Device, ei::Pointer)>>>,
+    scroll: Arc<RwLock<Option<(ei::Device, ei::Scroll)>>>,
+    button: Arc<RwLock<Option<(ei::Device, ei::Button)>>>,
+    keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
+}
+
+pub(crate) struct LibeiEmulation<'a> {
+    context: ei::Context,
+    devices: Devices,
+    ei_task: JoinHandle<()>,
+    error: Arc<Mutex<Option<EmulationError>>>,
+    libei_error: Arc<AtomicBool>,
+    serial: AtomicU32,
+    _remote_desktop: RemoteDesktop<'a>,
+    session: Session<'a, RemoteDesktop<'a>>,
+}
+
+async fn get_ei_fd<'a>(
+) -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
+    let remote_desktop = RemoteDesktop::new().await?;
+
+    log::debug!("creating session ...");
+    let session = remote_desktop.create_session().await?;
+
+    log::debug!("selecting devices ...");
+    remote_desktop
+        .select_devices(
+            &session,
+            DeviceType::Keyboard | DeviceType::Pointer,
+            None,
+            PersistMode::ExplicitlyRevoked,
+        )
+        .await?;
+
+    log::info!("requesting permission for input emulation");
+    let _devices = remote_desktop
+        .start(&session, &WindowIdentifier::default())
+        .await?
+        .response()?;
+
+    let fd = remote_desktop.connect_to_eis(&session).await?;
+    Ok((remote_desktop, session, fd))
+}
+
+impl<'a> LibeiEmulation<'a> {
+    pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
+        let (_remote_desktop, session, eifd) = get_ei_fd().await?;
+        let stream = UnixStream::from(eifd);
+        stream.set_nonblocking(true)?;
+        let context = ei::Context::new(stream)?;
+        let mut events = EiEventStream::new(context.clone())?;
+        let handshake = ei_handshake(
+            &mut events,
+            "de.feschber.LanMouse",
+            ContextType::Sender,
+            &INTERFACES,
+        )
+        .await?;
+        let events = EiConvertEventStream::new(events, handshake.serial);
+        let devices = Devices::default();
+        let libei_error = Arc::new(AtomicBool::default());
+        let error = Arc::new(Mutex::new(None));
+        let ei_handler = ei_task(
+            events,
+            context.clone(),
+            devices.clone(),
+            libei_error.clone(),
+            error.clone(),
+        );
+        let ei_task = tokio::task::spawn_local(ei_handler);
+
+        let serial = AtomicU32::new(handshake.serial);
+
+        Ok(Self {
+            context,
+            devices,
+            ei_task,
+            error,
+            libei_error,
+            serial,
+            _remote_desktop,
+            session,
+        })
+    }
+}
+
+impl<'a> Drop for LibeiEmulation<'a> {
+    fn drop(&mut self) {
+        self.ei_task.abort();
+    }
+}
+
+#[async_trait]
+impl<'a> Emulation for LibeiEmulation<'a> {
+    async fn consume(
+        &mut self,
+        event: Event,
+        _handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_micros() as u64;
+        if self.libei_error.load(Ordering::SeqCst) {
+            // don't break sending additional events but signal error
+            if let Some(e) = self.error.lock().unwrap().take() {
+                return Err(e);
+            }
+        }
+        match event {
+            Event::Pointer(p) => match p {
+                PointerEvent::Motion { time: _, dx, dy } => {
+                    let pointer_device = self.devices.pointer.read().unwrap();
+                    if let Some((d, p)) = pointer_device.as_ref() {
+                        p.motion_relative(dx as f32, dy as f32);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    let button_device = self.devices.button.read().unwrap();
+                    if let Some((d, b)) = button_device.as_ref() {
+                        b.button(
+                            button,
+                            match state {
+                                0 => ButtonState::Released,
+                                _ => ButtonState::Press,
+                            },
+                        );
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    let scroll_device = self.devices.scroll.read().unwrap();
+                    if let Some((d, s)) = scroll_device.as_ref() {
+                        match axis {
+                            0 => s.scroll(0., value as f32),
+                            _ => s.scroll(value as f32, 0.),
+                        }
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    let scroll_device = self.devices.scroll.read().unwrap();
+                    if let Some((d, s)) = scroll_device.as_ref() {
+                        match axis {
+                            0 => s.scroll_discrete(0, value),
+                            _ => s.scroll_discrete(value, 0),
+                        }
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::Frame {} => {}
+            },
+            Event::Keyboard(k) => match k {
+                KeyboardEvent::Key {
+                    time: _,
+                    key,
+                    state,
+                } => {
+                    let keyboard_device = self.devices.keyboard.read().unwrap();
+                    if let Some((d, k)) = keyboard_device.as_ref() {
+                        k.key(
+                            key,
+                            match state {
+                                0 => KeyState::Released,
+                                _ => KeyState::Press,
+                            },
+                        );
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                KeyboardEvent::Modifiers { .. } => {}
+            },
+            _ => {}
+        }
+        self.context
+            .flush()
+            .map_err(|e| io::Error::new(e.kind(), e))?;
+        Ok(())
+    }
+
+    async fn create(&mut self, _: EmulationHandle) {}
+    async fn destroy(&mut self, _: EmulationHandle) {}
+
+    async fn terminate(&mut self) {
+        let _ = self.session.close().await;
+        self.ei_task.abort();
+    }
+}
+
+async fn ei_task(
+    mut events: EiConvertEventStream,
+    context: ei::Context,
+    devices: Devices,
+    libei_error: Arc<AtomicBool>,
+    error: Arc<Mutex<Option<EmulationError>>>,
+) {
+    loop {
+        match ei_event_handler(&mut events, &context, &devices).await {
+            Ok(()) => {}
+            Err(e) => {
+                libei_error.store(true, Ordering::SeqCst);
+                error.lock().unwrap().replace(e);
+                // wait for termination -> otherwise we will loop forever
+                future::pending::<()>().await;
+            }
+        }
+    }
+}
+
+async fn ei_event_handler(
+    events: &mut EiConvertEventStream,
+    context: &ei::Context,
+    devices: &Devices,
+) -> Result<(), EmulationError> {
+    loop {
+        let event = events
+            .next()
+            .await
+            .ok_or(EmulationError::EndOfStream)?
+            .map_err(ReisConvertStreamError::from)?;
+        const CAPABILITIES: &[DeviceCapability] = &[
+            DeviceCapability::Pointer,
+            DeviceCapability::PointerAbsolute,
+            DeviceCapability::Keyboard,
+            DeviceCapability::Touch,
+            DeviceCapability::Scroll,
+            DeviceCapability::Button,
+        ];
+        log::debug!("{event:?}");
+        match event {
+            EiEvent::Disconnected(e) => {
+                log::debug!("ei disconnected: {e:?}");
+                return Err(EmulationError::EndOfStream);
+            }
+            EiEvent::SeatAdded(e) => {
+                e.seat().bind_capabilities(CAPABILITIES);
+            }
+            EiEvent::SeatRemoved(e) => {
+                log::debug!("seat removed: {:?}", e.seat());
+            }
+            EiEvent::DeviceAdded(e) => {
+                let device_type = e.device().device_type();
+                log::debug!("device added: {device_type:?}");
+                e.device().device();
+                let device = e.device();
+                if let Some(pointer) = e.device().interface::<Pointer>() {
+                    devices
+                        .pointer
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), pointer));
+                }
+                if let Some(keyboard) = e.device().interface::<Keyboard>() {
+                    devices
+                        .keyboard
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), keyboard));
+                }
+                if let Some(scroll) = e.device().interface::<Scroll>() {
+                    devices
+                        .scroll
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), scroll));
+                }
+                if let Some(button) = e.device().interface::<Button>() {
+                    devices
+                        .button
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), button));
+                }
+            }
+            EiEvent::DeviceRemoved(e) => {
+                log::debug!("device removed: {:?}", e.device().device_type());
+            }
+            EiEvent::DevicePaused(e) => {
+                log::debug!("device paused: {:?}", e.device().device_type());
+            }
+            EiEvent::DeviceResumed(e) => {
+                log::debug!("device resumed: {:?}", e.device().device_type());
+                e.device().device().start_emulating(0, 0);
+            }
+            EiEvent::KeyboardModifiers(e) => {
+                log::debug!("modifiers: {e:?}");
+            }
+            // only for receiver context
+            // EiEvent::Frame(_) => { },
+            // EiEvent::DeviceStartEmulating(_) => { },
+            // EiEvent::DeviceStopEmulating(_) => { },
+            // EiEvent::PointerMotion(_) => { },
+            // EiEvent::PointerMotionAbsolute(_) => { },
+            // EiEvent::Button(_) => { },
+            // EiEvent::ScrollDelta(_) => { },
+            // EiEvent::ScrollStop(_) => { },
+            // EiEvent::ScrollCancel(_) => { },
+            // EiEvent::ScrollDiscrete(_) => { },
+            // EiEvent::KeyboardKey(_) => { },
+            // EiEvent::TouchDown(_) => { },
+            // EiEvent::TouchUp(_) => { },
+            // EiEvent::TouchMotion(_) => { },
+            _ => unreachable!("unexpected ei event"),
+        }
+        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
+    }
+}

input-emulation/src/macos.rs

@@ -1,23 +1,23 @@
-use crate::client::{ClientEvent, ClientHandle};
-use crate::consumer::EventConsumer;
-use crate::event::{Event, KeyboardEvent, PointerEvent};
-use anyhow::{anyhow, Result};
+use super::{error::EmulationError, Emulation, EmulationHandle};
 use async_trait::async_trait;
 use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
 use core_graphics::event::{
     CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
+use input_event::{Event, KeyboardEvent, PointerEvent};
 use keycode::{KeyMap, KeyMapping};
 use std::ops::{Index, IndexMut};
 use std::time::Duration;
 use tokio::task::AbortHandle;
 
+use super::error::MacOSEmulationCreationError;
+
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
 
-pub struct MacOSConsumer {
-    pub event_source: CGEventSource,
+pub(crate) struct MacOSEmulation {
+    event_source: CGEventSource,
     repeat_task: Option<AbortHandle>,
     button_state: ButtonState,
 }
@@ -50,14 +50,12 @@ impl IndexMut<CGMouseButton> for ButtonState {
     }
 }
 
-unsafe impl Send for MacOSConsumer {}
+unsafe impl Send for MacOSEmulation {}
 
-impl MacOSConsumer {
-    pub fn new() -> Result<Self> {
-        let event_source = match CGEventSource::new(CGEventSourceStateID::CombinedSessionState) {
-            Ok(e) => e,
-            Err(_) => return Err(anyhow!("event source creation failed!")),
-        };
+impl MacOSEmulation {
+    pub(crate) fn new() -> Result<Self, MacOSEmulationCreationError> {
+        let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
+            .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
         let button_state = ButtonState {
             left: false,
             right: false,
@@ -108,15 +106,15 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8) {
 }
 
 #[async_trait]
-impl EventConsumer for MacOSConsumer {
-    async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
+impl Emulation for MacOSEmulation {
+    async fn consume(
+        &mut self,
+        event: Event,
+        _handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion {
-                    time: _,
-                    relative_x,
-                    relative_y,
-                } => {
+                PointerEvent::Motion { time: _, dx, dy } => {
                     // FIXME secondary displays?
                     let (min_x, min_y, max_x, max_y) = unsafe {
                         let display = CGMainDisplayID();
@@ -131,12 +129,12 @@ impl EventConsumer for MacOSConsumer {
                         Some(l) => l,
                         None => {
                             log::warn!("could not get mouse location!");
-                            return;
+                            return Ok(());
                         }
                     };
 
-                    mouse_location.x = (mouse_location.x + relative_x).clamp(min_x, max_x - 1.);
-                    mouse_location.y = (mouse_location.y + relative_y).clamp(min_y, max_y - 1.);
+                    mouse_location.x = (mouse_location.x + dx).clamp(min_x, max_x - 1.);
+                    mouse_location.y = (mouse_location.y + dy).clamp(min_y, max_y - 1.);
 
                     let mut event_type = CGEventType::MouseMoved;
                     if self.button_state.left {
@@ -155,17 +153,11 @@ impl EventConsumer for MacOSConsumer {
                         Ok(e) => e,
                         Err(_) => {
                             log::warn!("mouse event creation failed!");
-                            return;
+                            return Ok(());
                         }
                     };
-                    event.set_integer_value_field(
-                        EventField::MOUSE_EVENT_DELTA_X,
-                        relative_x as i64,
-                    );
-                    event.set_integer_value_field(
-                        EventField::MOUSE_EVENT_DELTA_Y,
-                        relative_y as i64,
-                    );
+                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_X, dx as i64);
+                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_Y, dy as i64);
                     event.post(CGEventTapLocation::HID);
                 }
                 PointerEvent::Button {
@@ -174,27 +166,27 @@ impl EventConsumer for MacOSConsumer {
                     state,
                 } => {
                     let (event_type, mouse_button) = match (button, state) {
-                        (b, 1) if b == crate::event::BTN_LEFT => {
+                        (b, 1) if b == input_event::BTN_LEFT => {
                             (CGEventType::LeftMouseDown, CGMouseButton::Left)
                         }
-                        (b, 0) if b == crate::event::BTN_LEFT => {
+                        (b, 0) if b == input_event::BTN_LEFT => {
                             (CGEventType::LeftMouseUp, CGMouseButton::Left)
                         }
-                        (b, 1) if b == crate::event::BTN_RIGHT => {
+                        (b, 1) if b == input_event::BTN_RIGHT => {
                             (CGEventType::RightMouseDown, CGMouseButton::Right)
                         }
-                        (b, 0) if b == crate::event::BTN_RIGHT => {
+                        (b, 0) if b == input_event::BTN_RIGHT => {
                             (CGEventType::RightMouseUp, CGMouseButton::Right)
                         }
-                        (b, 1) if b == crate::event::BTN_MIDDLE => {
+                        (b, 1) if b == input_event::BTN_MIDDLE => {
                             (CGEventType::OtherMouseDown, CGMouseButton::Center)
                         }
-                        (b, 0) if b == crate::event::BTN_MIDDLE => {
+                        (b, 0) if b == input_event::BTN_MIDDLE => {
                             (CGEventType::OtherMouseUp, CGMouseButton::Center)
                         }
                         _ => {
                             log::warn!("invalid button event: {button},{state}");
-                            return;
+                            return Ok(());
                         }
                     };
                     // store button state
@@ -210,7 +202,7 @@ impl EventConsumer for MacOSConsumer {
                         Ok(e) => e,
                         Err(()) => {
                             log::warn!("mouse event creation failed!");
-                            return;
+                            return Ok(());
                         }
                     };
                     event.post(CGEventTapLocation::HID);
@@ -220,18 +212,18 @@ impl EventConsumer for MacOSConsumer {
                     axis,
                     value,
                 } => {
-                    let value = value as i32 / 10; // FIXME: high precision scroll events
+                    let value = value as i32;
                     let (count, wheel1, wheel2, wheel3) = match axis {
                         0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
                         1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
                         _ => {
                             log::warn!("invalid scroll event: {axis}, {value}");
-                            return;
+                            return Ok(());
                         }
                     };
                     let event = match CGEvent::new_scroll_event(
                         self.event_source.clone(),
-                        ScrollEventUnit::LINE,
+                        ScrollEventUnit::PIXEL,
                         count,
                         wheel1,
                         wheel2,
@@ -240,7 +232,32 @@ impl EventConsumer for MacOSConsumer {
                         Ok(e) => e,
                         Err(()) => {
                             log::warn!("scroll event creation failed!");
-                            return;
+                            return Ok(());
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    let (count, wheel1, wheel2, wheel3) = match axis {
+                        0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
+                        1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
+                        _ => {
+                            log::warn!("invalid scroll event: {axis}, {value}");
+                            return Ok(());
+                        }
+                    };
+                    let event = match CGEvent::new_scroll_event(
+                        self.event_source.clone(),
+                        ScrollEventUnit::PIXEL,
+                        count,
+                        wheel1,
+                        wheel2,
+                        wheel3,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("scroll event creation failed!");
+                            return Ok(());
                         }
                     };
                     event.post(CGEventTapLocation::HID);
@@ -257,7 +274,7 @@ impl EventConsumer for MacOSConsumer {
                         Ok(k) => k.mac as CGKeyCode,
                         Err(_) => {
                             log::warn!("unable to map key event");
-                            return;
+                            return Ok(());
                         }
                     };
                     match state {
@@ -271,9 +288,13 @@ impl EventConsumer for MacOSConsumer {
             },
             _ => (),
         }
+        // FIXME
+        Ok(())
     }
 
-    async fn notify(&mut self, _client_event: ClientEvent) {}
+    async fn create(&mut self, _handle: EmulationHandle) {}
 
-    async fn destroy(&mut self) {}
+    async fn destroy(&mut self, _handle: EmulationHandle) {}
+
+    async fn terminate(&mut self) {}
 }

input-emulation/src/windows.rs

@@ -1,52 +1,46 @@
-use crate::{
-    consumer::EventConsumer,
-    event::{KeyboardEvent, PointerEvent},
-    scancode,
-};
-use anyhow::Result;
-use async_trait::async_trait;
-use std::time::Duration;
-use tokio::task::AbortHandle;
-use winapi::um::winuser::{SendInput, KEYEVENTF_EXTENDEDKEY};
-use winapi::{
-    self,
-    um::winuser::{
-        INPUT, INPUT_KEYBOARD, INPUT_MOUSE, KEYBDINPUT, KEYEVENTF_KEYUP, KEYEVENTF_SCANCODE,
-        LPINPUT, MOUSEEVENTF_HWHEEL, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP,
-        MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN,
-        MOUSEEVENTF_RIGHTUP, MOUSEEVENTF_WHEEL, MOUSEINPUT,
-    },
+use super::error::{EmulationError, WindowsEmulationCreationError};
+use input_event::{
+    scancode, Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE,
+    BTN_RIGHT,
 };
 
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    event::Event,
+use async_trait::async_trait;
+use std::ops::BitOrAssign;
+use std::time::Duration;
+use tokio::task::AbortHandle;
+use windows::Win32::UI::Input::KeyboardAndMouse::{
+    SendInput, INPUT_0, KEYEVENTF_EXTENDEDKEY, MOUSEEVENTF_XDOWN, MOUSEEVENTF_XUP,
 };
+use windows::Win32::UI::Input::KeyboardAndMouse::{
+    INPUT, INPUT_KEYBOARD, INPUT_MOUSE, KEYBDINPUT, KEYEVENTF_KEYUP, KEYEVENTF_SCANCODE,
+    MOUSEEVENTF_HWHEEL, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP, MOUSEEVENTF_MIDDLEDOWN,
+    MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP,
+    MOUSEEVENTF_WHEEL, MOUSEINPUT,
+};
+use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};
+
+use super::{Emulation, EmulationHandle};
 
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
 
-pub struct WindowsConsumer {
+pub(crate) struct WindowsEmulation {
     repeat_task: Option<AbortHandle>,
 }
 
-impl WindowsConsumer {
-    pub fn new() -> Result<Self> {
+impl WindowsEmulation {
+    pub(crate) fn new() -> Result<Self, WindowsEmulationCreationError> {
         Ok(Self { repeat_task: None })
     }
 }
 
 #[async_trait]
-impl EventConsumer for WindowsConsumer {
-    async fn consume(&mut self, event: Event, _: ClientHandle) {
+impl Emulation for WindowsEmulation {
+    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion {
-                    time: _,
-                    relative_x,
-                    relative_y,
-                } => {
-                    rel_mouse(relative_x as i32, relative_y as i32);
+                PointerEvent::Motion { time: _, dx, dy } => {
+                    rel_mouse(dx as i32, dy as i32);
                 }
                 PointerEvent::Button {
                     time: _,
@@ -57,7 +51,8 @@ impl EventConsumer for WindowsConsumer {
                     time: _,
                     axis,
                     value,
-                } => scroll(axis, value),
+                } => scroll(axis, value as i32),
+                PointerEvent::AxisDiscrete120 { axis, value } => scroll(axis, value),
                 PointerEvent::Frame {} => {}
             },
             Event::Keyboard(keyboard_event) => match keyboard_event {
@@ -78,16 +73,18 @@ impl EventConsumer for WindowsConsumer {
             },
             _ => {}
         }
+        // FIXME
+        Ok(())
     }
 
-    async fn notify(&mut self, _: ClientEvent) {
-        // nothing to do
-    }
+    async fn create(&mut self, _handle: EmulationHandle) {}
 
-    async fn destroy(&mut self) {}
+    async fn destroy(&mut self, _handle: EmulationHandle) {}
+
+    async fn terminate(&mut self) {}
 }
 
-impl WindowsConsumer {
+impl WindowsEmulation {
     async fn spawn_repeat_task(&mut self, key: u32) {
         // there can only be one repeating key and it's
         // always the last to be pressed
@@ -108,21 +105,30 @@ impl WindowsConsumer {
     }
 }
 
-fn send_mouse_input(mi: MOUSEINPUT) {
+fn send_input_safe(input: INPUT) {
     unsafe {
-        let mut input = INPUT {
-            type_: INPUT_MOUSE,
-            u: std::mem::transmute(mi),
-        };
-
-        SendInput(
-            1_u32,
-            &mut input as LPINPUT,
-            std::mem::size_of::<INPUT>() as i32,
-        );
+        loop {
+            /* retval = number of successfully submitted events */
+            if SendInput(&[input], std::mem::size_of::<INPUT>() as i32) > 0 {
+                break;
+            }
+        }
     }
 }
 
+fn send_mouse_input(mi: MOUSEINPUT) {
+    send_input_safe(INPUT {
+        r#type: INPUT_MOUSE,
+        Anonymous: INPUT_0 { mi },
+    });
+}
+
+fn send_keyboard_input(ki: KEYBDINPUT) {
+    send_input_safe(INPUT {
+        r#type: INPUT_KEYBOARD,
+        Anonymous: INPUT_0 { ki },
+    });
+}
 fn rel_mouse(dx: i32, dy: i32) {
     let mi = MOUSEINPUT {
         dx,
@@ -138,23 +144,32 @@ fn rel_mouse(dx: i32, dy: i32) {
 fn mouse_button(button: u32, state: u32) {
     let dw_flags = match state {
         0 => match button {
-            0x110 => MOUSEEVENTF_LEFTUP,
-            0x111 => MOUSEEVENTF_RIGHTUP,
-            0x112 => MOUSEEVENTF_MIDDLEUP,
+            BTN_LEFT => MOUSEEVENTF_LEFTUP,
+            BTN_RIGHT => MOUSEEVENTF_RIGHTUP,
+            BTN_MIDDLE => MOUSEEVENTF_MIDDLEUP,
+            BTN_BACK => MOUSEEVENTF_XUP,
+            BTN_FORWARD => MOUSEEVENTF_XUP,
             _ => return,
         },
         1 => match button {
-            0x110 => MOUSEEVENTF_LEFTDOWN,
-            0x111 => MOUSEEVENTF_RIGHTDOWN,
-            0x112 => MOUSEEVENTF_MIDDLEDOWN,
+            BTN_LEFT => MOUSEEVENTF_LEFTDOWN,
+            BTN_RIGHT => MOUSEEVENTF_RIGHTDOWN,
+            BTN_MIDDLE => MOUSEEVENTF_MIDDLEDOWN,
+            BTN_BACK => MOUSEEVENTF_XDOWN,
+            BTN_FORWARD => MOUSEEVENTF_XDOWN,
             _ => return,
         },
         _ => return,
     };
+    let mouse_data = match button {
+        BTN_BACK => XBUTTON1 as u32,
+        BTN_FORWARD => XBUTTON2 as u32,
+        _ => 0,
+    };
     let mi = MOUSEINPUT {
         dx: 0,
         dy: 0, // no movement
-        mouseData: 0,
+        mouseData: mouse_data,
         dwFlags: dw_flags,
         time: 0,
         dwExtraInfo: 0,
@@ -162,7 +177,7 @@ fn mouse_button(button: u32, state: u32) {
     send_mouse_input(mi);
 }
 
-fn scroll(axis: u8, value: f64) {
+fn scroll(axis: u8, value: i32) {
     let event_type = match axis {
         0 => MOUSEEVENTF_WHEEL,
         1 => MOUSEEVENTF_HWHEEL,
@@ -171,7 +186,7 @@ fn scroll(axis: u8, value: f64) {
     let mi = MOUSEINPUT {
         dx: 0,
         dy: 0,
-        mouseData: (-value * 15.0) as i32 as u32,
+        mouseData: -value as u32,
         dwFlags: event_type,
         time: 0,
         dwExtraInfo: 0,
@@ -186,33 +201,23 @@ fn key_event(key: u32, state: u8) {
     };
     let extended = scancode > 0xff;
     let scancode = scancode & 0xff;
+    let mut flags = KEYEVENTF_SCANCODE;
+    if extended {
+        flags.bitor_assign(KEYEVENTF_EXTENDEDKEY);
+    }
+    if state == 0 {
+        flags.bitor_assign(KEYEVENTF_KEYUP);
+    }
     let ki = KEYBDINPUT {
-        wVk: 0,
+        wVk: Default::default(),
         wScan: scancode,
-        dwFlags: KEYEVENTF_SCANCODE
-            | if extended { KEYEVENTF_EXTENDEDKEY } else { 0 }
-            | match state {
-                0 => KEYEVENTF_KEYUP,
-                1 => 0u32,
-                _ => return,
-            },
+        dwFlags: flags,
         time: 0,
         dwExtraInfo: 0,
     };
     send_keyboard_input(ki);
 }
 
-fn send_keyboard_input(ki: KEYBDINPUT) {
-    unsafe {
-        let mut input = INPUT {
-            type_: INPUT_KEYBOARD,
-            u: std::mem::zeroed(),
-        };
-        *input.u.ki_mut() = ki;
-        SendInput(1_u32, &mut input, std::mem::size_of::<INPUT>() as i32);
-    }
-}
-
 fn linux_keycode_to_windows_scancode(linux_keycode: u32) -> Option<u16> {
     let linux_scancode = match scancode::Linux::try_from(linux_keycode) {
         Ok(s) => s,

input-emulation/src/wlroots.rs

@@ -1,5 +1,6 @@
-use crate::client::{ClientEvent, ClientHandle};
-use crate::consumer::EventConsumer;
+use crate::error::EmulationError;
+
+use super::{error::WlrootsEmulationCreationError, Emulation};
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -7,7 +8,6 @@ use std::os::fd::{AsFd, OwnedFd};
 use wayland_client::backend::WaylandError;
 use wayland_client::WEnum;
 
-use anyhow::{anyhow, Result};
 use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
 use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
@@ -28,11 +28,14 @@ use wayland_client::{
     Connection, Dispatch, EventQueue, QueueHandle,
 };
 
-use crate::event::{Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};
+
+use super::error::WaylandBindError;
+use super::EmulationHandle;
 
 struct State {
     keymap: Option<(u32, OwnedFd, u32)>,
-    input_for_client: HashMap<ClientHandle, VirtualInput>,
+    input_for_client: HashMap<EmulationHandle, VirtualInput>,
     seat: wl_seat::WlSeat,
     qh: QueueHandle<Self>,
     vpm: VpManager,
@@ -40,29 +43,32 @@ struct State {
 }
 
 // App State, implements Dispatch event handlers
-pub(crate) struct WlrootsConsumer {
+pub(crate) struct WlrootsEmulation {
     last_flush_failed: bool,
     state: State,
     queue: EventQueue<State>,
 }
 
-impl WlrootsConsumer {
-    pub fn new() -> Result<Self> {
+impl WlrootsEmulation {
+    pub(crate) fn new() -> Result<Self, WlrootsEmulationCreationError> {
         let conn = Connection::connect_to_env()?;
         let (globals, queue) = registry_queue_init::<State>(&conn)?;
         let qh = queue.handle();
 
-        let seat: wl_seat::WlSeat = match globals.bind(&qh, 7..=8, ()) {
-            Ok(wl_seat) => wl_seat,
-            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
-        };
+        let seat: wl_seat::WlSeat = globals
+            .bind(&qh, 7..=8, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
 
-        let vpm: VpManager = globals.bind(&qh, 1..=1, ())?;
-        let vkm: VkManager = globals.bind(&qh, 1..=1, ())?;
+        let vpm: VpManager = globals
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "wlr-virtual-pointer-unstable-v1"))?;
+        let vkm: VkManager = globals
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "virtual-keyboard-unstable-v1"))?;
 
-        let input_for_client: HashMap<ClientHandle, VirtualInput> = HashMap::new();
+        let input_for_client: HashMap<EmulationHandle, VirtualInput> = HashMap::new();
 
-        let mut consumer = WlrootsConsumer {
+        let mut emulate = WlrootsEmulation {
             last_flush_failed: false,
             state: State {
                 keymap: None,
@@ -74,21 +80,18 @@ impl WlrootsConsumer {
             },
             queue,
         };
-        while consumer.state.keymap.is_none() {
-            consumer
-                .queue
-                .blocking_dispatch(&mut consumer.state)
-                .unwrap();
+        while emulate.state.keymap.is_none() {
+            emulate.queue.blocking_dispatch(&mut emulate.state)?;
         }
-        // let fd = unsafe { &File::from_raw_fd(consumer.state.keymap.unwrap().1.as_raw_fd()) };
+        // let fd = unsafe { &File::from_raw_fd(emulate.state.keymap.unwrap().1.as_raw_fd()) };
         // let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
         // log::debug!("{:?}", &mmap[..100]);
-        Ok(consumer)
+        Ok(emulate)
     }
 }
 
 impl State {
-    fn add_client(&mut self, client: ClientHandle) {
+    fn add_client(&mut self, client: EmulationHandle) {
         let pointer: Vp = self.vpm.create_virtual_pointer(None, &self.qh, ());
         let keyboard: Vk = self.vkm.create_virtual_keyboard(&self.seat, &self.qh, ());
 
@@ -103,56 +106,68 @@ impl State {
 
         self.input_for_client.insert(client, vinput);
     }
+
+    fn destroy_client(&mut self, handle: EmulationHandle) {
+        if let Some(input) = self.input_for_client.remove(&handle) {
+            input.pointer.destroy();
+            input.keyboard.destroy();
+        }
+    }
 }
 
 #[async_trait]
-impl EventConsumer for WlrootsConsumer {
-    async fn consume(&mut self, event: Event, client_handle: ClientHandle) {
-        if let Some(virtual_input) = self.state.input_for_client.get(&client_handle) {
+impl Emulation for WlrootsEmulation {
+    async fn consume(
+        &mut self,
+        event: Event,
+        handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
+        if let Some(virtual_input) = self.state.input_for_client.get(&handle) {
             if self.last_flush_failed {
-                if let Err(WaylandError::Io(e)) = self.queue.flush() {
-                    if e.kind() == io::ErrorKind::WouldBlock {
+                match self.queue.flush() {
+                    Err(WaylandError::Io(e)) if e.kind() == io::ErrorKind::WouldBlock => {
                         /*
                          * outgoing buffer is full - sending more events
                          * will overwhelm the output buffer and leave the
                          * wayland connection in a broken state
                          */
-                        log::warn!(
-                            "can't keep up, discarding event: ({client_handle}) - {event:?}"
-                        );
-                        return;
+                        log::warn!("can't keep up, discarding event: ({handle}) - {event:?}");
+                        return Ok(());
                     }
+                    _ => {}
                 }
             }
-            virtual_input.consume_event(event).unwrap();
+            virtual_input
+                .consume_event(event)
+                .unwrap_or_else(|_| panic!("failed to convert event: {event:?}"));
             match self.queue.flush() {
                 Err(WaylandError::Io(e)) if e.kind() == io::ErrorKind::WouldBlock => {
                     self.last_flush_failed = true;
-                    log::warn!("can't keep up, retrying ...");
-                }
-                Err(WaylandError::Io(e)) => {
-                    log::error!("{e}")
-                }
-                Err(WaylandError::Protocol(e)) => {
-                    panic!("wayland protocol violation: {e}")
-                }
-                Ok(()) => {
-                    self.last_flush_failed = false;
+                    log::warn!("can't keep up, discarding event: ({handle}) - {event:?}");
                 }
+                Err(WaylandError::Protocol(e)) => panic!("wayland protocol violation: {e}"),
+                Ok(()) => self.last_flush_failed = false,
+                Err(e) => Err(e)?,
             }
         }
+        Ok(())
     }
 
-    async fn notify(&mut self, client_event: ClientEvent) {
-        if let ClientEvent::Create(client, _) = client_event {
-            self.state.add_client(client);
-            if let Err(e) = self.queue.flush() {
-                log::error!("{}", e);
-            }
+    async fn create(&mut self, handle: EmulationHandle) {
+        self.state.add_client(handle);
+        if let Err(e) = self.queue.flush() {
+            log::error!("{}", e);
         }
     }
-
-    async fn destroy(&mut self) {}
+    async fn destroy(&mut self, handle: EmulationHandle) {
+        self.state.destroy_client(handle);
+        if let Err(e) = self.queue.flush() {
+            log::error!("{}", e);
+        }
+    }
+    async fn terminate(&mut self) {
+        /* nothing to do */
+    }
 }
 
 struct VirtualInput {
@@ -165,11 +180,7 @@ impl VirtualInput {
         match event {
             Event::Pointer(e) => {
                 match e {
-                    PointerEvent::Motion {
-                        time,
-                        relative_x,
-                        relative_y,
-                    } => self.pointer.motion(time, relative_x, relative_y),
+                    PointerEvent::Motion { time, dx, dy } => self.pointer.motion(time, dx, dy),
                     PointerEvent::Button {
                         time,
                         button,
@@ -183,6 +194,12 @@ impl VirtualInput {
                         self.pointer.axis(time, axis, value);
                         self.pointer.frame();
                     }
+                    PointerEvent::AxisDiscrete120 { axis, value } => {
+                        let axis: Axis = (axis as u32).try_into()?;
+                        self.pointer
+                            .axis_discrete(0, axis, value as f64 / 6., value / 120);
+                        self.pointer.frame();
+                    }
                     PointerEvent::Frame {} => self.pointer.frame(),
                 }
                 self.pointer.frame();

input-emulation/src/x11.rs

@@ -1,4 +1,3 @@
-use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use std::ptr;
 use x11::{
@@ -6,26 +5,26 @@ use x11::{
     xtest,
 };
 
-use crate::{
-    client::ClientHandle,
-    consumer::EventConsumer,
-    event::{
-        Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
-    },
+use input_event::{
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
 
-pub struct X11Consumer {
+use crate::error::EmulationError;
+
+use super::{error::X11EmulationCreationError, Emulation, EmulationHandle};
+
+pub(crate) struct X11Emulation {
     display: *mut xlib::Display,
 }
 
-unsafe impl Send for X11Consumer {}
+unsafe impl Send for X11Emulation {}
 
-impl X11Consumer {
-    pub fn new() -> Result<Self> {
+impl X11Emulation {
+    pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
         let display = unsafe {
             match xlib::XOpenDisplay(ptr::null()) {
                 d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
-                    Err(anyhow!("could not open display"))
+                    Err(X11EmulationCreationError::OpenDisplay)
                 }
                 display => Ok(display),
             }
@@ -91,7 +90,7 @@ impl X11Consumer {
     }
 }
 
-impl Drop for X11Consumer {
+impl Drop for X11Emulation {
     fn drop(&mut self) {
         unsafe {
             XCloseDisplay(self.display);
@@ -100,16 +99,12 @@ impl Drop for X11Consumer {
 }
 
 #[async_trait]
-impl EventConsumer for X11Consumer {
-    async fn consume(&mut self, event: Event, _: ClientHandle) {
+impl Emulation for X11Emulation {
+    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion {
-                    time: _,
-                    relative_x,
-                    relative_y,
-                } => {
-                    self.relative_motion(relative_x as i32, relative_y as i32);
+                PointerEvent::Motion { time: _, dx, dy } => {
+                    self.relative_motion(dx as i32, dy as i32);
                 }
                 PointerEvent::Button {
                     time: _,
@@ -125,6 +120,9 @@ impl EventConsumer for X11Consumer {
                 } => {
                     self.emulate_scroll(axis, value);
                 }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    self.emulate_scroll(axis, value as f64);
+                }
                 PointerEvent::Frame {} => {}
             },
             Event::Keyboard(KeyboardEvent::Key {
@@ -139,11 +137,19 @@ impl EventConsumer for X11Consumer {
         unsafe {
             xlib::XFlush(self.display);
         }
+        // FIXME
+        Ok(())
     }
 
-    async fn notify(&mut self, _: crate::client::ClientEvent) {
+    async fn create(&mut self, _: EmulationHandle) {
         // for our purposes it does not matter what client sent the event
     }
 
-    async fn destroy(&mut self) {}
+    async fn destroy(&mut self, _: EmulationHandle) {
+        // for our purposes it does not matter what client sent the event
+    }
+
+    async fn terminate(&mut self) {
+        /* nothing to do */
+    }
 }

input-emulation/src/xdg_desktop_portal.rs

@@ -0,0 +1,167 @@
+use ashpd::{
+    desktop::{
+        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
+        PersistMode, Session,
+    },
+    zbus::AsyncDrop,
+    WindowIdentifier,
+};
+use async_trait::async_trait;
+
+use futures::FutureExt;
+use input_event::{
+    Event::{Keyboard, Pointer},
+    KeyboardEvent, PointerEvent,
+};
+
+use crate::error::EmulationError;
+
+use super::{error::XdpEmulationCreationError, Emulation, EmulationHandle};
+
+pub(crate) struct DesktopPortalEmulation<'a> {
+    proxy: RemoteDesktop<'a>,
+    session: Session<'a, RemoteDesktop<'a>>,
+}
+
+impl<'a> DesktopPortalEmulation<'a> {
+    pub(crate) async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
+        log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
+        let proxy = RemoteDesktop::new().await?;
+
+        // retry when user presses the cancel button
+        log::debug!("creating session ...");
+        let session = proxy.create_session().await?;
+
+        log::debug!("selecting devices ...");
+        proxy
+            .select_devices(
+                &session,
+                DeviceType::Keyboard | DeviceType::Pointer,
+                None,
+                PersistMode::ExplicitlyRevoked,
+            )
+            .await?;
+
+        log::info!("requesting permission for input emulation");
+        let _devices = proxy
+            .start(&session, &WindowIdentifier::default())
+            .await?
+            .response()?;
+
+        log::debug!("started session");
+        let session = session;
+
+        Ok(Self { proxy, session })
+    }
+}
+
+#[async_trait]
+impl<'a> Emulation for DesktopPortalEmulation<'a> {
+    async fn consume(
+        &mut self,
+        event: input_event::Event,
+        _client: EmulationHandle,
+    ) -> Result<(), EmulationError> {
+        match event {
+            Pointer(p) => match p {
+                PointerEvent::Motion { time: _, dx, dy } => {
+                    self.proxy
+                        .notify_pointer_motion(&self.session, dx, dy)
+                        .await?;
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    let state = match state {
+                        0 => KeyState::Released,
+                        _ => KeyState::Pressed,
+                    };
+                    self.proxy
+                        .notify_pointer_button(&self.session, button as i32, state)
+                        .await?;
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    let axis = match axis {
+                        0 => Axis::Vertical,
+                        _ => Axis::Horizontal,
+                    };
+                    self.proxy
+                        .notify_pointer_axis_discrete(&self.session, axis, value / 120)
+                        .await?;
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    let axis = match axis {
+                        0 => Axis::Vertical,
+                        _ => Axis::Horizontal,
+                    };
+                    let (dx, dy) = match axis {
+                        Axis::Vertical => (0., value),
+                        Axis::Horizontal => (value, 0.),
+                    };
+                    self.proxy
+                        .notify_pointer_axis(&self.session, dx, dy, true)
+                        .await?;
+                }
+                PointerEvent::Frame {} => {}
+            },
+            Keyboard(k) => {
+                match k {
+                    KeyboardEvent::Key {
+                        time: _,
+                        key,
+                        state,
+                    } => {
+                        let state = match state {
+                            0 => KeyState::Released,
+                            _ => KeyState::Pressed,
+                        };
+                        self.proxy
+                            .notify_keyboard_keycode(&self.session, key as i32, state)
+                            .await?;
+                    }
+                    KeyboardEvent::Modifiers { .. } => {
+                        // ignore
+                    }
+                }
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    async fn create(&mut self, _client: EmulationHandle) {}
+    async fn destroy(&mut self, _client: EmulationHandle) {}
+    async fn terminate(&mut self) {
+        if let Err(e) = self.session.close().await {
+            log::warn!("session.close(): {e}");
+        };
+        if let Err(e) = self.session.receive_closed().await {
+            log::warn!("session.receive_closed(): {e}");
+        };
+    }
+}
+
+impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {
+    #[doc = r" Perform the async cleanup."]
+    #[must_use]
+    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
+    fn async_drop<'async_trait>(
+        self,
+    ) -> ::core::pin::Pin<
+        Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Send + 'async_trait>,
+    >
+    where
+        Self: 'async_trait,
+    {
+        async move {
+            let _ = self.session.close().await;
+        }
+        .boxed()
+    }
+}

input-event/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "input-event"
+description = "cross-platform input-event types for input-capture / input-emulation"
+version = "0.2.1"
+edition = "2021"
+license = "GPL-3.0-or-later"
+repository = "https://github.com/feschber/lan-mouse"
+
+[dependencies]
+futures-core = "0.3.30"
+log = "0.4.22"
+num_enum = "0.7.2"
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "1.0.61"
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+reis = { version = "0.2.0", optional = true }
+
+[features]
+default = ["libei"]
+libei = ["dep:reis"]

input-event/src/error.rs

@@ -0,0 +1,17 @@
+use std::array::TryFromSliceError;
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum ProtocolError {
+    #[error(transparent)]
+    MissingData(#[from] TryFromSliceError),
+    #[error("invalid event id: `{0}`")]
+    InvalidEventId(u8),
+    #[error("invalid pointer event type: `{0}`")]
+    InvalidPointerEventId(u8),
+    #[error("invalid keyboard event type: `{0}`")]
+    InvalidKeyboardEventId(u8),
+    #[error("expected data at idx `{0:?}`")]
+    Data(String),
+}

input-event/src/lib.rs

@@ -0,0 +1,146 @@
+pub use error::ProtocolError;
+use std::fmt::{self, Display};
+
+pub mod error;
+pub mod proto;
+pub mod scancode;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+mod libei;
+
+// FIXME
+pub const BTN_LEFT: u32 = 0x110;
+pub const BTN_RIGHT: u32 = 0x111;
+pub const BTN_MIDDLE: u32 = 0x112;
+pub const BTN_BACK: u32 = 0x113;
+pub const BTN_FORWARD: u32 = 0x114;
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum PointerEvent {
+    /// relative motion event
+    Motion { time: u32, dx: f64, dy: f64 },
+    /// mouse button event
+    Button { time: u32, button: u32, state: u32 },
+    /// axis event, scroll event for touchpads
+    Axis { time: u32, axis: u8, value: f64 },
+    /// discrete axis event, scroll event for mice - 120 = one scroll tick
+    AxisDiscrete120 { axis: u8, value: i32 },
+    /// frame event
+    Frame {},
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum KeyboardEvent {
+    /// a key press / release event
+    Key { time: u32, key: u32, state: u8 },
+    /// modifiers changed state
+    Modifiers {
+        mods_depressed: u32,
+        mods_latched: u32,
+        mods_locked: u32,
+        group: u32,
+    },
+}
+
+#[derive(PartialEq, Debug, Clone, Copy)]
+pub enum Event {
+    /// pointer event (motion / button / axis)
+    Pointer(PointerEvent),
+    /// keyboard events (key / modifiers)
+    Keyboard(KeyboardEvent),
+    /// enter event: request to enter a client.
+    /// The client must release the pointer if it is grabbed
+    /// and reply with a leave event, as soon as its ready to
+    /// receive events
+    Enter(),
+    /// leave event: this client is now ready to receive events and will
+    /// not send any events after until it sends an enter event
+    Leave(),
+    /// ping a client, to see if it is still alive. A client that does
+    /// not respond with a pong event will be assumed to be offline.
+    Ping(),
+    /// 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 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            PointerEvent::Motion { time: _, dx, dy } => write!(f, "motion({dx},{dy})"),
+            PointerEvent::Button {
+                time: _,
+                button,
+                state,
+            } => {
+                let str = match *button {
+                    BTN_LEFT => Some("left"),
+                    BTN_RIGHT => Some("right"),
+                    BTN_MIDDLE => Some("middle"),
+                    BTN_FORWARD => Some("forward"),
+                    BTN_BACK => Some("back"),
+                    _ => None,
+                };
+                if let Some(button) = str {
+                    write!(f, "button({button}, {state})")
+                } else {
+                    write!(f, "button({button}, {state}")
+                }
+            }
+            PointerEvent::Axis {
+                time: _,
+                axis,
+                value,
+            } => write!(f, "scroll({axis}, {value})"),
+            PointerEvent::AxisDiscrete120 { axis, value } => {
+                write!(f, "scroll-120 ({axis}, {value})")
+            }
+            PointerEvent::Frame {} => write!(f, "frame()"),
+        }
+    }
+}
+
+impl Display for KeyboardEvent {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            KeyboardEvent::Key {
+                time: _,
+                key,
+                state,
+            } => {
+                let scan = scancode::Linux::try_from(*key);
+                if let Ok(scan) = scan {
+                    write!(f, "key({scan:?}, {state})")
+                } else {
+                    write!(f, "key({key}, {state})")
+                }
+            }
+            KeyboardEvent::Modifiers {
+                mods_depressed,
+                mods_latched,
+                mods_locked,
+                group,
+            } => write!(
+                f,
+                "modifiers({mods_depressed},{mods_latched},{mods_locked},{group})"
+            ),
+        }
+    }
+}
+
+impl Display for Event {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Event::Pointer(p) => write!(f, "{}", p),
+            Event::Keyboard(k) => write!(f, "{}", k),
+            Event::Enter() => write!(f, "enter"),
+            Event::Leave() => write!(f, "leave"),
+            Event::Ping() => write!(f, "ping"),
+            Event::Pong() => write!(f, "pong"),
+            Event::Disconnect() => write!(f, "disconnect"),
+        }
+    }
+}

input-event/src/libei.rs

@@ -0,0 +1,146 @@
+use reis::{
+    ei::{button::ButtonState, keyboard::KeyState},
+    event::EiEvent,
+};
+
+use crate::{Event, KeyboardEvent, PointerEvent};
+
+impl Event {
+    pub fn from_ei_event(ei_event: EiEvent) -> impl Iterator<Item = Self> {
+        to_input_events(ei_event).into_iter()
+    }
+}
+
+enum Events {
+    None,
+    One(Event),
+    Two(Event, Event),
+}
+
+impl Events {
+    fn into_iter(self) -> impl Iterator<Item = Event> {
+        EventIterator::new(self)
+    }
+}
+
+struct EventIterator {
+    events: [Option<Event>; 2],
+    pos: usize,
+}
+
+impl EventIterator {
+    fn new(events: Events) -> Self {
+        let events = match events {
+            Events::None => [None, None],
+            Events::One(e) => [Some(e), None],
+            Events::Two(e, f) => [Some(e), Some(f)],
+        };
+        Self { events, pos: 0 }
+    }
+}
+
+impl Iterator for EventIterator {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let res = if self.pos >= self.events.len() {
+            None
+        } else {
+            self.events[self.pos]
+        };
+        self.pos += 1;
+        res
+    }
+}
+
+fn to_input_events(ei_event: EiEvent) -> Events {
+    match ei_event {
+        EiEvent::KeyboardModifiers(mods) => {
+            let modifier_event = KeyboardEvent::Modifiers {
+                mods_depressed: mods.depressed,
+                mods_latched: mods.latched,
+                mods_locked: mods.locked,
+                group: mods.group,
+            };
+            Events::One(Event::Keyboard(modifier_event))
+        }
+        EiEvent::Frame(_) => Events::None, /* FIXME */
+        EiEvent::PointerMotion(motion) => {
+            let motion_event = PointerEvent::Motion {
+                time: motion.time as u32,
+                dx: motion.dx as f64,
+                dy: motion.dy as f64,
+            };
+            Events::One(Event::Pointer(motion_event))
+        }
+        EiEvent::PointerMotionAbsolute(_) => Events::None,
+        EiEvent::Button(button) => {
+            let button_event = PointerEvent::Button {
+                time: button.time as u32,
+                button: button.button,
+                state: match button.state {
+                    ButtonState::Released => 0,
+                    ButtonState::Press => 1,
+                },
+            };
+            Events::One(Event::Pointer(button_event))
+        }
+        EiEvent::ScrollDelta(delta) => {
+            let dy = Event::Pointer(PointerEvent::Axis {
+                time: 0,
+                axis: 0,
+                value: delta.dy as f64,
+            });
+            let dx = Event::Pointer(PointerEvent::Axis {
+                time: 0,
+                axis: 1,
+                value: delta.dx as f64,
+            });
+            if delta.dy != 0. && delta.dx != 0. {
+                Events::Two(dy, dx)
+            } else if delta.dy != 0. {
+                Events::One(dy)
+            } else if delta.dx != 0. {
+                Events::One(dx)
+            } else {
+                Events::None
+            }
+        }
+        EiEvent::ScrollStop(_) => Events::None,   /* TODO */
+        EiEvent::ScrollCancel(_) => Events::None, /* TODO */
+        EiEvent::ScrollDiscrete(scroll) => {
+            let dy = Event::Pointer(PointerEvent::AxisDiscrete120 {
+                axis: 0,
+                value: scroll.discrete_dy,
+            });
+            let dx = Event::Pointer(PointerEvent::AxisDiscrete120 {
+                axis: 1,
+                value: scroll.discrete_dx,
+            });
+            if scroll.discrete_dy != 0 && scroll.discrete_dx != 0 {
+                Events::Two(dy, dx)
+            } else if scroll.discrete_dy != 0 {
+                Events::One(dy)
+            } else if scroll.discrete_dx != 0 {
+                Events::One(dx)
+            } else {
+                Events::None
+            }
+        }
+        EiEvent::KeyboardKey(key) => {
+            let key_event = KeyboardEvent::Key {
+                key: key.key,
+                state: match key.state {
+                    KeyState::Press => 1,
+                    KeyState::Released => 0,
+                },
+                time: key.time as u32,
+            };
+            Events::One(Event::Keyboard(key_event))
+        }
+        EiEvent::TouchDown(_) => Events::None,   /* TODO */
+        EiEvent::TouchUp(_) => Events::None,     /* TODO */
+        EiEvent::TouchMotion(_) => Events::None, /* TODO */
+        _ => Events::None,
+    }
+}

input-event/src/proto.rs

@@ -0,0 +1,307 @@
+use std::{fmt::Debug, slice::SliceIndex};
+
+use crate::ProtocolError;
+
+use super::{Event, KeyboardEvent, PointerEvent};
+
+enum PointerEventType {
+    Motion,
+    Button,
+    Axis,
+    AxisDiscrete120,
+    Frame,
+}
+
+enum KeyboardEventType {
+    Key,
+    Modifiers,
+}
+
+enum EventType {
+    Pointer,
+    Keyboard,
+    Enter,
+    Leave,
+    Ping,
+    Pong,
+    Disconnect,
+}
+
+impl Event {
+    fn event_type(&self) -> EventType {
+        match self {
+            Self::Pointer(_) => EventType::Pointer,
+            Self::Keyboard(_) => EventType::Keyboard,
+            Self::Enter() => EventType::Enter,
+            Self::Leave() => EventType::Leave,
+            Self::Ping() => EventType::Ping,
+            Self::Pong() => EventType::Pong,
+            Self::Disconnect() => EventType::Disconnect,
+        }
+    }
+}
+
+impl PointerEvent {
+    fn event_type(&self) -> PointerEventType {
+        match self {
+            Self::Motion { .. } => PointerEventType::Motion,
+            Self::Button { .. } => PointerEventType::Button,
+            Self::Axis { .. } => PointerEventType::Axis,
+            Self::AxisDiscrete120 { .. } => PointerEventType::AxisDiscrete120,
+            Self::Frame { .. } => PointerEventType::Frame,
+        }
+    }
+}
+
+impl KeyboardEvent {
+    fn event_type(&self) -> KeyboardEventType {
+        match self {
+            KeyboardEvent::Key { .. } => KeyboardEventType::Key,
+            KeyboardEvent::Modifiers { .. } => KeyboardEventType::Modifiers,
+        }
+    }
+}
+
+impl TryFrom<u8> for PointerEventType {
+    type Error = ProtocolError;
+
+    fn try_from(value: u8) -> Result<Self, ProtocolError> {
+        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::AxisDiscrete120 as u8 => Ok(Self::AxisDiscrete120),
+            x if x == Self::Frame as u8 => Ok(Self::Frame),
+            _ => Err(ProtocolError::InvalidPointerEventId(value)),
+        }
+    }
+}
+
+impl TryFrom<u8> for KeyboardEventType {
+    type Error = ProtocolError;
+
+    fn try_from(value: u8) -> Result<Self, ProtocolError> {
+        match value {
+            x if x == Self::Key as u8 => Ok(Self::Key),
+            x if x == Self::Modifiers as u8 => Ok(Self::Modifiers),
+            _ => Err(ProtocolError::InvalidKeyboardEventId(value)),
+        }
+    }
+}
+
+impl From<&Event> for Vec<u8> {
+    fn from(event: &Event) -> Self {
+        let event_id = vec![event.event_type() as u8];
+        let event_data = match event {
+            Event::Pointer(p) => p.into(),
+            Event::Keyboard(k) => k.into(),
+            Event::Enter() => vec![],
+            Event::Leave() => vec![],
+            Event::Ping() => vec![],
+            Event::Pong() => vec![],
+            Event::Disconnect() => vec![],
+        };
+        [event_id, event_data].concat()
+    }
+}
+
+impl TryFrom<Vec<u8>> for Event {
+    type Error = ProtocolError;
+
+    fn try_from(value: Vec<u8>) -> Result<Self, ProtocolError> {
+        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()?)),
+            i if i == (EventType::Keyboard as u8) => Ok(Event::Keyboard(value.try_into()?)),
+            i if i == (EventType::Enter as u8) => Ok(Event::Enter()),
+            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()),
+            i if i == (EventType::Disconnect as u8) => Ok(Event::Disconnect()),
+            _ => Err(ProtocolError::InvalidEventId(event_id)),
+        }
+    }
+}
+
+impl From<&PointerEvent> for Vec<u8> {
+    fn from(event: &PointerEvent) -> Self {
+        let id = vec![event.event_type() as u8];
+        let data = match event {
+            PointerEvent::Motion { time, dx, dy } => {
+                let time = time.to_be_bytes();
+                let dx = dx.to_be_bytes();
+                let dy = dy.to_be_bytes();
+                [&time[..], &dx[..], &dy[..]].concat()
+            }
+            PointerEvent::Button {
+                time,
+                button,
+                state,
+            } => {
+                let time = time.to_be_bytes();
+                let button = button.to_be_bytes();
+                let state = state.to_be_bytes();
+                [&time[..], &button[..], &state[..]].concat()
+            }
+            PointerEvent::Axis { time, axis, value } => {
+                let time = time.to_be_bytes();
+                let axis = axis.to_be_bytes();
+                let value = value.to_be_bytes();
+                [&time[..], &axis[..], &value[..]].concat()
+            }
+            PointerEvent::AxisDiscrete120 { axis, value } => {
+                let axis = axis.to_be_bytes();
+                let value = value.to_be_bytes();
+                [&axis[..], &value[..]].concat()
+            }
+            PointerEvent::Frame {} => {
+                vec![]
+            }
+        };
+        [id, data].concat()
+    }
+}
+
+fn decode_u8<I>(data: &[u8], idx: I) -> Result<u8, ProtocolError>
+where
+    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
+{
+    let data = data
+        .get(idx.clone())
+        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
+    Ok(u8::from_be_bytes(data.try_into()?))
+}
+
+fn decode_u32<I>(data: &[u8], idx: I) -> Result<u32, ProtocolError>
+where
+    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
+{
+    let data = data
+        .get(idx.clone())
+        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
+    Ok(u32::from_be_bytes(data.try_into()?))
+}
+
+fn decode_i32<I>(data: &[u8], idx: I) -> Result<i32, ProtocolError>
+where
+    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
+{
+    let data = data
+        .get(idx.clone())
+        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
+    Ok(i32::from_be_bytes(data.try_into()?))
+}
+fn decode_f64<I>(data: &[u8], idx: I) -> Result<f64, ProtocolError>
+where
+    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
+{
+    let data = data
+        .get(idx.clone())
+        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
+    Ok(f64::from_be_bytes(data.try_into()?))
+}
+
+impl TryFrom<Vec<u8>> for PointerEvent {
+    type Error = ProtocolError;
+
+    fn try_from(data: Vec<u8>) -> Result<Self, ProtocolError> {
+        match data.get(1) {
+            Some(id) => match id.to_owned().try_into()? {
+                PointerEventType::Motion => {
+                    let time = decode_u32(&data, 2..6)?;
+                    let dx = decode_f64(&data, 6..14)?;
+                    let dy = decode_f64(&data, 14..22)?;
+
+                    Ok(Self::Motion { time, dx, dy })
+                }
+                PointerEventType::Button => {
+                    let time = decode_u32(&data, 2..6)?;
+                    let button = decode_u32(&data, 6..10)?;
+                    let state = decode_u32(&data, 10..14)?;
+
+                    Ok(Self::Button {
+                        time,
+                        button,
+                        state,
+                    })
+                }
+                PointerEventType::Axis => {
+                    let time = decode_u32(&data, 2..6)?;
+                    let axis = decode_u8(&data, 6..7)?;
+                    let value = decode_f64(&data, 7..15)?;
+                    Ok(Self::Axis { time, axis, value })
+                }
+                PointerEventType::AxisDiscrete120 => {
+                    let axis = decode_u8(&data, 2..3)?;
+                    let value = decode_i32(&data, 3..7)?;
+                    Ok(Self::AxisDiscrete120 { axis, value })
+                }
+                PointerEventType::Frame => Ok(Self::Frame {}),
+            },
+            None => Err(ProtocolError::Data("0".to_string())),
+        }
+    }
+}
+
+impl From<&KeyboardEvent> for Vec<u8> {
+    fn from(event: &KeyboardEvent) -> Self {
+        let id = vec![event.event_type() as u8];
+        let data = match event {
+            KeyboardEvent::Key { time, key, state } => {
+                let time = time.to_be_bytes();
+                let key = key.to_be_bytes();
+                let state = state.to_be_bytes();
+                [&time[..], &key[..], &state[..]].concat()
+            }
+            KeyboardEvent::Modifiers {
+                mods_depressed,
+                mods_latched,
+                mods_locked,
+                group,
+            } => {
+                let mods_depressed = mods_depressed.to_be_bytes();
+                let mods_latched = mods_latched.to_be_bytes();
+                let mods_locked = mods_locked.to_be_bytes();
+                let group = group.to_be_bytes();
+                [
+                    &mods_depressed[..],
+                    &mods_latched[..],
+                    &mods_locked[..],
+                    &group[..],
+                ]
+                .concat()
+            }
+        };
+        [id, data].concat()
+    }
+}
+
+impl TryFrom<Vec<u8>> for KeyboardEvent {
+    type Error = ProtocolError;
+
+    fn try_from(data: Vec<u8>) -> Result<Self, ProtocolError> {
+        match data.get(1) {
+            Some(id) => match id.to_owned().try_into()? {
+                KeyboardEventType::Key => {
+                    let time = decode_u32(&data, 2..6)?;
+                    let key = decode_u32(&data, 6..10)?;
+                    let state = decode_u8(&data, 10..11)?;
+                    Ok(KeyboardEvent::Key { time, key, state })
+                }
+                KeyboardEventType::Modifiers => {
+                    let mods_depressed = decode_u32(&data, 2..6)?;
+                    let mods_latched = decode_u32(&data, 6..10)?;
+                    let mods_locked = decode_u32(&data, 10..14)?;
+                    let group = decode_u32(&data, 14..18)?;
+                    Ok(KeyboardEvent::Modifiers {
+                        mods_depressed,
+                        mods_latched,
+                        mods_locked,
+                        group,
+                    })
+                }
+            },
+            None => Err(ProtocolError::Data("0".to_string())),
+        }
+    }
+}

input-event/src/scancode.rs

@@ -1,10 +1,13 @@
+use num_enum::TryFromPrimitive;
 use serde::{Deserialize, Serialize};
 
 /*
  * https://learn.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input
+ * https://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf
+ * https://kbd-project.org/docs/scancodes/scancodes-1.html
  */
 #[repr(u32)]
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, TryFromPrimitive)]
 pub enum Windows {
     Shutdown = 0xE05E,
     SystemSleep = 0xE05F,
@@ -119,15 +122,15 @@ pub enum Windows {
     KeyF21 = 0x006C,
     KeyF22 = 0x006D,
     KeyF23 = 0x006E,
-    KeyF24 = 0x0076,
+    KeyF24 = 0x0076, // KeyLANG5
     KeypadComma = 0x007E,
     KeyInternational1 = 0x0073,
     KeyInternational2 = 0x0070,
-    KeyInternational3 = 0x007D,
+    KeyInternational3 = 0x007D, // typo in doc -> its Int'l 3 not Int'l 2
     #[allow(dead_code)]
-    KeyInternational4 = 0x0079, // FIXME unused
+    KeyInternational4 = 0x0079,
     #[allow(dead_code)]
-    KeyInternational5 = 0x007B, // FIXME unused
+    KeyInternational5 = 0x007B,
     // KeyInternational6 = 0x005C,
     KeyLANG1 = 0x0072,
     KeyLANG2 = 0x0071,
@@ -140,6 +143,7 @@ pub enum Windows {
     KeyLeftGUI = 0xE05B,
     KeyRightCtrl = 0xE01D,
     KeyRightShift = 0x0036,
+    KeyFakeRightShift = 0xE036,
     KeyRightAlt = 0xE038,
     KeyRightGUI = 0xE05C,
     KeyScanNextTrack = 0xE019,
@@ -167,7 +171,7 @@ pub enum Windows {
  * https://github.com/torvalds/linux/blob/master/include/uapi/linux/input-event-codes.h
  */
 #[repr(u32)]
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq, Hash, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq, Hash, PartialEq, TryFromPrimitive)]
 #[allow(dead_code)]
 pub enum Linux {
     KeyReserved = 0,
@@ -292,7 +296,7 @@ pub enum Linux {
     KeyPause = 119,
     KeyScale = 120, /* AL Compiz Scale (Expose) */
     KeyKpcomma = 121,
-    KeyHangeul = 122,
+    KeyHanguel = 122,
     // KEY_HANGUEL = KeyHangeul,
     KeyHanja = 123,
     KeyYen = 124,
@@ -428,18 +432,6 @@ pub enum Linux {
     KeyCount = 249,
 }
 
-impl TryFrom<u32> for Linux {
-    type Error = ();
-
-    fn try_from(value: u32) -> Result<Self, Self::Error> {
-        if value >= Self::KeyCount as u32 {
-            return Err(());
-        }
-        let code: Linux = unsafe { std::mem::transmute(value) };
-        Ok(code)
-    }
-}
-
 impl TryFrom<Linux> for Windows {
     type Error = ();
 
@@ -529,16 +521,16 @@ impl TryFrom<Linux> for Windows {
             Linux::KeyKp3 => Ok(Self::Keypad3PageDn),
             Linux::KeyKp0 => Ok(Self::Keypad0Insert),
             Linux::KeyKpDot => Ok(Self::KeypadDot),
-            Linux::KeyZenkakuhankaku => Ok(Self::KeyLANG1), // TODO unsure
-            Linux::Key102nd => Ok(Self::KeyNonUSSlashBar),  // TODO unsure
+            Linux::KeyZenkakuhankaku => Ok(Self::KeyF24), // KeyLANG5
+            Linux::Key102nd => Ok(Self::KeyNonUSSlashBar), // TODO unsure
             Linux::KeyF11 => Ok(Self::KeyF11),
             Linux::KeyF12 => Ok(Self::KeyF12),
-            Linux::KeyRo => Ok(Self::ErrorRollOver), // TODO unsure
-            Linux::KeyKatakana => Ok(Self::KeyLANG1), // TODO unsure
-            Linux::KeyHiragana => Ok(Self::KeyLANG2), // TODO unsure
-            Linux::KeyHenkan => Ok(Self::KeyLANG3),  // TODO unsure
-            Linux::KeyKatakanahiragana => Ok(Self::KeyLANG4), // TODO unsure
-            Linux::KeyMuhenkan => Ok(Self::KeyLANG4), // TODO unsure
+            Linux::KeyRo => Ok(Self::KeyInternational1),
+            Linux::KeyKatakana => Ok(Self::KeyLANG3),
+            Linux::KeyHiragana => Ok(Self::KeyLANG4),
+            Linux::KeyHenkan => Ok(Self::KeyInternational4),
+            Linux::KeyKatakanahiragana => Ok(Self::KeyInternational2),
+            Linux::KeyMuhenkan => Ok(Self::KeyInternational5),
             Linux::KeyKpJpComma => Ok(Self::KeypadComma),
             Linux::KeyKpEnter => Ok(Self::KeypadEnter),
             Linux::KeyRightCtrl => Ok(Self::KeyRightCtrl),
@@ -566,9 +558,9 @@ impl TryFrom<Linux> for Windows {
             Linux::KeyPause => Ok(Self::KeyPause),
             Linux::KeyScale => Err(()), // TODO
             Linux::KeyKpcomma => Ok(Self::KeypadComma),
-            Linux::KeyHangeul => Ok(Self::KeyInternational1), // TODO unsure
-            Linux::KeyHanja => Ok(Self::KeyInternational2),   // TODO unsure
-            Linux::KeyYen => Ok(Self::KeyInternational3),     // TODO unsure
+            Linux::KeyHanguel => Ok(Self::KeyLANG1), // FIXME should be 00F2?
+            Linux::KeyHanja => Ok(Self::KeyLANG2),   // FIXME should be 00F1?
+            Linux::KeyYen => Ok(Self::KeyInternational3),
             Linux::KeyLeftMeta => Ok(Self::KeyLeftGUI),
             Linux::KeyRightmeta => Ok(Self::KeyRightGUI),
             Linux::KeyCompose => Ok(Self::KeyApplication),
@@ -698,3 +690,162 @@ impl TryFrom<Linux> for Windows {
         }
     }
 }
+impl TryFrom<Windows> for Linux {
+    type Error = ();
+
+    fn try_from(value: Windows) -> Result<Self, Self::Error> {
+        match value {
+            Windows::Shutdown => Ok(Self::KeyPower),
+            Windows::SystemSleep => Ok(Self::KeySleep),
+            Windows::SystemWakeUp => Ok(Self::KeyWakeup),
+            Windows::ErrorRollOver => Ok(Self::KeyRo),
+            Windows::KeyA => Ok(Self::KeyA),
+            Windows::KeyB => Ok(Self::KeyB),
+            Windows::KeyC => Ok(Self::KeyC),
+            Windows::KeyD => Ok(Self::KeyD),
+            Windows::KeyE => Ok(Self::KeyE),
+            Windows::KeyF => Ok(Self::KeyF),
+            Windows::KeyG => Ok(Self::KeyG),
+            Windows::KeyH => Ok(Self::KeyH),
+            Windows::KeyI => Ok(Self::KeyI),
+            Windows::KeyJ => Ok(Self::KeyJ),
+            Windows::KeyK => Ok(Self::KeyK),
+            Windows::KeyL => Ok(Self::KeyL),
+            Windows::KeyM => Ok(Self::KeyM),
+            Windows::KeyN => Ok(Self::KeyN),
+            Windows::KeyO => Ok(Self::KeyO),
+            Windows::KeyP => Ok(Self::KeyP),
+            Windows::KeyQ => Ok(Self::KeyQ),
+            Windows::KeyR => Ok(Self::KeyR),
+            Windows::KeyS => Ok(Self::KeyS),
+            Windows::KeyT => Ok(Self::KeyT),
+            Windows::KeyU => Ok(Self::KeyU),
+            Windows::KeyV => Ok(Self::KeyV),
+            Windows::KeyW => Ok(Self::KeyW),
+            Windows::KeyX => Ok(Self::KeyX),
+            Windows::KeyY => Ok(Self::KeyY),
+            Windows::KeyZ => Ok(Self::KeyZ),
+            Windows::Key1 => Ok(Self::Key1),
+            Windows::Key2 => Ok(Self::Key2),
+            Windows::Key3 => Ok(Self::Key3),
+            Windows::Key4 => Ok(Self::Key4),
+            Windows::Key5 => Ok(Self::Key5),
+            Windows::Key6 => Ok(Self::Key6),
+            Windows::Key7 => Ok(Self::Key7),
+            Windows::Key8 => Ok(Self::Key8),
+            Windows::Key9 => Ok(Self::Key9),
+            Windows::Key0 => Ok(Self::Key0),
+            Windows::KeyEnter => Ok(Self::KeyEnter),
+            Windows::KeyEsc => Ok(Self::KeyEsc),
+            Windows::KeyDelete => Ok(Self::KeyBackspace),
+            Windows::KeyTab => Ok(Self::KeyTab),
+            Windows::KeySpace => Ok(Self::KeySpace),
+            Windows::KeyMinus => Ok(Self::KeyMinus),
+            Windows::KeyEqual => Ok(Self::KeyEqual),
+            Windows::KeyLeftBrace => Ok(Self::KeyLeftbrace),
+            Windows::KeyRightBrace => Ok(Self::KeyRightbrace),
+            Windows::KeyBackslash => Ok(Self::KeyBackslash),
+            Windows::KeySemiColon => Ok(Self::KeySemicolon),
+            Windows::KeyApostrophe => Ok(Self::KeyApostrophe),
+            Windows::KeyGrave => Ok(Self::KeyGrave),
+            Windows::KeyComma => Ok(Self::KeyComma),
+            Windows::KeyDot => Ok(Self::KeyDot),
+            Windows::KeySlash => Ok(Self::KeySlash),
+            Windows::KeyCapsLock => Ok(Self::KeyCapsLock),
+            Windows::KeyF1 => Ok(Self::KeyF1),
+            Windows::KeyF2 => Ok(Self::KeyF2),
+            Windows::KeyF3 => Ok(Self::KeyF3),
+            Windows::KeyF4 => Ok(Self::KeyF4),
+            Windows::KeyF5 => Ok(Self::KeyF5),
+            Windows::KeyF6 => Ok(Self::KeyF6),
+            Windows::KeyF7 => Ok(Self::KeyF7),
+            Windows::KeyF8 => Ok(Self::KeyF8),
+            Windows::KeyF9 => Ok(Self::KeyF9),
+            Windows::KeyF10 => Ok(Self::KeyF10),
+            Windows::KeyF11 => Ok(Self::KeyF11),
+            Windows::KeyF12 => Ok(Self::KeyF12),
+            Windows::KeyPrintScreen => Ok(Self::KeySysrq),
+            Windows::KeyScrollLock => Ok(Self::KeyScrollLock),
+            Windows::KeyPause => Ok(Self::KeyPause),
+            Windows::KeyInsert => Ok(Self::KeyInsert),
+            Windows::KeyHome => Ok(Self::KeyHome),
+            Windows::KeyPageUp => Ok(Self::KeyPageup),
+            Windows::KeyDeleteForward => Ok(Self::KeyDelete),
+            Windows::KeyEnd => Ok(Self::KeyEnd),
+            Windows::KeyPageDown => Ok(Self::KeyPagedown),
+            Windows::KeyRight => Ok(Self::KeyRight),
+            Windows::KeyLeft => Ok(Self::KeyLeft),
+            Windows::KeyDown => Ok(Self::KeyDown),
+            Windows::KeyUp => Ok(Self::KeyUp),
+            Windows::KeypadNumLock => Ok(Self::KeyNumlock),
+            Windows::KeypadSlash => Ok(Self::KeyKpslash),
+            Windows::KeypadStar => Ok(Self::KeyKpAsterisk),
+            Windows::KeypadDash => Ok(Self::KeyKpMinus),
+            Windows::KeypadPlus => Ok(Self::KeyKpplus),
+            Windows::KeypadEnter => Ok(Self::KeyKpEnter),
+            Windows::Keypad1End => Ok(Self::KeyKp1),
+            Windows::Keypad2DownArrow => Ok(Self::KeyKp2),
+            Windows::Keypad3PageDn => Ok(Self::KeyKp3),
+            Windows::Keypad4LeftArrow => Ok(Self::KeyKp4),
+            Windows::Keypad5 => Ok(Self::KeyKp5),
+            Windows::Keypad6RightArrow => Ok(Self::KeyKp6),
+            Windows::Keypad7Home => Ok(Self::KeyKp7),
+            Windows::Keypad8UpArrow => Ok(Self::KeyKp8),
+            Windows::Keypad9PageUp => Ok(Self::KeyKp9),
+            Windows::Keypad0Insert => Ok(Self::KeyKp0),
+            Windows::KeypadDot => Ok(Self::KeyKpDot),
+            Windows::KeyNonUSSlashBar => Ok(Self::Key102nd),
+            Windows::KeyApplication => Ok(Self::KeyMenu),
+            Windows::KeypadEquals => Ok(Self::KeyKpequal),
+            Windows::KeyF13 => Ok(Self::KeyF13),
+            Windows::KeyF14 => Ok(Self::KeyF14),
+            Windows::KeyF15 => Ok(Self::KeyF15),
+            Windows::KeyF16 => Ok(Self::KeyF16),
+            Windows::KeyF17 => Ok(Self::KeyF17),
+            Windows::KeyF18 => Ok(Self::KeyF18),
+            Windows::KeyF19 => Ok(Self::KeyF19),
+            Windows::KeyF20 => Ok(Self::KeyF20),
+            Windows::KeyF21 => Ok(Self::KeyF21),
+            Windows::KeyF22 => Ok(Self::KeyF22),
+            Windows::KeyF23 => Ok(Self::KeyF23),
+            Windows::KeyF24 => Ok(Self::KeyF24),
+            Windows::KeypadComma => Ok(Self::KeyKpcomma),
+            Windows::KeyInternational1 => Ok(Self::KeyRo),
+            Windows::KeyInternational2 => Ok(Self::KeyKatakanahiragana),
+            Windows::KeyInternational3 => Ok(Self::KeyYen),
+            Windows::KeyInternational4 => Ok(Self::KeyHenkan),
+            Windows::KeyInternational5 => Ok(Self::KeyMuhenkan),
+            Windows::KeyLANG1 => Ok(Self::KeyHanguel),
+            Windows::KeyLANG2 => Ok(Self::KeyHanja),
+            Windows::KeyLANG3 => Ok(Self::KeyKatakana),
+            Windows::KeyLANG4 => Ok(Self::KeyHiragana),
+            Windows::KeyLeftCtrl => Ok(Self::KeyLeftCtrl),
+            Windows::KeyLeftShift => Ok(Self::KeyLeftShift),
+            Windows::KeyLeftAlt => Ok(Self::KeyLeftAlt),
+            Windows::KeyLeftGUI => Ok(Self::KeyLeftMeta),
+            Windows::KeyRightCtrl => Ok(Self::KeyRightCtrl),
+            Windows::KeyRightShift => Ok(Self::KeyRightShift),
+            Windows::KeyFakeRightShift => Ok(Self::KeyRightShift),
+            Windows::KeyRightAlt => Ok(Self::KeyRightalt),
+            Windows::KeyRightGUI => Ok(Self::KeyRightmeta),
+            Windows::KeyScanNextTrack => Ok(Self::KeyNextsong),
+            Windows::KeyScanPreviousTrack => Ok(Self::KeyPrevioussong),
+            Windows::KeyStop => Ok(Self::KeyStopcd),
+            Windows::KeyPlayPause => Ok(Self::KeyPlaypause),
+            Windows::KeyMute => Ok(Self::KeyMute),
+            Windows::KeyVolumeUp => Ok(Self::KeyVolumeUp),
+            Windows::KeyVolumeDown => Ok(Self::KeyVolumeDown),
+            Windows::ALConsumerControlConfiguration => Err(()),
+            Windows::ALEmailReader => Ok(Self::KeyMail),
+            Windows::ALCalculator => Ok(Self::KeyCalc),
+            Windows::ALLocalMachineBrowser => Ok(Self::KeyFile),
+            Windows::ACSearch => Ok(Self::KeyWww),
+            Windows::ACHome => Ok(Self::KeyHomepage),
+            Windows::ACBack => Ok(Self::KeyBack),
+            Windows::ACForward => Ok(Self::KeyForward),
+            Windows::ACStop => Ok(Self::KeyStop),
+            Windows::ACRefresh => Ok(Self::KeyRefresh),
+            Windows::ACBookmarks => Ok(Self::KeyBookmarks),
+        }
+    }
+}

nix/README.md

@@ -34,6 +34,9 @@ enable lan-mouse
     enable = true;
     # systemd = false;
     # package = inputs.lan-mouse.packages.${pkgs.stdenv.hostPlatform.system}.default
+    # Optional configuration in nix syntax, see config.toml for available options
+    # settings = { };
+    };
   };
 }
 

nix/default.nix

@@ -2,14 +2,19 @@
   rustPlatform,
   lib,
   pkgs,
-}:
+}: let
+  cargoToml = builtins.fromTOML (builtins.readFile ../Cargo.toml);
+  pname = cargoToml.package.name;
+  version = cargoToml.package.version;
+in
 rustPlatform.buildRustPackage {
-  pname = "lan-mouse";
-  version = "0.7.0";
+  pname = pname;
+  version = version;
 
   nativeBuildInputs = with pkgs; [
     pkg-config
     cmake
+    makeWrapper
     buildPackages.gtk4
   ];
 
@@ -18,10 +23,12 @@ rustPlatform.buildRustPackage {
     gtk4
     libadwaita
     xorg.libXtst
+  ] ++ lib.optionals stdenv.isDarwin [
+    darwin.apple_sdk_11_0.frameworks.CoreGraphics
   ];
 
   src = builtins.path {
-    name = "lan-mouse";
+    name = pname;
     path = lib.cleanSource ../.;
   };
 
@@ -30,13 +37,19 @@ rustPlatform.buildRustPackage {
   # Set Environment Variables
   RUST_BACKTRACE = "full";
 
+  # Needed to enable support for SVG icons in GTK
+  postInstall = ''
+    wrapProgram "$out/bin/lan-mouse" \
+      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
+  '';
+
   meta = with lib; {
     description = "Lan Mouse is a mouse and keyboard sharing software";
     longDescription = ''
       Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices. It allows for using multiple pcs with a single set of mouse and keyboard. This is also known as a Software KVM switch.
       The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).
     '';
-    mainProgram = "lan-mouse";
+    mainProgram = pname;
     platforms = platforms.all;
   };
 }

nix/hm-module.nix

@@ -7,6 +7,7 @@ self: {
 with lib; let
   cfg = config.programs.lan-mouse;
   defaultPackage = self.packages.${pkgs.stdenv.hostPlatform.system}.default;
+  tomlFormat = pkgs.formats.toml {};
 in {
   options.programs.lan-mouse = with types; {
     enable = mkEnableOption "Whether or not to enable lan-mouse.";
@@ -23,7 +24,23 @@ in {
     systemd = mkOption {
       type = types.bool;
       default = pkgs.stdenv.isLinux;
-      description = "Whether to enable to systemd service for lan-mouse.";
+      description = "Whether to enable to systemd service for lan-mouse on linux.";
+    };
+    launchd = mkOption {
+      type = types.bool;
+      default = pkgs.stdenv.isDarwin;
+      description = "Whether to enable to launchd service for lan-mouse on macOS.";
+    };
+    settings = lib.mkOption {
+      inherit (tomlFormat) type;
+      default = {};
+      example = builtins.fromTOML (builtins.readFile (self + /config.toml));
+      description = ''
+        Optional configuration written to {file}`$XDG_CONFIG_HOME/lan-mouse/config.toml`.
+
+        See <https://github.com/feschber/lan-mouse/> for
+        available options and documentation.
+      '';
     };
   };
 
@@ -43,8 +60,23 @@ in {
       ];
     };
 
+    launchd.agents.lan-mouse = lib.mkIf cfg.launchd {
+      enable = true;
+      config = {
+        ProgramArguments = [
+          "${cfg.package}/bin/lan-mouse"
+          "--daemon"
+        ];
+        KeepAlive = true;
+      };
+    };
+
     home.packages = [
       cfg.package
     ];
+
+    xdg.configFile."lan-mouse/config.toml" = lib.mkIf (cfg.settings != {}) {
+      source = tomlFormat.generate "config.toml" cfg.settings;
+    };
   };
 }

resources/client_row.ui

@@ -11,6 +11,20 @@
 				<property name="tooltip-text" translatable="yes">enable</property>
 			</object>
 		</child>
+		<child type="suffix">
+			<object class="GtkButton" id="dns_button">
+				<signal name="clicked" handler="handle_request_dns" swapped="true"/>
+				<!--<property name="icon-name">network-wired-disconnected-symbolic</property>-->
+				<property name="icon-name">network-wired-symbolic</property>
+				<property name="valign">center</property>
+				<property name="halign">end</property>
+				<property name="tooltip-text" translatable="yes">resolve host</property>
+			</object>
+		</child>
+		<child type="suffix">
+			<object class="GtkSpinner" id="dns_loading_indicator">
+			</object>
+		</child>
 		<!-- host -->
 		<child>
 			<object class="AdwActionRow">
@@ -30,6 +44,7 @@
 				<child>
 					<object class="GtkEntry" id="port">
 						<!-- <property name="title" translatable="yes">port</property> -->
+                        <property name="max-width-chars">5</property>
 						<property name="input_purpose">GTK_INPUT_PURPOSE_NUMBER</property>
 						<property name="xalign">0.5</property>
 						<property name="valign">center</property>
@@ -66,6 +81,7 @@
 						<property name="valign">center</property>
 						<property name="halign">center</property>
 						<property name="name">delete-button</property>
+						<style><class name="error"/></style>
 					</object>
 				</child>
 			</object>

resources/resources.gresource.xml

@@ -3,10 +3,8 @@
   <gresource prefix="/de/feschber/LanMouse">
     <file compressed="true" preprocess="xml-stripblanks">window.ui</file>
     <file compressed="true" preprocess="xml-stripblanks">client_row.ui</file>
-    <file compressed="true">style.css</file>
-    <file compressed="true">style-dark.css</file>
   </gresource>
   <gresource prefix="/de/feschber/LanMouse/icons">
-	<file compressed="true" preprocess="xml-stripblanks">de.feschber.LanMouse.svg</file>
+    <file compressed="true" preprocess="xml-stripblanks">de.feschber.LanMouse.svg</file>
   </gresource>
 </gresources>

resources/style-dark.css

@@ -1,11 +0,0 @@
-#delete-button {
-  color: @red_1;
-}
-
-#port-edit-cancel {
-  color: @red_1;
-}
-
-#port-edit-apply {
-  color: @green_1;
-}

resources/style.css

@@ -1,11 +0,0 @@
-#delete-button {
-  color: @red_3;
-}
-
-#port-edit-cancel {
-  color: @red_3;
-}
-
-#port-edit-apply {
-  color: @green_3;
-}

resources/window.ui

@@ -1,146 +1,227 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
-	<requires lib="gtk" version="4.0"/>
-	<requires lib="libadwaita" version="1.0"/>
-	<menu id="main-menu">
-		<item>
-			<attribute name="label" translatable="yes">_Close window</attribute>
-			<attribute name="action">window.close</attribute>
-		</item>
-	</menu>
-	<template class="LanMouseWindow" parent="AdwApplicationWindow">
-		<property name="width-request">600</property>
-		<property name="height-request">700</property>
-		<property name="title" translatable="yes">Lan Mouse</property>
-		<property name="show-menubar">True</property>
-		<property name="content">
-			<object class="GtkBox">
-				<property name="orientation">vertical</property>
-				<child type="top">
-					<object class="AdwHeaderBar">
-						<child type ="end">
-							<object class="GtkMenuButton">
-								<property name="icon-name">open-menu-symbolic</property>
-								<property name="menu-model">main-menu</property>
-							</object>
-						</child>
-						<style>
-							<class name="flat"/>
-						</style>
-					</object>
-				</child>
-				<child>
-					<object class="AdwToastOverlay" id="toast_overlay">
-						<child>
-							<object class="AdwStatusPage">
-								<property name="title" translatable="yes">Lan Mouse</property>
-								<property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
-								<property name="icon-name">de.feschber.LanMouse</property>
-								<property name="child">
-								  <object class="AdwClamp">
-									<property name="maximum-size">600</property>
-									<property name="tightening-threshold">0</property>
-									<property name="child">
-									  <object class="GtkBox">
-										<property name="orientation">vertical</property>
-										<property name="spacing">12</property>
-										<child>
-											<object class="AdwPreferencesGroup">
-												<property name="title" translatable="yes">General</property>
-												<!--
-												<child>
-													<object class="AdwActionRow">
-														<property name="title" translatable="yes">enable</property>
-														<child type="suffix">
-															<object class="GtkSwitch">
-																<property name="valign">center</property>
-																<property name="tooltip-text" translatable="yes">enable</property>
-															</object>
-														</child>
-													</object>
-												</child>
-												-->
-												<child>
-													<object class="AdwActionRow">
-														<property name="title">port</property>
-														<child>
-															<object class="GtkEntry" id="port_entry">
-																<signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
-																<signal name="changed" handler="handle_port_changed" swapped="true"/>
-																<!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
-																<!-- <property name="title" translatable="yes">port</property> -->
-																<property name="placeholder-text">4242</property>
-																<property name="width-chars">5</property>
-																<property name="xalign">0.5</property>
-																<property name="valign">center</property>
-																<!-- <property name="show-apply-button">True</property> -->
-																<property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
-															</object>
-														</child>
-														<child>
-															<object class="GtkButton" id="port_edit_apply">
-																<signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
-																<property name="icon-name">object-select-symbolic</property>
-																<property name="valign">center</property>
-																<property name="visible">false</property>
-																<property name="name">port-edit-apply</property>
-															</object>
-														</child>
-														<child>
-															<object class="GtkButton" id="port_edit_cancel">
-																<signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
-																<property name="icon-name">process-stop-symbolic</property>
-																<property name="valign">center</property>
-																<property name="visible">false</property>
-																<property name="name">port-edit-cancel</property>
-															</object>
-														</child>
-													</object>
-												</child>
-											</object>
-										</child>
-										<child>
-											<object class="AdwPreferencesGroup">
-												<property name="title" translatable="yes">Connections</property>
-												<property name="header-suffix">
-													<object class="GtkButton">
-														<signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
-														<property name="child">
-															<object class="AdwButtonContent">
-																<property name="icon-name">list-add-symbolic</property>
-																<property name="label" translatable="yes">Add</property>
-															</object>
-														</property>
-													<style>
-														<class name="flat"/>
-													</style>
-													</object>
-												</property>
-												<child>
-												  <object class="GtkListBox" id="client_list">
-														<property name="selection-mode">none</property>
-														<child type="placeholder">
-															<object class="AdwActionRow" id="client_placeholder">
-																<property name="title">No connections!</property>
-																<property name="subtitle">add a new client via the + button</property>
-															</object>
-														</child>
-														<style>
-															<class name="boxed-list" />
-														</style>
-												  </object>
-												</child>
-											</object>
-										</child>
-									  </object>
-									</property>
-								  </object>
-							  </property>
-							</object>
-						</child>
-					</object>
-				</child>
-			</object>
-		</property>
-	</template>
+  <requires lib="gtk" version="4.0"/>
+  <requires lib="libadwaita" version="1.0"/>
+  <menu id="main-menu">
+    <item>
+      <attribute name="label" translatable="yes">_Close window</attribute>
+      <attribute name="action">window.close</attribute>
+    </item>
+  </menu>
+  <template class="LanMouseWindow" parent="AdwApplicationWindow">
+    <property name="width-request">600</property>
+    <property name="height-request">700</property>
+    <property name="title" translatable="yes">Lan Mouse</property>
+    <property name="show-menubar">True</property>
+    <property name="content">
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child type="top">
+          <object class="AdwHeaderBar">
+            <child type ="end">
+              <object class="GtkMenuButton">
+                <property name="icon-name">open-menu-symbolic</property>
+                <property name="menu-model">main-menu</property>
+              </object>
+            </child>
+            <style>
+              <class name="flat"/>
+            </style>
+          </object>
+        </child>
+        <child>
+          <object class="AdwToastOverlay" id="toast_overlay">
+            <child>
+              <object class="AdwStatusPage">
+                <property name="title" translatable="yes">Lan Mouse</property>
+                <property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
+                <property name="icon-name">de.feschber.LanMouse</property>
+                <property name="child">
+                  <object class="AdwClamp">
+                  <property name="maximum-size">600</property>
+                  <property name="tightening-threshold">0</property>
+                  <property name="child">
+                    <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">12</property>
+                    <child>
+                      <object class="AdwPreferencesGroup" id="capture_emulation_group">
+                      <property name="title" translatable="yes">Capture / Emulation Status</property>
+                        <child>
+                          <object class="AdwActionRow" id="capture_status_row">
+                            <property name="title">input capture is disabled</property>
+                            <property name="subtitle">required for outgoing and incoming connections</property>
+                            <property name="icon-name">dialog-warning-symbolic</property>
+                            <child>
+                              <object class="GtkButton" id="input_capture_button">
+                                <property name="child">
+                                  <object class="AdwButtonContent">
+                                    <property name="icon-name">object-rotate-right-symbolic</property>
+                                    <property name="label" translatable="yes">Reenable</property>
+                                  </object>
+                                </property>
+                                <signal name="clicked" handler="handle_capture" swapped="true"/>
+                                <property name="valign">center</property>
+                                <style>
+                                  <class name="circular"/>
+                                  <class name="flat"/>
+                                </style>
+                              </object>
+                            </child>
+                            <style>
+                              <class name="warning"/>
+                            </style>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="AdwActionRow" id="emulation_status_row">
+                            <property name="title">input emulation is disabled</property>
+                            <property name="subtitle">required for incoming connections</property>
+                            <property name="icon-name">dialog-warning-symbolic</property>
+                            <child>
+                              <object class="GtkButton" id="input_emulation_button">
+                                <property name="child">
+                                  <object class="AdwButtonContent">
+                                    <property name="icon-name">object-rotate-right-symbolic</property>
+                                    <property name="label" translatable="yes">Reenable</property>
+                                  </object>
+                                </property>
+                                <property name="valign">center</property>
+                                <signal name="clicked" handler="handle_emulation" swapped="true"/>
+                                <style>
+                                  <class name="circular"/>
+                                  <class name="flat"/>
+                                </style>
+                              </object>
+                            </child>
+                            <child>
+                            </child>
+                            <style>
+                              <class name="warning"/>
+                            </style>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">General</property>
+                        <!--
+                        <child>
+                          <object class="AdwActionRow">
+                            <property name="title" translatable="yes">enable</property>
+                            <child type="suffix">
+                              <object class="GtkSwitch">
+                                <property name="valign">center</property>
+                                <property name="tooltip-text" translatable="yes">enable</property>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        -->
+                        <child>
+                          <object class="AdwActionRow">
+                            <property name="title">port</property>
+                            <child>
+                              <object class="GtkEntry" id="port_entry">
+                                <property name="max-width-chars">5</property>
+                                <signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
+                                <signal name="changed" handler="handle_port_changed" swapped="true"/>
+                                <!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
+                                <!-- <property name="title" translatable="yes">port</property> -->
+                                <property name="placeholder-text">4242</property>
+                                <property name="width-chars">5</property>
+                                <property name="xalign">0.5</property>
+                                <property name="valign">center</property>
+                                <!-- <property name="show-apply-button">True</property> -->
+                                <property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkButton" id="port_edit_apply">
+                                <signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
+                                <property name="icon-name">object-select-symbolic</property>
+                                <property name="valign">center</property>
+                                <property name="visible">false</property>
+                                <property name="name">port-edit-apply</property>
+                                <style><class name="success"/></style>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkButton" id="port_edit_cancel">
+                                <signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
+                                <property name="icon-name">process-stop-symbolic</property>
+                                <property name="valign">center</property>
+                                <property name="visible">false</property>
+                                <property name="name">port-edit-cancel</property>
+                                <style><class name="error"/></style>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="AdwActionRow">
+                            <property name="title">hostname</property>
+                            <child>
+                              <object class="GtkLabel" id="hostname_label">
+                                <property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
+                                <property name="use-markup">true</property>
+                                <property name="valign">center</property>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkButton" id="copy-hostname-button">
+                                <property name="icon-name">edit-copy-symbolic</property>
+                                <property name="valign">center</property>
+                                <signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">Connections</property>
+                        <property name="header-suffix">
+                          <object class="GtkButton">
+                            <signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
+                            <property name="child">
+                              <object class="AdwButtonContent">
+                                <property name="icon-name">list-add-symbolic</property>
+                                <property name="label" translatable="yes">Add</property>
+                              </object>
+                            </property>
+                          <style>
+                            <class name="flat"/>
+                          </style>
+                          </object>
+                        </property>
+                        <child>
+                          <object class="GtkListBox" id="client_list">
+                            <property name="selection-mode">none</property>
+                            <child type="placeholder">
+                              <object class="AdwActionRow" id="client_placeholder">
+                                <property name="title">No connections!</property>
+                                <property name="subtitle">add a new client via the + button</property>
+                              </object>
+                            </child>
+                            <style>
+                              <class name="boxed-list" />
+                            </style>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    </object>
+                  </property>
+                  </object>
+                </property>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </property>
+  </template>
 </interface>

src/backend.rs

@@ -1,2 +0,0 @@
-pub mod consumer;
-pub mod producer;

src/backend/consumer.rs

@@ -1,20 +0,0 @@
-#[cfg(windows)]
-pub mod windows;
-
-#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-pub mod x11;
-
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-pub mod wlroots;
-
-#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-pub mod xdg_desktop_portal;
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-pub mod libei;
-
-#[cfg(target_os = "macos")]
-pub mod macos;
-
-/// fallback consumer
-pub mod dummy;

src/backend/consumer/dummy.rs

@@ -1,26 +0,0 @@
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    consumer::EventConsumer,
-    event::Event,
-};
-use async_trait::async_trait;
-
-#[derive(Default)]
-pub struct DummyConsumer;
-
-impl DummyConsumer {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-#[async_trait]
-impl EventConsumer for DummyConsumer {
-    async fn consume(&mut self, event: Event, client_handle: ClientHandle) {
-        log::info!("received event: ({client_handle}) {event}");
-    }
-    async fn notify(&mut self, client_event: ClientEvent) {
-        log::info!("{client_event:?}");
-    }
-    async fn destroy(&mut self) {}
-}

src/backend/consumer/libei.rs

@@ -1,387 +0,0 @@
-use std::{
-    collections::HashMap,
-    os::{fd::OwnedFd, unix::net::UnixStream},
-    time::{SystemTime, UNIX_EPOCH},
-};
-
-use anyhow::{anyhow, Result};
-use ashpd::{
-    desktop::{
-        remote_desktop::{DeviceType, RemoteDesktop},
-        ResponseError,
-    },
-    WindowIdentifier,
-};
-use async_trait::async_trait;
-use futures::StreamExt;
-
-use reis::{
-    ei::{self, button::ButtonState, handshake::ContextType, keyboard::KeyState},
-    tokio::EiEventStream,
-    PendingRequestResult,
-};
-
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    consumer::EventConsumer,
-    event::Event,
-};
-
-pub struct LibeiConsumer {
-    handshake: bool,
-    context: ei::Context,
-    events: EiEventStream,
-    pointer: Option<(ei::Device, ei::Pointer)>,
-    has_pointer: bool,
-    scroll: Option<(ei::Device, ei::Scroll)>,
-    has_scroll: bool,
-    button: Option<(ei::Device, ei::Button)>,
-    has_button: bool,
-    keyboard: Option<(ei::Device, ei::Keyboard)>,
-    has_keyboard: bool,
-    capabilities: HashMap<String, u64>,
-    capability_mask: u64,
-    sequence: u32,
-    serial: u32,
-}
-
-async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
-    let proxy = RemoteDesktop::new().await?;
-
-    // retry when user presses the cancel button
-    let (session, _) = loop {
-        log::debug!("creating session ...");
-        let session = proxy.create_session().await?;
-
-        log::debug!("selecting devices ...");
-        proxy
-            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
-            .await?;
-
-        log::info!("requesting permission for input emulation");
-        match proxy
-            .start(&session, &WindowIdentifier::default())
-            .await?
-            .response()
-        {
-            Ok(d) => break (session, d),
-            Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
-                log::warn!("request cancelled!");
-                continue;
-            }
-            e => e?,
-        };
-    };
-
-    proxy.connect_to_eis(&session).await
-}
-
-impl LibeiConsumer {
-    pub async fn new() -> Result<Self> {
-        // fd is owned by the message, so we need to dup it
-        let eifd = get_ei_fd().await?;
-        let stream = UnixStream::from(eifd);
-        // let stream = UnixStream::connect("/run/user/1000/eis-0")?;
-        stream.set_nonblocking(true)?;
-        let context = ei::Context::new(stream)?;
-        context.flush()?;
-        let events = EiEventStream::new(context.clone())?;
-        Ok(Self {
-            handshake: false,
-            context,
-            events,
-            pointer: None,
-            button: None,
-            scroll: None,
-            keyboard: None,
-            has_pointer: false,
-            has_button: false,
-            has_scroll: false,
-            has_keyboard: false,
-            capabilities: HashMap::new(),
-            capability_mask: 0,
-            sequence: 0,
-            serial: 0,
-        })
-    }
-}
-
-#[async_trait]
-impl EventConsumer for LibeiConsumer {
-    async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
-        let now = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_micros() as u64;
-        match event {
-            Event::Pointer(p) => match p {
-                crate::event::PointerEvent::Motion {
-                    time: _,
-                    relative_x,
-                    relative_y,
-                } => {
-                    if !self.has_pointer {
-                        return;
-                    }
-                    if let Some((d, p)) = self.pointer.as_mut() {
-                        p.motion_relative(relative_x as f32, relative_y as f32);
-                        d.frame(self.serial, now);
-                    }
-                }
-                crate::event::PointerEvent::Button {
-                    time: _,
-                    button,
-                    state,
-                } => {
-                    if !self.has_button {
-                        return;
-                    }
-                    if let Some((d, b)) = self.button.as_mut() {
-                        b.button(
-                            button,
-                            match state {
-                                0 => ButtonState::Released,
-                                _ => ButtonState::Press,
-                            },
-                        );
-                        d.frame(self.serial, now);
-                    }
-                }
-                crate::event::PointerEvent::Axis {
-                    time: _,
-                    axis,
-                    value,
-                } => {
-                    if !self.has_scroll {
-                        return;
-                    }
-                    if let Some((d, s)) = self.scroll.as_mut() {
-                        match axis {
-                            0 => s.scroll(0., value as f32),
-                            _ => s.scroll(value as f32, 0.),
-                        }
-                        d.frame(self.serial, now);
-                    }
-                }
-                crate::event::PointerEvent::Frame {} => {}
-            },
-            Event::Keyboard(k) => match k {
-                crate::event::KeyboardEvent::Key {
-                    time: _,
-                    key,
-                    state,
-                } => {
-                    if !self.has_keyboard {
-                        return;
-                    }
-                    if let Some((d, k)) = &mut self.keyboard {
-                        k.key(
-                            key,
-                            match state {
-                                0 => KeyState::Released,
-                                _ => KeyState::Press,
-                            },
-                        );
-                        d.frame(self.serial, now);
-                    }
-                }
-                crate::event::KeyboardEvent::Modifiers { .. } => {}
-            },
-            _ => {}
-        }
-        self.context.flush().unwrap();
-    }
-
-    async fn dispatch(&mut self) -> Result<()> {
-        let event = match self.events.next().await {
-            Some(e) => e?,
-            None => return Err(anyhow!("libei connection lost")),
-        };
-        let event = match event {
-            PendingRequestResult::Request(result) => result,
-            PendingRequestResult::ParseError(e) => {
-                return Err(anyhow!("libei protocol violation: {e}"))
-            }
-            PendingRequestResult::InvalidObject(e) => return Err(anyhow!("invalid object {e}")),
-        };
-        match event {
-            ei::Event::Handshake(handshake, request) => match request {
-                ei::handshake::Event::HandshakeVersion { version } => {
-                    if self.handshake {
-                        return Ok(());
-                    }
-                    log::info!("libei version {}", version);
-                    // sender means we are sending events _to_ the eis server
-                    handshake.handshake_version(version); // FIXME
-                    handshake.context_type(ContextType::Sender);
-                    handshake.name("ei-demo-client");
-                    handshake.interface_version("ei_connection", 1);
-                    handshake.interface_version("ei_callback", 1);
-                    handshake.interface_version("ei_pingpong", 1);
-                    handshake.interface_version("ei_seat", 1);
-                    handshake.interface_version("ei_device", 2);
-                    handshake.interface_version("ei_pointer", 1);
-                    handshake.interface_version("ei_pointer_absolute", 1);
-                    handshake.interface_version("ei_scroll", 1);
-                    handshake.interface_version("ei_button", 1);
-                    handshake.interface_version("ei_keyboard", 1);
-                    handshake.interface_version("ei_touchscreen", 1);
-                    handshake.finish();
-                    self.handshake = true;
-                }
-                ei::handshake::Event::InterfaceVersion { name, version } => {
-                    log::debug!("handshake: Interface {name} @ {version}");
-                }
-                ei::handshake::Event::Connection { serial, connection } => {
-                    connection.sync(1);
-                    self.serial = serial;
-                }
-                _ => unreachable!(),
-            },
-            ei::Event::Connection(_connection, request) => match request {
-                ei::connection::Event::Seat { seat } => {
-                    log::debug!("connected to seat: {seat:?}");
-                }
-                ei::connection::Event::Ping { ping } => {
-                    ping.done(0);
-                }
-                ei::connection::Event::Disconnected {
-                    last_serial: _,
-                    reason,
-                    explanation,
-                } => {
-                    log::debug!("ei - disconnected: reason: {reason:?}: {explanation}")
-                }
-                ei::connection::Event::InvalidObject {
-                    last_serial,
-                    invalid_id,
-                } => {
-                    return Err(anyhow!(
-                        "invalid object: id: {invalid_id}, serial: {last_serial}"
-                    ));
-                }
-                _ => unreachable!(),
-            },
-            ei::Event::Device(device, request) => match request {
-                ei::device::Event::Destroyed { serial } => {
-                    log::debug!("device destroyed: {device:?} - serial: {serial}")
-                }
-                ei::device::Event::Name { name } => {
-                    log::debug!("device name: {name}")
-                }
-                ei::device::Event::DeviceType { device_type } => {
-                    log::debug!("device type: {device_type:?}")
-                }
-                ei::device::Event::Dimensions { width, height } => {
-                    log::debug!("device dimensions: {width}x{height}")
-                }
-                ei::device::Event::Region {
-                    offset_x,
-                    offset_y,
-                    width,
-                    hight,
-                    scale,
-                } => log::debug!(
-                    "device region: {width}x{hight} @ ({offset_x},{offset_y}), scale: {scale}"
-                ),
-                ei::device::Event::Interface { object } => {
-                    log::debug!("device interface: {object:?}");
-                    if object.interface().eq("ei_pointer") {
-                        log::debug!("GOT POINTER DEVICE");
-                        self.pointer.replace((device, object.downcast().unwrap()));
-                    } else if object.interface().eq("ei_button") {
-                        log::debug!("GOT BUTTON DEVICE");
-                        self.button.replace((device, object.downcast().unwrap()));
-                    } else if object.interface().eq("ei_scroll") {
-                        log::debug!("GOT SCROLL DEVICE");
-                        self.scroll.replace((device, object.downcast().unwrap()));
-                    } else if object.interface().eq("ei_keyboard") {
-                        log::debug!("GOT KEYBOARD DEVICE");
-                        self.keyboard.replace((device, object.downcast().unwrap()));
-                    }
-                }
-                ei::device::Event::Done => {
-                    log::debug!("device: done {device:?}");
-                }
-                ei::device::Event::Resumed { serial } => {
-                    self.serial = serial;
-                    device.start_emulating(serial, self.sequence);
-                    self.sequence += 1;
-                    log::debug!("resumed: {device:?}");
-                    if let Some((d, _)) = &mut self.pointer {
-                        if d == &device {
-                            log::debug!("pointer resumed {serial}");
-                            self.has_pointer = true;
-                        }
-                    }
-                    if let Some((d, _)) = &mut self.button {
-                        if d == &device {
-                            log::debug!("button resumed {serial}");
-                            self.has_button = true;
-                        }
-                    }
-                    if let Some((d, _)) = &mut self.scroll {
-                        if d == &device {
-                            log::debug!("scroll resumed {serial}");
-                            self.has_scroll = true;
-                        }
-                    }
-                    if let Some((d, _)) = &mut self.keyboard {
-                        if d == &device {
-                            log::debug!("keyboard resumed {serial}");
-                            self.has_keyboard = true;
-                        }
-                    }
-                }
-                ei::device::Event::Paused { serial } => {
-                    self.has_pointer = false;
-                    self.has_button = false;
-                    self.serial = serial;
-                }
-                ei::device::Event::StartEmulating { serial, sequence } => {
-                    log::debug!("start emulating {serial}, {sequence}")
-                }
-                ei::device::Event::StopEmulating { serial } => {
-                    log::debug!("stop emulating {serial}")
-                }
-                ei::device::Event::Frame { serial, timestamp } => {
-                    log::debug!("frame: {serial}, {timestamp}");
-                }
-                ei::device::Event::RegionMappingId { mapping_id } => {
-                    log::debug!("RegionMappingId {mapping_id}")
-                }
-                e => log::debug!("invalid event: {e:?}"),
-            },
-            ei::Event::Seat(seat, request) => match request {
-                ei::seat::Event::Destroyed { serial } => {
-                    self.serial = serial;
-                    log::debug!("seat destroyed: {seat:?}");
-                }
-                ei::seat::Event::Name { name } => {
-                    log::debug!("seat name: {name}");
-                }
-                ei::seat::Event::Capability { mask, interface } => {
-                    log::debug!("seat capabilities: {mask}, interface: {interface:?}");
-                    self.capabilities.insert(interface, mask);
-                    self.capability_mask |= mask;
-                }
-                ei::seat::Event::Done => {
-                    log::debug!("seat done");
-                    log::debug!("binding capabilities: {}", self.capability_mask);
-                    seat.bind(self.capability_mask);
-                }
-                ei::seat::Event::Device { device } => {
-                    log::debug!("seat: new device - {device:?}");
-                }
-                _ => todo!(),
-            },
-            e => log::debug!("unhandled event: {e:?}"),
-        }
-        self.context.flush()?;
-        Ok(())
-    }
-
-    async fn notify(&mut self, _client_event: ClientEvent) {}
-
-    async fn destroy(&mut self) {}
-}

src/backend/consumer/xdg_desktop_portal.rs

@@ -1,154 +0,0 @@
-use anyhow::Result;
-use ashpd::{
-    desktop::{
-        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
-        ResponseError, Session,
-    },
-    WindowIdentifier,
-};
-use async_trait::async_trait;
-
-use crate::{
-    client::ClientEvent,
-    consumer::EventConsumer,
-    event::{
-        Event::{Keyboard, Pointer},
-        KeyboardEvent, PointerEvent,
-    },
-};
-
-pub struct DesktopPortalConsumer<'a> {
-    proxy: RemoteDesktop<'a>,
-    session: Session<'a>,
-}
-
-impl<'a> DesktopPortalConsumer<'a> {
-    pub async fn new() -> Result<DesktopPortalConsumer<'a>> {
-        log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
-        let proxy = RemoteDesktop::new().await?;
-
-        // retry when user presses the cancel button
-        let (session, _) = loop {
-            log::debug!("creating session ...");
-            let session = proxy.create_session().await?;
-
-            log::debug!("selecting devices ...");
-            proxy
-                .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
-                .await?;
-
-            log::info!("requesting permission for input emulation");
-            match proxy
-                .start(&session, &WindowIdentifier::default())
-                .await?
-                .response()
-            {
-                Ok(d) => break (session, d),
-                Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
-                    log::warn!("request cancelled!");
-                    continue;
-                }
-                e => e?,
-            };
-        };
-
-        log::debug!("started session");
-
-        Ok(Self { proxy, session })
-    }
-}
-
-#[async_trait]
-impl<'a> EventConsumer for DesktopPortalConsumer<'a> {
-    async fn consume(&mut self, event: crate::event::Event, _client: crate::client::ClientHandle) {
-        match event {
-            Pointer(p) => {
-                match p {
-                    PointerEvent::Motion {
-                        time: _,
-                        relative_x,
-                        relative_y,
-                    } => {
-                        if let Err(e) = self
-                            .proxy
-                            .notify_pointer_motion(&self.session, relative_x, relative_y)
-                            .await
-                        {
-                            log::warn!("{e}");
-                        }
-                    }
-                    PointerEvent::Button {
-                        time: _,
-                        button,
-                        state,
-                    } => {
-                        let state = match state {
-                            0 => KeyState::Released,
-                            _ => KeyState::Pressed,
-                        };
-                        if let Err(e) = self
-                            .proxy
-                            .notify_pointer_button(&self.session, button as i32, state)
-                            .await
-                        {
-                            log::warn!("{e}");
-                        }
-                    }
-                    PointerEvent::Axis {
-                        time: _,
-                        axis,
-                        value,
-                    } => {
-                        let axis = match axis {
-                            0 => Axis::Vertical,
-                            _ => Axis::Horizontal,
-                        };
-                        // TODO smooth scrolling
-                        if let Err(e) = self
-                            .proxy
-                            .notify_pointer_axis_discrete(&self.session, axis, value as i32)
-                            .await
-                        {
-                            log::warn!("{e}");
-                        }
-                    }
-                    PointerEvent::Frame {} => {}
-                }
-            }
-            Keyboard(k) => {
-                match k {
-                    KeyboardEvent::Key {
-                        time: _,
-                        key,
-                        state,
-                    } => {
-                        let state = match state {
-                            0 => KeyState::Released,
-                            _ => KeyState::Pressed,
-                        };
-                        if let Err(e) = self
-                            .proxy
-                            .notify_keyboard_keycode(&self.session, key as i32, state)
-                            .await
-                        {
-                            log::warn!("{e}");
-                        }
-                    }
-                    KeyboardEvent::Modifiers { .. } => {
-                        // ignore
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    async fn notify(&mut self, _client: ClientEvent) {}
-
-    async fn destroy(&mut self) {
-        log::debug!("closing remote desktop session");
-        if let Err(e) = self.session.close().await {
-            log::error!("failed to close remote desktop session: {e}");
-        }
-    }
-}

src/backend/producer.rs

@@ -1,17 +0,0 @@
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-pub mod libei;
-
-#[cfg(target_os = "macos")]
-pub mod macos;
-
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-pub mod wayland;
-
-#[cfg(windows)]
-pub mod windows;
-
-#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-pub mod x11;
-
-/// fallback event producer
-pub mod dummy;

src/backend/producer/dummy.rs

@@ -1,42 +0,0 @@
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use futures_core::Stream;
-
-use crate::event::Event;
-use crate::producer::EventProducer;
-
-use crate::client::{ClientEvent, ClientHandle};
-
-pub struct DummyProducer {}
-
-impl DummyProducer {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl Default for DummyProducer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl EventProducer for DummyProducer {
-    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl Stream for DummyProducer {
-    type Item = io::Result<(ClientHandle, Event)>;
-
-    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Poll::Pending
-    }
-}

src/backend/producer/libei.rs

@@ -1,555 +0,0 @@
-use anyhow::{anyhow, Result};
-use ashpd::{
-    desktop::{
-        input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
-        ResponseError, Session,
-    },
-    enumflags2::BitFlags,
-};
-use futures::StreamExt;
-use reis::{
-    ei::{self, keyboard::KeyState},
-    eis::button::ButtonState,
-    event::{DeviceCapability, EiEvent},
-    tokio::{EiConvertEventStream, EiEventStream},
-};
-use std::{
-    cell::Cell,
-    collections::HashMap,
-    io,
-    os::unix::net::UnixStream,
-    pin::Pin,
-    rc::Rc,
-    task::{ready, Context, Poll},
-};
-use tokio::{
-    sync::mpsc::{Receiver, Sender},
-    task::JoinHandle,
-};
-
-use futures_core::Stream;
-use once_cell::sync::Lazy;
-
-use crate::{
-    client::{ClientEvent, ClientHandle, Position},
-    event::{Event, KeyboardEvent, PointerEvent},
-    producer::EventProducer,
-};
-
-#[derive(Debug)]
-enum ProducerEvent {
-    Release,
-    ClientEvent(ClientEvent),
-}
-
-#[allow(dead_code)]
-pub struct LibeiProducer<'a> {
-    input_capture: Pin<Box<InputCapture<'a>>>,
-    libei_task: JoinHandle<Result<()>>,
-    event_rx: tokio::sync::mpsc::Receiver<(u32, Event)>,
-    notify_tx: tokio::sync::mpsc::Sender<ProducerEvent>,
-}
-
-static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
-    let mut m = HashMap::new();
-    m.insert("ei_connection", 1);
-    m.insert("ei_callback", 1);
-    m.insert("ei_pingpong", 1);
-    m.insert("ei_seat", 1);
-    m.insert("ei_device", 2);
-    m.insert("ei_pointer", 1);
-    m.insert("ei_pointer_absolute", 1);
-    m.insert("ei_scroll", 1);
-    m.insert("ei_button", 1);
-    m.insert("ei_keyboard", 1);
-    m.insert("ei_touchscreen", 1);
-    m
-});
-
-fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
-    let (x, y) = (r.x_offset(), r.y_offset());
-    let (width, height) = (r.width() as i32, r.height() as i32);
-    match pos {
-        Position::Left => (x, y, x, y + height - 1), // start pos, end pos, inclusive
-        Position::Right => (x + width, y, x + width, y + height - 1),
-        Position::Top => (x, y, x + width - 1, y),
-        Position::Bottom => (x, y + height, x + width - 1, y + height),
-    }
-}
-
-fn select_barriers(
-    zones: &Zones,
-    clients: &Vec<(ClientHandle, Position)>,
-    next_barrier_id: &mut u32,
-) -> (Vec<Barrier>, HashMap<BarrierID, ClientHandle>) {
-    let mut client_for_barrier = HashMap::new();
-    let mut barriers: Vec<Barrier> = vec![];
-
-    for (handle, pos) in clients {
-        let mut client_barriers = zones
-            .regions()
-            .iter()
-            .map(|r| {
-                let id = *next_barrier_id;
-                *next_barrier_id = id + 1;
-                let position = pos_to_barrier(r, *pos);
-                client_for_barrier.insert(id, *handle);
-                Barrier::new(id, position)
-            })
-            .collect();
-        barriers.append(&mut client_barriers);
-    }
-    (barriers, client_for_barrier)
-}
-
-async fn update_barriers(
-    input_capture: &InputCapture<'_>,
-    session: &Session<'_>,
-    active_clients: &Vec<(ClientHandle, Position)>,
-    next_barrier_id: &mut u32,
-) -> Result<HashMap<BarrierID, ClientHandle>> {
-    let zones = input_capture.zones(session).await?.response()?;
-    log::debug!("zones: {zones:?}");
-
-    let (barriers, id_map) = select_barriers(&zones, active_clients, next_barrier_id);
-    log::debug!("barriers: {barriers:?}");
-    log::debug!("client for barrier id: {id_map:?}");
-
-    let response = input_capture
-        .set_pointer_barriers(session, &barriers, zones.zone_set())
-        .await?;
-    let response = response.response()?;
-    log::info!("{response:?}");
-    Ok(id_map)
-}
-
-impl<'a> Drop for LibeiProducer<'a> {
-    fn drop(&mut self) {
-        self.libei_task.abort();
-    }
-}
-
-async fn create_session<'a>(
-    input_capture: &'a InputCapture<'a>,
-) -> Result<(Session<'a>, BitFlags<Capabilities>)> {
-    log::info!("creating input capture session");
-    let (session, capabilities) = loop {
-        match input_capture
-            .create_session(
-                &ashpd::WindowIdentifier::default(),
-                Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
-            )
-            .await
-        {
-            Ok(s) => break s,
-            Err(ashpd::Error::Response(ResponseError::Cancelled)) => continue,
-            o => o?,
-        };
-    };
-    log::debug!("capabilities: {capabilities:?}");
-    Ok((session, capabilities))
-}
-
-async fn connect_to_eis(
-    input_capture: &InputCapture<'_>,
-    session: &Session<'_>,
-) -> Result<(ei::Context, EiConvertEventStream)> {
-    log::info!("connect_to_eis");
-    let fd = input_capture.connect_to_eis(session).await?;
-
-    // create unix stream from fd
-    let stream = UnixStream::from(fd);
-    stream.set_nonblocking(true)?;
-
-    // create ei context
-    let context = ei::Context::new(stream)?;
-    let mut event_stream = EiEventStream::new(context.clone())?;
-    let response = match reis::tokio::ei_handshake(
-        &mut event_stream,
-        "de.feschber.LanMouse",
-        ei::handshake::ContextType::Receiver,
-        &INTERFACES,
-    )
-    .await
-    {
-        Ok(res) => res,
-        Err(e) => return Err(anyhow!("ei handshake failed: {e:?}")),
-    };
-    let event_stream = EiConvertEventStream::new(event_stream, response.serial);
-
-    Ok((context, event_stream))
-}
-
-async fn libei_event_handler(
-    mut ei_event_stream: EiConvertEventStream,
-    context: ei::Context,
-    event_tx: Sender<(u32, Event)>,
-    current_client: Rc<Cell<Option<ClientHandle>>>,
-) -> Result<()> {
-    loop {
-        let ei_event = match ei_event_stream.next().await {
-            Some(Ok(event)) => event,
-            Some(Err(e)) => return Err(anyhow!("libei connection closed: {e:?}")),
-            None => return Err(anyhow!("libei connection closed")),
-        };
-        log::trace!("from ei: {ei_event:?}");
-        let client = current_client.get();
-        handle_ei_event(ei_event, client, &context, &event_tx).await;
-    }
-}
-
-async fn wait_for_active_client(
-    notify_rx: &mut Receiver<ProducerEvent>,
-    active_clients: &mut Vec<(ClientHandle, Position)>,
-) -> Result<()> {
-    // wait for a client update
-    while let Some(producer_event) = notify_rx.recv().await {
-        if let ProducerEvent::ClientEvent(c) = producer_event {
-            handle_producer_event(ProducerEvent::ClientEvent(c), active_clients)?;
-            break;
-        }
-    }
-    Ok(())
-}
-
-impl<'a> LibeiProducer<'a> {
-    pub async fn new() -> Result<Self> {
-        let input_capture = Box::pin(InputCapture::new().await?);
-        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
-        let mut first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
-
-        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
-        let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
-        let libei_task = tokio::task::spawn_local(async move {
-            /* safety: libei_task does not outlive Self */
-            let input_capture = unsafe { &*input_capture_ptr };
-
-            let mut active_clients: Vec<(ClientHandle, Position)> = vec![];
-            let mut next_barrier_id = 1u32;
-
-            /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
-             * prevents receiving further events after a session has been disabled once.
-             * Therefore the session needs to recreated when the barriers are updated */
-
-            loop {
-                // otherwise it asks to capture input even with no active clients
-                if active_clients.is_empty() {
-                    wait_for_active_client(&mut notify_rx, &mut active_clients).await?;
-                    continue;
-                }
-
-                let current_client = Rc::new(Cell::new(None));
-
-                // create session
-                let (session, _) = match first_session.take() {
-                    Some(s) => s,
-                    _ => create_session(input_capture).await?,
-                };
-
-                // connect to eis server
-                let (context, ei_event_stream) = connect_to_eis(input_capture, &session).await?;
-
-                // async event task
-                let mut ei_task: JoinHandle<Result<(), anyhow::Error>> =
-                    tokio::task::spawn_local(libei_event_handler(
-                        ei_event_stream,
-                        context,
-                        event_tx.clone(),
-                        current_client.clone(),
-                    ));
-
-                let mut activated = input_capture.receive_activated().await?;
-                let mut zones_changed = input_capture.receive_zones_changed().await?;
-
-                // set barriers
-                let client_for_barrier_id = update_barriers(
-                    input_capture,
-                    &session,
-                    &active_clients,
-                    &mut next_barrier_id,
-                )
-                .await?;
-
-                log::info!("enabling session");
-                input_capture.enable(&session).await?;
-
-                loop {
-                    tokio::select! {
-                        activated = activated.next() => {
-                            let activated = activated.ok_or(anyhow!("error receiving activation token"))?;
-                            log::debug!("activated: {activated:?}");
-
-                            let client = *client_for_barrier_id
-                                .get(&activated.barrier_id())
-                                .expect("invalid barrier id");
-                            current_client.replace(Some(client));
-
-                            event_tx.send((client, Event::Enter())).await?;
-
-                            tokio::select! {
-                                producer_event = notify_rx.recv() => {
-                                    let producer_event = producer_event.expect("channel closed");
-                                    if handle_producer_event(producer_event, &mut active_clients)? {
-                                        break; /* clients updated */
-                                    }
-                                }
-                                zones_changed = zones_changed.next() => {
-                                    log::debug!("zones changed: {zones_changed:?}");
-                                    break;
-                                }
-                                res = &mut ei_task => {
-                                    if let Err(e) = res.expect("ei task paniced") {
-                                        log::warn!("libei task exited: {e}");
-                                    }
-                                    break;
-                                }
-                            }
-                            release_capture(
-                                input_capture,
-                                &session,
-                                activated,
-                                client,
-                                &active_clients,
-                            ).await?;
-                        }
-                        producer_event = notify_rx.recv() => {
-                            let producer_event = producer_event.expect("channel closed");
-                            if handle_producer_event(producer_event, &mut active_clients)? {
-                                /* clients updated */
-                                break;
-                            }
-                        },
-                        res = &mut ei_task => {
-                            if let Err(e) = res.expect("ei task paniced") {
-                                log::warn!("libei task exited: {e}");
-                            }
-                            break;
-                        }
-                    }
-                }
-                ei_task.abort();
-                input_capture.disable(&session).await?;
-            }
-        });
-
-        let producer = Self {
-            input_capture,
-            event_rx,
-            libei_task,
-            notify_tx,
-        };
-
-        Ok(producer)
-    }
-}
-
-async fn release_capture(
-    input_capture: &InputCapture<'_>,
-    session: &Session<'_>,
-    activated: Activated,
-    current_client: ClientHandle,
-    active_clients: &[(ClientHandle, Position)],
-) -> Result<()> {
-    log::debug!("releasing input capture {}", activated.activation_id());
-    let (x, y) = activated.cursor_position();
-    let pos = active_clients
-        .iter()
-        .filter(|(c, _)| *c == current_client)
-        .map(|(_, p)| p)
-        .next()
-        .unwrap(); // FIXME
-    let (dx, dy) = match pos {
-        // offset cursor position to not enter again immediately
-        Position::Left => (1., 0.),
-        Position::Right => (-1., 0.),
-        Position::Top => (0., 1.),
-        Position::Bottom => (0., -1.),
-    };
-    // release 1px to the right of the entered zone
-    let cursor_position = (x as f64 + dx, y as f64 + dy);
-    input_capture
-        .release(session, activated.activation_id(), cursor_position)
-        .await?;
-    Ok(())
-}
-
-fn handle_producer_event(
-    producer_event: ProducerEvent,
-    active_clients: &mut Vec<(ClientHandle, Position)>,
-) -> Result<bool> {
-    log::debug!("handling event: {producer_event:?}");
-    let updated = match producer_event {
-        ProducerEvent::Release => false,
-        ProducerEvent::ClientEvent(ClientEvent::Create(c, p)) => {
-            active_clients.push((c, p));
-            true
-        }
-        ProducerEvent::ClientEvent(ClientEvent::Destroy(c)) => {
-            active_clients.retain(|(h, _)| *h != c);
-            true
-        }
-    };
-    Ok(updated)
-}
-
-async fn handle_ei_event(
-    ei_event: EiEvent,
-    current_client: Option<ClientHandle>,
-    context: &ei::Context,
-    event_tx: &Sender<(u32, Event)>,
-) {
-    match ei_event {
-        EiEvent::SeatAdded(s) => {
-            s.seat.bind_capabilities(&[
-                DeviceCapability::Pointer,
-                DeviceCapability::PointerAbsolute,
-                DeviceCapability::Keyboard,
-                DeviceCapability::Touch,
-                DeviceCapability::Scroll,
-                DeviceCapability::Button,
-            ]);
-            context.flush().unwrap();
-        }
-        EiEvent::SeatRemoved(_) => {}
-        EiEvent::DeviceAdded(_) => {}
-        EiEvent::DeviceRemoved(_) => {}
-        EiEvent::DevicePaused(_) => {}
-        EiEvent::DeviceResumed(_) => {}
-        EiEvent::KeyboardModifiers(mods) => {
-            let modifier_event = KeyboardEvent::Modifiers {
-                mods_depressed: mods.depressed,
-                mods_latched: mods.latched,
-                mods_locked: mods.locked,
-                group: mods.group,
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Keyboard(modifier_event)))
-                    .await
-                    .unwrap();
-            }
-        }
-        EiEvent::Frame(_) => {}
-        EiEvent::DeviceStartEmulating(_) => {
-            log::debug!("START EMULATING =============>");
-        }
-        EiEvent::DeviceStopEmulating(_) => {
-            log::debug!("==================> STOP EMULATING");
-        }
-        EiEvent::PointerMotion(motion) => {
-            let motion_event = PointerEvent::Motion {
-                time: motion.time as u32,
-                relative_x: motion.dx as f64,
-                relative_y: motion.dy as f64,
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Pointer(motion_event)))
-                    .await
-                    .unwrap();
-            }
-        }
-        EiEvent::PointerMotionAbsolute(_) => {}
-        EiEvent::Button(button) => {
-            let button_event = PointerEvent::Button {
-                time: button.time as u32,
-                button: button.button,
-                state: match button.state {
-                    ButtonState::Released => 0,
-                    ButtonState::Press => 1,
-                },
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Pointer(button_event)))
-                    .await
-                    .unwrap();
-            }
-        }
-        EiEvent::ScrollDelta(_) => {}
-        EiEvent::ScrollStop(_) => {}
-        EiEvent::ScrollCancel(_) => {}
-        EiEvent::ScrollDiscrete(scroll) => {
-            if scroll.discrete_dy != 0 {
-                let event = PointerEvent::Axis {
-                    time: 0,
-                    axis: 0,
-                    value: scroll.discrete_dy as f64,
-                };
-                if let Some(current_client) = current_client {
-                    event_tx
-                        .send((current_client, Event::Pointer(event)))
-                        .await
-                        .unwrap();
-                }
-            }
-            if scroll.discrete_dx != 0 {
-                let event = PointerEvent::Axis {
-                    time: 0,
-                    axis: 1,
-                    value: scroll.discrete_dx as f64,
-                };
-                if let Some(current_client) = current_client {
-                    event_tx
-                        .send((current_client, Event::Pointer(event)))
-                        .await
-                        .unwrap();
-                }
-            };
-        }
-        EiEvent::KeyboardKey(key) => {
-            let key_event = KeyboardEvent::Key {
-                key: key.key,
-                state: match key.state {
-                    KeyState::Press => 1,
-                    KeyState::Released => 0,
-                },
-                time: key.time as u32,
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Keyboard(key_event)))
-                    .await
-                    .unwrap();
-            }
-        }
-        EiEvent::TouchDown(_) => {}
-        EiEvent::TouchUp(_) => {}
-        EiEvent::TouchMotion(_) => {}
-        EiEvent::Disconnected(d) => {
-            log::error!("disconnect: {d:?}");
-        }
-    }
-}
-
-impl<'a> EventProducer for LibeiProducer<'a> {
-    fn notify(&mut self, event: ClientEvent) -> io::Result<()> {
-        let notify_tx = self.notify_tx.clone();
-        tokio::task::spawn_local(async move {
-            log::debug!("notifying {event:?}");
-            let _ = notify_tx.send(ProducerEvent::ClientEvent(event)).await;
-            log::debug!("done !");
-        });
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        let notify_tx = self.notify_tx.clone();
-        tokio::task::spawn_local(async move {
-            log::debug!("notifying Release");
-            let _ = notify_tx.send(ProducerEvent::Release).await;
-        });
-        Ok(())
-    }
-}
-
-impl<'a> Stream for LibeiProducer<'a> {
-    type Item = io::Result<(ClientHandle, Event)>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        match ready!(self.event_rx.poll_recv(cx)) {
-            None => Poll::Ready(None),
-            Some(e) => Poll::Ready(Some(Ok(e))),
-        }
-    }
-}

src/backend/producer/macos.rs

@@ -1,33 +0,0 @@
-use crate::client::{ClientEvent, ClientHandle};
-use crate::event::Event;
-use crate::producer::EventProducer;
-use anyhow::{anyhow, Result};
-use futures_core::Stream;
-use std::task::{Context, Poll};
-use std::{io, pin::Pin};
-
-pub struct MacOSProducer;
-
-impl MacOSProducer {
-    pub fn new() -> Result<Self> {
-        Err(anyhow!("not yet implemented"))
-    }
-}
-
-impl Stream for MacOSProducer {
-    type Item = io::Result<(ClientHandle, Event)>;
-
-    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Poll::Pending
-    }
-}
-
-impl EventProducer for MacOSProducer {
-    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}

src/backend/producer/windows.rs

@@ -1,35 +0,0 @@
-use anyhow::{anyhow, Result};
-use core::task::{Context, Poll};
-use futures::Stream;
-use std::{io, pin::Pin};
-
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    event::Event,
-    producer::EventProducer,
-};
-
-pub struct WindowsProducer {}
-
-impl EventProducer for WindowsProducer {
-    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl WindowsProducer {
-    pub(crate) fn new() -> Result<Self> {
-        Err(anyhow!("not implemented"))
-    }
-}
-
-impl Stream for WindowsProducer {
-    type Item = io::Result<(ClientHandle, Event)>;
-    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Poll::Pending
-    }
-}

src/backend/producer/x11.rs

@@ -1,39 +0,0 @@
-use anyhow::{anyhow, Result};
-use std::io;
-use std::task::Poll;
-
-use futures_core::Stream;
-
-use crate::event::Event;
-use crate::producer::EventProducer;
-
-use crate::client::{ClientEvent, ClientHandle};
-
-pub struct X11Producer {}
-
-impl X11Producer {
-    pub fn new() -> Result<Self> {
-        Err(anyhow!("not implemented"))
-    }
-}
-
-impl EventProducer for X11Producer {
-    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl Stream for X11Producer {
-    type Item = io::Result<(ClientHandle, Event)>;
-
-    fn poll_next(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        Poll::Pending
-    }
-}

src/capture_test.rs

@@ -0,0 +1,54 @@
+use crate::config::Config;
+use futures::StreamExt;
+use input_capture::{self, CaptureError, InputCapture, InputCaptureError, Position};
+use input_event::{Event, KeyboardEvent};
+use tokio::task::LocalSet;
+
+pub fn run() -> anyhow::Result<()> {
+    log::info!("running input capture test");
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+
+    let config = Config::new()?;
+
+    Ok(runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))?)
+}
+
+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?;
+        log::info!("creating clients");
+        input_capture.create(0, Position::Left).await?;
+        input_capture.create(1, Position::Right).await?;
+        input_capture.create(2, Position::Top).await?;
+        input_capture.create(3, Position::Bottom).await?;
+        if let Err(e) = do_capture(&mut input_capture).await {
+            log::warn!("{e} - recreating capture");
+        }
+        let _ = input_capture.terminate().await;
+    }
+}
+
+async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError> {
+    loop {
+        let (client, event) = input_capture
+            .next()
+            .await
+            .ok_or(CaptureError::EndOfStream)??;
+        let pos = match client {
+            0 => Position::Left,
+            1 => Position::Right,
+            2 => Position::Top,
+            _ => Position::Bottom,
+        };
+        log::info!("position: {pos}, event: {event}");
+        if let Event::Keyboard(KeyboardEvent::Key { key: 1, .. }) = event {
+            input_capture.release().await?;
+            break Ok(());
+        }
+    }
+}

src/client.rs

@@ -2,31 +2,52 @@ use std::{
     collections::HashSet,
     fmt::Display,
     net::{IpAddr, SocketAddr},
+    str::FromStr,
 };
 
 use serde::{Deserialize, Serialize};
+use slab::Slab;
+use thiserror::Error;
 
-#[derive(Debug, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
+use crate::config::DEFAULT_PORT;
+use input_capture;
+
+#[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
 pub enum Position {
+    #[default]
     Left,
     Right,
     Top,
     Bottom,
 }
 
-impl Default for Position {
-    fn default() -> Self {
-        Self::Left
+impl From<Position> for input_capture::Position {
+    fn from(position: Position) -> input_capture::Position {
+        match position {
+            Position::Left => input_capture::Position::Left,
+            Position::Right => input_capture::Position::Right,
+            Position::Top => input_capture::Position::Top,
+            Position::Bottom => input_capture::Position::Bottom,
+        }
     }
 }
 
-impl Position {
-    pub fn opposite(&self) -> Self {
-        match self {
-            Position::Left => Self::Right,
-            Position::Right => Self::Left,
-            Position::Top => Self::Bottom,
-            Position::Bottom => Self::Top,
+#[derive(Debug, Error)]
+#[error("not a valid position: {pos}")]
+pub struct PositionParseError {
+    pos: String,
+}
+
+impl FromStr for Position {
+    type Err = PositionParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "left" => Ok(Self::Left),
+            "right" => Ok(Self::Right),
+            "top" => Ok(Self::Top),
+            "bottom" => Ok(Self::Bottom),
+            _ => Err(PositionParseError { pos: s.into() }),
         }
     }
 }
@@ -61,37 +82,35 @@ impl TryFrom<&str> for Position {
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
-pub struct Client {
+pub struct ClientConfig {
     /// hostname of this client
     pub hostname: Option<String>,
     /// fix ips, determined by the user
     pub fix_ips: Vec<IpAddr>,
-    /// unique handle to refer to the client.
-    /// This way any event consumer / producer backend does not
-    /// need to know anything about a client other than its handle.
-    pub handle: ClientHandle,
-    /// all ip addresses associated with a particular client
-    /// e.g. Laptops usually have at least an ethernet and a wifi port
-    /// which have different ip addresses
-    pub ips: HashSet<IpAddr>,
     /// both active_addr and addrs can be None / empty so port needs to be stored seperately
     pub port: u16,
     /// position of a client on screen
     pub pos: Position,
+    /// enter hook
+    pub cmd: Option<String>,
 }
 
-#[derive(Clone, Copy, Debug)]
-pub enum ClientEvent {
-    Create(ClientHandle, Position),
-    Destroy(ClientHandle),
+impl Default for ClientConfig {
+    fn default() -> Self {
+        Self {
+            port: DEFAULT_PORT,
+            hostname: Default::default(),
+            fix_ips: Default::default(),
+            pos: Default::default(),
+            cmd: None,
+        }
+    }
 }
 
-pub type ClientHandle = u32;
+pub type ClientHandle = u64;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct ClientState {
-    /// information about the client
-    pub client: Client,
     /// events should be sent to and received from the client
     pub active: bool,
     /// `active` address of the client, used to send data to.
@@ -100,66 +119,27 @@ pub struct ClientState {
     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>,
+    /// ips from dns
+    pub dns_ips: Vec<IpAddr>,
+    /// all ip addresses associated with a particular client
+    /// 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,
+    /// dns resolving in progress
+    pub resolving: bool,
 }
 
+#[derive(Default)]
 pub struct ClientManager {
-    clients: Vec<Option<ClientState>>, // HashMap likely not beneficial
-}
-
-impl Default for ClientManager {
-    fn default() -> Self {
-        Self::new()
-    }
+    clients: Slab<(ClientConfig, ClientState)>,
 }
 
 impl ClientManager {
-    pub fn new() -> Self {
-        Self { clients: vec![] }
-    }
-
     /// add a new client to this manager
-    pub fn add_client(
-        &mut self,
-        hostname: Option<String>,
-        ips: HashSet<IpAddr>,
-        port: u16,
-        pos: Position,
-        active: bool,
-    ) -> ClientHandle {
-        // get a new client_handle
-        let handle = self.free_id();
-
-        // store fix ip addresses
-        let fix_ips = ips.iter().cloned().collect();
-
-        // store the client
-        let client = Client {
-            hostname,
-            fix_ips,
-            handle,
-            ips,
-            port,
-            pos,
-        };
-
-        // client was never seen, nor pinged
-        let client_state = ClientState {
-            client,
-            active,
-            active_addr: None,
-            alive: false,
-            pressed_keys: HashSet::new(),
-        };
-
-        if handle as usize >= self.clients.len() {
-            assert_eq!(handle as usize, self.clients.len());
-            self.clients.push(Some(client_state));
-        } else {
-            self.clients[handle as usize] = Some(client_state);
-        }
-        handle
+    pub fn add_client(&mut self) -> ClientHandle {
+        self.clients.insert(Default::default()) as ClientHandle
     }
 
     /// find a client by its address
@@ -168,49 +148,54 @@ impl ClientManager {
         // time this is likely faster than using a HashMap
         self.clients
             .iter()
-            .position(|c| {
-                if let Some(c) = c {
-                    c.active && c.client.ips.contains(&addr.ip())
+            .find_map(|(k, (_, s))| {
+                if s.active && s.ips.contains(&addr.ip()) {
+                    Some(k)
                 } else {
-                    false
+                    None
+                }
+            })
+            .map(|p| p as ClientHandle)
+    }
+
+    pub fn find_client(&self, pos: Position) -> Option<ClientHandle> {
+        self.clients
+            .iter()
+            .find_map(|(k, (c, s))| {
+                if s.active && c.pos == pos {
+                    Some(k)
+                } else {
+                    None
                 }
             })
             .map(|p| p as ClientHandle)
     }
 
     /// remove a client from the list
-    pub fn remove_client(&mut self, client: ClientHandle) -> Option<ClientState> {
+    pub fn remove_client(&mut self, client: ClientHandle) -> Option<(ClientConfig, ClientState)> {
         // remove id from occupied ids
-        self.clients.get_mut(client as usize)?.take()
-    }
-
-    /// get a free slot in the client list
-    fn free_id(&mut self) -> ClientHandle {
-        for i in 0..u32::MAX {
-            if self.clients.get(i as usize).is_none()
-                || self.clients.get(i as usize).unwrap().is_none()
-            {
-                return i;
-            }
-        }
-        panic!("Out of client ids");
+        self.clients.try_remove(client as usize)
     }
 
     // returns an immutable reference to the client state corresponding to `client`
-    pub fn get(&self, client: ClientHandle) -> Option<&ClientState> {
-        self.clients.get(client as usize)?.as_ref()
+    pub fn get(&self, handle: ClientHandle) -> Option<&(ClientConfig, ClientState)> {
+        self.clients.get(handle as usize)
     }
 
     /// returns a mutable reference to the client state corresponding to `client`
-    pub fn get_mut(&mut self, client: ClientHandle) -> Option<&mut ClientState> {
-        self.clients.get_mut(client as usize)?.as_mut()
+    pub fn get_mut(&mut self, handle: ClientHandle) -> Option<&mut (ClientConfig, ClientState)> {
+        self.clients.get_mut(handle as usize)
     }
 
-    pub fn get_client_states(&self) -> impl Iterator<Item = &ClientState> {
-        self.clients.iter().filter_map(|x| x.as_ref())
+    pub fn get_client_states(
+        &self,
+    ) -> impl Iterator<Item = (ClientHandle, &(ClientConfig, ClientState))> {
+        self.clients.iter().map(|(k, v)| (k as ClientHandle, v))
     }
 
-    pub fn get_client_states_mut(&mut self) -> impl Iterator<Item = &mut ClientState> {
-        self.clients.iter_mut().filter_map(|x| x.as_mut())
+    pub fn get_client_states_mut(
+        &mut self,
+    ) -> impl Iterator<Item = (ClientHandle, &mut (ClientConfig, ClientState))> {
+        self.clients.iter_mut().map(|(k, v)| (k as ClientHandle, v))
     }
 }

src/config.rs

@@ -1,22 +1,28 @@
 use anyhow::Result;
-use clap::Parser;
+use clap::{Parser, ValueEnum};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::env;
+use std::fmt::Display;
 use std::net::IpAddr;
 use std::{error::Error, fs};
 use toml;
 
 use crate::client::Position;
-use crate::scancode;
-use crate::scancode::Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift};
+
+use input_event::scancode::{
+    self,
+    Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
+};
 
 pub const DEFAULT_PORT: u16 = 4242;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ConfigToml {
+    pub capture_backend: Option<CaptureBackend>,
+    pub emulation_backend: Option<EmulationBackend>,
     pub port: Option<u16>,
-    pub frontend: Option<String>,
+    pub frontend: Option<Frontend>,
     pub release_bind: Option<Vec<scancode::Linux>>,
     pub left: Option<TomlClient>,
     pub right: Option<TomlClient>,
@@ -26,11 +32,13 @@ pub struct ConfigToml {
 
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct TomlClient {
+    pub capture_backend: Option<CaptureBackend>,
     pub hostname: Option<String>,
     pub host_name: Option<String>,
     pub ips: Option<Vec<IpAddr>>,
     pub port: Option<u16>,
     pub activate_on_startup: Option<bool>,
+    pub enter_hook: Option<String>,
 }
 
 impl ConfigToml {
@@ -50,7 +58,7 @@ struct CliArgs {
 
     /// the frontend to use [cli | gtk]
     #[arg(short, long)]
-    frontend: Option<String>,
+    frontend: Option<Frontend>,
 
     /// non-default config file location
     #[arg(short, long)]
@@ -59,21 +67,159 @@ struct CliArgs {
     /// run only the service as a daemon without the frontend
     #[arg(short, long)]
     daemon: bool,
+
+    /// test input capture
+    #[arg(long)]
+    test_capture: bool,
+
+    /// test input emulation
+    #[arg(long)]
+    test_emulation: bool,
+
+    /// capture backend override
+    #[arg(long)]
+    capture_backend: Option<CaptureBackend>,
+
+    /// emulation backend override
+    #[arg(long)]
+    emulation_backend: Option<EmulationBackend>,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
+pub enum CaptureBackend {
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    InputCapturePortal,
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    LayerShell,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl Display for CaptureBackend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            CaptureBackend::InputCapturePortal => write!(f, "input-capture-portal"),
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            CaptureBackend::LayerShell => write!(f, "layer-shell"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            CaptureBackend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            CaptureBackend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            CaptureBackend::MacOs => write!(f, "MacOS"),
+            CaptureBackend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+impl From<CaptureBackend> for input_capture::Backend {
+    fn from(backend: CaptureBackend) -> Self {
+        match backend {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            CaptureBackend::InputCapturePortal => Self::InputCapturePortal,
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            CaptureBackend::LayerShell => Self::LayerShell,
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            CaptureBackend::X11 => Self::X11,
+            #[cfg(windows)]
+            CaptureBackend::Windows => Self::Windows,
+            #[cfg(target_os = "macos")]
+            CaptureBackend::MacOs => Self::MacOs,
+            CaptureBackend::Dummy => Self::Dummy,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
+pub enum EmulationBackend {
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    Wlroots,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei,
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    Xdp,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl From<EmulationBackend> for input_emulation::Backend {
+    fn from(backend: EmulationBackend) -> Self {
+        match backend {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            EmulationBackend::Wlroots => Self::Wlroots,
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            EmulationBackend::Libei => Self::Libei,
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            EmulationBackend::Xdp => Self::Xdp,
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            EmulationBackend::X11 => Self::X11,
+            #[cfg(windows)]
+            EmulationBackend::Windows => Self::Windows,
+            #[cfg(target_os = "macos")]
+            EmulationBackend::MacOs => Self::MacOs,
+            EmulationBackend::Dummy => Self::Dummy,
+        }
+    }
+}
+
+impl Display for EmulationBackend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            EmulationBackend::Wlroots => write!(f, "wlroots"),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            EmulationBackend::Libei => write!(f, "libei"),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            EmulationBackend::Xdp => write!(f, "xdg-desktop-portal"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            EmulationBackend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            EmulationBackend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            EmulationBackend::MacOs => write!(f, "macos"),
+            EmulationBackend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
 pub enum Frontend {
     Gtk,
     Cli,
 }
 
+impl Default for Frontend {
+    fn default() -> Self {
+        if cfg!(feature = "gtk") {
+            Self::Gtk
+        } else {
+            Self::Cli
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Config {
+    pub capture_backend: Option<CaptureBackend>,
+    pub emulation_backend: Option<EmulationBackend>,
     pub frontend: Frontend,
     pub port: u16,
     pub clients: Vec<(TomlClient, Position)>,
     pub daemon: bool,
     pub release_bind: Vec<scancode::Linux>,
+    pub test_capture: bool,
+    pub test_emulation: bool,
 }
 
 pub struct ConfigClient {
@@ -82,6 +228,7 @@ pub struct ConfigClient {
     pub port: u16,
     pub pos: Position,
     pub active: bool,
+    pub enter_hook: Option<String>,
 }
 
 const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
@@ -117,33 +264,14 @@ impl Config {
             Ok(c) => Some(c),
         };
 
-        let frontend = match args.frontend {
-            None => match &config_toml {
-                Some(c) => c.frontend.clone(),
-                None => None,
-            },
-            frontend => frontend,
-        };
+        let frontend_arg = args.frontend;
+        let frontend_cfg = config_toml.as_ref().and_then(|c| c.frontend);
+        let frontend = frontend_arg.or(frontend_cfg).unwrap_or_default();
 
-        let frontend = match frontend {
-            #[cfg(feature = "gtk")]
-            None => Frontend::Gtk,
-            #[cfg(not(feature = "gtk"))]
-            None => Frontend::Cli,
-            Some(s) => match s.as_str() {
-                "cli" => Frontend::Cli,
-                "gtk" => Frontend::Gtk,
-                _ => Frontend::Cli,
-            },
-        };
-
-        let port = match args.port {
-            Some(port) => port,
-            None => match &config_toml {
-                Some(c) => c.port.unwrap_or(DEFAULT_PORT),
-                None => DEFAULT_PORT,
-            },
-        };
+        let port = args
+            .port
+            .or(config_toml.as_ref().and_then(|c| c.port))
+            .unwrap_or(DEFAULT_PORT);
 
         log::debug!("{config_toml:?}");
         let release_bind = config_toml
@@ -151,6 +279,14 @@ impl Config {
             .and_then(|c| c.release_bind.clone())
             .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()));
 
+        let capture_backend = args
+            .capture_backend
+            .or(config_toml.as_ref().and_then(|c| c.capture_backend));
+
+        let emulation_backend = args
+            .emulation_backend
+            .or(config_toml.as_ref().and_then(|c| c.emulation_backend));
+
         let mut clients: Vec<(TomlClient, Position)> = vec![];
 
         if let Some(config_toml) = config_toml {
@@ -169,13 +305,19 @@ impl Config {
         }
 
         let daemon = args.daemon;
+        let test_capture = args.test_capture;
+        let test_emulation = args.test_emulation;
 
         Ok(Config {
+            capture_backend,
+            emulation_backend,
             daemon,
             frontend,
             clients,
             port,
             release_bind,
+            test_capture,
+            test_emulation,
         })
     }
 
@@ -194,12 +336,14 @@ impl Config {
                     None => c.host_name.clone(),
                 };
                 let active = c.activate_on_startup.unwrap_or(false);
+                let enter_hook = c.enter_hook.clone();
                 ConfigClient {
                     ips,
                     hostname,
                     port,
                     pos: *pos,
                     active,
+                    enter_hook,
                 }
             })
             .collect()

src/consumer.rs

@@ -1,78 +0,0 @@
-use async_trait::async_trait;
-use std::future;
-
-use crate::{
-    backend::consumer,
-    client::{ClientEvent, ClientHandle},
-    event::Event,
-};
-use anyhow::Result;
-
-#[async_trait]
-pub trait EventConsumer: Send {
-    async fn consume(&mut self, event: Event, client_handle: ClientHandle);
-    async fn notify(&mut self, client_event: ClientEvent);
-    /// this function is waited on continuously and can be used to handle events
-    async fn dispatch(&mut self) -> Result<()> {
-        let _: () = future::pending().await;
-        Ok(())
-    }
-
-    async fn destroy(&mut self);
-}
-
-pub async fn create() -> Box<dyn EventConsumer> {
-    #[cfg(windows)]
-    match consumer::windows::WindowsConsumer::new() {
-        Ok(c) => return Box::new(c),
-        Err(e) => log::warn!("windows event consumer unavailable: {e}"),
-    }
-
-    #[cfg(target_os = "macos")]
-    match consumer::macos::MacOSConsumer::new() {
-        Ok(c) => {
-            log::info!("using macos event consumer");
-            return Box::new(c);
-        }
-        Err(e) => log::error!("macos consumer not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    match consumer::wlroots::WlrootsConsumer::new() {
-        Ok(c) => {
-            log::info!("using wlroots event consumer");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("wayland backend not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    match consumer::libei::LibeiConsumer::new().await {
-        Ok(c) => {
-            log::info!("using libei event consumer");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("libei not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-    match consumer::xdg_desktop_portal::DesktopPortalConsumer::new().await {
-        Ok(c) => {
-            log::info!("using xdg-remote-desktop-portal event consumer");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("remote desktop portal not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    match consumer::x11::X11Consumer::new() {
-        Ok(c) => {
-            log::info!("using x11 event consumer");
-            return Box::new(c);
-        }
-        Err(e) => log::info!("x11 consumer not available: {e}"),
-    }
-
-    log::error!("falling back to dummy event consumer");
-    Box::new(consumer::dummy::DummyConsumer::new())
-}

src/dns.rs

@@ -1,23 +1,62 @@
-use anyhow::Result;
-use std::{error::Error, net::IpAddr};
+use std::net::IpAddr;
+use tokio::sync::mpsc::Receiver;
 
-use trust_dns_resolver::TokioAsyncResolver;
+use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
 
-pub struct DnsResolver {
+use crate::{client::ClientHandle, server::Server};
+
+pub(crate) struct DnsResolver {
     resolver: TokioAsyncResolver,
+    dns_request: Receiver<ClientHandle>,
 }
+
 impl DnsResolver {
-    pub(crate) async fn new() -> Result<Self> {
+    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
         let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
-        Ok(Self { resolver })
+        Ok(Self {
+            resolver,
+            dns_request,
+        })
     }
 
-    pub(crate) async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
-        log::info!("resolving {host} ...");
+    async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
         let response = self.resolver.lookup_ip(host).await?;
         for ip in response.iter() {
             log::info!("{host}: adding ip {ip}");
         }
         Ok(response.iter().collect())
     }
+
+    pub(crate) async fn run(mut self, server: Server) {
+        tokio::select! {
+            _ = server.cancelled() => {},
+            _ = self.do_dns(&server) => {},
+        }
+    }
+
+    async fn do_dns(&mut self, server: &Server) {
+        loop {
+            let handle = self.dns_request.recv().await.expect("channel closed");
+
+            /* update resolving status */
+            let hostname = match server.get_hostname(handle) {
+                Some(hostname) => hostname,
+                None => continue,
+            };
+
+            log::info!("resolving ({handle}) `{hostname}` ...");
+            server.set_resolving(handle, true);
+
+            let ips = match self.resolve(&hostname).await {
+                Ok(ips) => ips,
+                Err(e) => {
+                    log::warn!("could not resolve host '{hostname}': {e}");
+                    vec![]
+                }
+            };
+
+            server.update_dns_ips(handle, ips);
+            server.set_resolving(handle, false);
+        }
+    }
 }

src/emulation_test.rs

@@ -0,0 +1,46 @@
+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};
+use tokio::task::LocalSet;
+
+pub fn run() -> Result<()> {
+    log::info!("running input emulation test");
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+
+    let config = Config::new()?;
+
+    runtime.block_on(LocalSet::new().run_until(input_emulation_test(config)))
+}
+
+const FREQUENCY_HZ: f64 = 1.0;
+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?;
+    emulation.create(0).await;
+    let start = Instant::now();
+    let mut offset = (0, 0);
+    loop {
+        tokio::time::sleep(Duration::from_millis(1)).await;
+        let elapsed = start.elapsed();
+        let elapsed_sec_f64 = elapsed.as_secs_f64();
+        let second_fraction = elapsed_sec_f64 - elapsed_sec_f64 as u64 as f64;
+        let radians = second_fraction * 2. * PI * FREQUENCY_HZ;
+        let new_offset_f = (radians.cos() * RADIUS * 2., (radians * 2.).sin() * RADIUS);
+        let new_offset = (new_offset_f.0 as i32, new_offset_f.1 as i32);
+        if new_offset != offset {
+            let relative_motion = (new_offset.0 - offset.0, new_offset.1 - offset.1);
+            offset = new_offset;
+            let (dx, dy) = (relative_motion.0 as f64, relative_motion.1 as f64);
+            let event = Event::Pointer(PointerEvent::Motion { time: 0, dx, dy });
+            emulation.consume(event, 0).await?;
+        }
+    }
+}

src/event.rs

@@ -1,530 +0,0 @@
-use anyhow::{anyhow, Result};
-use std::{
-    error::Error,
-    fmt::{self, Display},
-};
-
-// FIXME
-pub const BTN_LEFT: u32 = 0x110;
-pub const BTN_RIGHT: u32 = 0x111;
-pub const BTN_MIDDLE: u32 = 0x112;
-pub const BTN_BACK: u32 = 0x113;
-pub const BTN_FORWARD: u32 = 0x114;
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum PointerEvent {
-    Motion {
-        time: u32,
-        relative_x: f64,
-        relative_y: f64,
-    },
-    Button {
-        time: u32,
-        button: u32,
-        state: u32,
-    },
-    Axis {
-        time: u32,
-        axis: u8,
-        value: f64,
-    },
-    Frame {},
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum KeyboardEvent {
-    Key {
-        time: u32,
-        key: u32,
-        state: u8,
-    },
-    Modifiers {
-        mods_depressed: u32,
-        mods_latched: u32,
-        mods_locked: u32,
-        group: u32,
-    },
-}
-
-#[derive(PartialEq, Debug, Clone, Copy)]
-pub enum Event {
-    /// pointer event (motion / button / axis)
-    Pointer(PointerEvent),
-    /// keyboard events (key / modifiers)
-    Keyboard(KeyboardEvent),
-    /// enter event: request to enter a client.
-    /// The client must release the pointer if it is grabbed
-    /// and reply with a leave event, as soon as its ready to
-    /// receive events
-    Enter(),
-    /// leave event: this client is now ready to receive events and will
-    /// not send any events after until it sends an enter event
-    Leave(),
-    /// ping a client, to see if it is still alive. A client that does
-    /// not respond with a pong event will be assumed to be offline.
-    Ping(),
-    /// 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 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            PointerEvent::Motion {
-                time: _,
-                relative_x,
-                relative_y,
-            } => write!(f, "motion({relative_x},{relative_y})"),
-            PointerEvent::Button {
-                time: _,
-                button,
-                state,
-            } => write!(f, "button({button}, {state})"),
-            PointerEvent::Axis {
-                time: _,
-                axis,
-                value,
-            } => write!(f, "scroll({axis}, {value})"),
-            PointerEvent::Frame {} => write!(f, "frame()"),
-        }
-    }
-}
-
-impl Display for KeyboardEvent {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            KeyboardEvent::Key {
-                time: _,
-                key,
-                state,
-            } => write!(f, "key({key}, {state})"),
-            KeyboardEvent::Modifiers {
-                mods_depressed,
-                mods_latched,
-                mods_locked,
-                group,
-            } => write!(
-                f,
-                "modifiers({mods_depressed},{mods_latched},{mods_locked},{group})"
-            ),
-        }
-    }
-}
-
-impl Display for Event {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Event::Pointer(p) => write!(f, "{}", p),
-            Event::Keyboard(k) => write!(f, "{}", k),
-            Event::Enter() => write!(f, "enter"),
-            Event::Leave() => write!(f, "leave"),
-            Event::Ping() => write!(f, "ping"),
-            Event::Pong() => write!(f, "pong"),
-            Event::Disconnect() => write!(f, "disconnect"),
-        }
-    }
-}
-
-impl Event {
-    fn event_type(&self) -> EventType {
-        match self {
-            Self::Pointer(_) => EventType::Pointer,
-            Self::Keyboard(_) => EventType::Keyboard,
-            Self::Enter() => EventType::Enter,
-            Self::Leave() => EventType::Leave,
-            Self::Ping() => EventType::Ping,
-            Self::Pong() => EventType::Pong,
-            Self::Disconnect() => EventType::Disconnect,
-        }
-    }
-}
-
-impl PointerEvent {
-    fn event_type(&self) -> PointerEventType {
-        match self {
-            Self::Motion { .. } => PointerEventType::Motion,
-            Self::Button { .. } => PointerEventType::Button,
-            Self::Axis { .. } => PointerEventType::Axis,
-            Self::Frame { .. } => PointerEventType::Frame,
-        }
-    }
-}
-
-impl KeyboardEvent {
-    fn event_type(&self) -> KeyboardEventType {
-        match self {
-            KeyboardEvent::Key { .. } => KeyboardEventType::Key,
-            KeyboardEvent::Modifiers { .. } => KeyboardEventType::Modifiers,
-        }
-    }
-}
-
-enum PointerEventType {
-    Motion,
-    Button,
-    Axis,
-    Frame,
-}
-enum KeyboardEventType {
-    Key,
-    Modifiers,
-}
-enum EventType {
-    Pointer,
-    Keyboard,
-    Enter,
-    Leave,
-    Ping,
-    Pong,
-    Disconnect,
-}
-
-impl TryFrom<u8> for PointerEventType {
-    type Error = anyhow::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(anyhow!(ProtocolError {
-                msg: format!("invalid pointer event type {}", value),
-            })),
-        }
-    }
-}
-
-impl TryFrom<u8> for KeyboardEventType {
-    type Error = anyhow::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(anyhow!(ProtocolError {
-                msg: format!("invalid keyboard event type {}", value),
-            })),
-        }
-    }
-}
-
-impl From<&Event> for Vec<u8> {
-    fn from(event: &Event) -> Self {
-        let event_id = vec![event.event_type() as u8];
-        let event_data = match event {
-            Event::Pointer(p) => p.into(),
-            Event::Keyboard(k) => k.into(),
-            Event::Enter() => vec![],
-            Event::Leave() => vec![],
-            Event::Ping() => vec![],
-            Event::Pong() => vec![],
-            Event::Disconnect() => vec![],
-        };
-        [event_id, event_data].concat()
-    }
-}
-
-#[derive(Debug)]
-struct ProtocolError {
-    msg: String,
-}
-
-impl fmt::Display for ProtocolError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Protocol violation: {}", self.msg)
-    }
-}
-impl Error for ProtocolError {}
-
-impl TryFrom<Vec<u8>> for Event {
-    type Error = anyhow::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()?)),
-            i if i == (EventType::Keyboard as u8) => Ok(Event::Keyboard(value.try_into()?)),
-            i if i == (EventType::Enter as u8) => Ok(Event::Enter()),
-            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()),
-            i if i == (EventType::Disconnect as u8) => Ok(Event::Disconnect()),
-            _ => Err(anyhow!(ProtocolError {
-                msg: format!("invalid event_id {}", event_id),
-            })),
-        }
-    }
-}
-
-impl From<&PointerEvent> for Vec<u8> {
-    fn from(event: &PointerEvent) -> Self {
-        let id = vec![event.event_type() as u8];
-        let data = match event {
-            PointerEvent::Motion {
-                time,
-                relative_x,
-                relative_y,
-            } => {
-                let time = time.to_be_bytes();
-                let relative_x = relative_x.to_be_bytes();
-                let relative_y = relative_y.to_be_bytes();
-                [&time[..], &relative_x[..], &relative_y[..]].concat()
-            }
-            PointerEvent::Button {
-                time,
-                button,
-                state,
-            } => {
-                let time = time.to_be_bytes();
-                let button = button.to_be_bytes();
-                let state = state.to_be_bytes();
-                [&time[..], &button[..], &state[..]].concat()
-            }
-            PointerEvent::Axis { time, axis, value } => {
-                let time = time.to_be_bytes();
-                let axis = axis.to_be_bytes();
-                let value = value.to_be_bytes();
-                [&time[..], &axis[..], &value[..]].concat()
-            }
-            PointerEvent::Frame {} => {
-                vec![]
-            }
-        };
-        [id, data].concat()
-    }
-}
-
-impl TryFrom<Vec<u8>> for PointerEvent {
-    type Error = anyhow::Error;
-
-    fn try_from(data: Vec<u8>) -> Result<Self> {
-        match data.get(1) {
-            Some(id) => {
-                let event_type = match id.to_owned().try_into() {
-                    Ok(event_type) => event_type,
-                    Err(e) => return Err(e),
-                };
-                match event_type {
-                    PointerEventType::Motion => {
-                        let time = match data.get(2..6) {
-                            Some(d) => u32::from_be_bytes(d.try_into()?),
-                            None => {
-                                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(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(anyhow!(ProtocolError {
-                                    msg: "Expected 8 Bytes at index 14".into(),
-                                }))
-                            }
-                        };
-                        Ok(Self::Motion {
-                            time,
-                            relative_x,
-                            relative_y,
-                        })
-                    }
-                    PointerEventType::Button => {
-                        let time = match data.get(2..6) {
-                            Some(d) => u32::from_be_bytes(d.try_into()?),
-                            None => {
-                                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(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(anyhow!(ProtocolError {
-                                    msg: "Expected 4 Bytes at index 14".into(),
-                                }))
-                            }
-                        };
-                        Ok(Self::Button {
-                            time,
-                            button,
-                            state,
-                        })
-                    }
-                    PointerEventType::Axis => {
-                        let time = match data.get(2..6) {
-                            Some(d) => u32::from_be_bytes(d.try_into()?),
-                            None => {
-                                return Err(anyhow!(ProtocolError {
-                                    msg: "Expected 4 Bytes at index 2".into(),
-                                }))
-                            }
-                        };
-                        let axis = match data.get(6) {
-                            Some(d) => *d,
-                            None => {
-                                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(anyhow!(ProtocolError {
-                                    msg: "Expected 8 Bytes at index 7".into(),
-                                }));
-                            }
-                        };
-                        Ok(Self::Axis { time, axis, value })
-                    }
-                    PointerEventType::Frame => Ok(Self::Frame {}),
-                }
-            }
-            None => Err(anyhow!(ProtocolError {
-                msg: "Expected an element at index 0".into(),
-            })),
-        }
-    }
-}
-
-impl From<&KeyboardEvent> for Vec<u8> {
-    fn from(event: &KeyboardEvent) -> Self {
-        let id = vec![event.event_type() as u8];
-        let data = match event {
-            KeyboardEvent::Key { time, key, state } => {
-                let time = time.to_be_bytes();
-                let key = key.to_be_bytes();
-                let state = state.to_be_bytes();
-                [&time[..], &key[..], &state[..]].concat()
-            }
-            KeyboardEvent::Modifiers {
-                mods_depressed,
-                mods_latched,
-                mods_locked,
-                group,
-            } => {
-                let mods_depressed = mods_depressed.to_be_bytes();
-                let mods_latched = mods_latched.to_be_bytes();
-                let mods_locked = mods_locked.to_be_bytes();
-                let group = group.to_be_bytes();
-                [
-                    &mods_depressed[..],
-                    &mods_latched[..],
-                    &mods_locked[..],
-                    &group[..],
-                ]
-                .concat()
-            }
-        };
-        [id, data].concat()
-    }
-}
-
-impl TryFrom<Vec<u8>> for KeyboardEvent {
-    type Error = anyhow::Error;
-
-    fn try_from(data: Vec<u8>) -> Result<Self> {
-        match data.get(1) {
-            Some(id) => {
-                let event_type = match id.to_owned().try_into() {
-                    Ok(event_type) => event_type,
-                    Err(e) => return Err(e),
-                };
-                match event_type {
-                    KeyboardEventType::Key => {
-                        let time = match data.get(2..6) {
-                            Some(d) => u32::from_be_bytes(d.try_into()?),
-                            None => {
-                                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(anyhow!(ProtocolError {
-                                    msg: "Expected 4 Bytes at index 10".into(),
-                                }))
-                            }
-                        };
-                        let state = match data.get(10) {
-                            Some(d) => *d,
-                            None => {
-                                return Err(anyhow!(ProtocolError {
-                                    msg: "Expected 1 Bytes at index 14".into(),
-                                }))
-                            }
-                        };
-                        Ok(KeyboardEvent::Key { time, key, state })
-                    }
-                    KeyboardEventType::Modifiers => {
-                        let mods_depressed = match data.get(2..6) {
-                            Some(d) => u32::from_be_bytes(d.try_into()?),
-                            None => {
-                                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(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(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(anyhow!(ProtocolError {
-                                    msg: "Expected 4 Bytes at index 18".into(),
-                                }))
-                            }
-                        };
-                        Ok(KeyboardEvent::Modifiers {
-                            mods_depressed,
-                            mods_latched,
-                            mods_locked,
-                            group,
-                        })
-                    }
-                }
-            }
-            None => Err(anyhow!(ProtocolError {
-                msg: "Expected an element at index 0".into(),
-            })),
-        }
-    }
-}

src/frontend.rs

@@ -1,5 +1,5 @@
 use anyhow::{anyhow, Result};
-use std::{cmp::min, io::ErrorKind, str, time::Duration};
+use std::{cmp::min, io::ErrorKind, net::IpAddr, str, time::Duration};
 
 #[cfg(unix)]
 use std::{
@@ -23,7 +23,7 @@ use tokio::net::TcpStream;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    client::{Client, ClientHandle, Position},
+    client::{ClientConfig, ClientHandle, ClientState, Position},
     config::{Config, Frontend},
 };
 
@@ -84,34 +84,71 @@ pub fn wait_for_service() -> Result<std::net::TcpStream> {
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
-pub enum FrontendEvent {
-    /// add a new client
-    AddClient(Option<String>, u16, Position),
+pub enum FrontendRequest {
     /// activate/deactivate client
-    ActivateClient(ClientHandle, bool),
+    Activate(ClientHandle, bool),
+    /// add a new client
+    Create,
     /// change the listen port (recreate udp listener)
     ChangePort(u16),
     /// remove a client
-    DelClient(ClientHandle),
-    /// request an enumertaion of all clients
+    Delete(ClientHandle),
+    /// request an enumeration of all clients
     Enumerate(),
-    /// service shutdown
-    Shutdown(),
-    /// update a client (hostname, port, position)
-    UpdateClient(ClientHandle, Option<String>, u16, Position),
+    /// resolve dns
+    ResolveDns(ClientHandle),
+    /// update hostname
+    UpdateHostname(ClientHandle, Option<String>),
+    /// update port
+    UpdatePort(ClientHandle, u16),
+    /// update position
+    UpdatePosition(ClientHandle, Position),
+    /// update fix-ips
+    UpdateFixIps(ClientHandle, Vec<IpAddr>),
+    /// request the state of the given client
+    GetState(ClientHandle),
+    /// request reenabling input capture
+    EnableCapture,
+    /// request reenabling input emulation
+    EnableEmulation,
+}
+
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
+pub enum Status {
+    #[default]
+    Disabled,
+    Enabled,
+}
+
+impl From<Status> for bool {
+    fn from(status: Status) -> Self {
+        match status {
+            Status::Enabled => true,
+            Status::Disabled => false,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum FrontendNotify {
-    NotifyClientActivate(ClientHandle, bool),
-    NotifyClientCreate(Client),
-    NotifyClientUpdate(Client),
-    NotifyClientDelete(ClientHandle),
+pub enum FrontendEvent {
+    /// a client was created
+    Created(ClientHandle, ClientConfig, ClientState),
+    /// no such client
+    NoSuchClient(ClientHandle),
+    /// state changed
+    State(ClientHandle, ClientConfig, ClientState),
+    /// the client was deleted
+    Deleted(ClientHandle),
     /// new port, reason of failure (if failed)
-    NotifyPortChange(u16, Option<String>),
-    /// Client State, active
-    Enumerate(Vec<(Client, bool)>),
-    NotifyError(String),
+    PortChanged(u16, Option<String>),
+    /// list of all clients, used for initial state synchronization
+    Enumerate(Vec<(ClientHandle, ClientConfig, ClientState)>),
+    /// an error occured
+    Error(String),
+    /// capture status
+    CaptureStatus(Status),
+    /// emulation status
+    EmulationStatus(Status),
 }
 
 pub struct FrontendListener {
@@ -217,13 +254,12 @@ impl FrontendListener {
         Ok(rx)
     }
 
-    pub(crate) async fn notify_all(&mut self, notify: FrontendNotify) -> Result<()> {
+    pub(crate) async fn broadcast(&mut self, notify: FrontendEvent) {
         // encode event
         let json = serde_json::to_string(&notify).unwrap();
         let payload = json.as_bytes();
         let len = payload.len().to_be_bytes();
-        log::debug!("json: {json}, len: {}", payload.len());
-
+        log::debug!("broadcasting event to streams: {json}");
         let mut keep = vec![];
         // TODO do simultaneously
         for tx in self.tx_streams.iter_mut() {
@@ -242,7 +278,6 @@ impl FrontendListener {
         // could not find a better solution because async
         let mut keep = keep.into_iter();
         self.tx_streams.retain(|_| keep.next().unwrap());
-        Ok(())
     }
 }
 
@@ -255,7 +290,7 @@ impl Drop for FrontendListener {
 }
 
 #[cfg(unix)]
-pub async fn read_event(stream: &mut ReadHalf<UnixStream>) -> Result<FrontendEvent> {
+pub async fn wait_for_request(stream: &mut ReadHalf<UnixStream>) -> Result<FrontendRequest> {
     let len = stream.read_u64().await?;
     assert!(len <= 256);
     let mut buf = [0u8; 256];
@@ -264,7 +299,7 @@ pub async fn read_event(stream: &mut ReadHalf<UnixStream>) -> Result<FrontendEve
 }
 
 #[cfg(windows)]
-pub async fn read_event(stream: &mut ReadHalf<TcpStream>) -> Result<FrontendEvent> {
+pub async fn wait_for_request(stream: &mut ReadHalf<TcpStream>) -> Result<FrontendRequest> {
     let len = stream.read_u64().await?;
     let mut buf = [0u8; 256];
     stream.read_exact(&mut buf[..len as usize]).await?;

src/frontend/cli.rs

@@ -1,242 +1,331 @@
-use anyhow::{anyhow, Context, Result};
-
-use std::{
-    io::{ErrorKind, Read, Write},
-    str::SplitWhitespace,
-    thread,
+use anyhow::{anyhow, Result};
+use tokio::{
+    io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader},
+    task::LocalSet,
 };
 
-use crate::{client::Position, config::DEFAULT_PORT};
+#[cfg(windows)]
+use tokio::net::tcp::{ReadHalf, WriteHalf};
+#[cfg(unix)]
+use tokio::net::unix::{ReadHalf, WriteHalf};
 
-use super::{FrontendEvent, FrontendNotify};
+use std::io::{self, Write};
+
+use crate::{
+    client::{ClientConfig, ClientHandle, ClientState},
+    config::DEFAULT_PORT,
+};
+
+use self::command::{Command, CommandType};
+
+use super::{FrontendEvent, FrontendRequest};
+
+mod command;
 
 pub fn run() -> Result<()> {
-    let Ok(mut tx) = super::wait_for_service() else {
+    let Ok(stream) = super::wait_for_service() else {
         return Err(anyhow!("Could not connect to lan-mouse-socket"));
     };
 
-    let mut rx = tx.try_clone()?;
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+    runtime.block_on(LocalSet::new().run_until(async move {
+        stream.set_nonblocking(true)?;
+        #[cfg(unix)]
+        let mut stream = tokio::net::UnixStream::from_std(stream)?;
+        #[cfg(windows)]
+        let mut stream = tokio::net::TcpStream::from_std(stream)?;
+        let (rx, tx) = stream.split();
 
-    let reader = thread::Builder::new()
-        .name("cli-frontend".to_string())
-        .spawn(move || {
-            // all further prompts
-            prompt();
-            loop {
-                let mut buf = String::new();
-                match std::io::stdin().read_line(&mut buf) {
-                    Ok(0) => return,
-                    Ok(len) => {
-                        if let Some(events) = parse_cmd(buf, len) {
-                            for event in events.iter() {
-                                let json = serde_json::to_string(&event).unwrap();
-                                let bytes = json.as_bytes();
-                                let len = bytes.len().to_be_bytes();
-                                if let Err(e) = tx.write(&len) {
-                                    log::error!("error sending message: {e}");
-                                };
-                                if let Err(e) = tx.write(bytes) {
-                                    log::error!("error sending message: {e}");
-                                };
-                                if *event == FrontendEvent::Shutdown() {
-                                    return;
-                                }
-                            }
-                            // prompt is printed after the server response is received
-                        } else {
-                            prompt();
-                        }
-                    }
-                    Err(e) => {
-                        if e.kind() != ErrorKind::UnexpectedEof {
-                            log::error!("error reading from stdin: {e}");
-                        }
-                        return;
-                    }
-                }
-            }
-        })?;
-
-    let _ = thread::Builder::new()
-        .name("cli-frontend-notify".to_string())
-        .spawn(move || {
-            loop {
-                // read len
-                let mut len = [0u8; 8];
-                match rx.read_exact(&mut len) {
-                    Ok(()) => (),
-                    Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
-                    Err(e) => break log::error!("{e}"),
-                };
-                let len = usize::from_be_bytes(len);
-
-                // read payload
-                let mut buf: Vec<u8> = vec![0u8; len];
-                match rx.read_exact(&mut buf[..len]) {
-                    Ok(()) => (),
-                    Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
-                    Err(e) => break log::error!("{e}"),
-                };
-
-                let notify: FrontendNotify = match serde_json::from_slice(&buf) {
-                    Ok(n) => n,
-                    Err(e) => break log::error!("{e}"),
-                };
-                match notify {
-                    FrontendNotify::NotifyClientActivate(handle, active) => {
-                        if active {
-                            log::info!("client {handle} activated");
-                        } else {
-                            log::info!("client {handle} deactivated");
-                        }
-                    }
-                    FrontendNotify::NotifyClientCreate(client) => {
-                        let handle = client.handle;
-                        let port = client.port;
-                        let pos = client.pos;
-                        let hostname = client.hostname.as_deref().unwrap_or("");
-                        log::info!("new client ({handle}): {hostname}:{port} - {pos}");
-                    }
-                    FrontendNotify::NotifyClientUpdate(client) => {
-                        let handle = client.handle;
-                        let port = client.port;
-                        let pos = client.pos;
-                        let hostname = client.hostname.as_deref().unwrap_or("");
-                        log::info!("client ({handle}) updated: {hostname}:{port} - {pos}");
-                    }
-                    FrontendNotify::NotifyClientDelete(client) => {
-                        log::info!("client ({client}) deleted.");
-                    }
-                    FrontendNotify::NotifyError(e) => {
-                        log::warn!("{e}");
-                    }
-                    FrontendNotify::Enumerate(clients) => {
-                        for (client, active) in clients.into_iter() {
-                            log::info!(
-                                "client ({}) [{}]: active: {}, associated addresses: [{}]",
-                                client.handle,
-                                client.hostname.as_deref().unwrap_or(""),
-                                if active { "yes" } else { "no" },
-                                client
-                                    .ips
-                                    .into_iter()
-                                    .map(|a| a.to_string())
-                                    .collect::<Vec<String>>()
-                                    .join(", ")
-                            );
-                        }
-                    }
-                    FrontendNotify::NotifyPortChange(port, msg) => match msg {
-                        Some(msg) => log::info!("could not change port: {msg}"),
-                        None => log::info!("port changed: {port}"),
-                    },
-                }
-                prompt();
-            }
-        })?;
-    match reader.join() {
-        Ok(_) => {}
-        Err(e) => {
-            let msg = match (e.downcast_ref::<&str>(), e.downcast_ref::<String>()) {
-                (Some(&s), _) => s,
-                (_, Some(s)) => s,
-                _ => "no panic info",
-            };
-            log::error!("reader thread paniced: {msg}");
-        }
-    }
+        let mut cli = Cli::new(rx, tx);
+        cli.run().await
+    }))?;
     Ok(())
 }
 
-fn prompt() {
+struct Cli<'a> {
+    clients: Vec<(ClientHandle, ClientConfig, ClientState)>,
+    rx: ReadHalf<'a>,
+    tx: WriteHalf<'a>,
+}
+
+impl<'a> Cli<'a> {
+    fn new(rx: ReadHalf<'a>, tx: WriteHalf<'a>) -> Cli<'a> {
+        Self {
+            clients: vec![],
+            rx,
+            tx,
+        }
+    }
+
+    async fn run(&mut self) -> Result<()> {
+        let stdin = tokio::io::stdin();
+        let stdin = BufReader::new(stdin);
+        let mut stdin = stdin.lines();
+
+        /* initial state sync */
+        let request = FrontendRequest::Enumerate();
+        self.send_request(request).await?;
+
+        self.clients = loop {
+            let event = self.await_event().await?;
+            if let FrontendEvent::Enumerate(clients) = event {
+                break clients;
+            }
+        };
+
+        loop {
+            prompt()?;
+            tokio::select! {
+                line = stdin.next_line() => {
+                    let Some(line) = line? else {
+                        break Ok(());
+                    };
+                    let cmd: Command = match line.parse() {
+                        Ok(cmd) => cmd,
+                        Err(e) => {
+                            eprintln!("{e}");
+                            continue;
+                        }
+                    };
+                    self.execute(cmd).await?;
+                }
+                event = self.await_event() => {
+                    let event = event?;
+                    self.handle_event(event);
+                }
+            }
+        }
+    }
+
+    async fn update_client(&mut self, handle: ClientHandle) -> Result<()> {
+        self.send_request(FrontendRequest::GetState(handle)).await?;
+        loop {
+            let event = self.await_event().await?;
+            self.handle_event(event.clone());
+            if let FrontendEvent::State(_, _, _) | FrontendEvent::NoSuchClient(_) = event {
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    async fn execute(&mut self, cmd: Command) -> Result<()> {
+        match cmd {
+            Command::None => {}
+            Command::Connect(pos, host, port) => {
+                let request = FrontendRequest::Create;
+                self.send_request(request).await?;
+                let handle = loop {
+                    let event = self.await_event().await?;
+                    match event {
+                        FrontendEvent::Created(h, c, s) => {
+                            self.clients.push((h, c, s));
+                            break h;
+                        }
+                        _ => {
+                            self.handle_event(event);
+                            continue;
+                        }
+                    }
+                };
+                for request in [
+                    FrontendRequest::UpdateHostname(handle, Some(host.clone())),
+                    FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT)),
+                    FrontendRequest::UpdatePosition(handle, pos),
+                ] {
+                    self.send_request(request).await?;
+                }
+                self.update_client(handle).await?;
+            }
+            Command::Disconnect(id) => {
+                self.send_request(FrontendRequest::Delete(id)).await?;
+                loop {
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Deleted(_) = event {
+                        self.handle_event(event);
+                        break;
+                    }
+                }
+            }
+            Command::Activate(id) => {
+                self.send_request(FrontendRequest::Activate(id, true))
+                    .await?;
+                self.update_client(id).await?;
+            }
+            Command::Deactivate(id) => {
+                self.send_request(FrontendRequest::Activate(id, false))
+                    .await?;
+                self.update_client(id).await?;
+            }
+            Command::List => {
+                self.send_request(FrontendRequest::Enumerate()).await?;
+                loop {
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Enumerate(_) = event {
+                        break;
+                    }
+                }
+            }
+            Command::SetHost(handle, host) => {
+                let request = FrontendRequest::UpdateHostname(handle, Some(host.clone()));
+                self.send_request(request).await?;
+                self.update_client(handle).await?;
+            }
+            Command::SetPort(handle, port) => {
+                let request = FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT));
+                self.send_request(request).await?;
+                self.update_client(handle).await?;
+            }
+            Command::Help => {
+                for cmd_type in [
+                    CommandType::List,
+                    CommandType::Connect,
+                    CommandType::Disconnect,
+                    CommandType::Activate,
+                    CommandType::Deactivate,
+                    CommandType::SetHost,
+                    CommandType::SetPort,
+                ] {
+                    eprintln!("{}", cmd_type.usage());
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn find_mut(
+        &mut self,
+        handle: ClientHandle,
+    ) -> Option<&mut (ClientHandle, ClientConfig, ClientState)> {
+        self.clients.iter_mut().find(|(h, _, _)| *h == handle)
+    }
+
+    fn remove(
+        &mut self,
+        handle: ClientHandle,
+    ) -> Option<(ClientHandle, ClientConfig, ClientState)> {
+        let idx = self.clients.iter().position(|(h, _, _)| *h == handle);
+        idx.map(|i| self.clients.swap_remove(i))
+    }
+
+    fn handle_event(&mut self, event: FrontendEvent) {
+        match event {
+            FrontendEvent::Created(h, c, s) => {
+                eprint!("client added ({h}): ");
+                print_config(&c);
+                eprint!(" ");
+                print_state(&s);
+                eprintln!();
+                self.clients.push((h, c, s));
+            }
+            FrontendEvent::NoSuchClient(h) => {
+                eprintln!("no such client: {h}");
+            }
+            FrontendEvent::State(h, c, s) => {
+                if let Some((_, config, state)) = self.find_mut(h) {
+                    let old_host = config.hostname.clone().unwrap_or("\"\"".into());
+                    let new_host = c.hostname.clone().unwrap_or("\"\"".into());
+                    if old_host != new_host {
+                        eprintln!(
+                            "client {h}: hostname updated ({} -> {})",
+                            old_host, new_host
+                        );
+                    }
+                    if config.port != c.port {
+                        eprintln!("client {h} changed port: {} -> {}", config.port, c.port);
+                    }
+                    if config.fix_ips != c.fix_ips {
+                        eprintln!("client {h} ips updated: {:?}", c.fix_ips)
+                    }
+                    *config = c;
+                    if state.active ^ s.active {
+                        eprintln!(
+                            "client {h} {}",
+                            if s.active { "activated" } else { "deactivated" }
+                        );
+                    }
+                    *state = s;
+                }
+            }
+            FrontendEvent::Deleted(h) => {
+                if let Some((h, c, _)) = self.remove(h) {
+                    eprint!("client {h} removed (");
+                    print_config(&c);
+                    eprintln!(")");
+                }
+            }
+            FrontendEvent::PortChanged(p, e) => {
+                if let Some(e) = e {
+                    eprintln!("failed to change port: {e}");
+                } else {
+                    eprintln!("changed port to {p}");
+                }
+            }
+            FrontendEvent::Enumerate(clients) => {
+                self.clients = clients;
+                self.print_clients();
+            }
+            FrontendEvent::Error(e) => {
+                eprintln!("ERROR: {e}");
+            }
+            FrontendEvent::CaptureStatus(s) => {
+                eprintln!("capture status: {s:?}")
+            }
+            FrontendEvent::EmulationStatus(s) => {
+                eprintln!("emulation status: {s:?}")
+            }
+        }
+    }
+
+    fn print_clients(&mut self) {
+        for (h, c, s) in self.clients.iter() {
+            eprint!("client {h}: ");
+            print_config(c);
+            eprint!(" ");
+            print_state(s);
+            eprintln!();
+        }
+    }
+
+    async fn send_request(&mut self, request: FrontendRequest) -> io::Result<()> {
+        let json = serde_json::to_string(&request).unwrap();
+        let bytes = json.as_bytes();
+        let len = bytes.len();
+        self.tx.write_u64(len as u64).await?;
+        self.tx.write_all(bytes).await?;
+        Ok(())
+    }
+
+    async fn await_event(&mut self) -> Result<FrontendEvent> {
+        let len = self.rx.read_u64().await?;
+        let mut buf = vec![0u8; len as usize];
+        self.rx.read_exact(&mut buf).await?;
+        let event: FrontendEvent = serde_json::from_slice(&buf)?;
+        Ok(event)
+    }
+}
+
+fn prompt() -> io::Result<()> {
     eprint!("lan-mouse > ");
-    std::io::stderr().flush().unwrap();
+    std::io::stderr().flush()?;
+    Ok(())
 }
 
-fn parse_cmd(s: String, len: usize) -> Option<Vec<FrontendEvent>> {
-    if len == 0 {
-        return Some(vec![FrontendEvent::Shutdown()]);
-    }
-    let mut l = s.split_whitespace();
-    let cmd = l.next()?;
-    let res = match cmd {
-        "help" => {
-            log::info!("list                                                 list clients");
-            log::info!("connect <host> left|right|top|bottom [port]          add a new client");
-            log::info!("disconnect <client>                                  remove a client");
-            log::info!("activate <client>                                    activate a client");
-            log::info!("deactivate <client>                                  deactivate a client");
-            log::info!("exit                                                 exit lan-mouse");
-            log::info!("setport <port>                                       change port");
-            None
-        }
-        "exit" => return Some(vec![FrontendEvent::Shutdown()]),
-        "list" => return Some(vec![FrontendEvent::Enumerate()]),
-        "connect" => Some(parse_connect(l)),
-        "disconnect" => Some(parse_disconnect(l)),
-        "activate" => Some(parse_activate(l)),
-        "deactivate" => Some(parse_deactivate(l)),
-        "setport" => Some(parse_port(l)),
-        _ => {
-            log::error!("unknown command: {s}");
-            None
-        }
-    };
-    match res {
-        Some(Ok(e)) => Some(e),
-        Some(Err(e)) => {
-            log::warn!("{e}");
-            None
-        }
-        _ => None,
-    }
+fn print_config(c: &ClientConfig) {
+    eprint!(
+        "{}:{} ({}), ips: {:?}",
+        c.hostname.clone().unwrap_or("(no hostname)".into()),
+        c.port,
+        c.pos,
+        c.fix_ips
+    );
 }
 
-fn parse_connect(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
-    let usage = "usage: connect <host> left|right|top|bottom [port]";
-    let host = l.next().context(usage)?.to_owned();
-    let pos = match l.next().context(usage)? {
-        "right" => Position::Right,
-        "top" => Position::Top,
-        "bottom" => Position::Bottom,
-        _ => Position::Left,
-    };
-    let port = if let Some(p) = l.next() {
-        p.parse()?
-    } else {
-        DEFAULT_PORT
-    };
-    Ok(vec![
-        FrontendEvent::AddClient(Some(host), port, pos),
-        FrontendEvent::Enumerate(),
-    ])
-}
-
-fn parse_disconnect(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
-    let client = l.next().context("usage: disconnect <client_id>")?.parse()?;
-    Ok(vec![
-        FrontendEvent::DelClient(client),
-        FrontendEvent::Enumerate(),
-    ])
-}
-
-fn parse_activate(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
-    let client = l.next().context("usage: activate <client_id>")?.parse()?;
-    Ok(vec![
-        FrontendEvent::ActivateClient(client, true),
-        FrontendEvent::Enumerate(),
-    ])
-}
-
-fn parse_deactivate(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
-    let client = l.next().context("usage: deactivate <client_id>")?.parse()?;
-    Ok(vec![
-        FrontendEvent::ActivateClient(client, false),
-        FrontendEvent::Enumerate(),
-    ])
-}
-
-fn parse_port(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
-    let port = l.next().context("usage: setport <port>")?.parse()?;
-    Ok(vec![FrontendEvent::ChangePort(port)])
+fn print_state(s: &ClientState) {
+    eprint!("active: {}, dns: {:?}", s.active, s.ips);
 }

src/frontend/cli/command.rs

@@ -0,0 +1,153 @@
+use std::{
+    fmt::Display,
+    str::{FromStr, SplitWhitespace},
+};
+
+use crate::client::{ClientHandle, Position};
+
+pub(super) enum CommandType {
+    NoCommand,
+    Help,
+    Connect,
+    Disconnect,
+    Activate,
+    Deactivate,
+    List,
+    SetHost,
+    SetPort,
+}
+
+#[derive(Debug)]
+pub(super) struct InvalidCommand {
+    cmd: String,
+}
+
+impl Display for InvalidCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "invalid command: \"{}\"", self.cmd)
+    }
+}
+
+impl FromStr for CommandType {
+    type Err = InvalidCommand;
+
+    fn from_str(s: &str) -> std::prelude::v1::Result<Self, Self::Err> {
+        match s {
+            "connect" => Ok(Self::Connect),
+            "disconnect" => Ok(Self::Disconnect),
+            "activate" => Ok(Self::Activate),
+            "deactivate" => Ok(Self::Deactivate),
+            "list" => Ok(Self::List),
+            "set-host" => Ok(Self::SetHost),
+            "set-port" => Ok(Self::SetPort),
+            "help" => Ok(Self::Help),
+            _ => Err(InvalidCommand { cmd: s.to_string() }),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum Command {
+    None,
+    Help,
+    Connect(Position, String, Option<u16>),
+    Disconnect(ClientHandle),
+    Activate(ClientHandle),
+    Deactivate(ClientHandle),
+    List,
+    SetHost(ClientHandle, String),
+    SetPort(ClientHandle, Option<u16>),
+}
+
+impl CommandType {
+    pub(super) fn usage(&self) -> &'static str {
+        match self {
+            CommandType::Help => "help",
+            CommandType::NoCommand => "",
+            CommandType::Connect => "connect left|right|top|bottom <host> [<port>]",
+            CommandType::Disconnect => "disconnect <id>",
+            CommandType::Activate => "activate <id>",
+            CommandType::Deactivate => "deactivate <id>",
+            CommandType::List => "list",
+            CommandType::SetHost => "set-host <id> <host>",
+            CommandType::SetPort => "set-port <id> <host>",
+        }
+    }
+}
+
+pub(super) enum CommandParseError {
+    Usage(CommandType),
+    Invalid(InvalidCommand),
+}
+
+impl Display for CommandParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Usage(cmd) => write!(f, "usage: {}", cmd.usage()),
+            Self::Invalid(cmd) => write!(f, "{}", cmd),
+        }
+    }
+}
+
+impl FromStr for Command {
+    type Err = CommandParseError;
+
+    fn from_str(cmd: &str) -> Result<Self, Self::Err> {
+        let mut args = cmd.split_whitespace();
+        let cmd_type: CommandType = match args.next() {
+            Some(c) => c.parse().map_err(CommandParseError::Invalid),
+            None => Ok(CommandType::NoCommand),
+        }?;
+        match cmd_type {
+            CommandType::Help => Ok(Command::Help),
+            CommandType::NoCommand => Ok(Command::None),
+            CommandType::Connect => parse_connect_cmd(args),
+            CommandType::Disconnect => parse_disconnect_cmd(args),
+            CommandType::Activate => parse_activate_cmd(args),
+            CommandType::Deactivate => parse_deactivate_cmd(args),
+            CommandType::List => Ok(Command::List),
+            CommandType::SetHost => parse_set_host(args),
+            CommandType::SetPort => parse_set_port(args),
+        }
+    }
+}
+
+fn parse_connect_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Connect);
+    let pos = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    let host = args.next().ok_or(USAGE)?.to_string();
+    let port = args.next().and_then(|p| p.parse().ok());
+    Ok(Command::Connect(pos, host, port))
+}
+
+fn parse_disconnect_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Disconnect);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::Disconnect(id))
+}
+
+fn parse_activate_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Activate);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::Activate(id))
+}
+
+fn parse_deactivate_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Deactivate);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::Deactivate(id))
+}
+
+fn parse_set_host(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::SetHost);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    let host = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::SetHost(id, host))
+}
+
+fn parse_set_port(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::SetPort);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    let port = args.next().and_then(|p| p.parse().ok());
+    Ok(Command::SetPort(id, port))
+}

src/frontend/gtk.rs

@@ -11,15 +11,15 @@ use std::{
 use crate::frontend::gtk::window::Window;
 
 use adw::Application;
+use endi::{Endian, ReadBytes};
 use gtk::{
-    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, CssProvider,
-    IconTheme,
+    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
 };
 use gtk::{gio, glib, prelude::ApplicationExt};
 
 use self::client_object::ClientObject;
 
-use super::FrontendNotify;
+use super::FrontendEvent;
 
 pub fn run() -> glib::ExitCode {
     log::debug!("running gtk frontend");
@@ -51,23 +51,12 @@ fn gtk_main() -> glib::ExitCode {
         .build();
 
     app.connect_startup(|_| load_icons());
-    app.connect_startup(|_| load_css());
     app.connect_activate(build_ui);
 
     let args: Vec<&'static str> = vec![];
     app.run_with_args(&args)
 }
 
-fn load_css() {
-    let provider = CssProvider::new();
-    provider.load_from_resource("de/feschber/LanMouse/style.css");
-    gtk::style_context_add_provider_for_display(
-        &Display::default().expect("Could not connect to a display."),
-        &provider,
-        gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
-    );
-}
-
 fn load_icons() {
     let display = &Display::default().expect("Could not connect to a display.");
     let icon_theme = IconTheme::for_display(display);
@@ -97,16 +86,14 @@ fn build_ui(app: &Application) {
     gio::spawn_blocking(move || {
         match loop {
             // read length
-            let mut len = [0u8; 8];
-            match rx.read_exact(&mut len) {
-                Ok(_) => (),
+            let len = match rx.read_u64(Endian::Big) {
+                Ok(l) => l,
                 Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
                 Err(e) => break Err(e),
             };
-            let len = usize::from_be_bytes(len);
 
             // read payload
-            let mut buf = vec![0u8; len];
+            let mut buf = vec![0u8; len as usize];
             match rx.read_exact(&mut buf) {
                 Ok(_) => (),
                 Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
@@ -125,47 +112,56 @@ fn build_ui(app: &Application) {
         }
     });
 
-    let window = Window::new(app);
-    window.imp().stream.borrow_mut().replace(tx);
-    glib::spawn_future_local(clone!(@weak window => async move {
-        loop {
-            let notify = receiver.recv().await.unwrap();
-            match notify {
-                FrontendNotify::NotifyClientActivate(handle, active) => {
-                    window.activate_client(handle, active);
-                }
-                FrontendNotify::NotifyClientCreate(client) => {
-                    window.new_client(client, false);
-                },
-                FrontendNotify::NotifyClientUpdate(client) => {
-                    window.update_client(client);
-                }
-                FrontendNotify::NotifyError(e) => {
-                    window.show_toast(e.as_str());
-                },
-                FrontendNotify::NotifyClientDelete(client) => {
-                    window.delete_client(client);
-                }
-                FrontendNotify::Enumerate(clients) => {
-                    for (client, active) in clients {
-                        if window.client_idx(client.handle).is_some() {
-                            window.activate_client(client.handle, active);
-                            window.update_client(client);
-                        } else {
-                            window.new_client(client, active);
+    let window = Window::new(app, tx);
+
+    glib::spawn_future_local(clone!(
+        #[weak]
+        window,
+        async move {
+            loop {
+                let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
+                match notify {
+                    FrontendEvent::Created(handle, client, state) => {
+                        window.new_client(handle, client, state);
+                    }
+                    FrontendEvent::Deleted(client) => {
+                        window.delete_client(client);
+                    }
+                    FrontendEvent::State(handle, config, state) => {
+                        window.update_client_config(handle, config);
+                        window.update_client_state(handle, state);
+                    }
+                    FrontendEvent::NoSuchClient(_) => {}
+                    FrontendEvent::Error(e) => {
+                        window.show_toast(e.as_str());
+                    }
+                    FrontendEvent::Enumerate(clients) => {
+                        for (handle, client, state) in clients {
+                            if window.client_idx(handle).is_some() {
+                                window.update_client_config(handle, client);
+                                window.update_client_state(handle, state);
+                            } else {
+                                window.new_client(handle, client, state);
+                            }
                         }
                     }
-                },
-                FrontendNotify::NotifyPortChange(port, msg) => {
-                    match msg {
-                        None => window.show_toast(format!("port changed: {port}").as_str()),
-                        Some(msg) => window.show_toast(msg.as_str()),
+                    FrontendEvent::PortChanged(port, msg) => {
+                        match msg {
+                            None => window.show_toast(format!("port changed: {port}").as_str()),
+                            Some(msg) => window.show_toast(msg.as_str()),
+                        }
+                        window.imp().set_port(port);
+                    }
+                    FrontendEvent::CaptureStatus(s) => {
+                        window.set_capture(s.into());
+                    }
+                    FrontendEvent::EmulationStatus(s) => {
+                        window.set_emulation(s.into());
                     }
-                    window.imp().set_port(port);
                 }
             }
         }
-    }));
+    ));
 
     window.present();
 }

src/frontend/gtk/client_object.rs

@@ -3,20 +3,29 @@ mod imp;
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};
 
-use crate::client::{Client, ClientHandle};
+use crate::client::{ClientConfig, ClientHandle, ClientState};
 
 glib::wrapper! {
     pub struct ClientObject(ObjectSubclass<imp::ClientObject>);
 }
 
 impl ClientObject {
-    pub fn new(client: Client, active: bool) -> Self {
+    pub fn new(handle: ClientHandle, client: ClientConfig, state: ClientState) -> Self {
         Object::builder()
-            .property("handle", client.handle)
+            .property("handle", handle)
             .property("hostname", client.hostname)
             .property("port", client.port as u32)
             .property("position", client.pos.to_string())
-            .property("active", active)
+            .property("active", state.active)
+            .property(
+                "ips",
+                state
+                    .ips
+                    .iter()
+                    .map(|ip| ip.to_string())
+                    .collect::<Vec<_>>(),
+            )
+            .property("resolving", state.resolving)
             .build()
     }
 
@@ -32,4 +41,6 @@ pub struct ClientData {
     pub port: u32,
     pub active: bool,
     pub position: String,
+    pub resolving: bool,
+    pub ips: Vec<String>,
 }

src/frontend/gtk/client_object/imp.rs

@@ -17,6 +17,8 @@ pub struct ClientObject {
     #[property(name = "port", get, set, type = u32, member = port, maximum = u16::MAX as u32)]
     #[property(name = "active", get, set, type = bool, member = active)]
     #[property(name = "position", get, set, type = String, member = position)]
+    #[property(name = "resolving", get, set, type = bool, member = resolving)]
+    #[property(name = "ips", get, set, type = Vec<String>, member = ips)]
     pub data: RefCell<ClientData>,
 }
 

src/frontend/gtk/client_row.rs

@@ -109,6 +109,27 @@ impl ClientRow {
             .sync_create()
             .build();
 
+        let resolve_binding = client_object
+            .bind_property(
+                "resolving",
+                &self.imp().dns_loading_indicator.get(),
+                "spinning",
+            )
+            .sync_create()
+            .build();
+
+        let ip_binding = client_object
+            .bind_property("ips", &self.imp().dns_button.get(), "tooltip-text")
+            .transform_to(|_, ips: Vec<String>| {
+                if ips.is_empty() {
+                    Some("no ip addresses associated with this client".into())
+                } else {
+                    Some(ips.join("\n"))
+                }
+            })
+            .sync_create()
+            .build();
+
         bindings.push(active_binding);
         bindings.push(switch_position_binding);
         bindings.push(hostname_binding);
@@ -116,6 +137,8 @@ impl ClientRow {
         bindings.push(port_binding);
         bindings.push(subtitle_binding);
         bindings.push(position_binding);
+        bindings.push(resolve_binding);
+        bindings.push(ip_binding);
     }
 
     pub fn unbind(&self) {

src/frontend/gtk/client_row/imp.rs

@@ -14,6 +14,8 @@ pub struct ClientRow {
     #[template_child]
     pub enable_switch: TemplateChild<gtk::Switch>,
     #[template_child]
+    pub dns_button: TemplateChild<gtk::Button>,
+    #[template_child]
     pub hostname: TemplateChild<gtk::Entry>,
     #[template_child]
     pub port: TemplateChild<gtk::Entry>,
@@ -23,6 +25,8 @@ pub struct ClientRow {
     pub delete_row: TemplateChild<ActionRow>,
     #[template_child]
     pub delete_button: TemplateChild<gtk::Button>,
+    #[template_child]
+    pub dns_loading_indicator: TemplateChild<gtk::Spinner>,
     pub bindings: RefCell<Vec<Binding>>,
 }
 
@@ -48,16 +52,20 @@ impl ObjectSubclass for ClientRow {
 impl ObjectImpl for ClientRow {
     fn constructed(&self) {
         self.parent_constructed();
-        self.delete_button
-            .connect_clicked(clone!(@weak self as row => move |button| {
+        self.delete_button.connect_clicked(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |button| {
                 row.handle_client_delete(button);
-            }));
+            }
+        ));
     }
 
     fn signals() -> &'static [glib::subclass::Signal] {
         static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
         SIGNALS.get_or_init(|| {
             vec![
+                Signal::builder("request-dns").build(),
                 Signal::builder("request-update")
                     .param_types([bool::static_type()])
                     .build(),
@@ -76,6 +84,11 @@ impl ClientRow {
         true // dont run default handler
     }
 
+    #[template_callback]
+    fn handle_request_dns(&self, _: Button) {
+        self.obj().emit_by_name::<()>("request-dns", &[]);
+    }
+
     #[template_callback]
     fn handle_client_delete(&self, _button: &Button) {
         log::debug!("delete button pressed -> requesting delete");

src/frontend/gtk/window.rs

@@ -2,19 +2,26 @@ mod imp;
 
 use std::io::Write;
 
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
+#[cfg(windows)]
+use std::net::TcpStream;
+
 use adw::prelude::*;
 use adw::subclass::prelude::*;
+use endi::{Endian, WriteBytes};
 use glib::{clone, Object};
 use gtk::{
     gio,
     glib::{self, closure_local},
-    NoSelection,
+    ListBox, NoSelection,
 };
 
 use crate::{
-    client::{Client, ClientHandle, Position},
+    client::{ClientConfig, ClientHandle, ClientState, Position},
     config::DEFAULT_PORT,
-    frontend::{gtk::client_object::ClientObject, FrontendEvent},
+    frontend::{gtk::client_object::ClientObject, FrontendRequest},
 };
 
 use super::client_row::ClientRow;
@@ -27,8 +34,14 @@ glib::wrapper! {
 }
 
 impl Window {
-    pub(crate) fn new(app: &adw::Application) -> Self {
-        Object::builder().property("application", app).build()
+    pub(crate) fn new(
+        app: &adw::Application,
+        #[cfg(unix)] tx: UnixStream,
+        #[cfg(windows)] tx: TcpStream,
+    ) -> Self {
+        let window: Self = Object::builder().property("application", app).build();
+        window.imp().stream.borrow_mut().replace(tx);
+        window
     }
 
     pub fn clients(&self) -> gio::ListStore {
@@ -39,6 +52,10 @@ impl Window {
             .expect("Could not get clients")
     }
 
+    fn client_by_idx(&self, idx: u32) -> Option<ClientObject> {
+        self.clients().item(idx).map(|o| o.downcast().unwrap())
+    }
+
     fn setup_clients(&self) {
         let model = gio::ListStore::new::<ClientObject>();
         self.imp().clients.replace(Some(model));
@@ -46,23 +63,61 @@ impl Window {
         let selection_model = NoSelection::new(Some(self.clients()));
         self.imp().client_list.bind_model(
             Some(&selection_model),
-            clone!(@weak self as window => @default-panic, move |obj| {
-                let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
-                let row = window.create_client_row(client_object);
-                row.connect_closure("request-update", false, closure_local!(@strong window => move |row: ClientRow, active: bool| {
-                    let index = row.index() as u32;
-                    let Some(client) = window.clients().item(index) else {
-                        return;
-                    };
-                    let client = client.downcast_ref::<ClientObject>().unwrap();
-                    window.request_client_update(client, active);
-                }));
-                row.connect_closure("request-delete", false, closure_local!(@strong window => move |row: ClientRow| {
-                    let index = row.index() as u32;
-                    window.request_client_delete(index);
-                }));
-                row.upcast()
-            })
+            clone!(
+                #[weak(rename_to = window)]
+                self,
+                #[upgrade_or_panic]
+                move |obj| {
+                    let client_object = obj
+                        .downcast_ref()
+                        .expect("Expected object of type `ClientObject`.");
+                    let row = window.create_client_row(client_object);
+                    row.connect_closure(
+                        "request-update",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow, active: bool| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_activate(&client, active);
+                                    window.request_client_update(&client);
+                                    window.request_client_state(&client);
+                                }
+                            }
+                        ),
+                    );
+                    row.connect_closure(
+                        "request-delete",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_delete(&client);
+                                }
+                            }
+                        ),
+                    );
+                    row.connect_closure(
+                        "request-dns",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_update(&client);
+                                    window.request_dns(&client);
+                                    window.request_client_state(&client);
+                                }
+                            }
+                        ),
+                    );
+                    row.upcast()
+                }
+            ),
         );
     }
 
@@ -87,10 +142,11 @@ impl Window {
         row
     }
 
-    pub fn new_client(&self, client: Client, active: bool) {
-        let client = ClientObject::new(client, active);
+    pub fn new_client(&self, handle: ClientHandle, client: ClientConfig, state: ClientState) {
+        let client = ClientObject::new(handle, client, state.clone());
         self.clients().append(&client);
         self.set_placeholder_visible(false);
+        self.update_dns_state(handle, !state.ips.is_empty());
     }
 
     pub fn client_idx(&self, handle: ClientHandle) -> Option<usize> {
@@ -115,9 +171,9 @@ impl Window {
         }
     }
 
-    pub fn update_client(&self, client: Client) {
-        let Some(idx) = self.client_idx(client.handle) else {
-            log::warn!("could not find client with handle {}", client.handle);
+    pub fn update_client_config(&self, handle: ClientHandle, client: ClientConfig) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
             return;
         };
         let client_object = self.clients().item(idx as u32).unwrap();
@@ -137,75 +193,112 @@ impl Window {
         }
     }
 
-    pub fn activate_client(&self, handle: ClientHandle, active: bool) {
+    pub fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
         let Some(idx) = self.client_idx(handle) else {
-            log::warn!("could not find client with handle {handle}");
+            log::warn!("could not find client with handle {}", handle);
             return;
         };
         let client_object = self.clients().item(idx as u32).unwrap();
         let client_object: &ClientObject = client_object.downcast_ref().unwrap();
         let data = client_object.get_data();
-        if data.active != active {
-            client_object.set_active(active);
-            log::debug!("set active to {active}");
+
+        if state.active != data.active {
+            client_object.set_active(state.active);
+            log::debug!("set active to {}", state.active);
         }
+
+        if state.resolving != data.resolving {
+            client_object.set_resolving(state.resolving);
+            log::debug!("resolving {}: {}", data.handle, state.resolving);
+        }
+
+        self.update_dns_state(handle, !state.ips.is_empty());
+        let ips = state
+            .ips
+            .into_iter()
+            .map(|ip| ip.to_string())
+            .collect::<Vec<_>>();
+        client_object.set_ips(ips);
     }
 
-    pub fn request_client_create(&self) {
-        let event = FrontendEvent::AddClient(None, DEFAULT_PORT, Position::default());
-        self.imp().set_port(DEFAULT_PORT);
-        self.request(event);
+    pub fn update_dns_state(&self, handle: ClientHandle, resolved: bool) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
+            return;
+        };
+        let list_box: ListBox = self.imp().client_list.get();
+        let row = list_box.row_at_index(idx as i32).unwrap();
+        let client_row: ClientRow = row.downcast().expect("expected ClientRow Object");
+        if resolved {
+            client_row.imp().dns_button.set_css_classes(&["success"])
+        } else {
+            client_row.imp().dns_button.set_css_classes(&["warning"])
+        }
     }
 
     pub fn request_port_change(&self) {
-        let port = self.imp().port_entry.get().text().to_string();
-        if let Ok(port) = port.as_str().parse::<u16>() {
-            self.request(FrontendEvent::ChangePort(port));
-        } else {
-            self.request(FrontendEvent::ChangePort(DEFAULT_PORT));
-        }
+        let port = self
+            .imp()
+            .port_entry
+            .get()
+            .text()
+            .as_str()
+            .parse::<u16>()
+            .unwrap_or(DEFAULT_PORT);
+        self.request(FrontendRequest::ChangePort(port));
     }
 
-    pub fn request_client_update(&self, client: &ClientObject, active: bool) {
+    pub fn request_capture(&self) {
+        self.request(FrontendRequest::EnableCapture);
+    }
+
+    pub fn request_emulation(&self) {
+        self.request(FrontendRequest::EnableEmulation);
+    }
+
+    pub fn request_client_state(&self, client: &ClientObject) {
+        self.request(FrontendRequest::GetState(client.handle()));
+    }
+
+    pub fn request_client_create(&self) {
+        self.request(FrontendRequest::Create);
+    }
+
+    pub fn request_dns(&self, client: &ClientObject) {
+        self.request(FrontendRequest::ResolveDns(client.get_data().handle));
+    }
+
+    pub fn request_client_update(&self, client: &ClientObject) {
+        let handle = client.handle();
         let data = client.get_data();
-        let position = match Position::try_from(data.position.as_str()) {
-            Ok(pos) => pos,
-            _ => {
-                log::error!("invalid position: {}", data.position);
-                return;
-            }
-        };
+        let position = Position::try_from(data.position.as_str()).expect("invalid position");
         let hostname = data.hostname;
         let port = data.port as u16;
 
-        let event = FrontendEvent::UpdateClient(client.handle(), hostname, port, position);
-        log::debug!("requesting update: {event:?}");
-        self.request(event);
-
-        let event = FrontendEvent::ActivateClient(client.handle(), active);
-        log::debug!("requesting activate: {event:?}");
-        self.request(event);
-    }
-
-    pub fn request_client_delete(&self, idx: u32) {
-        if let Some(obj) = self.clients().item(idx) {
-            let client_object: &ClientObject = obj
-                .downcast_ref()
-                .expect("Expected object of type `ClientObject`.");
-            let handle = client_object.handle();
-            let event = FrontendEvent::DelClient(handle);
+        for event in [
+            FrontendRequest::UpdateHostname(handle, hostname),
+            FrontendRequest::UpdatePosition(handle, position),
+            FrontendRequest::UpdatePort(handle, port),
+        ] {
             self.request(event);
         }
     }
 
-    fn request(&self, event: FrontendEvent) {
+    pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
+        self.request(FrontendRequest::Activate(client.handle(), active));
+    }
+
+    pub fn request_client_delete(&self, client: &ClientObject) {
+        self.request(FrontendRequest::Delete(client.handle()));
+    }
+
+    pub fn request(&self, event: FrontendRequest) {
         let json = serde_json::to_string(&event).unwrap();
-        log::debug!("requesting {json}");
+        log::debug!("requesting: {json}");
         let mut stream = self.imp().stream.borrow_mut();
         let stream = stream.as_mut().unwrap();
         let bytes = json.as_bytes();
-        let len = bytes.len().to_be_bytes();
-        if let Err(e) = stream.write(&len) {
+        if let Err(e) = stream.write_u64(Endian::Big, bytes.len() as u64) {
             log::error!("error sending message: {e}");
         };
         if let Err(e) = stream.write(bytes) {
@@ -218,4 +311,24 @@ impl Window {
         let toast_overlay = &self.imp().toast_overlay;
         toast_overlay.add_toast(toast);
     }
+
+    pub fn set_capture(&self, active: bool) {
+        self.imp().capture_active.replace(active);
+        self.update_capture_emulation_status();
+    }
+
+    pub fn set_emulation(&self, active: bool) {
+        self.imp().emulation_active.replace(active);
+        self.update_capture_emulation_status();
+    }
+
+    fn update_capture_emulation_status(&self) {
+        let capture = self.imp().capture_active.get();
+        let emulation = self.imp().emulation_active.get();
+        self.imp().capture_status_row.set_visible(!capture);
+        self.imp().emulation_status_row.set_visible(!emulation);
+        self.imp()
+            .capture_emulation_group
+            .set_visible(!capture || !emulation);
+    }
 }

src/frontend/gtk/window/imp.rs

@@ -6,9 +6,10 @@ use std::net::TcpStream;
 use std::os::unix::net::UnixStream;
 
 use adw::subclass::prelude::*;
-use adw::{prelude::*, ActionRow, ToastOverlay};
+use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
 use glib::subclass::InitializingObject;
-use gtk::{gio, glib, Button, CompositeTemplate, Entry, ListBox};
+use gtk::glib::clone;
+use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};
 
 use crate::config::DEFAULT_PORT;
 
@@ -26,13 +27,27 @@ pub struct Window {
     #[template_child]
     pub port_entry: TemplateChild<Entry>,
     #[template_child]
+    pub hostname_label: TemplateChild<Label>,
+    #[template_child]
     pub toast_overlay: TemplateChild<ToastOverlay>,
+    #[template_child]
+    pub capture_emulation_group: TemplateChild<PreferencesGroup>,
+    #[template_child]
+    pub capture_status_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub emulation_status_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub input_emulation_button: TemplateChild<Button>,
+    #[template_child]
+    pub input_capture_button: TemplateChild<Button>,
     pub clients: RefCell<Option<gio::ListStore>>,
     #[cfg(unix)]
     pub stream: RefCell<Option<UnixStream>>,
     #[cfg(windows)]
     pub stream: RefCell<Option<TcpStream>>,
     pub port: Cell<u16>,
+    pub capture_active: Cell<bool>,
+    pub emulation_active: Cell<bool>,
 }
 
 #[glib::object_subclass]
@@ -61,6 +76,26 @@ impl Window {
         self.obj().request_client_create();
     }
 
+    #[template_callback]
+    fn handle_copy_hostname(&self, button: &Button) {
+        if let Ok(hostname) = hostname::get() {
+            let display = gdk::Display::default().unwrap();
+            let clipboard = display.clipboard();
+            clipboard.set_text(hostname.to_str().expect("hostname: invalid utf8"));
+            button.set_icon_name("emblem-ok-symbolic");
+            button.set_css_classes(&["success"]);
+            glib::spawn_future_local(clone!(
+                #[weak]
+                button,
+                async move {
+                    glib::timeout_future_seconds(1).await;
+                    button.set_icon_name("edit-copy-symbolic");
+                    button.set_css_classes(&[]);
+                }
+            ));
+        }
+    }
+
     #[template_callback]
     fn handle_port_changed(&self, _entry: &Entry) {
         self.port_edit_apply.set_visible(true);
@@ -81,6 +116,16 @@ impl Window {
         self.port_edit_cancel.set_visible(false);
     }
 
+    #[template_callback]
+    fn handle_emulation(&self) {
+        self.obj().request_emulation();
+    }
+
+    #[template_callback]
+    fn handle_capture(&self) {
+        self.obj().request_capture();
+    }
+
     pub fn set_port(&self, port: u16) {
         self.port.set(port);
         if port == DEFAULT_PORT {
@@ -95,6 +140,10 @@ impl Window {
 
 impl ObjectImpl for Window {
     fn constructed(&self) {
+        if let Ok(hostname) = hostname::get() {
+            self.hostname_label
+                .set_text(hostname.to_str().expect("hostname: invalid utf8"));
+        }
         self.parent_constructed();
         self.set_port(DEFAULT_PORT);
         let obj = self.obj();

src/lib.rs

@@ -1,12 +1,8 @@
 pub mod client;
 pub mod config;
 pub mod dns;
-pub mod event;
 pub mod server;
 
-pub mod consumer;
-pub mod producer;
-
-pub mod backend;
+pub mod capture_test;
+pub mod emulation_test;
 pub mod frontend;
-pub mod scancode;

src/main.rs

@@ -2,7 +2,7 @@ use anyhow::Result;
 use std::process::{self, Child, Command};
 
 use env_logger::Env;
-use lan_mouse::{config::Config, frontend, server::Server};
+use lan_mouse::{capture_test, config::Config, emulation_test, frontend, server::Server};
 
 use tokio::task::LocalSet;
 
@@ -31,9 +31,13 @@ pub fn run() -> Result<()> {
     log::debug!("{config:?}");
     log::info!("release bind: {:?}", config.release_bind);
 
-    if config.daemon {
+    if config.test_capture {
+        capture_test::run()?;
+    } else if config.test_emulation {
+        emulation_test::run()?;
+    } else if config.daemon {
         // if daemon is specified we run the service
-        run_service(&config)?;
+        run_service(config)?;
     } else {
         //  otherwise start the service as a child process and
         //  run a frontend
@@ -54,7 +58,7 @@ pub fn run() -> Result<()> {
     anyhow::Ok(())
 }
 
-fn run_service(config: &Config) -> Result<()> {
+fn run_service(config: Config) -> Result<()> {
     // create single threaded tokio runtime
     let runtime = tokio::runtime::Builder::new_current_thread()
         .enable_io()
@@ -64,9 +68,9 @@ fn run_service(config: &Config) -> Result<()> {
     // run async event loop
     runtime.block_on(LocalSet::new().run_until(async {
         // run main loop
-        log::info!("Press Ctrl+Alt+Shift+Super to release the mouse");
+        log::info!("Press {:?} to release the mouse", config.release_bind);
 
-        let server = Server::new(config);
+        let mut server = Server::new(config);
         server.run().await?;
 
         log::debug!("service exiting");

src/producer.rs

@@ -1,61 +0,0 @@
-use std::io;
-
-use futures_core::Stream;
-
-use crate::backend::producer;
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    event::Event,
-};
-
-pub async fn create() -> Box<dyn EventProducer> {
-    #[cfg(target_os = "macos")]
-    match producer::macos::MacOSProducer::new() {
-        Ok(p) => return Box::new(p),
-        Err(e) => log::info!("macos event producer not available: {e}"),
-    }
-
-    #[cfg(windows)]
-    match producer::windows::WindowsProducer::new() {
-        Ok(p) => return Box::new(p),
-        Err(e) => log::info!("windows event producer not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    match producer::libei::LibeiProducer::new().await {
-        Ok(p) => {
-            log::info!("using libei event producer");
-            return Box::new(p);
-        }
-        Err(e) => log::info!("libei event producer not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    match producer::wayland::WaylandEventProducer::new() {
-        Ok(p) => {
-            log::info!("using layer-shell event producer");
-            return Box::new(p);
-        }
-        Err(e) => log::info!("layer_shell event producer not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    match producer::x11::X11Producer::new() {
-        Ok(p) => {
-            log::info!("using x11 event producer");
-            return Box::new(p);
-        }
-        Err(e) => log::info!("x11 event producer not available: {e}"),
-    }
-
-    log::error!("falling back to dummy event producer");
-    Box::new(producer::dummy::DummyProducer::new())
-}
-
-pub trait EventProducer: Stream<Item = io::Result<(ClientHandle, Event)>> + Unpin {
-    /// notify event producer of configuration changes
-    fn notify(&mut self, event: ClientEvent) -> io::Result<()>;
-
-    /// release mouse
-    fn release(&mut self) -> io::Result<()>;
-}

src/server.rs

@@ -1,27 +1,41 @@
+use capture_task::CaptureRequest;
+use emulation_task::EmulationRequest;
 use log;
 use std::{
     cell::{Cell, RefCell},
+    collections::{HashSet, VecDeque},
+    io::ErrorKind,
+    net::{IpAddr, SocketAddr},
     rc::Rc,
 };
-use tokio::signal;
+use tokio::{
+    io::ReadHalf,
+    join, signal,
+    sync::{
+        mpsc::{channel, Sender},
+        Notify,
+    },
+    task::JoinHandle,
+};
+use tokio_util::sync::CancellationToken;
 
 use crate::{
-    client::{ClientHandle, ClientManager},
+    client::{ClientConfig, ClientHandle, ClientManager, ClientState, Position},
     config::Config,
-    dns,
-    frontend::{FrontendEvent, FrontendListener},
-    server::producer_task::ProducerEvent,
+    dns::DnsResolver,
+    frontend::{self, FrontendEvent, FrontendListener, FrontendRequest, Status},
 };
-use crate::{consumer, producer};
 
-use self::{consumer_task::ConsumerEvent, resolver_task::DnsRequest};
+#[cfg(unix)]
+use tokio::net::UnixStream;
 
-mod consumer_task;
-mod frontend_task;
+#[cfg(windows)]
+use tokio::net::TcpStream;
+
+mod capture_task;
+mod emulation_task;
 mod network_task;
 mod ping_task;
-mod producer_task;
-mod resolver_task;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum State {
@@ -37,170 +51,580 @@ enum State {
 #[derive(Clone)]
 pub struct Server {
     active_client: Rc<Cell<Option<ClientHandle>>>,
-    client_manager: Rc<RefCell<ClientManager>>,
+    pub(crate) client_manager: Rc<RefCell<ClientManager>>,
     port: Rc<Cell<u16>>,
     state: Rc<Cell<State>>,
-    release_bind: Vec<crate::scancode::Linux>,
+    release_bind: Vec<input_event::scancode::Linux>,
+    notifies: Rc<Notifies>,
+    config: Rc<Config>,
+    pending_frontend_events: Rc<RefCell<VecDeque<FrontendEvent>>>,
+    pending_dns_requests: Rc<RefCell<VecDeque<ClientHandle>>>,
+    capture_status: Rc<Cell<Status>>,
+    emulation_status: Rc<Cell<Status>>,
+}
+
+#[derive(Default)]
+struct Notifies {
+    capture: Notify,
+    emulation: Notify,
+    ping: Notify,
+    port_changed: Notify,
+    frontend_event_pending: Notify,
+    dns_request_pending: Notify,
+    cancel: CancellationToken,
 }
 
 impl Server {
-    pub fn new(config: &Config) -> Self {
+    pub fn new(config: Config) -> Self {
         let active_client = Rc::new(Cell::new(None));
-        let client_manager = Rc::new(RefCell::new(ClientManager::new()));
+        let client_manager = Rc::new(RefCell::new(ClientManager::default()));
         let state = Rc::new(Cell::new(State::Receiving));
         let port = Rc::new(Cell::new(config.port));
         for config_client in config.get_clients() {
-            client_manager.borrow_mut().add_client(
-                config_client.hostname,
-                config_client.ips,
-                config_client.port,
-                config_client.pos,
-                config_client.active,
-            );
+            let client = ClientConfig {
+                hostname: config_client.hostname,
+                fix_ips: config_client.ips.into_iter().collect(),
+                port: config_client.port,
+                pos: config_client.pos,
+                cmd: config_client.enter_hook,
+            };
+            let state = ClientState {
+                active: config_client.active,
+                ips: HashSet::from_iter(client.fix_ips.iter().cloned()),
+                ..Default::default()
+            };
+            let mut client_manager = client_manager.borrow_mut();
+            let handle = client_manager.add_client();
+            let c = client_manager.get_mut(handle).expect("invalid handle");
+            *c = (client, state);
         }
+
+        // task notification tokens
+        let notifies = Rc::new(Notifies::default());
         let release_bind = config.release_bind.clone();
+
+        let config = Rc::new(config);
+
         Self {
+            config,
             active_client,
             client_manager,
             port,
             state,
             release_bind,
+            notifies,
+            pending_frontend_events: Rc::new(RefCell::new(VecDeque::new())),
+            pending_dns_requests: Rc::new(RefCell::new(VecDeque::new())),
+            capture_status: Default::default(),
+            emulation_status: Default::default(),
         }
     }
 
-    pub async fn run(&self) -> anyhow::Result<()> {
-        // create frontend communication adapter
-        let frontend = match FrontendListener::new().await {
+    pub async fn run(&mut self) -> anyhow::Result<()> {
+        // create frontend communication adapter, exit if already running
+        let mut frontend = match FrontendListener::new().await {
             Some(f) => f?,
             None => {
-                // none means some other instance is already running
                 log::info!("service already running, exiting");
-                return anyhow::Ok(());
+                return Ok(());
             }
         };
-        let (consumer, producer) = tokio::join!(consumer::create(), producer::create());
 
-        let (timer_tx, timer_rx) = tokio::sync::mpsc::channel(1);
-        let (frontend_notify_tx, frontend_notify_rx) = tokio::sync::mpsc::channel(1);
+        let (capture_tx, capture_rx) = channel(1); /* requests for input capture */
+        let (emulation_tx, emulation_rx) = channel(1); /* emulation requests */
+        let (udp_recv_tx, udp_recv_rx) = channel(1); /* udp receiver */
+        let (udp_send_tx, udp_send_rx) = channel(1); /* udp sender */
+        let (request_tx, mut request_rx) = channel(1); /* frontend requests */
+        let (dns_tx, dns_rx) = channel(1); /* dns requests */
 
         // udp task
-        let (mut udp_task, sender_tx, receiver_rx, port_tx) =
-            network_task::new(self.clone(), frontend_notify_tx).await?;
+        let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
 
-        // event producer
-        let (mut producer_task, producer_channel) = producer_task::new(
-            producer,
-            self.clone(),
-            sender_tx.clone(),
-            timer_tx.clone(),
-            self.release_bind.clone(),
-        );
+        // input capture
+        let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
 
-        // event consumer
-        let (mut consumer_task, consumer_channel) = consumer_task::new(
-            consumer,
+        // input emulation
+        let emulation = emulation_task::new(
             self.clone(),
-            receiver_rx,
-            sender_tx.clone(),
-            producer_channel.clone(),
-            timer_tx,
+            emulation_rx,
+            udp_recv_rx,
+            udp_send_tx.clone(),
+            capture_tx.clone(),
         );
 
         // create dns resolver
-        let resolver = dns::DnsResolver::new().await?;
-        let (mut resolver_task, resolve_tx) = resolver_task::new(resolver, self.clone());
-
-        // frontend listener
-        let (mut frontend_task, frontend_tx) = frontend_task::new(
-            frontend,
-            frontend_notify_rx,
-            self.clone(),
-            producer_channel.clone(),
-            consumer_channel.clone(),
-            resolve_tx.clone(),
-            port_tx,
-        );
+        let resolver = DnsResolver::new(dns_rx)?;
+        let dns_task = tokio::task::spawn_local(resolver.run(self.clone()));
 
         // task that pings clients to see if they are responding
-        let mut ping_task = ping_task::new(
+        let ping = ping_task::new(
             self.clone(),
-            sender_tx.clone(),
-            consumer_channel.clone(),
-            producer_channel.clone(),
-            timer_rx,
+            udp_send_tx.clone(),
+            emulation_tx.clone(),
+            capture_tx.clone(),
         );
 
-        let active = self
-            .client_manager
-            .borrow()
-            .get_client_states()
-            .filter_map(|s| {
-                if s.active {
-                    Some((s.client.handle, s.client.hostname.clone()))
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
-        for (handle, hostname) in active {
-            frontend_tx
-                .send(FrontendEvent::ActivateClient(handle, true))
-                .await?;
-            if let Some(hostname) = hostname {
-                let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
-            }
+        for handle in self.active_clients() {
+            self.request_dns(handle);
         }
+
         log::info!("running service");
 
-        tokio::select! {
-            _ = signal::ctrl_c() => {
-                log::info!("terminating service");
-            }
-            e = &mut producer_task => {
-                if let Ok(Err(e)) = e {
-                    log::error!("error in event producer: {e}");
+        let mut join_handles = vec![];
+
+        loop {
+            tokio::select! {
+                stream = frontend.accept() => {
+                    match stream {
+                        Ok(s) => join_handles.push(handle_frontend_stream(self.notifies.cancel.clone(), s, request_tx.clone())),
+                        Err(e) => log::warn!("error accepting frontend connection: {e}"),
+                    };
+                    self.enumerate();
+                    self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status.get()));
+                    self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status.get()));
+                    self.notify_frontend(FrontendEvent::PortChanged(self.port.get(), None));
+                }
+                request = request_rx.recv() => {
+                    let request = request.expect("channel closed");
+                    log::debug!("received frontend request: {request:?}");
+                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request).await;
+                    log::debug!("handled frontend request");
+                }
+                _ = self.notifies.frontend_event_pending.notified() => {
+                    while let Some(event) = {
+                        /* need to drop borrow before next iteration! */
+                        let event = self.pending_frontend_events.borrow_mut().pop_front();
+                        event
+                    } {
+                        frontend.broadcast(event).await;
+                    }
+                },
+                _ = self.notifies.dns_request_pending.notified() => {
+                    while let Some(request) = {
+                        /* need to drop borrow before next iteration! */
+                        let request = self.pending_dns_requests.borrow_mut().pop_front();
+                        request
+                    } {
+                        dns_tx.send(request).await.expect("channel closed");
+                    }
+                }
+                _ = self.cancelled() => break,
+                r = signal::ctrl_c() => {
+                    r.expect("failed to wait for CTRL+C");
+                    break;
                 }
             }
-            e = &mut consumer_task => {
-                if let Ok(Err(e)) = e {
-                    log::error!("error in event consumer: {e}");
-                }
-            }
-            e = &mut frontend_task => {
-                if let Ok(Err(e)) = e {
-                    log::error!("error in frontend listener: {e}");
-                }
-            }
-            _ = &mut resolver_task => { }
-            _ = &mut udp_task => { }
-            _ = &mut ping_task => { }
         }
 
-        let _ = consumer_channel.send(ConsumerEvent::Terminate).await;
-        let _ = producer_channel.send(ProducerEvent::Terminate).await;
-        let _ = frontend_tx.send(FrontendEvent::Shutdown()).await;
+        log::info!("terminating service");
 
-        if !producer_task.is_finished() {
-            if let Err(e) = producer_task.await {
-                log::error!("error in event producer: {e}");
-            }
-        }
-        if !consumer_task.is_finished() {
-            if let Err(e) = consumer_task.await {
-                log::error!("error in event consumer: {e}");
-            }
-        }
+        assert!(!capture_tx.is_closed());
+        assert!(!emulation_tx.is_closed());
+        assert!(!udp_recv_tx.is_closed());
+        assert!(!udp_send_tx.is_closed());
+        assert!(!request_tx.is_closed());
+        assert!(!dns_tx.is_closed());
 
-        if !frontend_task.is_finished() {
-            if let Err(e) = frontend_task.await {
-                log::error!("error in frontend listener: {e}");
-            }
-        }
-
-        resolver_task.abort();
-        udp_task.abort();
-        ping_task.abort();
+        self.cancel();
+        futures::future::join_all(join_handles).await;
+        let _ = join!(capture, dns_task, emulation, network, ping);
 
         Ok(())
     }
+
+    fn notify_frontend(&self, event: FrontendEvent) {
+        self.pending_frontend_events.borrow_mut().push_back(event);
+        self.notifies.frontend_event_pending.notify_one();
+    }
+
+    fn cancel(&self) {
+        self.notifies.cancel.cancel();
+    }
+
+    pub(crate) async fn cancelled(&self) {
+        self.notifies.cancel.cancelled().await
+    }
+
+    fn is_cancelled(&self) -> bool {
+        self.notifies.cancel.is_cancelled()
+    }
+
+    fn notify_capture(&self) {
+        self.notifies.capture.notify_waiters()
+    }
+
+    async fn capture_enabled(&self) {
+        self.notifies.capture.notified().await
+    }
+
+    fn notify_emulation(&self) {
+        self.notifies.emulation.notify_waiters()
+    }
+
+    async fn emulation_notified(&self) {
+        self.notifies.emulation.notified().await
+    }
+
+    fn restart_ping_timer(&self) {
+        self.notifies.ping.notify_waiters()
+    }
+
+    async fn ping_timer_notified(&self) {
+        self.notifies.ping.notified().await
+    }
+
+    fn request_port_change(&self, port: u16) {
+        self.port.replace(port);
+        self.notifies.port_changed.notify_one();
+    }
+
+    fn notify_port_changed(&self, port: u16, msg: Option<String>) {
+        self.port.replace(port);
+        self.notify_frontend(FrontendEvent::PortChanged(port, msg));
+    }
+
+    pub(crate) fn client_updated(&self, handle: ClientHandle) {
+        let state = self.client_manager.borrow().get(handle).cloned();
+        if let Some((config, state)) = state {
+            self.notify_frontend(FrontendEvent::State(handle, config, state));
+        }
+    }
+
+    fn active_clients(&self) -> Vec<ClientHandle> {
+        self.client_manager
+            .borrow()
+            .get_client_states()
+            .filter(|(_, (_, s))| s.active)
+            .map(|(h, _)| h)
+            .collect()
+    }
+
+    fn request_dns(&self, handle: ClientHandle) {
+        self.pending_dns_requests.borrow_mut().push_back(handle);
+        self.notifies.dns_request_pending.notify_one();
+    }
+
+    async fn handle_request(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        event: FrontendRequest,
+    ) -> bool {
+        log::debug!("frontend: {event:?}");
+        match event {
+            FrontendRequest::EnableCapture => {
+                log::info!("received capture enable request");
+                self.notify_capture();
+            }
+            FrontendRequest::EnableEmulation => {
+                log::info!("received emulation enable request");
+                self.notify_emulation();
+            }
+            FrontendRequest::Create => {
+                let handle = self.add_client().await;
+                self.request_dns(handle);
+            }
+            FrontendRequest::Activate(handle, active) => {
+                if active {
+                    self.activate_client(capture, emulate, handle).await;
+                } else {
+                    self.deactivate_client(capture, emulate, handle).await;
+                }
+            }
+            FrontendRequest::ChangePort(port) => self.request_port_change(port),
+            FrontendRequest::Delete(handle) => {
+                self.remove_client(capture, emulate, handle).await;
+                self.notify_frontend(FrontendEvent::Deleted(handle));
+            }
+            FrontendRequest::Enumerate() => self.enumerate(),
+            FrontendRequest::GetState(handle) => self.broadcast_client(handle),
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
+                self.update_fix_ips(handle, fix_ips);
+                self.request_dns(handle);
+            }
+            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
+            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
+            FrontendRequest::UpdatePosition(handle, pos) => {
+                self.update_pos(handle, capture, emulate, pos).await;
+            }
+            FrontendRequest::ResolveDns(handle) => self.request_dns(handle),
+        };
+        false
+    }
+
+    fn enumerate(&self) {
+        let clients = self
+            .client_manager
+            .borrow()
+            .get_client_states()
+            .map(|(h, (c, s))| (h, c.clone(), s.clone()))
+            .collect();
+        self.notify_frontend(FrontendEvent::Enumerate(clients));
+    }
+
+    async fn add_client(&self) -> ClientHandle {
+        let handle = self.client_manager.borrow_mut().add_client();
+        log::info!("added client {handle}");
+        let (c, s) = self.client_manager.borrow().get(handle).unwrap().clone();
+        self.notify_frontend(FrontendEvent::Created(handle, c, s));
+        handle
+    }
+
+    async fn deactivate_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        log::debug!("deactivating client {handle}");
+        match self.client_manager.borrow_mut().get_mut(handle) {
+            Some((_, s)) => s.active = false,
+            None => return,
+        };
+
+        let _ = capture.send(CaptureRequest::Destroy(handle)).await;
+        let _ = emulate.send(EmulationRequest::Destroy(handle)).await;
+        log::debug!("deactivating client {handle} done");
+    }
+
+    async fn activate_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        log::debug!("activating client");
+        /* deactivate potential other client at this position */
+        let pos = match self.client_manager.borrow().get(handle) {
+            Some((client, _)) => client.pos,
+            None => return,
+        };
+
+        let other = self.client_manager.borrow_mut().find_client(pos);
+        if let Some(other) = other {
+            if other != handle {
+                self.deactivate_client(capture, emulate, other).await;
+            }
+        }
+
+        /* activate the client */
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.active = true;
+        } else {
+            return;
+        };
+
+        /* notify emulation, capture and frontends */
+        let _ = capture
+            .send(CaptureRequest::Create(handle, pos.into()))
+            .await;
+        let _ = emulate.send(EmulationRequest::Create(handle)).await;
+        log::debug!("activating client {handle} done");
+    }
+
+    async fn remove_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        let Some(active) = self
+            .client_manager
+            .borrow_mut()
+            .remove_client(handle)
+            .map(|(_, s)| s.active)
+        else {
+            return;
+        };
+
+        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;
+        }
+    }
+
+    fn update_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
+        if let Some((c, _)) = self.client_manager.borrow_mut().get_mut(handle) {
+            c.fix_ips = fix_ips;
+        };
+        self.update_ips(handle);
+    }
+
+    pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.dns_ips = dns_ips;
+        };
+        self.update_ips(handle);
+    }
+
+    fn update_ips(&self, handle: ClientHandle) {
+        if let Some((c, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.ips = c
+                .fix_ips
+                .iter()
+                .cloned()
+                .chain(s.dns_ips.iter().cloned())
+                .collect::<HashSet<_>>();
+        }
+    }
+
+    fn update_hostname(&self, handle: ClientHandle, hostname: Option<String>) {
+        let mut client_manager = self.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        // hostname changed
+        if c.hostname != hostname {
+            c.hostname = hostname;
+            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
+            s.active_addr = None;
+            self.request_dns(handle);
+        }
+    }
+
+    fn update_port(&self, handle: ClientHandle, port: u16) {
+        let mut client_manager = self.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        if c.port != port {
+            c.port = port;
+            s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
+        }
+    }
+
+    async fn update_pos(
+        &self,
+        handle: ClientHandle,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        pos: Position,
+    ) {
+        let (changed, active) = {
+            let mut client_manager = self.client_manager.borrow_mut();
+            let Some((c, s)) = client_manager.get_mut(handle) else {
+                return;
+            };
+
+            let changed = c.pos != pos;
+            c.pos = pos;
+            (changed, s.active)
+        };
+
+        // 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(CaptureRequest::Create(handle, pos.into()))
+                .await;
+            let _ = emulate.send(EmulationRequest::Create(handle)).await;
+        }
+    }
+
+    fn broadcast_client(&self, handle: ClientHandle) {
+        let client = self.client_manager.borrow().get(handle).cloned();
+        let event = if let Some((config, state)) = client {
+            FrontendEvent::State(handle, config, state)
+        } else {
+            FrontendEvent::NoSuchClient(handle)
+        };
+        self.notify_frontend(event);
+    }
+
+    fn set_emulation_status(&self, status: Status) {
+        self.emulation_status.replace(status);
+        let status = FrontendEvent::EmulationStatus(status);
+        self.notify_frontend(status);
+    }
+
+    fn set_capture_status(&self, status: Status) {
+        self.capture_status.replace(status);
+        let status = FrontendEvent::CaptureStatus(status);
+        self.notify_frontend(status);
+    }
+
+    pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.resolving = status;
+        }
+        self.client_updated(handle);
+    }
+
+    pub(crate) fn get_hostname(&self, handle: u64) -> Option<String> {
+        self.client_manager
+            .borrow_mut()
+            .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(
+    request_tx: Sender<FrontendRequest>,
+    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
+    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
+) {
+    use std::io;
+    loop {
+        let request = frontend::wait_for_request(&mut stream).await;
+        match request {
+            Ok(request) => {
+                let _ = request_tx.send(request).await;
+            }
+            Err(e) => {
+                if let Some(e) = e.downcast_ref::<io::Error>() {
+                    if e.kind() == ErrorKind::UnexpectedEof {
+                        return;
+                    }
+                }
+                log::error!("error reading frontend event: {e}");
+                return;
+            }
+        }
+    }
+}
+
+fn handle_frontend_stream(
+    cancel: CancellationToken,
+    #[cfg(unix)] stream: ReadHalf<UnixStream>,
+    #[cfg(windows)] stream: ReadHalf<TcpStream>,
+    request_tx: Sender<FrontendRequest>,
+) -> JoinHandle<()> {
+    tokio::task::spawn_local(async move {
+        tokio::select! {
+            _ = listen_frontend(request_tx, stream) => {},
+            _ = cancel.cancelled() => {},
+        }
+    })
 }

src/server/capture_task.rs

@@ -0,0 +1,191 @@
+use futures::StreamExt;
+use std::net::SocketAddr;
+
+use tokio::{
+    process::Command,
+    sync::mpsc::{Receiver, Sender},
+    task::JoinHandle,
+};
+
+use input_capture::{self, CaptureError, CaptureHandle, InputCapture, InputCaptureError, Position};
+
+use input_event::Event;
+
+use crate::{client::ClientHandle, frontend::Status, server::State};
+
+use super::Server;
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum CaptureRequest {
+    /// capture must release the mouse
+    Release,
+    /// add a capture client
+    Create(CaptureHandle, Position),
+    /// destory a capture client
+    Destroy(CaptureHandle),
+}
+
+pub(crate) fn new(
+    server: Server,
+    capture_rx: Receiver<CaptureRequest>,
+    udp_send: Sender<(Event, SocketAddr)>,
+) -> JoinHandle<()> {
+    let backend = server.config.capture_backend.map(|b| b.into());
+    tokio::task::spawn_local(capture_task(server, backend, udp_send, capture_rx))
+}
+
+async fn capture_task(
+    server: Server,
+    backend: Option<input_capture::Backend>,
+    sender_tx: Sender<(Event, SocketAddr)>,
+    mut notify_rx: Receiver<CaptureRequest>,
+) {
+    loop {
+        if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await {
+            log::warn!("input capture exited: {e}");
+        }
+        server.set_capture_status(Status::Disabled);
+        if server.is_cancelled() {
+            break;
+        }
+
+        // allow cancellation
+        loop {
+            tokio::select! {
+                _ = notify_rx.recv() => continue, /* need to ignore requests here! */
+                _ = server.capture_enabled() => break,
+                _ = server.cancelled() => return,
+            }
+        }
+    }
+}
+
+async fn do_capture(
+    backend: Option<input_capture::Backend>,
+    server: &Server,
+    sender_tx: &Sender<(Event, SocketAddr)>,
+    notify_rx: &mut Receiver<CaptureRequest>,
+) -> Result<(), InputCaptureError> {
+    /* allow cancelling capture request */
+    let mut capture = tokio::select! {
+        r = InputCapture::new(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?;
+    }
+
+    loop {
+        tokio::select! {
+            event = capture.next() => match event {
+                Some(event) => handle_capture_event(server, &mut capture, sender_tx, event?).await?,
+                None => return Ok(()),
+            },
+            e = notify_rx.recv() => {
+                log::debug!("input capture notify rx: {e:?}");
+                match e {
+                    Some(e) => match e {
+                        CaptureRequest::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?,
+                    },
+                    None => break,
+                }
+            }
+            _ = server.cancelled() => break,
+        }
+    }
+    capture.terminate().await?;
+    Ok(())
+}
+
+async fn handle_capture_event(
+    server: &Server,
+    capture: &mut InputCapture,
+    sender_tx: &Sender<(Event, SocketAddr)>,
+    event: (CaptureHandle, Event),
+) -> Result<(), CaptureError> {
+    let (handle, event) = event;
+    log::trace!("({handle}) {event:?}");
+
+    // capture started
+    if event == Event::Enter() {
+        server.set_state(State::AwaitingLeave);
+        server.set_active(Some(handle));
+        server.restart_ping_timer();
+        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");
+    }
+    Ok(())
+}
+
+fn spawn_hook_command(server: &Server, handle: ClientHandle) {
+    let Some(cmd) = server
+        .client_manager
+        .borrow()
+        .get(handle)
+        .and_then(|(c, _)| c.cmd.clone())
+    else {
+        return;
+    };
+    tokio::task::spawn_local(async move {
+        log::info!("spawning command!");
+        let mut child = match Command::new("sh").arg("-c").arg(cmd.as_str()).spawn() {
+            Ok(c) => c,
+            Err(e) => {
+                log::warn!("could not execute cmd: {e}");
+                return;
+            }
+        };
+        match child.wait().await {
+            Ok(s) => {
+                if s.success() {
+                    log::info!("{cmd} exited successfully");
+                } else {
+                    log::warn!("{cmd} exited with {s}");
+                }
+            }
+            Err(e) => log::warn!("{cmd}: {e}"),
+        }
+    });
+}

src/server/consumer_task.rs

@@ -1,240 +0,0 @@
-use anyhow::{anyhow, Result};
-use std::net::SocketAddr;
-
-use tokio::{
-    sync::mpsc::{Receiver, Sender},
-    task::JoinHandle,
-};
-
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    consumer::EventConsumer,
-    event::{Event, KeyboardEvent},
-    scancode,
-    server::State,
-};
-
-use super::{ProducerEvent, Server};
-
-#[derive(Clone, Debug)]
-pub enum ConsumerEvent {
-    /// consumer is notified of a change in client states
-    ClientEvent(ClientEvent),
-    /// consumer must release keys for client
-    ReleaseKeys(ClientHandle),
-    /// termination signal
-    Terminate,
-}
-
-pub fn new(
-    mut consumer: Box<dyn EventConsumer>,
-    server: Server,
-    mut udp_rx: Receiver<Result<(Event, SocketAddr)>>,
-    sender_tx: Sender<(Event, SocketAddr)>,
-    producer_tx: Sender<ProducerEvent>,
-    timer_tx: Sender<()>,
-) -> (JoinHandle<Result<()>>, Sender<ConsumerEvent>) {
-    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-    let consumer_task = tokio::task::spawn_local(async move {
-        let mut last_ignored = None;
-
-        loop {
-            tokio::select! {
-                udp_event = udp_rx.recv() => {
-                    let udp_event = udp_event.ok_or(anyhow!("receiver closed"))??;
-                    handle_udp_rx(&server, &producer_tx, &mut consumer, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await;
-                }
-                consumer_event = rx.recv() => {
-                    match consumer_event {
-                        Some(e) => match e {
-                            ConsumerEvent::ClientEvent(e) => consumer.notify(e).await,
-                            ConsumerEvent::ReleaseKeys(c) => release_keys(&server, &mut consumer, c).await,
-                            ConsumerEvent::Terminate => break,
-                        },
-                        None => break,
-                    }
-                }
-                res = consumer.dispatch() => {
-                    res?;
-                }
-            }
-        }
-
-        // release potentially still pressed keys
-        let clients = server
-            .client_manager
-            .borrow()
-            .get_client_states()
-            .map(|s| s.client.handle)
-            .collect::<Vec<_>>();
-        for client in clients {
-            release_keys(&server, &mut consumer, client).await;
-        }
-
-        // destroy consumer
-        consumer.destroy().await;
-        anyhow::Ok(())
-    });
-    (consumer_task, tx)
-}
-
-async fn handle_udp_rx(
-    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer: &mut Box<dyn EventConsumer>,
-    sender_tx: &Sender<(Event, SocketAddr)>,
-    last_ignored: &mut Option<SocketAddr>,
-    event: (Event, SocketAddr),
-    timer_tx: &Sender<()>,
-) {
-    let (event, addr) = event;
-
-    // get handle for addr
-    let handle = match server.client_manager.borrow().get_client(addr) {
-        Some(a) => a,
-        None => {
-            if last_ignored.is_none() || last_ignored.is_some() && last_ignored.unwrap() != addr {
-                log::warn!("ignoring events from client {addr}");
-                last_ignored.replace(addr);
-            }
-            return;
-        }
-    };
-
-    // next event can be logged as ignored again
-    last_ignored.take();
-
-    log::trace!("{:20} <-<-<-<------ {addr} ({handle})", event.to_string());
-    {
-        let mut client_manager = server.client_manager.borrow_mut();
-        let client_state = match client_manager.get_mut(handle) {
-            Some(s) => s,
-            None => {
-                log::error!("unknown handle");
-                return;
-            }
-        };
-
-        // reset ttl for client and
-        client_state.alive = true;
-        // set addr as new default for this client
-        client_state.active_addr = Some(addr);
-    }
-
-    match (event, addr) {
-        (Event::Pong(), _) => { /* ignore pong events */ }
-        (Event::Ping(), addr) => {
-            let _ = sender_tx.send((Event::Pong(), addr)).await;
-        }
-        (Event::Disconnect(), _) => {
-            release_keys(server, consumer, handle).await;
-        }
-        (event, addr) => {
-            // tell clients that we are ready to receive events
-            if let Event::Enter() = event {
-                let _ = sender_tx.send((Event::Leave(), addr)).await;
-            }
-
-            match server.state.get() {
-                State::Sending => {
-                    if let Event::Leave() = event {
-                        // ignore additional leave events that may
-                        // have been sent for redundancy
-                    } else {
-                        // upon receiving any event, we go back to receiving mode
-                        server.state.replace(State::Receiving);
-                        let _ = producer_notify_tx.send(ProducerEvent::Release).await;
-                        log::trace!("STATE ===> Receiving");
-                    }
-                }
-                State::Receiving => {
-                    let mut ignore_event = false;
-                    if let Event::Keyboard(KeyboardEvent::Key {
-                        time: _,
-                        key,
-                        state,
-                    }) = event
-                    {
-                        let mut client_manager = server.client_manager.borrow_mut();
-                        let client_state =
-                            if let Some(client_state) = client_manager.get_mut(handle) {
-                                client_state
-                            } else {
-                                log::error!("unknown handle");
-                                return;
-                            };
-                        if state == 0 {
-                            // ignore release event if key not pressed
-                            ignore_event = !client_state.pressed_keys.remove(&key);
-                        } else {
-                            // ignore press event if key not released
-                            ignore_event = !client_state.pressed_keys.insert(key);
-                            let _ = timer_tx.try_send(());
-                        }
-                    }
-                    // ignore double press / release events to
-                    // workaround buggy rdp backend.
-                    if !ignore_event {
-                        // consume event
-                        consumer.consume(event, handle).await;
-                        log::trace!("{event:?} => consumer");
-                    }
-                }
-                State::AwaitingLeave => {
-                    // we just entered the deadzone of a client, so
-                    // we need to ignore events that may still
-                    // be on the way until a leave event occurs
-                    // telling us the client registered the enter
-                    if let Event::Leave() = event {
-                        server.state.replace(State::Sending);
-                        log::trace!("STATE ===> Sending");
-                    }
-
-                    // entering a client that is waiting for a leave
-                    // event should still be possible
-                    if let Event::Enter() = event {
-                        server.state.replace(State::Receiving);
-                        let _ = producer_notify_tx.send(ProducerEvent::Release).await;
-                        log::trace!("STATE ===> Receiving");
-                    }
-                }
-            }
-        }
-    }
-}
-
-async fn release_keys(
-    server: &Server,
-    consumer: &mut Box<dyn EventConsumer>,
-    client: ClientHandle,
-) {
-    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,
-        });
-        consumer.consume(event, client).await;
-        if let Ok(key) = scancode::Linux::try_from(key) {
-            log::warn!("releasing stuck key: {key:?}");
-        }
-    }
-
-    let modifiers_event = KeyboardEvent::Modifiers {
-        mods_depressed: 0,
-        mods_latched: 0,
-        mods_locked: 0,
-        group: 0,
-    };
-    consumer
-        .consume(Event::Keyboard(modifiers_event), client)
-        .await;
-}

src/server/emulation_task.rs

@@ -0,0 +1,225 @@
+use std::net::SocketAddr;
+
+use tokio::{
+    sync::mpsc::{Receiver, Sender},
+    task::JoinHandle,
+};
+
+use crate::{
+    client::{ClientHandle, ClientManager},
+    frontend::Status,
+    server::State,
+};
+use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
+use input_event::Event;
+
+use super::{network_task::NetworkError, CaptureRequest, Server};
+
+#[derive(Clone, Debug)]
+pub(crate) enum EmulationRequest {
+    /// create a new client
+    Create(EmulationHandle),
+    /// destroy a client
+    Destroy(EmulationHandle),
+    /// input emulation must release keys for client
+    ReleaseKeys(ClientHandle),
+}
+
+pub(crate) fn new(
+    server: Server,
+    emulation_rx: Receiver<EmulationRequest>,
+    udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
+    sender_tx: Sender<(Event, SocketAddr)>,
+    capture_tx: Sender<CaptureRequest>,
+) -> JoinHandle<()> {
+    let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx, capture_tx);
+    tokio::task::spawn_local(emulation_task)
+}
+
+async fn emulation_task(
+    server: Server,
+    mut rx: Receiver<EmulationRequest>,
+    mut udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
+    sender_tx: Sender<(Event, SocketAddr)>,
+    capture_tx: Sender<CaptureRequest>,
+) {
+    loop {
+        if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_tx, &capture_tx).await {
+            log::warn!("input emulation exited: {e}");
+        }
+        server.set_emulation_status(Status::Disabled);
+        if server.is_cancelled() {
+            break;
+        }
+
+        // allow cancellation
+        loop {
+            tokio::select! {
+                _ = rx.recv() => continue, /* need to ignore requests here! */
+                _ = server.emulation_notified() => break,
+                _ = server.cancelled() => return,
+            }
+        }
+    }
+}
+
+async fn do_emulation(
+    server: &Server,
+    rx: &mut Receiver<EmulationRequest>,
+    udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
+    sender_tx: &Sender<(Event, SocketAddr)>,
+    capture_tx: &Sender<CaptureRequest>,
+) -> 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?,
+        _ = server.cancelled() => return Ok(()),
+    };
+
+    server.set_emulation_status(Status::Enabled);
+
+    // add clients
+    for handle in server.active_clients() {
+        emulation.create(handle).await;
+    }
+
+    let res = do_emulation_session(server, &mut emulation, rx, udp_rx, sender_tx, capture_tx).await;
+    emulation.terminate().await; // manual drop
+    res
+}
+
+async fn do_emulation_session(
+    server: &Server,
+    emulation: &mut InputEmulation,
+    rx: &mut Receiver<EmulationRequest>,
+    udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
+    sender_tx: &Sender<(Event, SocketAddr)>,
+    capture_tx: &Sender<CaptureRequest>,
+) -> Result<(), InputEmulationError> {
+    let mut last_ignored = None;
+
+    loop {
+        tokio::select! {
+            udp_event = udp_rx.recv() => {
+                let udp_event = match udp_event.expect("channel closed") {
+                    Ok(e) => e,
+                    Err(e) => {
+                        log::warn!("network error: {e}");
+                        continue;
+                    }
+                };
+                handle_udp_rx(server, capture_tx, emulation, sender_tx, &mut last_ignored, udp_event).await?;
+            }
+            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?,
+                }
+            }
+            _ = server.notifies.cancel.cancelled() => break Ok(()),
+        }
+    }
+}
+
+async fn handle_udp_rx(
+    server: &Server,
+    capture_tx: &Sender<CaptureRequest>,
+    emulate: &mut InputEmulation,
+    sender_tx: &Sender<(Event, SocketAddr)>,
+    last_ignored: &mut Option<SocketAddr>,
+    event: (Event, SocketAddr),
+) -> Result<(), EmulationError> {
+    let (event, addr) = event;
+
+    log::trace!("{:20} <-<-<-<------ {addr}", event.to_string());
+
+    // get client handle for addr
+    let Some(handle) =
+        activate_client_if_exists(&mut server.client_manager.borrow_mut(), addr, last_ignored)
+    else {
+        return Ok(());
+    };
+
+    match (event, addr) {
+        (Event::Pong(), _) => { /* ignore pong events */ }
+        (Event::Ping(), addr) => {
+            let _ = sender_tx.send((Event::Pong(), addr)).await;
+        }
+        (Event::Disconnect(), _) => emulate.release_keys(handle).await?,
+        (event, addr) => {
+            // tell clients that we are ready to receive events
+            if let Event::Enter() = event {
+                let _ = sender_tx.send((Event::Leave(), addr)).await;
+            }
+
+            match server.state.get() {
+                State::Sending => {
+                    if let Event::Leave() = event {
+                        // ignore additional leave events that may
+                        // have been sent for redundancy
+                    } else {
+                        // upon receiving any event, we go back to receiving mode
+                        server.state.replace(State::Receiving);
+                        let _ = capture_tx.send(CaptureRequest::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();
+                    }
+                }
+                State::AwaitingLeave => {
+                    // we just entered the deadzone of a client, so
+                    // we need to ignore events that may still
+                    // be on the way until a leave event occurs
+                    // telling us the client registered the enter
+                    if let Event::Leave() = event {
+                        server.state.replace(State::Sending);
+                        log::trace!("STATE ===> Sending");
+                    }
+
+                    // entering a client that is waiting for a leave
+                    // event should still be possible
+                    if let Event::Enter() = event {
+                        server.state.replace(State::Receiving);
+                        let _ = capture_tx.send(CaptureRequest::Release).await;
+                        log::trace!("STATE ===> Receiving");
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn activate_client_if_exists(
+    client_manager: &mut ClientManager,
+    addr: SocketAddr,
+    last_ignored: &mut Option<SocketAddr>,
+) -> Option<ClientHandle> {
+    let Some(handle) = client_manager.get_client(addr) else {
+        // log ignored if it is the first event from the client in a series
+        if last_ignored.is_none() || last_ignored.is_some() && last_ignored.unwrap() != addr {
+            log::warn!("ignoring events from client {addr}");
+            last_ignored.replace(addr);
+        }
+        return None;
+    };
+    // next event can be logged as ignored again
+    last_ignored.take();
+
+    let (_, client_state) = client_manager.get_mut(handle)?;
+
+    // reset ttl for client
+    client_state.alive = true;
+    // set addr as new default for this client
+    client_state.active_addr = Some(addr);
+    Some(handle)
+}

src/server/frontend_task.rs

@@ -1,335 +0,0 @@
-use std::{
-    collections::HashSet,
-    io::ErrorKind,
-    net::{IpAddr, SocketAddr},
-};
-#[cfg(unix)]
-use tokio::net::UnixStream;
-
-#[cfg(windows)]
-use tokio::net::TcpStream;
-
-use anyhow::{anyhow, Result};
-use tokio::{
-    io::ReadHalf,
-    sync::mpsc::{Receiver, Sender},
-    task::JoinHandle,
-};
-
-use crate::{
-    client::{ClientEvent, ClientHandle, Position},
-    frontend::{self, FrontendEvent, FrontendListener, FrontendNotify},
-};
-
-use super::{
-    consumer_task::ConsumerEvent, producer_task::ProducerEvent, resolver_task::DnsRequest, Server,
-};
-
-pub(crate) fn new(
-    mut frontend: FrontendListener,
-    mut notify_rx: Receiver<FrontendNotify>,
-    server: Server,
-    producer_notify: Sender<ProducerEvent>,
-    consumer_notify: Sender<ConsumerEvent>,
-    resolve_ch: Sender<DnsRequest>,
-    port_tx: Sender<u16>,
-) -> (JoinHandle<Result<()>>, Sender<FrontendEvent>) {
-    let (event_tx, mut event_rx) = tokio::sync::mpsc::channel(32);
-    let event_tx_clone = event_tx.clone();
-    let frontend_task = tokio::task::spawn_local(async move {
-        loop {
-            tokio::select! {
-                stream = frontend.accept() => {
-                    let stream = match stream {
-                        Ok(s) => s,
-                        Err(e) => {
-                            log::warn!("error accepting frontend connection: {e}");
-                            continue;
-                        }
-                    };
-                    handle_frontend_stream(&event_tx_clone, stream).await;
-                }
-                event = event_rx.recv() => {
-                    let frontend_event = event.ok_or(anyhow!("frontend channel closed"))?;
-                    if handle_frontend_event(&server, &producer_notify, &consumer_notify, &resolve_ch, &mut frontend, &port_tx, frontend_event).await {
-                        break;
-                    }
-                }
-                notify = notify_rx.recv() => {
-                    let notify = notify.ok_or(anyhow!("frontend notify closed"))?;
-                    let _ = frontend.notify_all(notify).await;
-                }
-            }
-        }
-        anyhow::Ok(())
-    });
-    (frontend_task, event_tx)
-}
-
-async fn handle_frontend_stream(
-    frontend_tx: &Sender<FrontendEvent>,
-    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
-    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
-) {
-    use std::io;
-
-    let tx = frontend_tx.clone();
-    tokio::task::spawn_local(async move {
-        let _ = tx.send(FrontendEvent::Enumerate()).await;
-        loop {
-            let event = frontend::read_event(&mut stream).await;
-            match event {
-                Ok(event) => {
-                    let _ = tx.send(event).await;
-                }
-                Err(e) => {
-                    if let Some(e) = e.downcast_ref::<io::Error>() {
-                        if e.kind() == ErrorKind::UnexpectedEof {
-                            return;
-                        }
-                    }
-                    log::error!("error reading frontend event: {e}");
-                    return;
-                }
-            }
-        }
-    });
-}
-
-async fn handle_frontend_event(
-    server: &Server,
-    producer_tx: &Sender<ProducerEvent>,
-    consumer_tx: &Sender<ConsumerEvent>,
-    resolve_tx: &Sender<DnsRequest>,
-    frontend: &mut FrontendListener,
-    port_tx: &Sender<u16>,
-    event: FrontendEvent,
-) -> bool {
-    log::debug!("frontend: {event:?}");
-    let response = match event {
-        FrontendEvent::AddClient(hostname, port, pos) => {
-            let handle = add_client(server, resolve_tx, hostname, HashSet::new(), port, pos).await;
-
-            let client = server
-                .client_manager
-                .borrow()
-                .get(handle)
-                .unwrap()
-                .client
-                .clone();
-            Some(FrontendNotify::NotifyClientCreate(client))
-        }
-        FrontendEvent::ActivateClient(handle, active) => {
-            activate_client(server, producer_tx, consumer_tx, handle, active).await;
-            Some(FrontendNotify::NotifyClientActivate(handle, active))
-        }
-        FrontendEvent::ChangePort(port) => {
-            let _ = port_tx.send(port).await;
-            None
-        }
-        FrontendEvent::DelClient(handle) => {
-            remove_client(server, producer_tx, consumer_tx, frontend, handle).await;
-            Some(FrontendNotify::NotifyClientDelete(handle))
-        }
-        FrontendEvent::Enumerate() => {
-            let clients = server
-                .client_manager
-                .borrow()
-                .get_client_states()
-                .map(|s| (s.client.clone(), s.active))
-                .collect();
-            Some(FrontendNotify::Enumerate(clients))
-        }
-        FrontendEvent::Shutdown() => {
-            log::info!("terminating gracefully...");
-            return true;
-        }
-        FrontendEvent::UpdateClient(handle, hostname, port, pos) => {
-            update_client(
-                server,
-                producer_tx,
-                consumer_tx,
-                resolve_tx,
-                (handle, hostname, port, pos),
-            )
-            .await;
-
-            let client = server
-                .client_manager
-                .borrow()
-                .get(handle)
-                .unwrap()
-                .client
-                .clone();
-            Some(FrontendNotify::NotifyClientUpdate(client))
-        }
-    };
-    let Some(response) = response else {
-        return false;
-    };
-    if let Err(e) = frontend.notify_all(response).await {
-        log::error!("error notifying frontend: {e}");
-    }
-    false
-}
-
-pub async fn add_client(
-    server: &Server,
-    resolver_tx: &Sender<DnsRequest>,
-    hostname: Option<String>,
-    addr: HashSet<IpAddr>,
-    port: u16,
-    pos: Position,
-) -> ClientHandle {
-    log::info!(
-        "adding client [{}]{} @ {:?}",
-        pos,
-        hostname.as_deref().unwrap_or(""),
-        &addr
-    );
-    let handle =
-        server
-            .client_manager
-            .borrow_mut()
-            .add_client(hostname.clone(), addr, port, pos, false);
-
-    log::debug!("add_client {handle}");
-
-    if let Some(hostname) = hostname {
-        let _ = resolver_tx.send(DnsRequest { hostname, handle }).await;
-    }
-
-    handle
-}
-
-pub async fn activate_client(
-    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer_notify_tx: &Sender<ConsumerEvent>,
-    client: ClientHandle,
-    active: bool,
-) {
-    let (client, pos) = match server.client_manager.borrow_mut().get_mut(client) {
-        Some(state) => {
-            state.active = active;
-            (state.client.handle, state.client.pos)
-        }
-        None => return,
-    };
-    if active {
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Create(client, pos)))
-            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Create(client, pos)))
-            .await;
-    } else {
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Destroy(client)))
-            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Destroy(client)))
-            .await;
-    }
-}
-
-pub async fn remove_client(
-    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer_notify_tx: &Sender<ConsumerEvent>,
-    frontend: &mut FrontendListener,
-    client: ClientHandle,
-) -> Option<ClientHandle> {
-    let Some((client, active)) = server
-        .client_manager
-        .borrow_mut()
-        .remove_client(client)
-        .map(|s| (s.client.handle, s.active))
-    else {
-        return None;
-    };
-
-    if active {
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Destroy(client)))
-            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Destroy(client)))
-            .await;
-    }
-
-    let notify = FrontendNotify::NotifyClientDelete(client);
-    log::debug!("{notify:?}");
-    if let Err(e) = frontend.notify_all(notify).await {
-        log::error!("error notifying frontend: {e}");
-    }
-    Some(client)
-}
-
-async fn update_client(
-    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer_notify_tx: &Sender<ConsumerEvent>,
-    resolve_tx: &Sender<DnsRequest>,
-    client_update: (ClientHandle, Option<String>, u16, Position),
-) {
-    let (handle, hostname, port, pos) = client_update;
-    let mut changed = false;
-    let (hostname, handle, active) = {
-        // retrieve state
-        let mut client_manager = server.client_manager.borrow_mut();
-        let Some(state) = client_manager.get_mut(handle) else {
-            return;
-        };
-
-        // update pos
-        if state.client.pos != pos {
-            state.client.pos = pos;
-            changed = true;
-        }
-
-        // update port
-        if state.client.port != port {
-            state.client.port = port;
-            state.active_addr = state.active_addr.map(|a| SocketAddr::new(a.ip(), port));
-            changed = true;
-        }
-
-        // update hostname
-        if state.client.hostname != hostname {
-            state.client.ips = HashSet::new();
-            state.active_addr = None;
-            state.client.hostname = hostname;
-            changed = true;
-        }
-
-        log::debug!("client updated: {:?}", state);
-        (
-            state.client.hostname.clone(),
-            state.client.handle,
-            state.active,
-        )
-    };
-
-    // update state in event consumer & producer
-    if changed && active {
-        // resolve dns
-        if let Some(hostname) = hostname {
-            let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
-        }
-
-        // update state
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Destroy(handle)))
-            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Destroy(handle)))
-            .await;
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Create(handle, pos)))
-            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Create(handle, pos)))
-            .await;
-    }
-}

src/server/network_task.rs

@@ -1,90 +1,102 @@
-use std::net::SocketAddr;
+use std::{io, net::SocketAddr};
 
-use anyhow::Result;
+use thiserror::Error;
 use tokio::{
     net::UdpSocket,
     sync::mpsc::{Receiver, Sender},
     task::JoinHandle,
 };
 
-use crate::{event::Event, frontend::FrontendNotify};
+use input_event::{Event, ProtocolError};
 
 use super::Server;
 
-pub async fn new(
+pub(crate) async fn new(
     server: Server,
-    frontend_notify_tx: Sender<FrontendNotify>,
-) -> Result<(
-    JoinHandle<()>,
-    Sender<(Event, SocketAddr)>,
-    Receiver<Result<(Event, SocketAddr)>>,
-    Sender<u16>,
-)> {
+    udp_recv_tx: Sender<Result<(Event, SocketAddr), NetworkError>>,
+    udp_send_rx: Receiver<(Event, SocketAddr)>,
+) -> io::Result<JoinHandle<()>> {
     // bind the udp socket
     let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), server.port.get());
     let mut socket = UdpSocket::bind(listen_addr).await?;
-    let (receiver_tx, receiver_rx) = tokio::sync::mpsc::channel(32);
-    let (sender_tx, mut sender_rx) = tokio::sync::mpsc::channel(32);
-    let (port_tx, mut port_rx) = tokio::sync::mpsc::channel(32);
 
-    let udp_task = tokio::task::spawn_local(async move {
+    Ok(tokio::task::spawn_local(async move {
+        let mut sender_rx = udp_send_rx;
         loop {
+            let udp_receiver = udp_receiver(&socket, &udp_recv_tx);
+            let udp_sender = udp_sender(&socket, &mut sender_rx);
             tokio::select! {
-                event = receive_event(&socket) => {
-                    let _ = receiver_tx.send(event).await;
-                }
-                event = sender_rx.recv() => {
-                    let Some((event, addr)) = event else {
-                        break;
-                    };
-                    if let Err(e) = send_event(&socket, event, addr) {
-                        log::warn!("udp send failed: {e}");
-                    };
-                }
-                port = port_rx.recv() => {
-                    let Some(port) = port else {
-                        break;
-                    };
-
-                    if socket.local_addr().unwrap().port() == port {
-                        continue;
-                    }
-
-                    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), port);
-                    match UdpSocket::bind(listen_addr).await {
-                        Ok(new_socket) => {
-                            socket = new_socket;
-                            server.port.replace(port);
-                            let _ = frontend_notify_tx.send(FrontendNotify::NotifyPortChange(port, None)).await;
-                        }
-                        Err(e) => {
-                            log::warn!("could not change port: {e}");
-                            let port = socket.local_addr().unwrap().port();
-                            let _ = frontend_notify_tx.send(FrontendNotify::NotifyPortChange(
-                                    port,
-                                    Some(format!("could not change port: {e}")),
-                                )).await;
-                        }
-                    }
-
-                }
+                _ = udp_receiver => break, /* channel closed */
+                _ = udp_sender => break, /* channel closed */
+                _ = server.notifies.port_changed.notified() => update_port(&server, &mut socket).await,
+                _ = server.cancelled() => break, /* cancellation requested */
             }
         }
-    });
-    Ok((udp_task, sender_tx, receiver_rx, port_tx))
+    }))
 }
 
-async fn receive_event(socket: &UdpSocket) -> Result<(Event, SocketAddr)> {
+async fn update_port(server: &Server, socket: &mut UdpSocket) {
+    let new_port = server.port.get();
+    let current_port = socket.local_addr().expect("socket not bound").port();
+
+    // if port is the same, we dont need to change it
+    if current_port == new_port {
+        return;
+    }
+
+    // bind new socket
+    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), new_port);
+    let new_socket = UdpSocket::bind(listen_addr).await;
+    let err = match new_socket {
+        Ok(new_socket) => {
+            *socket = new_socket;
+            None
+        }
+        Err(e) => Some(e.to_string()),
+    };
+
+    // notify frontend of the actual port
+    let port = socket.local_addr().expect("socket not bound").port();
+    server.notify_port_changed(port, err);
+}
+
+async fn udp_receiver(
+    socket: &UdpSocket,
+    receiver_tx: &Sender<Result<(Event, SocketAddr), NetworkError>>,
+) {
+    loop {
+        let event = receive_event(socket).await;
+        receiver_tx.send(event).await.expect("channel closed");
+    }
+}
+
+async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(Event, SocketAddr)>) {
+    loop {
+        let (event, addr) = rx.recv().await.expect("channel closed");
+        if let Err(e) = send_event(socket, event, addr) {
+            log::warn!("udp send failed: {e}");
+        };
+    }
+}
+
+#[derive(Debug, Error)]
+pub(crate) enum NetworkError {
+    #[error(transparent)]
+    Protocol(#[from] ProtocolError),
+    #[error("network error: `{0}`")]
+    Io(#[from] io::Error),
+}
+
+async fn receive_event(socket: &UdpSocket) -> Result<(Event, SocketAddr), NetworkError> {
     let mut buf = vec![0u8; 22];
     let (_amt, src) = socket.recv_from(&mut buf).await?;
     Ok((Event::try_from(buf)?, src))
 }
 
-fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize> {
+fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize, NetworkError> {
     log::trace!("{:20} ------>->->-> {addr}", e.to_string());
     let data: Vec<u8> = (&e).into();
     // When udp blocks, we dont want to block the event loop.
-    // Dropping events is better than potentially crashing the event
-    // producer.
+    // Dropping events is better than potentially crashing the input capture.
     Ok(sock.try_send_to(&data, addr)?)
 }

src/server/ping_task.rs

@@ -1,131 +1,138 @@
 use std::{net::SocketAddr, time::Duration};
 
-use tokio::{
-    sync::mpsc::{Receiver, Sender},
-    task::JoinHandle,
-};
+use tokio::{sync::mpsc::Sender, task::JoinHandle};
 
-use crate::{client::ClientHandle, event::Event};
+use input_event::Event;
 
-use super::{consumer_task::ConsumerEvent, producer_task::ProducerEvent, Server, State};
+use crate::client::ClientHandle;
+
+use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State};
 
 const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);
 
-pub fn new(
+pub(crate) fn new(
     server: Server,
     sender_ch: Sender<(Event, SocketAddr)>,
-    consumer_notify: Sender<ConsumerEvent>,
-    producer_notify: Sender<ProducerEvent>,
-    mut timer_rx: Receiver<()>,
+    emulate_notify: Sender<EmulationRequest>,
+    capture_notify: Sender<CaptureRequest>,
 ) -> JoinHandle<()> {
     // timer task
-    let ping_task = tokio::task::spawn_local(async move {
+    tokio::task::spawn_local(async move {
+        tokio::select! {
+            _ = server.notifies.cancel.cancelled() => {}
+            _ = ping_task(&server, sender_ch, emulate_notify, capture_notify) => {}
+        }
+    })
+}
+
+async fn ping_task(
+    server: &Server,
+    sender_ch: Sender<(Event, SocketAddr)>,
+    emulate_notify: Sender<EmulationRequest>,
+    capture_notify: Sender<CaptureRequest>,
+) {
+    loop {
+        // wait for wake up signal
+        server.ping_timer_notified().await;
         loop {
-            // wait for wake up signal
-            let Some(_): Option<()> = timer_rx.recv().await else {
-                break;
-            };
-            loop {
-                let receiving = server.state.get() == State::Receiving;
-                let (ping_clients, ping_addrs) = {
-                    let mut client_manager = server.client_manager.borrow_mut();
+            let receiving = server.state.get() == State::Receiving;
+            let (ping_clients, ping_addrs) = {
+                let mut client_manager = server.client_manager.borrow_mut();
 
-                    let ping_clients: Vec<ClientHandle> = if receiving {
-                        // if receiving we care about clients with pressed keys
-                        client_manager
-                            .get_client_states_mut()
-                            .filter(|s| !s.pressed_keys.is_empty())
-                            .map(|s| s.client.handle)
-                            .collect()
-                    } else {
-                        // if sending we care about the active client
-                        server.active_client.get().iter().cloned().collect()
-                    };
-
-                    // get relevant socket addrs for clients
-                    let ping_addrs: Vec<SocketAddr> = {
-                        ping_clients
-                            .iter()
-                            .flat_map(|&c| client_manager.get(c))
-                            .flat_map(|state| {
-                                if state.alive && state.active_addr.is_some() {
-                                    vec![state.active_addr.unwrap()]
-                                } else {
-                                    state
-                                        .client
-                                        .ips
-                                        .iter()
-                                        .cloned()
-                                        .map(|ip| SocketAddr::new(ip, state.client.port))
-                                        .collect()
-                                }
-                            })
-                            .collect()
-                    };
-
-                    // reset alive
-                    for state in client_manager.get_client_states_mut() {
-                        state.alive = false;
-                    }
-
-                    (ping_clients, ping_addrs)
+                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)
+                        .map(|(h, _)| h)
+                        .collect()
+                } else {
+                    // if sending we care about the active client
+                    server.active_client.get().iter().cloned().collect()
                 };
 
-                if receiving && ping_clients.is_empty() {
-                    // receiving and no client has pressed keys
-                    // -> no need to keep pinging
-                    break;
-                }
-
-                // ping clients
-                for addr in ping_addrs {
-                    if sender_ch.send((Event::Ping(), addr)).await.is_err() {
-                        break;
-                    }
-                }
-
-                // give clients time to resond
-                if receiving {
-                    log::trace!("waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ...");
-                } else {
-                    log::trace!(
-                        "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
-                        server.state.get()
-                    );
-                }
-
-                tokio::time::sleep(MAX_RESPONSE_TIME).await;
-
-                // when anything is received from a client,
-                // the alive flag gets set
-                let unresponsive_clients: Vec<_> = {
-                    let client_manager = server.client_manager.borrow();
+                // get relevant socket addrs for clients
+                let ping_addrs: Vec<SocketAddr> = {
                     ping_clients
                         .iter()
-                        .filter_map(|&c| match client_manager.get(c) {
-                            Some(state) if !state.alive => Some(c),
-                            _ => None,
+                        .flat_map(|&h| client_manager.get(h))
+                        .flat_map(|(c, s)| {
+                            if s.alive && s.active_addr.is_some() {
+                                vec![s.active_addr.unwrap()]
+                            } else {
+                                s.ips
+                                    .iter()
+                                    .cloned()
+                                    .map(|ip| SocketAddr::new(ip, c.port))
+                                    .collect()
+                            }
                         })
                         .collect()
                 };
 
-                // we may not be receiving anymore but we should respond
-                // to the original state and not the "new" one
-                if receiving {
-                    for c in unresponsive_clients {
-                        log::warn!("device not responding, releasing keys!");
-                        let _ = consumer_notify.send(ConsumerEvent::ReleaseKeys(c)).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 _ = producer_notify.send(ProducerEvent::Release).await;
-                    }
+                // reset alive
+                for (_, (_, s)) in client_manager.get_client_states_mut() {
+                    s.alive = false;
+                }
+
+                (ping_clients, ping_addrs)
+            };
+
+            if receiving && ping_clients.is_empty() {
+                // receiving and no client has pressed keys
+                // -> no need to keep pinging
+                break;
+            }
+
+            // ping clients
+            for addr in ping_addrs {
+                if sender_ch.send((Event::Ping(), addr)).await.is_err() {
+                    break;
+                }
+            }
+
+            // give clients time to resond
+            if receiving {
+                log::trace!(
+                    "waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ..."
+                );
+            } else {
+                log::trace!(
+                    "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
+                    server.state.get()
+                );
+            }
+
+            tokio::time::sleep(MAX_RESPONSE_TIME).await;
+
+            // when anything is received from a client,
+            // the alive flag gets set
+            let unresponsive_clients: Vec<_> = {
+                let client_manager = server.client_manager.borrow();
+                ping_clients
+                    .iter()
+                    .filter_map(|&h| match client_manager.get(h) {
+                        Some((_, s)) if !s.alive => Some(h),
+                        _ => None,
+                    })
+                    .collect()
+            };
+
+            // we may not be receiving anymore but we should respond
+            // to the original state and not the "new" one
+            if receiving {
+                for h in unresponsive_clients {
+                    log::warn!("device not responding, releasing keys!");
+                    let _ = emulate_notify.send(EmulationRequest::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;
                 }
             }
         }
-    });
-    ping_task
+    }
 }

src/server/producer_task.rs

@@ -1,152 +0,0 @@
-use anyhow::{anyhow, Result};
-use futures::StreamExt;
-use std::{collections::HashSet, net::SocketAddr};
-
-use tokio::{sync::mpsc::Sender, task::JoinHandle};
-
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    event::{Event, KeyboardEvent},
-    producer::EventProducer,
-    scancode,
-    server::State,
-};
-
-use super::Server;
-
-#[derive(Clone, Copy, Debug)]
-pub enum ProducerEvent {
-    /// producer must release the mouse
-    Release,
-    /// producer is notified of a change in client states
-    ClientEvent(ClientEvent),
-    /// termination signal
-    Terminate,
-}
-
-pub fn new(
-    mut producer: Box<dyn EventProducer>,
-    server: Server,
-    sender_tx: Sender<(Event, SocketAddr)>,
-    timer_tx: Sender<()>,
-    release_bind: Vec<scancode::Linux>,
-) -> (JoinHandle<Result<()>>, Sender<ProducerEvent>) {
-    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-    let task = tokio::task::spawn_local(async move {
-        let mut pressed_keys = HashSet::new();
-        loop {
-            tokio::select! {
-                event = producer.next() => {
-                    match event {
-                        Some(Ok(event)) => handle_producer_event(&server, &mut producer, &sender_tx, &timer_tx, event, &mut pressed_keys, &release_bind).await?,
-                        Some(Err(e)) => return Err(anyhow!("event producer: {e:?}")),
-                        None => return Err(anyhow!("event producer closed")),
-                    }
-                }
-                e = rx.recv() => {
-                    log::debug!("producer notify rx: {e:?}");
-                    match e {
-                        Some(e) => match e {
-                            ProducerEvent::Release => {
-                                producer.release()?;
-                                server.state.replace(State::Receiving);
-
-                            }
-                            ProducerEvent::ClientEvent(e) => producer.notify(e)?,
-                            ProducerEvent::Terminate => break,
-                        },
-                        None => break,
-                    }
-                }
-            }
-        }
-        anyhow::Ok(())
-    });
-    (task, tx)
-}
-
-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_producer_event(
-    server: &Server,
-    producer: &mut Box<dyn EventProducer>,
-    sender_tx: &Sender<(Event, SocketAddr)>,
-    timer_tx: &Sender<()>,
-    event: (ClientHandle, Event),
-    pressed_keys: &mut HashSet<scancode::Linux>,
-    release_bind: &[scancode::Linux],
-) -> Result<()> {
-    let (c, mut e) = event;
-    log::trace!("({c}) {e:?}");
-
-    if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = e {
-        update_pressed_keys(pressed_keys, key, state);
-        log::debug!("{pressed_keys:?}");
-        if release_bind.iter().all(|k| pressed_keys.contains(k)) {
-            pressed_keys.clear();
-            log::info!("releasing pointer");
-            producer.release()?;
-            server.state.replace(State::Receiving);
-            log::trace!("STATE ===> Receiving");
-            // send an event to release all the modifiers
-            e = Event::Disconnect();
-        }
-    }
-
-    let (addr, enter, start_timer) = {
-        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 = match client_manager.get_mut(c) {
-            Some(state) => state,
-            None => {
-                // should not happen
-                log::warn!("unknown client!");
-                producer.release()?;
-                server.state.replace(State::Receiving);
-                log::trace!("STATE ===> Receiving");
-                return Ok(());
-            }
-        };
-
-        // 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(client_state.client.handle));
-            log::trace!("Active client => {}", client_state.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(());
-            }
-        }
-
-        (client_state.active_addr, enter, start_timer)
-    };
-    if start_timer {
-        let _ = timer_tx.try_send(());
-    }
-    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/resolver_task.rs

@@ -1,40 +0,0 @@
-use std::collections::HashSet;
-
-use tokio::{sync::mpsc::Sender, task::JoinHandle};
-
-use crate::{client::ClientHandle, dns::DnsResolver};
-
-use super::Server;
-
-#[derive(Clone)]
-pub struct DnsRequest {
-    pub hostname: String,
-    pub handle: ClientHandle,
-}
-
-pub fn new(resolver: DnsResolver, server: Server) -> (JoinHandle<()>, Sender<DnsRequest>) {
-    let (dns_tx, mut dns_rx) = tokio::sync::mpsc::channel::<DnsRequest>(32);
-    let resolver_task = tokio::task::spawn_local(async move {
-        loop {
-            let (host, handle) = match dns_rx.recv().await {
-                Some(r) => (r.hostname, r.handle),
-                None => break,
-            };
-            let ips = match resolver.resolve(&host).await {
-                Ok(ips) => ips,
-                Err(e) => {
-                    log::warn!("could not resolve host '{host}': {e}");
-                    continue;
-                }
-            };
-            if let Some(state) = server.client_manager.borrow_mut().get_mut(handle) {
-                let mut addrs = HashSet::from_iter(state.client.fix_ips.iter().cloned());
-                for ip in ips {
-                    addrs.insert(ip);
-                }
-                state.client.ips = addrs;
-            }
-        }
-    });
-    (resolver_task, dns_tx)
-}