cancel previous dns request if a new one is made

* Build a macOS bundle for Intel and ARM

* Build icon.icns file in a script

* Add imagemagick

* Add macOS bundling to pre/tagged-release actions

.github/workflows/pre-release.yml

@@ -84,36 +84,56 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
-      run: brew install gtk4 libadwaita
+      run: brew install gtk4 libadwaita imagemagick
     - name: Release Build
       run: |
         cargo build --release
         cp target/release/lan-mouse lan-mouse-macos-intel
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle --release
+    - name: Zip bundle
+      run: |
+        cd target/release/bundle/osx
+        zip -r "lan-mouse-macos-intel.zip" "Lan Mouse.app"
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
         name: lan-mouse-macos-intel
-        path: lan-mouse-macos-intel
+        path: target/release/bundle/osx/lan-mouse-macos-intel.zip
 
   macos-aarch64-release-build:
     runs-on: macos-14
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
-      run: brew install gtk4 libadwaita
+      run: brew install gtk4 libadwaita imagemagick
     - name: Release Build
       run: |
         cargo build --release
         cp target/release/lan-mouse lan-mouse-macos-aarch64
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle --release
+    - name: Zip bundle
+      run: |
+        cd target/release/bundle/osx
+        zip -r "lan-mouse-macos-aarch64.zip" "Lan Mouse.app"
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
         name: lan-mouse-macos-aarch64
-        path: lan-mouse-macos-aarch64
+        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
 
   pre-release:
     name: "Pre Release"
-    needs: [windows-release-build, linux-release-build, macos-release-build]
+    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
     runs-on: "ubuntu-latest"
     steps:
     - name: Download build artifacts
@@ -127,6 +147,6 @@ jobs:
         title: "Development Build"
         files: |
           lan-mouse-linux/lan-mouse
-          lan-mouse-macos-intel/lan-mouse-macos-intel
-          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
+          lan-mouse-macos-intel/lan-mouse-macos-intel.zip
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
           lan-mouse-windows/lan-mouse-windows.zip

.github/workflows/rust.yml

@@ -98,7 +98,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
-      run: brew install gtk4 libadwaita
+      run: brew install gtk4 libadwaita imagemagick
     - name: Build
       run: cargo build --verbose
     - name: Run tests
@@ -107,18 +107,28 @@ jobs:
       run: cargo fmt --check
     - name: Clippy
       run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle
+    - name: Zip bundle
+      run: |
+        cd target/debug/bundle/osx
+        zip -r "Lan Mouse macOS (Intel).zip" "Lan Mouse.app"
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos
-        path: target/debug/lan-mouse
+        name: Lan Mouse macOS (Intel)
+        path: target/debug/bundle/osx/Lan Mouse macOS (Intel).zip
 
   build-macos-aarch64:
     runs-on: macos-14
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
-      run: brew install gtk4 libadwaita
+      run: brew install gtk4 libadwaita imagemagick
     - name: Build
       run: cargo build --verbose
     - name: Run tests
@@ -127,8 +137,18 @@ jobs:
       run: cargo fmt --check
     - name: Clippy
       run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle
+    - name: Zip bundle
+      run: |
+        cd target/debug/bundle/osx
+        zip -r "Lan Mouse macOS (ARM).zip" "Lan Mouse.app"
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos-aarch64
-        path: target/debug/lan-mouse
+        name: Lan Mouse macOS (ARM)
+        path: target/debug/bundle/osx/Lan Mouse macOS (ARM).zip

.github/workflows/tagged-release.yml

@@ -3,7 +3,7 @@ name: "Tagged Release"
 on:
   push:
     tags:
-      - "v*"
+      - v**
 
 jobs:
   linux-release-build:
@@ -80,47 +80,67 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
-      run: brew install gtk4 libadwaita
+      run: brew install gtk4 libadwaita imagemagick
     - name: Release Build
       run: |
         cargo build --release
         cp target/release/lan-mouse lan-mouse-macos-intel
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle --release
+    - name: Zip bundle
+      run: |
+        cd target/release/bundle/osx
+        zip -r "lan-mouse-macos-intel.zip" "Lan Mouse.app"
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos-intel
-        path: lan-mouse-macos-intel
+        name: lan-mouse-macos-intel.zip
+        path: target/release/bundle/osx/lan-mouse-macos-intel.zip
 
   macos-aarch64-release-build:
     runs-on: macos-14
     steps:
     - uses: actions/checkout@v4
     - name: install dependencies
-      run: brew install gtk4 libadwaita
+      run: brew install gtk4 libadwaita imagemagick
     - name: Release Build
       run: |
         cargo build --release
         cp target/release/lan-mouse lan-mouse-macos-aarch64
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: cargo bundle --release
+    - name: Zip bundle
+      run: |
+        cd target/release/bundle/osx
+        zip -r "lan-mouse-macos-aarch64.zip" "Lan Mouse.app"
     - name: Upload build artifact
       uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos-aarch64
-        path: lan-mouse-macos-aarch64
+        name: lan-mouse-macos-aarch64.zip
+        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
 
   tagged-release:
     name: "Tagged Release"
-    needs: [windows-release-build, linux-release-build, macos-release-build]
+    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
     runs-on: "ubuntu-latest"
     steps:
     - name: Download build artifacts
       uses: actions/download-artifact@v4
-    - name: "Create Release"
+    - name: Create Release
       uses: "marvinpinto/action-automatic-releases@latest"
       with:
         repo_token: "${{ secrets.GITHUB_TOKEN }}"
         prerelease: false
         files: |
           lan-mouse-linux/lan-mouse
-          lan-mouse-macos-intel/lan-mouse-macos-intel
-          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
+          lan-mouse-macos-intel/lan-mouse-macos-intel.zip
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
           lan-mouse-windows/lan-mouse-windows.zip

.gitignore

@@ -4,4 +4,7 @@
 .vs/
 .vscode/
 .direnv/
-result
+result
+*.pem
+*.csr
+extfile.conf

Cargo.toml

@@ -18,8 +18,13 @@ license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
 
 [profile.release]
-strip = true
+codegen-units = 1
 lto = "fat"
+strip = true
+panic = "abort"
+
+[build-dependencies]
+shadow-rs = "0.38.0"
 
 [dependencies]
 input-event = { path = "input-event", version = "0.3.0" }
@@ -29,6 +34,7 @@ lan-mouse-cli = { path = "lan-mouse-cli", version = "0.2.0" }
 lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.2.0", optional = true }
 lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.2.0" }
 lan-mouse-proto = { path = "lan-mouse-proto", version = "0.2.0" }
+shadow-rs = { version = "0.38.0", features = ["metadata"] }
 
 hickory-resolver = "0.24.1"
 toml = "0.8"
@@ -52,6 +58,14 @@ slab = "0.4.9"
 thiserror = "2.0.0"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"
+webrtc-dtls = { version = "0.10.0", features = ["pem"] }
+webrtc-util = "0.9.0"
+rustls = { version = "0.23.12", default-features = false, features = [
+    "std",
+    "ring",
+] }
+rcgen = "0.13.1"
+sha2 = "0.10.8"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
@@ -75,3 +89,8 @@ libei_emulation = ["input-event/libei", "input-emulation/libei"]
 wlroots_emulation = ["input-emulation/wlroots"]
 x11_emulation = ["input-emulation/x11"]
 rdp_emulation = ["input-emulation/remote_desktop_portal"]
+
+[package.metadata.bundle]
+name = "Lan Mouse"
+icon = ["target/icon.icns"]
+identifier = "de.feschber.LanMouse"

README.md

@@ -4,7 +4,7 @@ It allows for using multiple PCs via a single set of mouse and keyboard.
 This is also known as a Software KVM switch.
 
 Goal of this project is to be an open-source alternative to proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/)
-and an alternative to other open source tools like [Deskflow](https://github.com/deskflow/deskflow) or [Input Leap](https://github.com/input-leap) (Synergy fork).
+and other open source tools like [Deskflow](https://github.com/deskflow/deskflow) or [Input Leap](https://github.com/input-leap) (Synergy fork).
 
 Focus lies on performance, ease of use and a maintainable implementation that can be expanded to support additional backends for e.g. Android, iOS, ... in the future.
 
@@ -19,15 +19,10 @@ Focus lies on performance, ease of use and a maintainable implementation that ca
 </picture>
 
 
-> [!WARNING]
-> DISCLAIMER:
-> Until [#200](https://github.com/feschber/lan-mouse/pull/200) is merged, all network traffic is **unencrypted** and sent in **plaintext**!
->
-> A malicious actor with access to the network could read input data or send input events with spoofed IPs to take control over a device.
->
-> Therefore you should only use this tool in your local network with trusted devices.
-> I take no responsibility for any security breaches!
+## Encryption
 
+Lan Mouse encrypts all network traffic using the DTLS implementation provided by [WebRTC.rs](https://github.com/webrtc-rs/webrtc).
+There are currently no mitigations in place for timing side-channel attacks.
 
 ## OS Support
 
@@ -55,6 +50,10 @@ Most current desktop environments and operating systems are fully supported, thi
 
 For more detailed information about os support see [Detailed OS Support](#detailed-os-support)
 
+### Android & IOS
+
+A proof of concept for an Android / IOS Application by [rohitsangwan01](https://github.com/rohitsangwan01) can be found [here](https://github.com/rohitsangwan01/lan-mouse-mobile).
+It can be used as a remote control for any device supported by Lan Mouse.
 
 ## Installation
 
@@ -190,14 +189,14 @@ sudo dnf install libadwaita-devel libXtst-devel libX11-devel
 </details>
 <details>
     <summary>Nix</summary>
-    
+
 ```sh
 nix-shell .
 ```
 </details>
 <details>
     <summary>Nix (flake)</summary>
-    
+
 ```sh
 nix develop
 ```
@@ -252,11 +251,17 @@ the gtk frontend (see conditional compilation).
 
 By default the gtk frontend will open when running `lan-mouse`.
 
-To add a new connection, simply click the `Add` button on *both* devices,
-enter the corresponding hostname and activate it.
+To connect a device you want to control, simply click the `Add` button and enter the hostname
+of the device.
 
-If the mouse can not be moved onto a device, make sure you have port `4242` (or the one selected)
-opened up in your firewall.
+On the *remote* device, authorize your *local* device for incoming traffic using the `Authorize` button
+under the "Incoming Connections" section.
+The fingerprint for authorization can be found under the general section of your *local* device.
+It is of the form "aa:bb:cc:..."
+
+Authorized devices can be persisted using the configuration file (see [Configuration](#configuration)).
+
+If the device still can not be entered, make sure you have UDP port `4242` (or the one selected) opened up in your firewall.
 </details>
 
 <details>
@@ -309,7 +314,7 @@ To create this file you can copy the following example config:
 ### Example config
 > [!TIP]
 > key symbols in the release bind are named according
-> to their names in [src/scancode.rs#L172](src/scancode.rs#L172).
+> to their names in [input-event/src/scancode.rs#L172](input-event/src/scancode.rs#L176).
 > This is bound to change
 
 ```toml
@@ -321,9 +326,14 @@ release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
 # optional port (defaults to 4242)
 port = 4242
 # # optional frontend -> defaults to gtk if available
-# # possible values are "cli" and "gtk" 
+# # possible values are "cli" and "gtk"
 # frontend = "gtk"
 
+# list of authorized tls certificate fingerprints that
+# are accepted for incoming traffic
+[authorized_fingerprints]
+"bc:05:ab:7a:a4:de:88:8c:2f:92:ac:bc:b8:49:b8:24:0d:44:b3:e6:a4:ef:d7:0b:6c:69:6d:77:53:0b:14:80" = "iridium"
+
 # define a client on the right side with host name "iridium"
 [right]
 # hostname
@@ -356,7 +366,7 @@ Where `left` can be either `left`, `right`, `top` or `bottom`.
 - [x] Libei Input Capture
 - [x] MacOS Input Capture
 - [x] Windows Input Capture
-- [ ] *Encryption* (WIP)
+- [x] Encryption
 - [ ] X11 Input Capture
 - [ ] Latency measurement and visualization
 - [ ] Bandwidth usage measurement and visualization
@@ -374,14 +384,14 @@ The following sections detail the emulation and capture backends provided by lan
 
 ### Input Emulation Support
 
-| Desktop / Backend         | layer-shell              | libei                    | windows                  |   macos                                | x11 |
-|---------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|-----|
-| Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                                        |     |
-| Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |     |
-| Wayland (Gnome)           |                          | :heavy_check_mark:       |                          |                                        |     |
-| Windows                   |                          |                          | :heavy_check_mark:       |                                        |     |
-| MacOS                     |                          |                          |                          |   :heavy_check_mark:                   |     |
-| X11                       |                          |                          |                          |                                        | WIP |
+| Desktop / Backend         | wlroots                  | libei                    | remote-desktop portal    | windows                  |   macos                                | x11                |
+|---------------------------|--------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|--------------------|
+| Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                          |                                        |                    |
+| Wayland (KDE)             |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
+| Wayland (Gnome)           |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
+| Windows                   |                          |                          |                          | :heavy_check_mark:       |                                        |                    |
+| MacOS                     |                          |                          |                          |                          |   :heavy_check_mark:                   |                    |
+| X11                       |                          |                          |                          |                          |                                        | :heavy_check_mark: |
 
 - `wlroots`: This backend makes use of the [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1) and [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1) protocols and is supported by most wlroots based compositors.
 - `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
@@ -394,20 +404,17 @@ The following sections detail the emulation and capture backends provided by lan
 
 ### Input Capture Support
 
-| Desktop / Backend         | wlroots                  | libei                    | remote-desktop portal    | windows                  |   macos                                | x11                |
-|---------------------------|--------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|--------------------|
-| Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                          |                                        |                    |
-| Wayland (KDE)             |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
-| Wayland (Gnome)           |                          | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |                    |
-| Windows                   |                          |                          |                          | :heavy_check_mark:       |                                        |                    |
-| MacOS                     |                          |                          |                          |                          |   :heavy_check_mark:                   |                    |
-| X11                       |                          |                          |                          |                          |                                        | :heavy_check_mark: |
+| Desktop / Backend         | layer-shell              | libei                    | windows                  |   macos                                | x11 |
+|---------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|-----|
+| Wayland (wlroots)         | :heavy_check_mark:       |                          |                          |                                        |     |
+| Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:       |                          |                                        |     |
+| Wayland (Gnome)           |                          | :heavy_check_mark:       |                          |                                        |     |
+| Windows                   |                          |                          | :heavy_check_mark:       |                                        |     |
+| MacOS                     |                          |                          |                          |   :heavy_check_mark:                   |     |
+| X11                       |                          |                          |                          |                                        | WIP |
 
 - `layer-shell`: This backend creates a single pixel wide window on the edges of Displays to capture the cursor using the [layer-shell protocol](https://wayland.app/protocols/wlr-layer-shell-unstable-v1).
 - `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
 - `windows`: Backend for input capture on Windows.
 - `macos`: Backend for input capture on MacOS.
 - `x11`: TODO (not yet supported)
-
-
-

build.rs

@@ -1,15 +1,8 @@
-use std::process::Command;
+use shadow_rs::ShadowBuilder;
 
 fn main() {
-    // commit hash
-    let git_describe = Command::new("git")
-        .arg("describe")
-        .arg("--always")
-        .arg("--dirty")
-        .arg("--tags")
-        .output()
-        .unwrap();
-
-    let git_describe = String::from_utf8(git_describe.stdout).unwrap();
-    println!("cargo::rustc-env=GIT_DESCRIBE={git_describe}");
+    ShadowBuilder::builder()
+        .deny_const(Default::default())
+        .build()
+        .expect("shadow build");
 }

config.toml

@@ -3,13 +3,18 @@
 # capture_backend = "LayerShell"
 
 # release bind
-release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
+release_bind = ["KeyA", "KeyS", "KeyD", "KeyF"]
 
 # optional port (defaults to 4242)
 port = 4242
 # optional frontend -> defaults to gtk if available
 # frontend = "gtk"
 
+# list of authorized tls certificate fingerprints that
+# are accepted for incoming traffic
+[authorized_fingerprints]
+"bc:05:ab:7a:a4:de:88:8c:2f:92:ac:bc:b8:49:b8:24:0d:44:b3:e6:a4:ef:d7:0b:6c:69:6d:77:53:0b:14:80" = "iridium"
+
 # define a client on the right side with host name "iridium"
 [right]
 # hostname

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1728018373,
-        "narHash": "sha256-NOiTvBbRLIOe5F6RbHaAh6++BNjsb149fGZd1T4+KBg=",
+        "lastModified": 1740560979,
+        "narHash": "sha256-Vr3Qi346M+8CjedtbyUevIGDZW8LcA1fTG0ugPY/Hic=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "bc947f541ae55e999ffdb4013441347d83b00feb",
+        "rev": "5135c59491985879812717f4c9fea69604e7f26f",
         "type": "github"
       },
       "original": {
@@ -29,11 +29,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1728181869,
-        "narHash": "sha256-sQXHXsjIcGEoIHkB+RO6BZdrPfB+43V1TEpyoWRI3ww=",
+        "lastModified": 1740623427,
+        "narHash": "sha256-3SdPQrZoa4odlScFDUHd4CUPQ/R1gtH4Mq9u8CBiK8M=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "cd46aa3906c14790ef5cbe278d9e54f2c38f95c0",
+        "rev": "d342e8b5fd88421ff982f383c853f0fc78a847ab",
         "type": "github"
       },
       "original": {

input-capture/src/layer_shell.rs

@@ -1,8 +1,9 @@
 use async_trait::async_trait;
 use futures_core::Stream;
 use std::{
-    collections::VecDeque,
+    collections::{HashSet, VecDeque},
     env,
+    fmt::{self, Display},
     io::{self, ErrorKind},
     os::fd::{AsFd, RawFd},
     pin::Pin,
@@ -46,13 +47,15 @@ use wayland_protocols_wlr::layer_shell::v1::client::{
 use wayland_client::{
     backend::{ReadEventsGuard, WaylandError},
     delegate_noop,
-    globals::{registry_queue_init, GlobalListContents},
+    globals::{registry_queue_init, Global, GlobalList, GlobalListContents},
     protocol::{
         wl_buffer, wl_compositor,
         wl_keyboard::{self, WlKeyboard},
         wl_output::{self, WlOutput},
         wl_pointer::{self, WlPointer},
-        wl_region, wl_registry, wl_seat, wl_shm, wl_shm_pool,
+        wl_region,
+        wl_registry::{self, WlRegistry},
+        wl_seat, wl_shm, wl_shm_pool,
         wl_surface::WlSurface,
     },
     Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
@@ -75,28 +78,42 @@ struct Globals {
     seat: wl_seat::WlSeat,
     shm: wl_shm::WlShm,
     layer_shell: ZwlrLayerShellV1,
-    outputs: Vec<WlOutput>,
     xdg_output_manager: ZxdgOutputManagerV1,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
+struct Output {
+    wl_output: WlOutput,
+    global: Global,
+    info: Option<OutputInfo>,
+    pending_info: OutputInfo,
+    has_xdg_info: bool,
+}
+
+impl Display for Output {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(info) = &self.info {
+            write!(
+                f,
+                "{} {}x{} @pos {:?} ({})",
+                info.name, info.size.0, info.size.1, info.position, info.description
+            )
+        } else {
+            write!(f, "unknown output")
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
 struct OutputInfo {
+    description: String,
     name: String,
     position: (i32, i32),
     size: (i32, i32),
 }
 
-impl OutputInfo {
-    fn new() -> Self {
-        Self {
-            name: "".to_string(),
-            position: (0, 0),
-            size: (0, 0),
-        }
-    }
-}
-
 struct State {
+    active_positions: HashSet<Position>,
     pointer: Option<WlPointer>,
     keyboard: Option<WlKeyboard>,
     pointer_lock: Option<ZwpLockedPointerV1>,
@@ -104,12 +121,13 @@ struct State {
     shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
     active_windows: Vec<Arc<Window>>,
     focused: Option<Arc<Window>>,
-    g: Globals,
+    global_list: GlobalList,
+    globals: Globals,
     wayland_fd: RawFd,
     read_guard: Option<ReadEventsGuard>,
     qh: QueueHandle<Self>,
     pending_events: VecDeque<(Position, CaptureEvent)>,
-    output_info: Vec<(WlOutput, OutputInfo)>,
+    outputs: Vec<Output>,
     scroll_discrete_pending: bool,
 }
 
@@ -142,7 +160,7 @@ impl Window {
         size: (i32, i32),
     ) -> Window {
         log::debug!("creating window output: {output:?}, size: {size:?}");
-        let g = &state.g;
+        let g = &state.globals;
 
         let (width, height) = match pos {
             Position::Left | Position::Right => (1, size.1 as u32),
@@ -203,41 +221,36 @@ impl Drop for Window {
     }
 }
 
-fn get_edges(outputs: &[(WlOutput, OutputInfo)], pos: Position) -> Vec<(WlOutput, i32)> {
+fn get_edges(outputs: &[Output], pos: Position) -> Vec<(Output, i32)> {
     outputs
         .iter()
-        .map(|(o, i)| {
-            (
-                o.clone(),
-                match pos {
-                    Position::Left => i.position.0,
-                    Position::Right => i.position.0 + i.size.0,
-                    Position::Top => i.position.1,
-                    Position::Bottom => i.position.1 + i.size.1,
-                },
-            )
+        .filter_map(|output| {
+            output.info.as_ref().map(|info| {
+                (
+                    output.clone(),
+                    match pos {
+                        Position::Left => info.position.0,
+                        Position::Right => info.position.0 + info.size.0,
+                        Position::Top => info.position.1,
+                        Position::Bottom => info.position.1 + info.size.1,
+                    },
+                )
+            })
         })
         .collect()
 }
 
-fn get_output_configuration(state: &State, pos: Position) -> Vec<(WlOutput, OutputInfo)> {
+fn get_output_configuration(state: &State, pos: Position) -> Vec<Output> {
     // get all output edges corresponding to the position
-    let edges = get_edges(&state.output_info, pos);
-    log::debug!("edges: {edges:?}");
-    let opposite_edges = get_edges(&state.output_info, pos.opposite());
+    let edges = get_edges(&state.outputs, pos);
+    let opposite_edges = get_edges(&state.outputs, pos.opposite());
 
     // remove those edges that are at the same position
     // as an opposite edge of a different output
-    let outputs: Vec<WlOutput> = edges
+    edges
         .iter()
         .filter(|(_, edge)| !opposite_edges.iter().map(|(_, e)| *e).any(|e| &e == edge))
         .map(|(o, _)| o.clone())
-        .collect();
-    state
-        .output_info
-        .iter()
-        .filter(|(o, _)| outputs.contains(o))
-        .map(|(o, i)| (o.clone(), i.clone()))
         .collect()
 }
 
@@ -259,36 +272,36 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
 impl LayerShellInputCapture {
     pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
         let conn = Connection::connect_to_env()?;
-        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
+        let (global_list, mut queue) = registry_queue_init::<State>(&conn)?;
 
         let qh = queue.handle();
 
-        let compositor: wl_compositor::WlCompositor = g
+        let compositor: wl_compositor::WlCompositor = global_list
             .bind(&qh, 4..=5, ())
             .map_err(|e| WaylandBindError::new(e, "wl_compositor 4..=5"))?;
-        let xdg_output_manager: ZxdgOutputManagerV1 = g
+        let xdg_output_manager: ZxdgOutputManagerV1 = global_list
             .bind(&qh, 1..=3, ())
             .map_err(|e| WaylandBindError::new(e, "xdg_output_manager 1..=3"))?;
-        let shm: wl_shm::WlShm = g
+        let shm: wl_shm::WlShm = global_list
             .bind(&qh, 1..=1, ())
             .map_err(|e| WaylandBindError::new(e, "wl_shm"))?;
-        let layer_shell: ZwlrLayerShellV1 = g
+        let layer_shell: ZwlrLayerShellV1 = global_list
             .bind(&qh, 3..=4, ())
             .map_err(|e| WaylandBindError::new(e, "wlr_layer_shell 3..=4"))?;
-        let seat: wl_seat::WlSeat = g
+        let seat: wl_seat::WlSeat = global_list
             .bind(&qh, 7..=8, ())
             .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
 
-        let pointer_constraints: ZwpPointerConstraintsV1 = g
+        let pointer_constraints: ZwpPointerConstraintsV1 = global_list
             .bind(&qh, 1..=1, ())
             .map_err(|e| WaylandBindError::new(e, "zwp_pointer_constraints_v1"))?;
-        let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
+        let relative_pointer_manager: ZwpRelativePointerManagerV1 = global_list
             .bind(&qh, 1..=1, ())
             .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
         let shortcut_inhibit_manager: Result<
             ZwpKeyboardShortcutsInhibitManagerV1,
             WaylandBindError,
-        > = g
+        > = global_list
             .bind(&qh, 1..=1, ())
             .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"));
         // layer-shell backend still works without this protocol so we make it an optional dependency
@@ -297,65 +310,41 @@ impl LayerShellInputCapture {
                 to the client");
         }
         let shortcut_inhibit_manager = shortcut_inhibit_manager.ok();
-        let outputs = vec![];
-
-        let g = Globals {
-            compositor,
-            shm,
-            layer_shell,
-            seat,
-            pointer_constraints,
-            relative_pointer_manager,
-            shortcut_inhibit_manager,
-            outputs,
-            xdg_output_manager,
-        };
-
-        // flush outgoing events
-        queue.flush()?;
-
-        let wayland_fd = queue.as_fd().as_raw_fd();
 
         let mut state = State {
+            active_positions: Default::default(),
             pointer: None,
             keyboard: None,
-            g,
+            global_list,
+            globals: Globals {
+                compositor,
+                shm,
+                layer_shell,
+                seat,
+                pointer_constraints,
+                relative_pointer_manager,
+                shortcut_inhibit_manager,
+                xdg_output_manager,
+            },
             pointer_lock: None,
             rel_pointer: None,
             shortcut_inhibitor: None,
             active_windows: Vec::new(),
             focused: None,
             qh,
-            wayland_fd,
+            wayland_fd: queue.as_fd().as_raw_fd(),
             read_guard: None,
             pending_events: VecDeque::new(),
-            output_info: vec![],
+            outputs: vec![],
             scroll_discrete_pending: false,
         };
 
-        // dispatch registry to () again, in order to read all wl_outputs
-        conn.display().get_registry(&state.qh, ());
-        log::debug!("==============> requested registry");
-
-        // roundtrip to read wl_output globals
-        queue.roundtrip(&mut state)?;
-        log::debug!("==============> roundtrip 1 done");
-
-        // read outputs
-        for output in state.g.outputs.iter() {
-            state
-                .g
-                .xdg_output_manager
-                .get_xdg_output(output, &state.qh, output.clone());
+        for global in state.global_list.contents().clone_list() {
+            state.register_global(global);
         }
 
-        // roundtrip to read xdg_output events
-        queue.roundtrip(&mut state)?;
-
-        log::debug!("==============> roundtrip 2 done");
-        for i in &state.output_info {
-            log::debug!("{:#?}", i.1);
-        }
+        // flush outgoing events
+        queue.flush()?;
 
         let read_guard = loop {
             match queue.prepare_read() {
@@ -379,6 +368,7 @@ impl LayerShellInputCapture {
 
     fn delete_client(&mut self, pos: Position) {
         let inner = self.0.get_mut();
+        inner.state.active_positions.remove(&pos);
         // remove all windows corresponding to this client
         while let Some(i) = inner.state.active_windows.iter().position(|w| w.pos == pos) {
             inner.state.active_windows.remove(i);
@@ -388,6 +378,52 @@ impl LayerShellInputCapture {
 }
 
 impl State {
+    fn update_output_info(&mut self, name: u32) {
+        let output = self
+            .outputs
+            .iter_mut()
+            .find(|o| o.global.name == name)
+            .expect("output not found");
+        if output.has_xdg_info {
+            output.info.replace(output.pending_info.clone());
+            self.update_windows();
+        }
+    }
+
+    fn register_global(&mut self, global: Global) {
+        if global.interface.as_str() == "wl_output" {
+            log::debug!("new output global: wl_output {}", global.name);
+            let wl_output = self.global_list.registry().bind::<WlOutput, _, _>(
+                global.name,
+                4,
+                &self.qh,
+                global.name,
+            );
+            self.globals
+                .xdg_output_manager
+                .get_xdg_output(&wl_output, &self.qh, global.name);
+            self.outputs.push(Output {
+                wl_output,
+                global,
+                info: None,
+                has_xdg_info: false,
+                pending_info: Default::default(),
+            })
+        }
+    }
+
+    fn deregister_global(&mut self, name: u32) {
+        self.outputs.retain(|o| {
+            if o.global.name == name {
+                log::debug!("{o} (global {:?}) removed", o.global);
+                o.wl_output.release();
+                false
+            } else {
+                true
+            }
+        });
+    }
+
     fn grab(
         &mut self,
         surface: &WlSurface,
@@ -408,7 +444,7 @@ impl State {
 
         // lock pointer
         if self.pointer_lock.is_none() {
-            self.pointer_lock = Some(self.g.pointer_constraints.lock_pointer(
+            self.pointer_lock = Some(self.globals.pointer_constraints.lock_pointer(
                 surface,
                 pointer,
                 None,
@@ -420,7 +456,7 @@ impl State {
 
         // request relative input
         if self.rel_pointer.is_none() {
-            self.rel_pointer = Some(self.g.relative_pointer_manager.get_relative_pointer(
+            self.rel_pointer = Some(self.globals.relative_pointer_manager.get_relative_pointer(
                 pointer,
                 qh,
                 (),
@@ -428,10 +464,14 @@ impl State {
         }
 
         // capture modifier keys
-        if let Some(shortcut_inhibit_manager) = &self.g.shortcut_inhibit_manager {
+        if let Some(shortcut_inhibit_manager) = &self.globals.shortcut_inhibit_manager {
             if self.shortcut_inhibitor.is_none() {
-                self.shortcut_inhibitor =
-                    Some(shortcut_inhibit_manager.inhibit_shortcuts(surface, &self.g.seat, qh, ()));
+                self.shortcut_inhibitor = Some(shortcut_inhibit_manager.inhibit_shortcuts(
+                    surface,
+                    &self.globals.seat,
+                    qh,
+                    (),
+                ));
             }
         }
     }
@@ -469,21 +509,39 @@ impl State {
     }
 
     fn add_client(&mut self, pos: Position) {
+        self.active_positions.insert(pos);
         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 = Arc::new(window);
-            self.active_windows.push(window);
+        log::info!(
+            "adding capture for position {pos} - using outputs: {:?}",
+            outputs
+                .iter()
+                .map(|o| o
+                    .info
+                    .as_ref()
+                    .map(|i| i.name.to_owned())
+                    .unwrap_or("unknown output".to_owned()))
+                .collect::<Vec<_>>()
+        );
+        outputs.iter().for_each(|o| {
+            if let Some(info) = o.info.as_ref() {
+                let window = Window::new(self, &self.qh, &o.wl_output, pos, info.size);
+                let window = Arc::new(window);
+                self.active_windows.push(window);
+            }
         });
     }
 
     fn update_windows(&mut self) {
-        log::debug!("updating windows");
-        log::debug!("output info: {:?}", self.output_info);
-        let clients: Vec<_> = self.active_windows.drain(..).map(|w| w.pos).collect();
-        for pos in clients {
+        log::info!("active outputs: ");
+        for output in self.outputs.iter().filter(|o| o.info.is_some()) {
+            log::info!(" * {}", output);
+        }
+
+        self.active_windows.clear();
+
+        let active_positions = self.active_positions.iter().cloned().collect::<Vec<_>>();
+        for pos in active_positions {
             self.add_client(pos);
         }
     }
@@ -835,7 +893,7 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
         } = event
         {
             if let Some(window) = &app.focused {
-                let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
+                let time = ((((utime_hi as u64) << 32) | utime_lo as u64) / 1000) as u32;
                 app.pending_events.push_back((
                     window.pos,
                     CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { time, dx, dy })),
@@ -872,94 +930,89 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
 }
 
 // delegate wl_registry events to App itself
-impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &wl_registry::WlRegistry,
-        _event: <wl_registry::WlRegistry as wayland_client::Proxy>::Event,
-        _data: &GlobalListContents,
-        _conn: &Connection,
-        _qhandle: &QueueHandle<Self>,
-    ) {
-    }
-}
-
-impl Dispatch<wl_registry::WlRegistry, ()> for State {
+impl Dispatch<WlRegistry, GlobalListContents> for State {
     fn event(
         state: &mut Self,
-        registry: &wl_registry::WlRegistry,
-        event: <wl_registry::WlRegistry as wayland_client::Proxy>::Event,
-        _: &(),
-        _: &Connection,
-        qh: &QueueHandle<Self>,
+        _registry: &WlRegistry,
+        event: <WlRegistry as wayland_client::Proxy>::Event,
+        _data: &GlobalListContents,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
     ) {
         match event {
             wl_registry::Event::Global {
                 name,
                 interface,
-                version: _,
+                version,
             } => {
-                if interface.as_str() == "wl_output" {
-                    log::debug!("wl_output global");
-                    state
-                        .g
-                        .outputs
-                        .push(registry.bind::<WlOutput, _, _>(name, 4, qh, ()))
-                }
+                state.register_global(Global {
+                    name,
+                    interface,
+                    version,
+                });
+            }
+            wl_registry::Event::GlobalRemove { name } => {
+                state.deregister_global(name);
             }
-            wl_registry::Event::GlobalRemove { .. } => {}
             _ => {}
         }
     }
 }
 
-impl Dispatch<ZxdgOutputV1, WlOutput> for State {
+impl Dispatch<ZxdgOutputV1, u32> for State {
     fn event(
         state: &mut Self,
         _: &ZxdgOutputV1,
         event: <ZxdgOutputV1 as wayland_client::Proxy>::Event,
-        wl_output: &WlOutput,
+        name: &u32,
         _: &Connection,
         _: &QueueHandle<Self>,
     ) {
-        log::debug!("xdg-output - {event:?}");
-        let output_info = match state.output_info.iter_mut().find(|(o, _)| o == wl_output) {
-            Some((_, c)) => c,
-            None => {
-                let output_info = OutputInfo::new();
-                state.output_info.push((wl_output.clone(), output_info));
-                &mut state.output_info.last_mut().unwrap().1
-            }
-        };
+        let output = state
+            .outputs
+            .iter_mut()
+            .find(|o| o.global.name == *name)
+            .expect("output");
 
+        log::debug!("xdg_output {name} - {:?}", event);
         match event {
             zxdg_output_v1::Event::LogicalPosition { x, y } => {
-                output_info.position = (x, y);
+                output.pending_info.position = (x, y);
+                output.has_xdg_info = true;
             }
             zxdg_output_v1::Event::LogicalSize { width, height } => {
-                output_info.size = (width, height);
+                output.pending_info.size = (width, height);
+                output.has_xdg_info = true;
+            }
+            zxdg_output_v1::Event::Done => {
+                log::warn!("Use of deprecated xdg-output event \"done\"");
+                state.update_output_info(*name);
             }
-            zxdg_output_v1::Event::Done => {}
             zxdg_output_v1::Event::Name { name } => {
-                output_info.name = name;
+                output.pending_info.name = name;
+                output.has_xdg_info = true;
             }
-            zxdg_output_v1::Event::Description { .. } => {}
-            _ => {}
+            zxdg_output_v1::Event::Description { description } => {
+                output.pending_info.description = description;
+                output.has_xdg_info = true;
+            }
+            _ => todo!(),
         }
     }
 }
 
-impl Dispatch<WlOutput, ()> for State {
+impl Dispatch<WlOutput, u32> for State {
     fn event(
         state: &mut Self,
-        _proxy: &WlOutput,
+        _wl_output: &WlOutput,
         event: <WlOutput as wayland_client::Proxy>::Event,
-        _data: &(),
+        name: &u32,
         _conn: &Connection,
         _qhandle: &QueueHandle<Self>,
     ) {
+        log::debug!("wl_output {name} - {:?}", event);
         if let wl_output::Event::Done = event {
-            state.update_windows();
+            state.update_output_info(*name);
         }
     }
 }

input-capture/src/libei.rs

@@ -153,7 +153,7 @@ async fn update_barriers(
 
 async fn create_session<'a>(
     input_capture: &'a InputCapture<'a>,
-) -> std::result::Result<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>), ashpd::Error> {
+) -> std::result::Result<(Session<'a, InputCapture<'a>>, BitFlags<Capabilities>), ashpd::Error> {
     log::debug!("creating input capture session");
     input_capture
         .create_session(
@@ -201,7 +201,7 @@ async fn libei_event_handler(
     }
 }
 
-impl<'a> LibeiInputCapture<'a> {
+impl LibeiInputCapture<'_> {
     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>;
@@ -561,7 +561,7 @@ async fn handle_ei_event(
 }
 
 #[async_trait]
-impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
+impl LanMouseInputCapture for LibeiInputCapture<'_> {
     async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
         let _ = self
             .notify_capture
@@ -594,7 +594,7 @@ impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
     }
 }
 
-impl<'a> Drop for LibeiInputCapture<'a> {
+impl Drop for LibeiInputCapture<'_> {
     fn drop(&mut self) {
         if !self.terminated {
             /* this workaround is needed until async drop is stabilized */
@@ -603,7 +603,7 @@ impl<'a> Drop for LibeiInputCapture<'a> {
     }
 }
 
-impl<'a> Stream for LibeiInputCapture<'a> {
+impl Stream for LibeiInputCapture<'_> {
     type Item = Result<(Position, CaptureEvent), CaptureError>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {

input-capture/src/windows.rs

@@ -1,94 +1,36 @@
 use async_trait::async_trait;
 use core::task::{Context, Poll};
+use event_thread::EventThread;
 use futures::Stream;
-use once_cell::unsync::Lazy;
+use std::pin::Pin;
 
-use std::collections::HashSet;
-use std::ptr::{addr_of, addr_of_mut};
-
-use futures::executor::block_on;
-use std::default::Default;
-use std::sync::atomic::{AtomicBool, 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 tokio::sync::mpsc::{channel, Receiver};
 
 use super::{Capture, CaptureError, CaptureEvent, Position};
 
-enum Request {
-    Create(Position),
-    Destroy(Position),
-}
+mod display_util;
+mod event_thread;
 
 pub struct WindowsInputCapture {
     event_rx: Receiver<(Position, CaptureEvent)>,
-    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!();
-    }
+    event_thread: EventThread,
 }
 
 #[async_trait]
 impl Capture for WindowsInputCapture {
     async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
-        unsafe {
-            {
-                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Create(pos));
-            }
-            signal_message_thread(EventType::Request);
-        }
+        self.event_thread.create(pos);
         Ok(())
     }
 
     async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        unsafe {
-            {
-                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Destroy(pos));
-            }
-            signal_message_thread(EventType::Request);
-        }
+        self.event_thread.destroy(pos);
         Ok(())
     }
 
     async fn release(&mut self) -> Result<(), CaptureError> {
-        unsafe { signal_message_thread(EventType::Release) };
+        self.event_thread.release_capture();
         Ok(())
     }
 
@@ -97,519 +39,13 @@ impl Capture for WindowsInputCapture {
     }
 }
 
-static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
-static mut ACTIVE_CLIENT: Option<Position> = None;
-static mut CLIENTS: Lazy<HashSet<Position>> = Lazy::new(HashSet::new);
-static mut EVENT_TX: Option<Sender<(Position, CaptureEvent)>> = 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: CaptureEvent) {
-    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 */
-    if !CLIENTS.contains(&pos) {
-        return ret;
-    }
-
-    /* update active client and entry point */
-    ACTIVE_CLIENT.replace(pos);
-    ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);
-
-    /* notify main thread */
-    log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
-    send_blocking(CaptureEvent::Begin);
-
-    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(pos) = 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 = (pos, CaptureEvent::Input(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, CaptureEvent::Input(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"),
-        }
-    }
-}
-
-static WINDOW_CLASS_REGISTERED: AtomicBool = AtomicBool::new(false);
-
-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()
-        };
-
-        if WINDOW_CLASS_REGISTERED
-            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
-            .is_ok()
-        {
-            /* register window class if not yet done so */
-            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(pos) => {
-            unsafe { CLIENTS.insert(pos) };
-        }
-        Request::Destroy(pos) => unsafe {
-            if let Some(active_pos) = ACTIVE_CLIENT {
-                if pos == active_pos {
-                    let _ = ACTIVE_CLIENT.take();
-                }
-            }
-            CLIENTS.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,
-            }
+        let (event_tx, event_rx) = channel(10);
+        let event_thread = EventThread::new(event_tx);
+        Self {
+            event_thread,
+            event_rx,
         }
     }
 }
@@ -623,10 +59,3 @@ impl Stream for WindowsInputCapture {
         }
     }
 }
-
-impl Drop for WindowsInputCapture {
-    fn drop(&mut self) {
-        unsafe { signal_message_thread(EventType::Exit) };
-        let _ = self.msg_thread.take().unwrap().join();
-    }
-}

input-capture/src/windows/display_util.rs

@@ -0,0 +1,99 @@
+use windows::Win32::Foundation::RECT;
+
+use crate::Position;
+
+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)
+}
+
+pub(crate) 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))
+}
+
+///
+/// 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
+///
+pub(crate) fn clamp_to_display_bounds(
+    display_regions: &[RECT],
+    prev_point: (i32, i32),
+    point: (i32, i32),
+) -> (i32, i32) {
+    /* find display where movement came from */
+    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))
+}

input-capture/src/windows/event_thread.rs

@@ -0,0 +1,545 @@
+use std::cell::{Cell, RefCell};
+use std::collections::HashSet;
+use std::ptr::addr_of_mut;
+
+use std::default::Default;
+use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+use tokio::sync::mpsc::error::TrySendError;
+use tokio::sync::mpsc::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::{display_util, CaptureEvent, Position};
+
+pub(crate) struct EventThread {
+    request_buffer: Arc<Mutex<Vec<ClientUpdate>>>,
+    thread: Option<thread::JoinHandle<()>>,
+    thread_id: u32,
+}
+
+impl EventThread {
+    pub(crate) fn new(event_tx: Sender<(Position, CaptureEvent)>) -> Self {
+        let request_buffer = Default::default();
+        let (thread, thread_id) = start(event_tx, Arc::clone(&request_buffer));
+        Self {
+            request_buffer,
+            thread: Some(thread),
+            thread_id,
+        }
+    }
+
+    pub(crate) fn release_capture(&self) {
+        self.signal(RequestType::Release);
+    }
+
+    pub(crate) fn create(&self, pos: Position) {
+        self.client_update(ClientUpdate::Create(pos));
+    }
+
+    pub(crate) fn destroy(&self, pos: Position) {
+        self.client_update(ClientUpdate::Destroy(pos));
+    }
+
+    fn exit(&self) {
+        self.signal(RequestType::Exit);
+    }
+
+    fn client_update(&self, request: ClientUpdate) {
+        {
+            let mut requests = self.request_buffer.lock().unwrap();
+            requests.push(request);
+        }
+        self.signal(RequestType::ClientUpdate);
+    }
+
+    fn signal(&self, event_type: RequestType) {
+        let id = self.thread_id;
+        unsafe { PostThreadMessageW(id, WM_USER, WPARAM(event_type as usize), LPARAM(0)).unwrap() };
+    }
+}
+
+impl Drop for EventThread {
+    fn drop(&mut self) {
+        self.exit();
+        let _ = self.thread.take().expect("thread").join();
+    }
+}
+
+enum RequestType {
+    ClientUpdate = 0,
+    Release = 1,
+    Exit = 2,
+}
+
+enum ClientUpdate {
+    Create(Position),
+    Destroy(Position),
+}
+
+fn blocking_send_event(pos: Position, event: CaptureEvent) {
+    EVENT_TX.with_borrow_mut(|tx| tx.as_mut().unwrap().blocking_send((pos, event)).unwrap())
+}
+
+fn try_send_event(
+    pos: Position,
+    event: CaptureEvent,
+) -> Result<(), TrySendError<(Position, CaptureEvent)>> {
+    EVENT_TX.with_borrow_mut(|tx| tx.as_mut().unwrap().try_send((pos, event)))
+}
+
+thread_local! {
+    /// all configured clients
+    static CLIENTS: RefCell<HashSet<Position>> = RefCell::new(HashSet::new());
+    /// currently active client
+    static ACTIVE_CLIENT: Cell<Option<Position>> = const { Cell::new(None) };
+    /// input event channel
+    static EVENT_TX: RefCell<Option<Sender<(Position, CaptureEvent)>>> = const { RefCell::new(None) };
+    /// position of barrier entry
+    static ENTRY_POINT: Cell<(i32, i32)> = const { Cell::new((0, 0)) };
+    /// previous mouse position
+    static PREV_POS: Cell<Option<(i32, i32)>> = const { Cell::new(None) };
+    /// displays and generation counter
+    static DISPLAYS: RefCell<(Vec<RECT>, i32)> = const { RefCell::new((Vec::new(), 0)) };
+}
+
+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 start(
+    event_tx: Sender<(Position, CaptureEvent)>,
+    request_buffer: Arc<Mutex<Vec<ClientUpdate>>>,
+) -> (thread::JoinHandle<()>, u32) {
+    /* condition variable to wait for thead id */
+    let thread_id = Arc::new((Condvar::new(), Mutex::new(None)));
+    let thread_id_ = Arc::clone(&thread_id);
+
+    let msg_thread = thread::spawn(|| start_routine(thread_id_, event_tx, request_buffer));
+
+    /* wait for thread to set its id */
+    let (cond, thread_id) = &*thread_id;
+    let mut thread_id = thread_id.lock().unwrap();
+    while (*thread_id).is_none() {
+        thread_id = cond.wait(thread_id).expect("channel closed");
+    }
+    (msg_thread, thread_id.expect("thread id"))
+}
+
+fn start_routine(
+    ready: Arc<(Condvar, Mutex<Option<u32>>)>,
+    event_tx: Sender<(Position, CaptureEvent)>,
+    request_buffer: Arc<Mutex<Vec<ClientUpdate>>>,
+) {
+    EVENT_TX.replace(Some(event_tx));
+    /* communicate thread id */
+    {
+        let (cnd, mtx) = &*ready;
+        let mut ready = mtx.lock().unwrap();
+        *ready = Some(unsafe { GetCurrentThreadId() });
+        cnd.notify_one();
+    }
+
+    let mouse_proc: HOOKPROC = Some(mouse_proc);
+    let kybrd_proc: HOOKPROC = Some(kybrd_proc);
+    let window_proc: WNDPROC = Some(window_proc);
+
+    /* register hooks */
+    unsafe {
+        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
+        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
+    }
+
+    let instance = unsafe { GetModuleHandleW(None).unwrap() };
+    let window_class: WNDCLASSW = WNDCLASSW {
+        lpfnWndProc: window_proc,
+        hInstance: instance.into(),
+        lpszClassName: w!("lan-mouse-message-window-class"),
+        ..Default::default()
+    };
+
+    static WINDOW_CLASS_REGISTERED: AtomicBool = AtomicBool::new(false);
+    if WINDOW_CLASS_REGISTERED
+        .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+        .is_ok()
+    {
+        /* register window class if not yet done so */
+        unsafe {
+            let ret = RegisterClassW(&window_class);
+            if ret == 0 {
+                panic!("RegisterClassW");
+            }
+        }
+    }
+
+    /* window is used ro receive WM_DISPLAYCHANGE messages */
+    unsafe {
+        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 == RequestType::Exit as usize => break,
+                x if x == RequestType::Release as usize => {
+                    ACTIVE_CLIENT.take();
+                }
+                x if x == RequestType::ClientUpdate 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 */
+            unsafe {
+                let _ = TranslateMessage(&msg);
+                DispatchMessageW(&msg);
+            }
+        }
+    }
+}
+
+fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
+    if wparam.0 != WM_MOUSEMOVE as usize {
+        return ACTIVE_CLIENT.get().is_some();
+    }
+    let mouse_low_level: MSLLHOOKSTRUCT = unsafe { *(lparam.0 as *const MSLLHOOKSTRUCT) };
+    let curr_pos = (mouse_low_level.pt.x, mouse_low_level.pt.y);
+    let prev_pos = PREV_POS.get().unwrap_or(curr_pos);
+    PREV_POS.replace(Some(curr_pos));
+
+    /* next event is the first actual event */
+    let ret = ACTIVE_CLIENT.get().is_some();
+
+    /* client already active, no need to check */
+    if ACTIVE_CLIENT.get().is_some() {
+        return ret;
+    }
+
+    /* check if a client was activated */
+    let entered = DISPLAYS.with_borrow_mut(|(displays, generation)| {
+        update_display_regions(displays, generation);
+        display_util::entered_barrier(prev_pos, curr_pos, displays)
+    });
+
+    let Some(pos) = entered else {
+        return ret;
+    };
+
+    /* check if a client is registered for the barrier */
+    if !CLIENTS.with_borrow(|clients| clients.contains(&pos)) {
+        return ret;
+    }
+
+    /* update active client and entry point */
+    ACTIVE_CLIENT.replace(Some(pos));
+    let entry_point = DISPLAYS.with_borrow(|(displays, _)| {
+        display_util::clamp_to_display_bounds(displays, prev_pos, curr_pos)
+    });
+    ENTRY_POINT.replace(entry_point);
+
+    /* notify main thread */
+    log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
+    let active = ACTIVE_CLIENT.get().expect("active client");
+    blocking_send_event(active, CaptureEvent::Begin);
+
+    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(pos) = ACTIVE_CLIENT.get() else {
+        return LRESULT(1);
+    };
+
+    /* convert to lan-mouse event */
+    let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
+        return LRESULT(1);
+    };
+
+    /* notify mainthread (drop events if sending too fast) */
+    if let Err(e) = try_send_event(pos, CaptureEvent::Input(Event::Pointer(pointer_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.get() 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);
+    };
+
+    if let Err(e) = try_send_event(client, CaptureEvent::Input(Event::Keyboard(key_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 {
+    if uint == WM_DISPLAYCHANGE {
+        log::debug!("display resolution changed");
+        DISPLAY_RESOLUTION_GENERATION.fetch_add(1, Ordering::Release);
+    }
+    LRESULT(1)
+}
+
+static DISPLAY_RESOLUTION_GENERATION: AtomicI32 = AtomicI32::new(1);
+
+fn update_display_regions(displays: &mut Vec<RECT>, generation: &mut i32) {
+    let global_generation = DISPLAY_RESOLUTION_GENERATION.load(Ordering::Acquire);
+    if *generation != global_generation {
+        enumerate_displays(displays);
+        log::debug!("displays: {displays:?}");
+        *generation = global_generation;
+    }
+}
+
+fn enumerate_displays(display_rects: &mut Vec<RECT>) {
+    display_rects.clear();
+    unsafe {
+        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,
+            });
+        }
+    }
+}
+
+fn update_clients(request: ClientUpdate) {
+    match request {
+        ClientUpdate::Create(pos) => {
+            CLIENTS.with_borrow_mut(|clients| clients.insert(pos));
+        }
+        ClientUpdate::Destroy(pos) => {
+            if let Some(active_pos) = ACTIVE_CLIENT.get() {
+                if pos == active_pos {
+                    let _ = ACTIVE_CLIENT.take();
+                }
+            }
+            CLIENTS.with_borrow_mut(|clients| clients.remove(&pos));
+        }
+    }
+}
+
+fn to_key_event(wparam: WPARAM, lparam: LPARAM) -> Option<KeyboardEvent> {
+    let kybrdllhookstruct: KBDLLHOOKSTRUCT = unsafe { *(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: 0,
+        }),
+        _ => None,
+    }
+}
+
+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 => {
+            let (x, y) = (mouse_low_level.pt.x, mouse_low_level.pt.y);
+            let (ex, ey) = ENTRY_POINT.get();
+            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
+        }
+    }
+}

input-emulation/Cargo.toml

@@ -25,6 +25,7 @@ tokio = { version = "1.32.0", features = [
 once_cell = "1.19.0"
 
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+bitflags = "2.6.0"
 wayland-client = { version = "0.31.1", optional = true }
 wayland-protocols = { version = "0.32.1", features = [
     "client",

input-emulation/src/libei.rs

@@ -74,7 +74,7 @@ async fn get_ei_fd<'a>(
     Ok((remote_desktop, session, fd))
 }
 
-impl<'a> LibeiEmulation<'a> {
+impl LibeiEmulation<'_> {
     pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
         let (_remote_desktop, session, eifd) = get_ei_fd().await?;
         let stream = UnixStream::from(eifd);
@@ -109,14 +109,14 @@ impl<'a> LibeiEmulation<'a> {
     }
 }
 
-impl<'a> Drop for LibeiEmulation<'a> {
+impl Drop for LibeiEmulation<'_> {
     fn drop(&mut self) {
         self.ei_task.abort();
     }
 }
 
 #[async_trait]
-impl<'a> Emulation for LibeiEmulation<'a> {
+impl Emulation for LibeiEmulation<'_> {
     async fn consume(
         &mut self,
         event: Event,

input-emulation/src/macos.rs

@@ -170,7 +170,7 @@ fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
         return Option::None;
     }
 
-    return displays.first().copied();
+    displays.first().copied()
 }
 
 fn get_display_bounds(display: CGDirectDisplayID) -> (CGFloat, CGFloat, CGFloat, CGFloat) {

input-emulation/src/wlroots.rs

@@ -2,9 +2,12 @@ use crate::error::EmulationError;
 
 use super::{error::WlrootsEmulationCreationError, Emulation};
 use async_trait::async_trait;
+use bitflags::bitflags;
 use std::collections::HashMap;
 use std::io;
 use std::os::fd::{AsFd, OwnedFd};
+use std::sync::{Arc, Mutex};
+use std::time::{SystemTime, UNIX_EPOCH};
 use wayland_client::backend::WaylandError;
 use wayland_client::WEnum;
 
@@ -28,7 +31,7 @@ use wayland_client::{
     Connection, Dispatch, EventQueue, QueueHandle,
 };
 
-use input_event::{Event, KeyboardEvent, PointerEvent};
+use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
 
 use super::error::WaylandBindError;
 use super::EmulationHandle;
@@ -102,7 +105,11 @@ impl State {
             panic!("no keymap");
         }
 
-        let vinput = VirtualInput { pointer, keyboard };
+        let vinput = VirtualInput {
+            pointer,
+            keyboard,
+            modifiers: Arc::new(Mutex::new(XMods::empty())),
+        };
 
         self.input_for_client.insert(client, vinput);
     }
@@ -173,10 +180,16 @@ impl Emulation for WlrootsEmulation {
 struct VirtualInput {
     pointer: Vp,
     keyboard: Vk,
+    modifiers: Arc<Mutex<XMods>>,
 }
 
 impl VirtualInput {
     fn consume_event(&self, event: Event) -> Result<(), ()> {
+        let now: u32 = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_millis() as u32;
+
         match event {
             Event::Pointer(e) => {
                 match e {
@@ -197,7 +210,7 @@ impl VirtualInput {
                     PointerEvent::AxisDiscrete120 { axis, value } => {
                         let axis: Axis = (axis as u32).try_into()?;
                         self.pointer
-                            .axis_discrete(0, axis, value as f64 / 6., value / 120);
+                            .axis_discrete(now, axis, value as f64 / 6., value / 120);
                         self.pointer.frame();
                     }
                 }
@@ -206,6 +219,17 @@ impl VirtualInput {
             Event::Keyboard(e) => match e {
                 KeyboardEvent::Key { time, key, state } => {
                     self.keyboard.key(time, key, state as u32);
+                    if let Ok(mut mods) = self.modifiers.lock() {
+                        if mods.update_by_key_event(key, state) {
+                            log::trace!("Key triggers modifier change: {:?}", mods);
+                            self.keyboard.modifiers(
+                                mods.mask_pressed().bits(),
+                                0,
+                                mods.mask_locks().bits(),
+                                0,
+                            );
+                        }
+                    }
                 }
                 KeyboardEvent::Modifiers {
                     depressed: mods_depressed,
@@ -213,6 +237,10 @@ impl VirtualInput {
                     locked: mods_locked,
                     group,
                 } => {
+                    // Synchronize internal modifier state, assuming server is authoritative
+                    if let Ok(mut mods) = self.modifiers.lock() {
+                        mods.update_by_mods_event(e);
+                    }
                     self.keyboard
                         .modifiers(mods_depressed, mods_latched, mods_locked, group);
                 }
@@ -273,3 +301,74 @@ impl Dispatch<WlSeat, ()> for State {
         }
     }
 }
+
+// From X11/X.h
+bitflags! {
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+    struct XMods: u32 {
+        const ShiftMask = (1<<0);
+        const LockMask = (1<<1);
+        const ControlMask = (1<<2);
+        const Mod1Mask = (1<<3);
+        const Mod2Mask = (1<<4);
+        const Mod3Mask = (1<<5);
+        const Mod4Mask = (1<<6);
+        const Mod5Mask = (1<<7);
+    }
+}
+
+impl XMods {
+    fn update_by_mods_event(&mut self, evt: KeyboardEvent) {
+        if let KeyboardEvent::Modifiers {
+            depressed, locked, ..
+        } = evt
+        {
+            *self = XMods::from_bits_truncate(depressed) | XMods::from_bits_truncate(locked);
+        }
+    }
+
+    fn update_by_key_event(&mut self, key: u32, state: u8) -> bool {
+        if let Ok(key) = scancode::Linux::try_from(key) {
+            log::trace!("Attempting to process modifier from: {:#?}", key);
+            let pressed_mask = match key {
+                scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
+                scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
+                scancode::Linux::KeyLeftAlt | scancode::Linux::KeyRightalt => XMods::Mod1Mask,
+                scancode::Linux::KeyLeftMeta | scancode::Linux::KeyRightmeta => XMods::Mod4Mask,
+                _ => XMods::empty(),
+            };
+
+            let locked_mask = match key {
+                scancode::Linux::KeyCapsLock => XMods::LockMask,
+                scancode::Linux::KeyNumlock => XMods::Mod2Mask,
+                scancode::Linux::KeyScrollLock => XMods::Mod3Mask,
+                _ => XMods::empty(),
+            };
+
+            // unchanged
+            if pressed_mask.is_empty() && locked_mask.is_empty() {
+                log::trace!("{:#?} is not a modifier key", key);
+                return false;
+            }
+            match state {
+                1 => self.insert(pressed_mask),
+                _ => {
+                    self.remove(pressed_mask);
+                    self.toggle(locked_mask);
+                }
+            }
+            true
+        } else {
+            false
+        }
+    }
+
+    fn mask_locks(&self) -> XMods {
+        *self & (XMods::LockMask | XMods::Mod2Mask | XMods::Mod3Mask)
+    }
+
+    fn mask_pressed(&self) -> XMods {
+        *self & (XMods::ShiftMask | XMods::ControlMask | XMods::Mod1Mask | XMods::Mod4Mask)
+    }
+}

input-emulation/src/xdg_desktop_portal.rs

@@ -52,7 +52,7 @@ impl<'a> DesktopPortalEmulation<'a> {
 }
 
 #[async_trait]
-impl<'a> Emulation for DesktopPortalEmulation<'a> {
+impl Emulation for DesktopPortalEmulation<'_> {
     async fn consume(
         &mut self,
         event: input_event::Event,
@@ -141,7 +141,7 @@ impl<'a> Emulation for DesktopPortalEmulation<'a> {
     }
 }
 
-impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {
+impl AsyncDrop for DesktopPortalEmulation<'_> {
     #[doc = r" Perform the async cleanup."]
     #[must_use]
     #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]

lan-mouse-cli/src/lib.rs

@@ -274,6 +274,17 @@ impl Cli {
             FrontendEvent::EmulationStatus(s) => {
                 eprintln!("emulation status: {s:?}")
             }
+            FrontendEvent::AuthorizedUpdated(fingerprints) => {
+                eprintln!("authorized keys changed:");
+                for (desc, fp) in fingerprints {
+                    eprintln!("{desc}: {fp}");
+                }
+            }
+            FrontendEvent::PublicKeyFingerprint(fp) => {
+                eprintln!("the public key fingerprint of this device is {fp}");
+            }
+            FrontendEvent::IncomingConnected(..) => {}
+            FrontendEvent::IncomingDisconnected(..) => {}
         }
     }
 

lan-mouse-gtk/resources/fingerprint_window.ui

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk" version="4.0"/>
+  <requires lib="libadwaita" version="1.0"/>
+  <template class="FingerprintWindow" parent="AdwWindow">
+    <property name="modal">True</property>
+    <property name="width-request">880</property>
+    <property name="default-width">880</property>
+    <property name="height-request">380</property>
+    <property name="default-height">380</property>
+    <property name="title" translatable="yes">Add Certificate Fingerprint</property>
+    <property name="content">
+      <object class="AdwToolbarView">
+        <child type="top">
+            <object class="AdwHeaderBar"/>
+        </child>
+        <property name="content">
+          <object class="AdwClamp">
+            <property name="maximum-size">770</property>
+            <property name="tightening-threshold">0</property>
+            <property name="child">
+              <object class="GtkBox">
+                <property name="orientation">vertical</property>
+                <property name="spacing">18</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="label">The certificate fingerprint serves as a unique identifier for your device.</property>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="label">You can find it under the `General` section of the device you want to connect</property>
+                  </object>
+                </child>
+                <child>
+                  <object class="AdwPreferencesGroup">
+                    <property name="title">description</property>
+                    <child>
+                      <object class="AdwActionRow">
+                        <property name="child">
+                          <object class="GtkText" id="description">
+                            <property name="margin-top">10</property>
+                            <property name="margin-bottom">10</property>
+                            <property name="margin-start">10</property>
+                            <property name="margin-end">10</property>
+                            <property name="enable-undo">True</property>
+                            <property name="hexpand">True</property>
+                            <property name="vexpand">True</property>
+                            <property name="max-length">0</property>
+                          </object>
+                        </property>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+                <child>
+                  <object class="AdwPreferencesGroup">
+                    <property name="title">sha256 fingerprint</property>
+                    <child>
+                      <object class="AdwActionRow">
+                        <property name="child">
+                          <object class="GtkText" id="fingerprint">
+                            <property name="margin-top">10</property>
+                            <property name="margin-bottom">10</property>
+                            <property name="margin-start">10</property>
+                            <property name="margin-end">10</property>
+                            <property name="enable-undo">True</property>
+                            <property name="hexpand">True</property>
+                            <property name="vexpand">True</property>
+                            <property name="max-length">0</property>
+                          </object>
+                        </property>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="halign">center</property>
+                    <child>
+                      <object class="GtkButton" id="confirm_button">
+                        <signal name="clicked" handler="handle_confirm" swapped="true"/>
+                        <property name="label" translatable="yes">Confirm</property>
+                        <property name="can-shrink">True</property>
+                        <style>
+                            <class name="pill"/>
+                            <class name="suggested-action"/>
+                        </style>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </property>
+          </object>
+        </property>
+      </object>
+    </property>
+  </template>
+</interface>

lan-mouse-gtk/resources/key_row.ui

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+	<template class="KeyRow" parent="AdwActionRow">
+		<child type="prefix">
+			<object class="GtkButton" id="delete_button">
+				<property name="valign">center</property>
+				<property name="halign">end</property>
+				<property name="tooltip-text" translatable="yes">revoke authorization</property>
+                <property name="icon-name">edit-delete-symbolic</property>
+				<style>
+                    <class name="flat"/>
+				</style>
+			</object>
+		</child>
+	</template>
+</interface>

lan-mouse-gtk/resources/resources.gresource.xml

@@ -2,7 +2,9 @@
 <gresources>
   <gresource prefix="/de/feschber/LanMouse">
     <file compressed="true" preprocess="xml-stripblanks">window.ui</file>
+    <file compressed="true" preprocess="xml-stripblanks">fingerprint_window.ui</file>
     <file compressed="true" preprocess="xml-stripblanks">client_row.ui</file>
+    <file compressed="true" preprocess="xml-stripblanks">key_row.ui</file>
   </gresource>
   <gresource prefix="/de/feschber/LanMouse/icons">
     <file compressed="true" preprocess="xml-stripblanks">de.feschber.LanMouse.svg</file>

lan-mouse-gtk/resources/window.ui

@@ -121,7 +121,31 @@
                         -->
                         <child>
                           <object class="AdwActionRow">
-                            <property name="title">port</property>
+                            <property name="title">hostname &#38;amp; port</property>
+                            <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"/>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="spacing">30</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="GtkImage" id="hostname_copy_icon">
+                                        <property name="icon-name">edit-copy-symbolic</property>
+                                      </object>
+                                    </child>
+                                  </object>
+                                </child>
+                              </object>
+                            </child>
                             <child>
                               <object class="GtkEntry" id="port_entry">
                                 <property name="max-width-chars">5</property>
@@ -160,20 +184,14 @@
                           </object>
                         </child>
                         <child>
-                          <object class="AdwActionRow">
-                            <property name="title">hostname</property>
+                          <object class="AdwActionRow" id="fingerprint_row">
+                            <property name="title">certificate fingerprint</property>
+                            <property name="icon-name">auth-fingerprint-symbolic</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">
+                              <object class="GtkButton" id="copy-fingerprint-button">
                                 <property name="icon-name">edit-copy-symbolic</property>
                                 <property name="valign">center</property>
-                                <signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
+                                <signal name="clicked" handler="handle_copy_fingerprint" swapped="true"/>
                               </object>
                             </child>
                           </object>
@@ -213,6 +231,39 @@
                         </child>
                       </object>
                     </child>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">Incoming Connections</property>
+                        <property name="header-suffix">
+                          <object class="GtkButton">
+                            <signal name="clicked" handler="handle_add_cert_fingerprint" swapped="true"/>
+                            <property name="child">
+                              <object class="AdwButtonContent">
+                                <property name="icon-name">auth-fingerprint-symbolic</property>
+                                <property name="label" translatable="yes">Authorize</property>
+                              </object>
+                            </property>
+                            <style>
+                              <class name="flat"/>
+                            </style>
+                          </object>
+                        </property>
+                        <child>
+                          <object class="GtkListBox" id="authorized_list">
+                            <property name="selection-mode">none</property>
+                            <child type="placeholder">
+                              <object class="AdwActionRow" id="authorized_placeholder">
+                                <property name="title">no devices registered!</property>
+                                <property name="subtitle">authorize a new device via the "Authorize" button</property>
+                              </object>
+                            </child>
+                            <style>
+                              <class name="boxed-list" />
+                            </style>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
                     </object>
                   </property>
                   </object>

lan-mouse-gtk/src/fingerprint_window.rs

@@ -0,0 +1,18 @@
+mod imp;
+
+use glib::Object;
+use gtk::{gio, glib};
+
+glib::wrapper! {
+    pub struct FingerprintWindow(ObjectSubclass<imp::FingerprintWindow>)
+    @extends adw::Window, gtk::Window, gtk::Widget,
+    @implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable,
+                gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
+}
+
+impl FingerprintWindow {
+    pub(crate) fn new() -> Self {
+        let window: Self = Object::builder().build();
+        window
+    }
+}

lan-mouse-gtk/src/fingerprint_window/imp.rs

@@ -0,0 +1,64 @@
+use std::sync::OnceLock;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use glib::subclass::InitializingObject;
+use gtk::{
+    glib::{self, subclass::Signal},
+    template_callbacks, Button, CompositeTemplate, Text,
+};
+
+#[derive(CompositeTemplate, Default)]
+#[template(resource = "/de/feschber/LanMouse/fingerprint_window.ui")]
+pub struct FingerprintWindow {
+    #[template_child]
+    pub description: TemplateChild<Text>,
+    #[template_child]
+    pub fingerprint: TemplateChild<Text>,
+    #[template_child]
+    pub confirm_button: TemplateChild<Button>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for FingerprintWindow {
+    const NAME: &'static str = "FingerprintWindow";
+    const ABSTRACT: bool = false;
+
+    type Type = super::FingerprintWindow;
+    type ParentType = adw::Window;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+        klass.bind_template_callbacks();
+    }
+
+    fn instance_init(obj: &InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+#[template_callbacks]
+impl FingerprintWindow {
+    #[template_callback]
+    fn handle_confirm(&self, _button: Button) {
+        let desc = self.description.text().as_str().trim().to_owned();
+        let fp = self.fingerprint.text().as_str().trim().to_owned();
+        self.obj().emit_by_name("confirm-clicked", &[&desc, &fp])
+    }
+}
+
+impl ObjectImpl for FingerprintWindow {
+    fn signals() -> &'static [Signal] {
+        static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
+        SIGNALS.get_or_init(|| {
+            vec![Signal::builder("confirm-clicked")
+                .param_types([String::static_type(), String::static_type()])
+                .build()]
+        })
+    }
+}
+
+impl WidgetImpl for FingerprintWindow {}
+impl WindowImpl for FingerprintWindow {}
+impl ApplicationWindowImpl for FingerprintWindow {}
+impl AdwWindowImpl for FingerprintWindow {}

lan-mouse-gtk/src/key_object.rs

@@ -0,0 +1,25 @@
+mod imp;
+
+use adw::subclass::prelude::*;
+use gtk::glib::{self, Object};
+
+glib::wrapper! {
+    pub struct KeyObject(ObjectSubclass<imp::KeyObject>);
+}
+
+impl KeyObject {
+    pub fn new(desc: String, fp: String) -> Self {
+        Object::builder()
+            .property("description", desc)
+            .property("fingerprint", fp)
+            .build()
+    }
+
+    pub fn get_description(&self) -> String {
+        self.imp().description.borrow().clone()
+    }
+
+    pub fn get_fingerprint(&self) -> String {
+        self.imp().fingerprint.borrow().clone()
+    }
+}

lan-mouse-gtk/src/key_object/imp.rs

@@ -0,0 +1,24 @@
+use std::cell::RefCell;
+
+use glib::Properties;
+use gtk::glib;
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+
+#[derive(Properties, Default)]
+#[properties(wrapper_type = super::KeyObject)]
+pub struct KeyObject {
+    #[property(name = "description", get, set, type = String)]
+    pub description: RefCell<String>,
+    #[property(name = "fingerprint", get, set, type = String)]
+    pub fingerprint: RefCell<String>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for KeyObject {
+    const NAME: &'static str = "KeyObject";
+    type Type = super::KeyObject;
+}
+
+#[glib::derived_properties]
+impl ObjectImpl for KeyObject {}

lan-mouse-gtk/src/key_row.rs

@@ -0,0 +1,48 @@
+mod imp;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use gtk::glib::{self, Object};
+
+use super::KeyObject;
+
+glib::wrapper! {
+    pub struct KeyRow(ObjectSubclass<imp::KeyRow>)
+    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
+    @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
+}
+
+impl Default for KeyRow {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl KeyRow {
+    pub fn new() -> Self {
+        Object::builder().build()
+    }
+
+    pub fn bind(&self, key_object: &KeyObject) {
+        let mut bindings = self.imp().bindings.borrow_mut();
+
+        let title_binding = key_object
+            .bind_property("description", self, "title")
+            .sync_create()
+            .build();
+
+        let subtitle_binding = key_object
+            .bind_property("fingerprint", self, "subtitle")
+            .sync_create()
+            .build();
+
+        bindings.push(title_binding);
+        bindings.push(subtitle_binding);
+    }
+
+    pub fn unbind(&self) {
+        for binding in self.imp().bindings.borrow_mut().drain(..) {
+            binding.unbind();
+        }
+    }
+}

lan-mouse-gtk/src/key_row/imp.rs

@@ -0,0 +1,68 @@
+use std::cell::RefCell;
+
+use adw::subclass::prelude::*;
+use adw::{prelude::*, ActionRow};
+use glib::{subclass::InitializingObject, Binding};
+use gtk::glib::clone;
+use gtk::glib::subclass::Signal;
+use gtk::{glib, Button, CompositeTemplate};
+use std::sync::OnceLock;
+
+#[derive(CompositeTemplate, Default)]
+#[template(resource = "/de/feschber/LanMouse/key_row.ui")]
+pub struct KeyRow {
+    #[template_child]
+    pub delete_button: TemplateChild<gtk::Button>,
+    pub bindings: RefCell<Vec<Binding>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for KeyRow {
+    // `NAME` needs to match `class` attribute of template
+    const NAME: &'static str = "KeyRow";
+    const ABSTRACT: bool = false;
+
+    type Type = super::KeyRow;
+    type ParentType = ActionRow;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+        klass.bind_template_callbacks();
+    }
+
+    fn instance_init(obj: &InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+impl ObjectImpl for KeyRow {
+    fn constructed(&self) {
+        self.parent_constructed();
+        self.delete_button.connect_clicked(clone!(
+            #[weak(rename_to = row)]
+            self,
+            move |button| {
+                row.handle_delete(button);
+            }
+        ));
+    }
+
+    fn signals() -> &'static [glib::subclass::Signal] {
+        static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
+        SIGNALS.get_or_init(|| vec![Signal::builder("request-delete").build()])
+    }
+}
+
+#[gtk::template_callbacks]
+impl KeyRow {
+    #[template_callback]
+    fn handle_delete(&self, _button: &Button) {
+        self.obj().emit_by_name::<()>("request-delete", &[]);
+    }
+}
+
+impl WidgetImpl for KeyRow {}
+impl BoxImpl for KeyRow {}
+impl ListBoxRowImpl for KeyRow {}
+impl PreferencesRowImpl for KeyRow {}
+impl ActionRowImpl for KeyRow {}

lan-mouse-gtk/src/lib.rs

@@ -1,5 +1,8 @@
 mod client_object;
 mod client_row;
+mod fingerprint_window;
+mod key_object;
+mod key_row;
 mod window;
 
 use std::{env, process, str};
@@ -15,6 +18,7 @@ use gtk::{
 use gtk::{gio, glib, prelude::ApplicationExt};
 
 use self::client_object::ClientObject;
+use self::key_object::KeyObject;
 
 pub fn run() -> glib::ExitCode {
     log::debug!("running gtk frontend");
@@ -45,7 +49,11 @@ fn gtk_main() -> glib::ExitCode {
         .application_id("de.feschber.LanMouse")
         .build();
 
-    app.connect_startup(|_| load_icons());
+    app.connect_startup(|app| {
+        load_icons();
+        setup_actions(app);
+        setup_menu(app);
+    });
     app.connect_activate(build_ui);
 
     let args: Vec<&'static str> = vec![];
@@ -58,6 +66,33 @@ fn load_icons() {
     icon_theme.add_resource_path("/de/feschber/LanMouse/icons");
 }
 
+// Add application actions
+fn setup_actions(app: &adw::Application) {
+    // Quit action
+    // This is important on macOS, where users expect a File->Quit action with a Cmd+Q shortcut.
+    let quit_action = gio::SimpleAction::new("quit", None);
+    quit_action.connect_activate({
+        let app = app.clone();
+        move |_, _| {
+            app.quit();
+        }
+    });
+    app.add_action(&quit_action);
+}
+
+// Set up a global menu
+//
+// Currently this is used only on macOS
+fn setup_menu(app: &adw::Application) {
+    let menu = gio::Menu::new();
+
+    let file_menu = gio::Menu::new();
+    file_menu.append(Some("Quit"), Some("app.quit"));
+    menu.append_submenu(Some("_File"), &file_menu);
+
+    app.set_menubar(Some(&menu))
+}
+
 fn build_ui(app: &Application) {
     log::debug!("connecting to lan-mouse-socket");
     let (mut frontend_rx, frontend_tx) = match lan_mouse_ipc::connect() {
@@ -132,6 +167,14 @@ fn build_ui(app: &Application) {
                     FrontendEvent::EmulationStatus(s) => {
                         window.set_emulation(s.into());
                     }
+                    FrontendEvent::AuthorizedUpdated(keys) => {
+                        window.set_authorized_keys(keys);
+                    }
+                    FrontendEvent::PublicKeyFingerprint(fp) => {
+                        window.set_pk_fp(&fp);
+                    }
+                    FrontendEvent::IncomingConnected(..) => {}
+                    FrontendEvent::IncomingDisconnected(..) => {}
                 }
             }
         }

lan-mouse-gtk/src/window.rs

@@ -1,5 +1,7 @@
 mod imp;
 
+use std::collections::HashMap;
+
 use adw::prelude::*;
 use adw::subclass::prelude::*;
 use glib::{clone, Object};
@@ -14,6 +16,8 @@ use lan_mouse_ipc::{
     DEFAULT_PORT,
 };
 
+use crate::{fingerprint_window::FingerprintWindow, key_object::KeyObject, key_row::KeyRow};
+
 use super::{client_object::ClientObject, client_row::ClientRow};
 
 glib::wrapper! {
@@ -42,10 +46,55 @@ impl Window {
             .expect("Could not get clients")
     }
 
+    pub fn authorized(&self) -> gio::ListStore {
+        self.imp()
+            .authorized
+            .borrow()
+            .clone()
+            .expect("Could not get authorized")
+    }
+
     fn client_by_idx(&self, idx: u32) -> Option<ClientObject> {
         self.clients().item(idx).map(|o| o.downcast().unwrap())
     }
 
+    fn authorized_by_idx(&self, idx: u32) -> Option<KeyObject> {
+        self.authorized().item(idx).map(|o| o.downcast().unwrap())
+    }
+
+    fn setup_authorized(&self) {
+        let store = gio::ListStore::new::<KeyObject>();
+        self.imp().authorized.replace(Some(store));
+        let selection_model = NoSelection::new(Some(self.authorized()));
+        self.imp().authorized_list.bind_model(
+            Some(&selection_model),
+            clone!(
+                #[weak(rename_to = window)]
+                self,
+                #[upgrade_or_panic]
+                move |obj| {
+                    let key_obj = obj.downcast_ref().expect("object of type `KeyObject`");
+                    let row = window.create_key_row(key_obj);
+                    row.connect_closure(
+                        "request-delete",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: KeyRow| {
+                                if let Some(key_obj) = window.authorized_by_idx(row.index() as u32)
+                                {
+                                    window.request_fingerprint_remove(key_obj.get_fingerprint());
+                                }
+                            }
+                        ),
+                    );
+                    row.upcast()
+                }
+            ),
+        )
+    }
+
     fn setup_clients(&self) {
         let model = gio::ListStore::new::<ClientObject>();
         self.imp().clients.replace(Some(model));
@@ -114,7 +163,8 @@ impl Window {
     /// workaround for a bug in libadwaita that shows an ugly line beneath
     /// the last element if a placeholder is set.
     /// https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/6308
-    pub fn set_placeholder_visible(&self, visible: bool) {
+    pub fn update_placeholder_visibility(&self) {
+        let visible = self.clients().n_items() == 0;
         let placeholder = self.imp().client_placeholder.get();
         self.imp().client_list.set_placeholder(match visible {
             true => Some(&placeholder),
@@ -122,6 +172,15 @@ impl Window {
         });
     }
 
+    pub fn update_auth_placeholder_visibility(&self) {
+        let visible = self.authorized().n_items() == 0;
+        let placeholder = self.imp().authorized_placeholder.get();
+        self.imp().authorized_list.set_placeholder(match visible {
+            true => Some(&placeholder),
+            false => None,
+        });
+    }
+
     fn setup_icon(&self) {
         self.set_icon_name(Some("de.feschber.LanMouse"));
     }
@@ -132,10 +191,16 @@ impl Window {
         row
     }
 
+    fn create_key_row(&self, key_object: &KeyObject) -> KeyRow {
+        let row = KeyRow::new();
+        row.bind(key_object);
+        row
+    }
+
     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_placeholder_visibility();
         self.update_dns_state(handle, !state.ips.is_empty());
     }
 
@@ -157,7 +222,7 @@ impl Window {
 
         self.clients().remove(idx as u32);
         if self.clients().n_items() == 0 {
-            self.set_placeholder_visible(true);
+            self.update_placeholder_visibility();
         }
     }
 
@@ -286,6 +351,32 @@ impl Window {
         self.request(FrontendRequest::Delete(client.handle()));
     }
 
+    pub fn open_fingerprint_dialog(&self) {
+        let window = FingerprintWindow::new();
+        window.set_transient_for(Some(self));
+        window.connect_closure(
+            "confirm-clicked",
+            false,
+            closure_local!(
+                #[strong(rename_to = parent)]
+                self,
+                move |w: FingerprintWindow, desc: String, fp: String| {
+                    parent.request_fingerprint_add(desc, fp);
+                    w.close();
+                }
+            ),
+        );
+        window.present();
+    }
+
+    pub fn request_fingerprint_add(&self, desc: String, fp: String) {
+        self.request(FrontendRequest::AuthorizeKey(desc, fp));
+    }
+
+    pub fn request_fingerprint_remove(&self, fp: String) {
+        self.request(FrontendRequest::RemoveAuthorizedKey(fp));
+    }
+
     pub fn request(&self, request: FrontendRequest) {
         let mut requester = self.imp().frontend_request_writer.borrow_mut();
         let requester = requester.as_mut().unwrap();
@@ -319,4 +410,20 @@ impl Window {
             .capture_emulation_group
             .set_visible(!capture || !emulation);
     }
+
+    pub(crate) fn set_authorized_keys(&self, fingerprints: HashMap<String, String>) {
+        let authorized = self.authorized();
+        // clear list
+        authorized.remove_all();
+        // insert fingerprints
+        for (fingerprint, description) in fingerprints {
+            let key_obj = KeyObject::new(description, fingerprint);
+            authorized.append(&key_obj);
+        }
+        self.update_auth_placeholder_visibility();
+    }
+
+    pub(crate) fn set_pk_fp(&self, fingerprint: &str) {
+        self.imp().fingerprint_row.set_subtitle(fingerprint);
+    }
 }

lan-mouse-gtk/src/window/imp.rs

@@ -4,13 +4,17 @@ use adw::subclass::prelude::*;
 use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
 use glib::subclass::InitializingObject;
 use gtk::glib::clone;
-use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};
+use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Image, Label, ListBox};
 
 use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};
 
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/window.ui")]
 pub struct Window {
+    #[template_child]
+    pub authorized_placeholder: TemplateChild<ActionRow>,
+    #[template_child]
+    pub fingerprint_row: TemplateChild<ActionRow>,
     #[template_child]
     pub port_edit_apply: TemplateChild<Button>,
     #[template_child]
@@ -22,6 +26,8 @@ pub struct Window {
     #[template_child]
     pub port_entry: TemplateChild<Entry>,
     #[template_child]
+    pub hostname_copy_icon: TemplateChild<Image>,
+    #[template_child]
     pub hostname_label: TemplateChild<Label>,
     #[template_child]
     pub toast_overlay: TemplateChild<ToastOverlay>,
@@ -35,7 +41,10 @@ pub struct Window {
     pub input_emulation_button: TemplateChild<Button>,
     #[template_child]
     pub input_capture_button: TemplateChild<Button>,
+    #[template_child]
+    pub authorized_list: TemplateChild<ListBox>,
     pub clients: RefCell<Option<gio::ListStore>>,
+    pub authorized: RefCell<Option<gio::ListStore>>,
     pub frontend_request_writer: RefCell<Option<FrontendRequestWriter>>,
     pub port: Cell<u16>,
     pub capture_active: Cell<bool>,
@@ -69,25 +78,45 @@ impl Window {
     }
 
     #[template_callback]
-    fn handle_copy_hostname(&self, button: &Button) {
+    fn handle_copy_hostname(&self, _: &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"]);
+            let icon = self.hostname_copy_icon.clone();
+            icon.set_icon_name(Some("emblem-ok-symbolic"));
+            icon.set_css_classes(&["success"]);
             glib::spawn_future_local(clone!(
                 #[weak]
-                button,
+                icon,
                 async move {
                     glib::timeout_future_seconds(1).await;
-                    button.set_icon_name("edit-copy-symbolic");
-                    button.set_css_classes(&[]);
+                    icon.set_icon_name(Some("edit-copy-symbolic"));
+                    icon.set_css_classes(&[]);
                 }
             ));
         }
     }
 
+    #[template_callback]
+    fn handle_copy_fingerprint(&self, button: &Button) {
+        let fingerprint: String = self.fingerprint_row.property("subtitle");
+        let display = gdk::Display::default().unwrap();
+        let clipboard = display.clipboard();
+        clipboard.set_text(&fingerprint);
+        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);
@@ -118,6 +147,11 @@ impl Window {
         self.obj().request_capture();
     }
 
+    #[template_callback]
+    fn handle_add_cert_fingerprint(&self, _button: &Button) {
+        self.obj().open_fingerprint_dialog();
+    }
+
     pub fn set_port(&self, port: u16) {
         self.port.set(port);
         if port == DEFAULT_PORT {
@@ -141,6 +175,7 @@ impl ObjectImpl for Window {
         let obj = self.obj();
         obj.setup_icon();
         obj.setup_clients();
+        obj.setup_authorized();
     }
 }
 

lan-mouse-ipc/src/lib.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::HashSet,
+    collections::{HashMap, HashSet},
     env::VarError,
     fmt::Display,
     io,
@@ -33,7 +33,7 @@ pub enum ConnectionError {
 }
 
 #[derive(Debug, Error)]
-pub enum ListenerCreationError {
+pub enum IpcListenerCreationError {
     #[error("could not determine socket-path: `{0}`")]
     SocketPath(#[from] SocketPathError),
     #[error("service already running!")]
@@ -51,7 +51,7 @@ pub enum IpcError {
     #[error(transparent)]
     Connection(#[from] ConnectionError),
     #[error(transparent)]
-    Listen(#[from] ListenerCreationError),
+    Listen(#[from] IpcListenerCreationError),
 }
 
 pub const DEFAULT_PORT: u16 = 4242;
@@ -65,6 +65,17 @@ pub enum Position {
     Bottom,
 }
 
+impl Position {
+    pub fn opposite(&self) -> Self {
+        match self {
+            Position::Left => Position::Right,
+            Position::Right => Position::Left,
+            Position::Top => Position::Bottom,
+            Position::Bottom => Position::Top,
+        }
+    }
+}
+
 #[derive(Debug, Error)]
 #[error("not a valid position: {pos}")]
 pub struct PositionParseError {
@@ -150,7 +161,7 @@ pub struct ClientState {
     /// This should generally be the socket address where data
     /// was last received from.
     pub active_addr: Option<SocketAddr>,
-    /// tracks whether or not the client is responding to pings
+    /// tracks whether or not the client is available for emulation
     pub alive: bool,
     /// ips from dns
     pub dns_ips: Vec<IpAddr>,
@@ -186,6 +197,14 @@ pub enum FrontendEvent {
     CaptureStatus(Status),
     /// emulation status
     EmulationStatus(Status),
+    /// authorized public key fingerprints have been updated
+    AuthorizedUpdated(HashMap<String, String>),
+    /// public key fingerprint of this device
+    PublicKeyFingerprint(String),
+    /// incoming connected
+    IncomingConnected(String, SocketAddr, Position),
+    /// incoming disconnected
+    IncomingDisconnected(SocketAddr),
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
@@ -218,9 +237,13 @@ pub enum FrontendRequest {
     EnableEmulation,
     /// synchronize all state
     Sync,
+    /// authorize fingerprint (description, fingerprint)
+    AuthorizeKey(String, String),
+    /// remove fingerprint (fingerprint)
+    RemoveAuthorizedKey(String),
 }
 
-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]
 pub enum Status {
     #[default]
     Disabled,

lan-mouse-ipc/src/listen.rs

@@ -20,7 +20,7 @@ use tokio::net::TcpListener;
 #[cfg(windows)]
 use tokio::net::TcpStream;
 
-use crate::{FrontendEvent, FrontendRequest, IpcError, ListenerCreationError};
+use crate::{FrontendEvent, FrontendRequest, IpcError, IpcListenerCreationError};
 
 pub struct AsyncFrontendListener {
     #[cfg(windows)]
@@ -40,7 +40,7 @@ pub struct AsyncFrontendListener {
 }
 
 impl AsyncFrontendListener {
-    pub async fn new() -> Result<Self, ListenerCreationError> {
+    pub async fn new() -> Result<Self, IpcListenerCreationError> {
         #[cfg(unix)]
         let (socket_path, listener) = {
             let socket_path = crate::default_socket_path()?;
@@ -51,7 +51,7 @@ impl AsyncFrontendListener {
                 // of lan-mouse is already running
                 match UnixStream::connect(&socket_path).await {
                     // connected -> lan-mouse is already running
-                    Ok(_) => return Err(ListenerCreationError::AlreadyRunning),
+                    Ok(_) => return Err(IpcListenerCreationError::AlreadyRunning),
                     // lan-mouse is not running but a socket was left behind
                     Err(e) => {
                         log::debug!("{socket_path:?}: {e} - removing left behind socket");
@@ -63,9 +63,9 @@ impl AsyncFrontendListener {
                 Ok(ls) => ls,
                 // some other lan-mouse instance has bound the socket in the meantime
                 Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                    return Err(ListenerCreationError::AlreadyRunning)
+                    return Err(IpcListenerCreationError::AlreadyRunning)
                 }
-                Err(e) => return Err(ListenerCreationError::Bind(e)),
+                Err(e) => return Err(IpcListenerCreationError::Bind(e)),
             };
             (socket_path, listener)
         };
@@ -75,9 +75,9 @@ impl AsyncFrontendListener {
             Ok(ls) => ls,
             // some other lan-mouse instance has bound the socket in the meantime
             Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                return Err(ListenerCreationError::AlreadyRunning)
+                return Err(IpcListenerCreationError::AlreadyRunning)
             }
-            Err(e) => return Err(ListenerCreationError::Bind(e)),
+            Err(e) => return Err(IpcListenerCreationError::Bind(e)),
         };
 
         let adapter = Self {

lan-mouse-proto/src/lib.rs

@@ -2,7 +2,7 @@ use input_event::{Event as InputEvent, KeyboardEvent, PointerEvent};
 use num_enum::{IntoPrimitive, TryFromPrimitive, TryFromPrimitiveError};
 use paste::paste;
 use std::{
-    fmt::{Debug, Display},
+    fmt::{Debug, Display, Formatter},
     mem::size_of,
 };
 use thiserror::Error;
@@ -18,14 +18,39 @@ pub enum ProtocolError {
     /// event type does not exist
     #[error("invalid event id: `{0}`")]
     InvalidEventId(#[from] TryFromPrimitiveError<EventType>),
+    /// position type does not exist
+    #[error("invalid event id: `{0}`")]
+    InvalidPosition(#[from] TryFromPrimitiveError<Position>),
+}
+
+/// Position of a client
+#[derive(Clone, Copy, Debug, TryFromPrimitive, IntoPrimitive)]
+#[repr(u8)]
+pub enum Position {
+    Left,
+    Right,
+    Top,
+    Bottom,
+}
+
+impl Display for Position {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let pos = match self {
+            Position::Left => "left",
+            Position::Right => "right",
+            Position::Top => "top",
+            Position::Bottom => "bottom",
+        };
+        write!(f, "{pos}")
+    }
 }
 
 /// main lan-mouse protocol event type
 #[derive(Clone, Copy, Debug)]
 pub enum ProtoEvent {
-    /// notify a client that the cursor entered its region
+    /// notify a client that the cursor entered its region at the given position
     /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
-    Enter(u32),
+    Enter(Position),
     /// notify a client that the cursor left its region
     /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
     Leave(u32),
@@ -36,19 +61,25 @@ pub enum ProtoEvent {
     /// Ping event for tracking unresponsive clients.
     /// A client has to respond with [`ProtoEvent::Pong`].
     Ping,
-    /// Response to [`ProtoEvent::Ping`]
-    Pong,
+    /// Response to [`ProtoEvent::Ping`], true if emulation is enabled / available
+    Pong(bool),
 }
 
 impl Display for ProtoEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             ProtoEvent::Enter(s) => write!(f, "Enter({s})"),
             ProtoEvent::Leave(s) => write!(f, "Leave({s})"),
             ProtoEvent::Ack(s) => write!(f, "Ack({s})"),
             ProtoEvent::Input(e) => write!(f, "{e}"),
             ProtoEvent::Ping => write!(f, "ping"),
-            ProtoEvent::Pong => write!(f, "pong"),
+            ProtoEvent::Pong(alive) => {
+                write!(
+                    f,
+                    "pong: {}",
+                    if *alive { "alive" } else { "not available" }
+                )
+            }
         }
     }
 }
@@ -85,7 +116,7 @@ impl ProtoEvent {
                 },
             },
             ProtoEvent::Ping => EventType::Ping,
-            ProtoEvent::Pong => EventType::Pong,
+            ProtoEvent::Pong(_) => EventType::Pong,
             ProtoEvent::Enter(_) => EventType::Enter,
             ProtoEvent::Leave(_) => EventType::Leave,
             ProtoEvent::Ack(_) => EventType::Ack,
@@ -139,8 +170,8 @@ impl TryFrom<[u8; MAX_EVENT_SIZE]> for ProtoEvent {
                 },
             ))),
             EventType::Ping => Ok(Self::Ping),
-            EventType::Pong => Ok(Self::Pong),
-            EventType::Enter => Ok(Self::Enter(decode_u32(&mut buf)?)),
+            EventType::Pong => Ok(Self::Pong(decode_u8(&mut buf)? != 0)),
+            EventType::Enter => Ok(Self::Enter(decode_u8(&mut buf)?.try_into()?)),
             EventType::Leave => Ok(Self::Leave(decode_u32(&mut buf)?)),
             EventType::Ack => Ok(Self::Ack(decode_u32(&mut buf)?)),
         }
@@ -203,8 +234,8 @@ impl From<ProtoEvent> for ([u8; MAX_EVENT_SIZE], usize) {
                     },
                 },
                 ProtoEvent::Ping => {}
-                ProtoEvent::Pong => {}
-                ProtoEvent::Enter(serial) => encode_u32(buf, len, serial),
+                ProtoEvent::Pong(alive) => encode_u8(buf, len, alive as u8),
+                ProtoEvent::Enter(pos) => encode_u8(buf, len, pos as u8),
                 ProtoEvent::Leave(serial) => encode_u32(buf, len, serial),
                 ProtoEvent::Ack(serial) => encode_u32(buf, len, serial),
             }

scripts/makeicns.sh

@@ -0,0 +1,42 @@
+#!/bin/sh
+set -e
+
+usage() {
+    cat <<EOF
+$0: Make a macOS icns file from an SVG with ImageMagick and iconutil.
+usage: $0 [SVG [ICNS [ICONSET]]
+
+ARGUMENTS
+    SVG     The SVG file to convert
+            Defaults to ./lan-mouse-gtk/resources/de.feschber.LanMouse.svg
+    ICNS    The icns file to create
+            Defaults to ./target/icon.icns
+    ICONSET The iconset directory to create
+            Defaults to ./target/icon.iconset
+            This is just a temporary directory
+EOF
+}
+
+if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
+    usage
+    exit 0
+fi
+
+svg="${1:-./lan-mouse-gtk/resources/de.feschber.LanMouse.svg}"
+icns="${2:-./target/icon.icns}"
+iconset="${3:-./target/icon.iconset}"
+
+set -u
+
+mkdir -p "$iconset"
+magick convert -background none -resize 1024x1024 "$svg" "$iconset"/icon_512x512@2x.png
+magick convert -background none -resize 512x512 "$svg" "$iconset"/icon_512x512.png
+magick convert -background none -resize 256x256 "$svg" "$iconset"/icon_256x256.png
+magick convert -background none -resize 128x128 "$svg" "$iconset"/icon_128x128.png
+magick convert -background none -resize 64x64 "$svg" "$iconset"/icon_32x32@2x.png
+magick convert -background none -resize 32x32 "$svg" "$iconset"/icon_32x32.png
+magick convert -background none -resize 16x16 "$svg" "$iconset"/icon_16x16.png
+cp "$iconset"/icon_512x512.png "$iconset"/icon_256x256@2x.png
+cp "$iconset"/icon_256x256.png "$iconset"/icon_128x128@2x.png
+cp "$iconset"/icon_32x32.png "$iconset"/icon_16x16@2x.png
+iconutil -c icns "$iconset" -o "$icns"

src/capture.rs

@@ -0,0 +1,418 @@
+use std::{
+    cell::{Cell, RefCell},
+    rc::Rc,
+    time::{Duration, Instant},
+};
+
+use futures::StreamExt;
+use input_capture::{
+    CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
+};
+use input_event::scancode;
+use lan_mouse_proto::ProtoEvent;
+use local_channel::mpsc::{channel, Receiver, Sender};
+use tokio::task::{spawn_local, JoinHandle};
+use tokio_util::sync::CancellationToken;
+
+use crate::connect::LanMouseConnection;
+
+pub(crate) struct Capture {
+    cancellation_token: CancellationToken,
+    request_tx: Sender<CaptureRequest>,
+    task: JoinHandle<()>,
+    event_rx: Receiver<ICaptureEvent>,
+}
+
+pub(crate) enum ICaptureEvent {
+    /// a client was entered
+    CaptureBegin(CaptureHandle),
+    /// capture disabled
+    CaptureDisabled,
+    /// capture disabled
+    CaptureEnabled,
+    /// A (new) client was entered.
+    /// In contrast to [`ICaptureEvent::CaptureBegin`] this
+    /// event is only triggered when the capture was
+    /// explicitly released in the meantime by
+    /// either the remote client leaving its device region,
+    /// a new device entering the screen or the release bind.
+    ClientEntered(u64),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum CaptureType {
+    /// a normal input capture
+    Default,
+    /// A capture only interested in [`CaptureEvent::Begin`] events.
+    /// The capture is released immediately, if there is no
+    /// Default capture at the same position.
+    EnterOnly,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum CaptureRequest {
+    /// capture must release the mouse
+    Release,
+    /// add a capture client
+    Create(CaptureHandle, Position, CaptureType),
+    /// destory a capture client
+    Destroy(CaptureHandle),
+    /// reenable input capture
+    Reenable,
+}
+
+impl Capture {
+    pub(crate) fn new(
+        backend: Option<input_capture::Backend>,
+        conn: LanMouseConnection,
+        release_bind: Vec<scancode::Linux>,
+    ) -> Self {
+        let (request_tx, request_rx) = channel();
+        let (event_tx, event_rx) = channel();
+        let cancellation_token = CancellationToken::new();
+        let capture_task = CaptureTask {
+            active_client: None,
+            backend,
+            cancellation_token: cancellation_token.clone(),
+            captures: Default::default(),
+            conn,
+            event_tx,
+            request_rx,
+            release_bind: Rc::new(RefCell::new(release_bind)),
+            state: Default::default(),
+        };
+        let task = spawn_local(capture_task.run());
+        Self {
+            cancellation_token,
+            request_tx,
+            task,
+            event_rx,
+        }
+    }
+
+    pub(crate) fn reenable(&self) {
+        self.request_tx
+            .send(CaptureRequest::Reenable)
+            .expect("channel closed");
+    }
+
+    pub(crate) async fn terminate(&mut self) {
+        self.cancellation_token.cancel();
+        log::debug!("terminating capture");
+        if let Err(e) = (&mut self.task).await {
+            log::warn!("{e}");
+        }
+    }
+
+    pub(crate) fn create(
+        &self,
+        handle: CaptureHandle,
+        pos: lan_mouse_ipc::Position,
+        capture_type: CaptureType,
+    ) {
+        let pos = to_capture_pos(pos);
+        self.request_tx
+            .send(CaptureRequest::Create(handle, pos, capture_type))
+            .expect("channel closed");
+    }
+
+    pub(crate) fn destroy(&self, handle: CaptureHandle) {
+        self.request_tx
+            .send(CaptureRequest::Destroy(handle))
+            .expect("channel closed");
+    }
+
+    pub(crate) fn release(&self) {
+        self.request_tx
+            .send(CaptureRequest::Release)
+            .expect("channel closed");
+    }
+
+    pub(crate) async fn event(&mut self) -> ICaptureEvent {
+        self.event_rx.recv().await.expect("channel closed")
+    }
+}
+
+/// debounce a statement `$st`, i.e. the statement is executed only if the
+/// time since the previous execution is at least `$dur`.
+/// `$prev` is used to keep track of this timestamp
+macro_rules! debounce {
+    ($prev:ident, $dur:expr, $st:stmt) => {
+        let exec = match $prev.get() {
+            None => true,
+            Some(instant) if instant.elapsed() > $dur => true,
+            _ => false,
+        };
+        if exec {
+            $prev.replace(Some(Instant::now()));
+            $st
+        }
+    };
+}
+
+struct CaptureTask {
+    active_client: Option<CaptureHandle>,
+    backend: Option<input_capture::Backend>,
+    cancellation_token: CancellationToken,
+    captures: Vec<(CaptureHandle, Position, CaptureType)>,
+    conn: LanMouseConnection,
+    event_tx: Sender<ICaptureEvent>,
+    release_bind: Rc<RefCell<Vec<scancode::Linux>>>,
+    request_rx: Receiver<CaptureRequest>,
+    state: State,
+}
+
+impl CaptureTask {
+    fn add_capture(&mut self, handle: CaptureHandle, pos: Position, capture_type: CaptureType) {
+        self.captures.push((handle, pos, capture_type));
+    }
+
+    fn remove_capture(&mut self, handle: CaptureHandle) {
+        self.captures.retain(|&(h, ..)| handle != h);
+    }
+
+    fn is_default_capture_at(&self, pos: Position) -> bool {
+        self.captures
+            .iter()
+            .any(|&(_, p, t)| p == pos && t == CaptureType::Default)
+    }
+
+    fn get_pos(&self, handle: CaptureHandle) -> Position {
+        self.captures
+            .iter()
+            .find(|(h, ..)| *h == handle)
+            .expect("no such capture")
+            .1
+    }
+
+    fn get_type(&self, handle: CaptureHandle) -> CaptureType {
+        self.captures
+            .iter()
+            .find(|(h, ..)| *h == handle)
+            .expect("no such capture")
+            .2
+    }
+
+    async fn run(mut self) {
+        loop {
+            if let Err(e) = self.do_capture().await {
+                log::warn!("input capture exited: {e}");
+            }
+            loop {
+                tokio::select! {
+                    r = self.request_rx.recv() => match r.expect("channel closed") {
+                        CaptureRequest::Reenable => break,
+                        CaptureRequest::Create(h, p, t) => self.add_capture(h, p, t),
+                        CaptureRequest::Destroy(h) => self.remove_capture(h),
+                        CaptureRequest::Release => { /* nothing to do */ }
+                    },
+                    _ = self.cancellation_token.cancelled() => return,
+                }
+            }
+        }
+    }
+
+    async fn do_capture(&mut self) -> Result<(), InputCaptureError> {
+        /* allow cancelling capture request */
+        let mut capture = tokio::select! {
+            r = InputCapture::new(self.backend) => r?,
+            _ = self.cancellation_token.cancelled() => return Ok(()),
+        };
+
+        let _capture_guard = DropGuard::new(
+            self.event_tx.clone(),
+            ICaptureEvent::CaptureEnabled,
+            ICaptureEvent::CaptureDisabled,
+        );
+
+        /* create barriers for active clients */
+        let r = self.create_captures(&mut capture).await;
+        if let Err(e) = r {
+            capture.terminate().await?;
+            return Err(e.into());
+        }
+
+        let r = self.do_capture_session(&mut capture).await;
+
+        // FIXME replace with async drop when stabilized
+        capture.terminate().await?;
+
+        r
+    }
+
+    async fn create_captures(&mut self, capture: &mut InputCapture) -> Result<(), CaptureError> {
+        let captures = self.captures.clone();
+        for (handle, pos, _type) in captures {
+            tokio::select! {
+                r = capture.create(handle, pos) => r?,
+                _ = self.cancellation_token.cancelled() => return Ok(()),
+            }
+        }
+        Ok(())
+    }
+
+    async fn do_capture_session(
+        &mut self,
+        capture: &mut InputCapture,
+    ) -> Result<(), InputCaptureError> {
+        loop {
+            tokio::select! {
+                event = capture.next() => match event {
+                    Some(event) => self.handle_capture_event(capture, event?).await?,
+                    None => return Ok(()),
+                },
+                (handle, event) = self.conn.recv() => {
+                    if let Some(active) = self.active_client {
+                        if handle != active {
+                            // we only care about events coming from the client we are currently connected to
+                            // only `Ack` and `Leave` are relevant
+                            continue
+                        }
+                    }
+
+                    match event {
+                        // connection acknowlegded => set state to Sending
+                        ProtoEvent::Ack(_) => {
+                            log::info!("client {handle} acknowledged the connection!");
+                            self.state = State::Sending;
+                        }
+                        // client disconnected
+                        ProtoEvent::Leave(_) => {
+                            log::info!("releasing capture: left remote client device region");
+                            self.release_capture(capture).await?;
+                        },
+                        _ => {}
+                    }
+                },
+                e = self.request_rx.recv() => match e.expect("channel closed") {
+                    CaptureRequest::Reenable => { /* already active */ },
+                    CaptureRequest::Release => self.release_capture(capture).await?,
+                    CaptureRequest::Create(h, p, t) => {
+                        self.add_capture(h, p, t);
+                        capture.create(h, p).await?;
+                    }
+                    CaptureRequest::Destroy(h) => {
+                        self.remove_capture(h);
+                        capture.destroy(h).await?;
+                    }
+                },
+                _ = self.cancellation_token.cancelled() => break,
+            }
+        }
+        Ok(())
+    }
+
+    async fn handle_capture_event(
+        &mut self,
+        capture: &mut InputCapture,
+        event: (CaptureHandle, CaptureEvent),
+    ) -> Result<(), CaptureError> {
+        let (handle, event) = event;
+        log::trace!("({handle}): {event:?}");
+
+        if capture.keys_pressed(&self.release_bind.borrow()) {
+            log::info!("releasing capture: release-bind pressed");
+            return self.release_capture(capture).await;
+        }
+
+        if event == CaptureEvent::Begin {
+            self.event_tx
+                .send(ICaptureEvent::CaptureBegin(handle))
+                .expect("channel closed");
+        }
+
+        // enter only capture (for incoming connections)
+        if self.get_type(handle) == CaptureType::EnterOnly {
+            // if there is no active outgoing connection at the current capture,
+            // we release the capture
+            if !self.is_default_capture_at(self.get_pos(handle)) {
+                log::info!("releasing capture: no active client at this position");
+                capture.release().await?;
+            }
+            // we dont care about events from incoming handles except for releasing the capture
+            return Ok(());
+        }
+
+        // activated a new client
+        if event == CaptureEvent::Begin && Some(handle) != self.active_client {
+            self.state = State::WaitingForAck;
+            self.active_client.replace(handle);
+            self.event_tx
+                .send(ICaptureEvent::ClientEntered(handle))
+                .expect("channel closed");
+        }
+
+        let opposite_pos = to_proto_pos(self.get_pos(handle).opposite());
+
+        let event = match event {
+            CaptureEvent::Begin => ProtoEvent::Enter(opposite_pos),
+            CaptureEvent::Input(e) => match self.state {
+                // connection not acknowledged, repeat `Enter` event
+                State::WaitingForAck => ProtoEvent::Enter(opposite_pos),
+                State::Sending => ProtoEvent::Input(e),
+            },
+        };
+
+        if let Err(e) = self.conn.send(event, handle).await {
+            const DUR: Duration = Duration::from_millis(500);
+            debounce!(PREV_LOG, DUR, log::warn!("releasing capture: {e}"));
+            capture.release().await?;
+        }
+        Ok(())
+    }
+
+    async fn release_capture(&mut self, capture: &mut InputCapture) -> Result<(), CaptureError> {
+        self.active_client.take();
+        capture.release().await
+    }
+}
+
+thread_local! {
+    static PREV_LOG: Cell<Option<Instant>> = const { Cell::new(None) };
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+enum State {
+    #[default]
+    WaitingForAck,
+    Sending,
+}
+
+fn to_capture_pos(pos: lan_mouse_ipc::Position) -> input_capture::Position {
+    match pos {
+        lan_mouse_ipc::Position::Left => input_capture::Position::Left,
+        lan_mouse_ipc::Position::Right => input_capture::Position::Right,
+        lan_mouse_ipc::Position::Top => input_capture::Position::Top,
+        lan_mouse_ipc::Position::Bottom => input_capture::Position::Bottom,
+    }
+}
+
+fn to_proto_pos(pos: input_capture::Position) -> lan_mouse_proto::Position {
+    match pos {
+        input_capture::Position::Left => lan_mouse_proto::Position::Left,
+        input_capture::Position::Right => lan_mouse_proto::Position::Right,
+        input_capture::Position::Top => lan_mouse_proto::Position::Top,
+        input_capture::Position::Bottom => lan_mouse_proto::Position::Bottom,
+    }
+}
+
+struct DropGuard<T> {
+    tx: Sender<T>,
+    on_drop: Option<T>,
+}
+
+impl<T> DropGuard<T> {
+    fn new(tx: Sender<T>, on_new: T, on_drop: T) -> Self {
+        tx.send(on_new).expect("channel closed");
+        let on_drop = Some(on_drop);
+        Self { tx, on_drop }
+    }
+}
+
+impl<T> Drop for DropGuard<T> {
+    fn drop(&mut self) {
+        self.tx
+            .send(self.on_drop.take().expect("item"))
+            .expect("channel closed");
+    }
+}

src/client.rs

@@ -1,18 +1,63 @@
-use std::net::SocketAddr;
+use std::{
+    cell::RefCell,
+    collections::HashSet,
+    net::{IpAddr, SocketAddr},
+    rc::Rc,
+};
 
 use slab::Slab;
 
 use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState, Position};
 
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct ClientManager {
-    clients: Slab<(ClientConfig, ClientState)>,
+    clients: Rc<RefCell<Slab<(ClientConfig, ClientState)>>>,
 }
 
 impl ClientManager {
     /// add a new client to this manager
-    pub fn add_client(&mut self) -> ClientHandle {
-        self.clients.insert(Default::default()) as ClientHandle
+    pub fn add_client(&self) -> ClientHandle {
+        self.clients.borrow_mut().insert(Default::default()) as ClientHandle
+    }
+
+    /// set the config of the given client
+    pub fn set_config(&self, handle: ClientHandle, config: ClientConfig) {
+        if let Some((c, _)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            *c = config;
+        }
+    }
+
+    /// set the state of the given client
+    pub fn set_state(&self, handle: ClientHandle, state: ClientState) {
+        if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            *s = state;
+        }
+    }
+
+    /// activate the given client
+    /// returns, whether the client was activated
+    pub fn activate_client(&self, handle: ClientHandle) -> bool {
+        let mut clients = self.clients.borrow_mut();
+        match clients.get_mut(handle as usize) {
+            Some((_, s)) if !s.active => {
+                s.active = true;
+                true
+            }
+            _ => false,
+        }
+    }
+
+    /// deactivate the given client
+    /// returns, whether the client was deactivated
+    pub fn deactivate_client(&self, handle: ClientHandle) -> bool {
+        let mut clients = self.clients.borrow_mut();
+        match clients.get_mut(handle as usize) {
+            Some((_, s)) if s.active => {
+                s.active = false;
+                true
+            }
+            _ => false,
+        }
     }
 
     /// find a client by its address
@@ -20,6 +65,7 @@ impl ClientManager {
         // since there shouldn't be more than a handful of clients at any given
         // time this is likely faster than using a HashMap
         self.clients
+            .borrow()
             .iter()
             .find_map(|(k, (_, s))| {
                 if s.active && s.ips.contains(&addr.ip()) {
@@ -31,8 +77,10 @@ impl ClientManager {
             .map(|p| p as ClientHandle)
     }
 
-    pub fn find_client(&self, pos: Position) -> Option<ClientHandle> {
+    /// get the client at the given position
+    pub fn client_at(&self, pos: Position) -> Option<ClientHandle> {
         self.clients
+            .borrow()
             .iter()
             .find_map(|(k, (c, s))| {
                 if s.active && c.pos == pos {
@@ -44,31 +92,176 @@ impl ClientManager {
             .map(|p| p as ClientHandle)
     }
 
+    pub(crate) fn get_hostname(&self, handle: ClientHandle) -> Option<String> {
+        self.clients
+            .borrow_mut()
+            .get_mut(handle as usize)
+            .and_then(|(c, _)| c.hostname.clone())
+    }
+
+    /// get the position of the corresponding client
+    pub(crate) fn get_pos(&self, handle: ClientHandle) -> Option<Position> {
+        self.clients
+            .borrow()
+            .get(handle as usize)
+            .map(|(c, _)| c.pos)
+    }
+
     /// remove a client from the list
-    pub fn remove_client(&mut self, client: ClientHandle) -> Option<(ClientConfig, ClientState)> {
+    pub fn remove_client(&self, client: ClientHandle) -> Option<(ClientConfig, ClientState)> {
         // remove id from occupied ids
-        self.clients.try_remove(client as usize)
+        self.clients.borrow_mut().try_remove(client as usize)
     }
 
-    // returns an immutable reference to the client state corresponding to `client`
-    pub fn get(&self, handle: ClientHandle) -> Option<&(ClientConfig, ClientState)> {
-        self.clients.get(handle as usize)
+    /// get the config & state of the given client
+    pub fn get_state(&self, handle: ClientHandle) -> Option<(ClientConfig, ClientState)> {
+        self.clients.borrow().get(handle as usize).cloned()
     }
 
-    /// returns a mutable reference to the client state corresponding to `client`
-    pub fn get_mut(&mut self, handle: ClientHandle) -> Option<&mut (ClientConfig, ClientState)> {
-        self.clients.get_mut(handle as usize)
+    /// get the current config & state of all clients
+    pub fn get_client_states(&self) -> Vec<(ClientHandle, ClientConfig, ClientState)> {
+        self.clients
+            .borrow()
+            .iter()
+            .map(|(k, v)| (k as ClientHandle, v.0.clone(), v.1.clone()))
+            .collect()
     }
 
-    pub fn get_client_states(
-        &self,
-    ) -> impl Iterator<Item = (ClientHandle, &(ClientConfig, ClientState))> {
-        self.clients.iter().map(|(k, v)| (k as ClientHandle, v))
+    /// update the fix ips of the client
+    pub fn set_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
+        if let Some((c, _)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            c.fix_ips = fix_ips
+        }
+        self.update_ips(handle);
     }
 
-    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))
+    /// update the dns-ips of the client
+    pub fn set_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
+        if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            s.dns_ips = dns_ips
+        }
+        self.update_ips(handle);
+    }
+
+    fn update_ips(&self, handle: ClientHandle) {
+        if let Some((c, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            s.ips = c
+                .fix_ips
+                .iter()
+                .cloned()
+                .chain(s.dns_ips.iter().cloned())
+                .collect::<HashSet<_>>();
+        }
+    }
+
+    /// update the hostname of the given client
+    /// this automatically clears the active ip address and ips from dns
+    pub fn set_hostname(&self, handle: ClientHandle, hostname: Option<String>) -> bool {
+        let mut clients = self.clients.borrow_mut();
+        let Some((c, s)) = clients.get_mut(handle as usize) else {
+            return false;
+        };
+
+        // hostname changed
+        if c.hostname != hostname {
+            c.hostname = hostname;
+            s.active_addr = None;
+            s.dns_ips.clear();
+            drop(clients);
+            self.update_ips(handle);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// update the port of the client
+    pub(crate) fn set_port(&self, handle: ClientHandle, port: u16) {
+        match self.clients.borrow_mut().get_mut(handle as usize) {
+            Some((c, s)) if c.port != port => {
+                c.port = port;
+                s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
+            }
+            _ => {}
+        };
+    }
+
+    /// update the position of the client
+    /// returns true, if a change in capture position is required (pos changed & client is active)
+    pub(crate) fn set_pos(&self, handle: ClientHandle, pos: Position) -> bool {
+        match self.clients.borrow_mut().get_mut(handle as usize) {
+            Some((c, s)) if c.pos != pos => {
+                log::info!("update pos {handle} {} -> {}", c.pos, pos);
+                c.pos = pos;
+                s.active
+            }
+            _ => false,
+        }
+    }
+
+    /// set resolving status of the client
+    pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
+        if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            s.resolving = status;
+        }
+    }
+
+    /// get the enter hook command
+    pub(crate) fn get_enter_cmd(&self, handle: ClientHandle) -> Option<String> {
+        self.clients
+            .borrow()
+            .get(handle as usize)
+            .and_then(|(c, _)| c.cmd.clone())
+    }
+
+    /// returns all clients that are currently active
+    pub(crate) fn active_clients(&self) -> Vec<ClientHandle> {
+        self.clients
+            .borrow()
+            .iter()
+            .filter(|(_, (_, s))| s.active)
+            .map(|(h, _)| h as ClientHandle)
+            .collect()
+    }
+
+    pub(crate) fn set_active_addr(&self, handle: ClientHandle, addr: Option<SocketAddr>) {
+        if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            s.active_addr = addr;
+        }
+    }
+
+    pub(crate) fn set_alive(&self, handle: ClientHandle, alive: bool) {
+        if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
+            s.alive = alive;
+        }
+    }
+
+    pub(crate) fn active_addr(&self, handle: ClientHandle) -> Option<SocketAddr> {
+        self.clients
+            .borrow()
+            .get(handle as usize)
+            .and_then(|(_, s)| s.active_addr)
+    }
+
+    pub(crate) fn alive(&self, handle: ClientHandle) -> bool {
+        self.clients
+            .borrow()
+            .get(handle as usize)
+            .map(|(_, s)| s.alive)
+            .unwrap_or(false)
+    }
+
+    pub(crate) fn get_port(&self, handle: ClientHandle) -> Option<u16> {
+        self.clients
+            .borrow()
+            .get(handle as usize)
+            .map(|(c, _)| c.port)
+    }
+
+    pub(crate) fn get_ips(&self, handle: ClientHandle) -> Option<HashSet<IpAddr>> {
+        self.clients
+            .borrow()
+            .get(handle as usize)
+            .map(|(_, s)| s.ips.clone())
     }
 }

src/config.rs

@@ -1,9 +1,11 @@
 use clap::{Parser, ValueEnum};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::env::{self, VarError};
 use std::fmt::Display;
 use std::fs;
 use std::net::IpAddr;
+use std::path::{Path, PathBuf};
 use std::{collections::HashSet, io};
 use thiserror::Error;
 use toml;
@@ -15,6 +17,10 @@ use input_event::scancode::{
     Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
 };
 
+use shadow_rs::shadow;
+
+shadow!(build);
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ConfigToml {
     pub capture_backend: Option<CaptureBackend>,
@@ -22,10 +28,12 @@ pub struct ConfigToml {
     pub port: Option<u16>,
     pub frontend: Option<Frontend>,
     pub release_bind: Option<Vec<scancode::Linux>>,
+    pub cert_path: Option<PathBuf>,
     pub left: Option<TomlClient>,
     pub right: Option<TomlClient>,
     pub top: Option<TomlClient>,
     pub bottom: Option<TomlClient>,
+    pub authorized_fingerprints: Option<HashMap<String, String>>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
@@ -40,15 +48,14 @@ pub struct TomlClient {
 }
 
 impl ConfigToml {
-    pub fn new(path: &str) -> Result<ConfigToml, ConfigError> {
+    pub fn new(path: &Path) -> Result<ConfigToml, ConfigError> {
         let config = fs::read_to_string(path)?;
-        log::info!("using config: \"{path}\"");
         Ok(toml::from_str::<_>(&config)?)
     }
 }
 
 #[derive(Parser, Debug)]
-#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None)]
+#[command(author, version=build::CLAP_LONG_VERSION, about, long_about = None)]
 struct CliArgs {
     /// the listen port for lan-mouse
     #[arg(short, long)]
@@ -81,6 +88,10 @@ struct CliArgs {
     /// emulation backend override
     #[arg(long)]
     emulation_backend: Option<EmulationBackend>,
+
+    /// path to non-default certificate location
+    #[arg(long)]
+    cert_path: Option<PathBuf>,
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
@@ -224,15 +235,30 @@ impl Default for Frontend {
 
 #[derive(Debug)]
 pub struct Config {
+    /// the path to the configuration file used
+    pub path: PathBuf,
+    /// public key fingerprints authorized for connection
+    pub authorized_fingerprints: HashMap<String, String>,
+    /// optional input-capture backend override
     pub capture_backend: Option<CaptureBackend>,
+    /// optional input-emulation backend override
     pub emulation_backend: Option<EmulationBackend>,
+    /// the frontend to use
     pub frontend: Frontend,
+    /// the port to use (initially)
     pub port: u16,
+    /// list of clients
     pub clients: Vec<(TomlClient, Position)>,
+    /// whether or not to run as a daemon
     pub daemon: bool,
+    /// configured release bind
     pub release_bind: Vec<scancode::Linux>,
+    /// test capture instead of running the app
     pub test_capture: bool,
+    /// test emulation instead of running the app
     pub test_emulation: bool,
+    /// path to the tls certificate to use
+    pub cert_path: PathBuf,
 }
 
 pub struct ConfigClient {
@@ -260,27 +286,32 @@ const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
 impl Config {
     pub fn new() -> Result<Self, ConfigError> {
         let args = CliArgs::parse();
-        let config_file = "config.toml";
+        const CONFIG_FILE_NAME: &str = "config.toml";
+        const CERT_FILE_NAME: &str = "lan-mouse.pem";
+
         #[cfg(unix)]
         let config_path = {
             let xdg_config_home =
                 env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
-            format!("{xdg_config_home}/lan-mouse/{config_file}")
+            format!("{xdg_config_home}/lan-mouse/")
         };
 
         #[cfg(not(unix))]
         let config_path = {
             let app_data =
                 env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
-            format!("{app_data}\\lan-mouse\\{config_file}")
+            format!("{app_data}\\lan-mouse\\")
         };
 
-        // --config <file> overrules default location
-        let config_path = args.config.unwrap_or(config_path);
+        let config_path = PathBuf::from(config_path);
+        let config_file = config_path.join(CONFIG_FILE_NAME);
 
-        let config_toml = match ConfigToml::new(config_path.as_str()) {
+        // --config <file> overrules default location
+        let config_file = args.config.map(PathBuf::from).unwrap_or(config_file);
+
+        let mut config_toml = match ConfigToml::new(&config_file) {
             Err(e) => {
-                log::warn!("{config_path}: {e}");
+                log::warn!("{config_file:?}: {e}");
                 log::warn!("Continuing without config file ...");
                 None
             }
@@ -310,6 +341,16 @@ impl Config {
             .emulation_backend
             .or(config_toml.as_ref().and_then(|c| c.emulation_backend));
 
+        let cert_path = args
+            .cert_path
+            .or(config_toml.as_ref().and_then(|c| c.cert_path.clone()))
+            .unwrap_or(config_path.join(CERT_FILE_NAME));
+
+        let authorized_fingerprints = config_toml
+            .as_mut()
+            .and_then(|c| std::mem::take(&mut c.authorized_fingerprints))
+            .unwrap_or_default();
+
         let mut clients: Vec<(TomlClient, Position)> = vec![];
 
         if let Some(config_toml) = config_toml {
@@ -332,6 +373,8 @@ impl Config {
         let test_emulation = args.test_emulation;
 
         Ok(Config {
+            path: config_path,
+            authorized_fingerprints,
             capture_backend,
             emulation_backend,
             daemon,
@@ -341,6 +384,7 @@ impl Config {
             release_bind,
             test_capture,
             test_emulation,
+            cert_path,
         })
     }
 

src/connect.rs

@@ -0,0 +1,281 @@
+use crate::client::ClientManager;
+use lan_mouse_ipc::{ClientHandle, DEFAULT_PORT};
+use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
+use local_channel::mpsc::{channel, Receiver, Sender};
+use std::{
+    cell::RefCell,
+    collections::{HashMap, HashSet},
+    io,
+    net::SocketAddr,
+    rc::Rc,
+    sync::Arc,
+    time::Duration,
+};
+use thiserror::Error;
+use tokio::{
+    net::UdpSocket,
+    sync::Mutex,
+    task::{spawn_local, JoinSet},
+};
+use webrtc_dtls::{
+    config::{Config, ExtendedMasterSecretType},
+    conn::DTLSConn,
+    crypto::Certificate,
+};
+use webrtc_util::Conn;
+
+#[derive(Debug, Error)]
+pub(crate) enum LanMouseConnectionError {
+    #[error(transparent)]
+    Bind(#[from] io::Error),
+    #[error(transparent)]
+    Dtls(#[from] webrtc_dtls::Error),
+    #[error(transparent)]
+    Webrtc(#[from] webrtc_util::Error),
+    #[error("not connected")]
+    NotConnected,
+    #[error("emulation is disabled on the target device")]
+    TargetEmulationDisabled,
+    #[error("Connection timed out")]
+    Timeout,
+}
+
+const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
+
+async fn connect(
+    addr: SocketAddr,
+    cert: Certificate,
+) -> Result<(Arc<dyn Conn + Sync + Send>, SocketAddr), (SocketAddr, LanMouseConnectionError)> {
+    log::info!("connecting to {addr} ...");
+    let conn = Arc::new(
+        UdpSocket::bind("0.0.0.0:0")
+            .await
+            .map_err(|e| (addr, e.into()))?,
+    );
+    conn.connect(addr).await.map_err(|e| (addr, e.into()))?;
+    let config = Config {
+        certificates: vec![cert],
+        server_name: "ignored".to_owned(),
+        insecure_skip_verify: true,
+        extended_master_secret: ExtendedMasterSecretType::Require,
+        ..Default::default()
+    };
+    let timeout = tokio::time::sleep(DEFAULT_CONNECTION_TIMEOUT);
+    tokio::select! {
+        _ = timeout => Err((addr, LanMouseConnectionError::Timeout)),
+        result = DTLSConn::new(conn, config, true, None) => match result {
+            Ok(dtls_conn) => Ok((Arc::new(dtls_conn), addr)),
+            Err(e) => Err((addr, e.into())),
+        }
+    }
+}
+
+async fn connect_any(
+    addrs: &[SocketAddr],
+    cert: Certificate,
+) -> Result<(Arc<dyn Conn + Send + Sync>, SocketAddr), LanMouseConnectionError> {
+    let mut joinset = JoinSet::new();
+    for &addr in addrs {
+        joinset.spawn_local(connect(addr, cert.clone()));
+    }
+    loop {
+        match joinset.join_next().await {
+            None => return Err(LanMouseConnectionError::NotConnected),
+            Some(r) => match r.expect("join error") {
+                Ok(conn) => return Ok(conn),
+                Err((a, e)) => {
+                    log::warn!("failed to connect to {a}: `{e}`")
+                }
+            },
+        };
+    }
+}
+
+pub(crate) struct LanMouseConnection {
+    cert: Certificate,
+    client_manager: ClientManager,
+    conns: Rc<Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>>,
+    connecting: Rc<Mutex<HashSet<ClientHandle>>>,
+    recv_rx: Receiver<(ClientHandle, ProtoEvent)>,
+    recv_tx: Sender<(ClientHandle, ProtoEvent)>,
+    ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
+}
+
+impl LanMouseConnection {
+    pub(crate) fn new(cert: Certificate, client_manager: ClientManager) -> Self {
+        let (recv_tx, recv_rx) = channel();
+        Self {
+            cert,
+            client_manager,
+            conns: Default::default(),
+            connecting: Default::default(),
+            recv_rx,
+            recv_tx,
+            ping_response: Default::default(),
+        }
+    }
+
+    pub(crate) async fn recv(&mut self) -> (ClientHandle, ProtoEvent) {
+        self.recv_rx.recv().await.expect("channel closed")
+    }
+
+    pub(crate) async fn send(
+        &self,
+        event: ProtoEvent,
+        handle: ClientHandle,
+    ) -> Result<(), LanMouseConnectionError> {
+        let (buf, len): ([u8; MAX_EVENT_SIZE], usize) = event.into();
+        let buf = &buf[..len];
+        if let Some(addr) = self.client_manager.active_addr(handle) {
+            let conn = {
+                let conns = self.conns.lock().await;
+                conns.get(&addr).cloned()
+            };
+            if let Some(conn) = conn {
+                if !self.client_manager.alive(handle) {
+                    return Err(LanMouseConnectionError::TargetEmulationDisabled);
+                }
+                match conn.send(buf).await {
+                    Ok(_) => {}
+                    Err(e) => {
+                        log::warn!("client {handle} failed to send: {e}");
+                        disconnect(&self.client_manager, handle, addr, &self.conns).await;
+                    }
+                }
+                log::trace!("{event} >->->->->- {addr}");
+                return Ok(());
+            }
+        }
+
+        // check if we are already trying to connect
+        let mut connecting = self.connecting.lock().await;
+        if !connecting.contains(&handle) {
+            connecting.insert(handle);
+            // connect in the background
+            spawn_local(connect_to_handle(
+                self.client_manager.clone(),
+                self.cert.clone(),
+                handle,
+                self.conns.clone(),
+                self.connecting.clone(),
+                self.recv_tx.clone(),
+                self.ping_response.clone(),
+            ));
+        }
+        Err(LanMouseConnectionError::NotConnected)
+    }
+}
+
+async fn connect_to_handle(
+    client_manager: ClientManager,
+    cert: Certificate,
+    handle: ClientHandle,
+    conns: Rc<Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>>,
+    connecting: Rc<Mutex<HashSet<ClientHandle>>>,
+    tx: Sender<(ClientHandle, ProtoEvent)>,
+    ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
+) -> Result<(), LanMouseConnectionError> {
+    log::info!("client {handle} connecting ...");
+    // sending did not work, figure out active conn.
+    if let Some(addrs) = client_manager.get_ips(handle) {
+        let port = client_manager.get_port(handle).unwrap_or(DEFAULT_PORT);
+        let addrs = addrs
+            .into_iter()
+            .map(|a| SocketAddr::new(a, port))
+            .collect::<Vec<_>>();
+        log::info!("client ({handle}) connecting ... (ips: {addrs:?})");
+        let res = connect_any(&addrs, cert).await;
+        let (conn, addr) = match res {
+            Ok(c) => c,
+            Err(e) => {
+                connecting.lock().await.remove(&handle);
+                return Err(e);
+            }
+        };
+        log::info!("client ({handle}) connected @ {addr}");
+        client_manager.set_active_addr(handle, Some(addr));
+        conns.lock().await.insert(addr, conn.clone());
+        connecting.lock().await.remove(&handle);
+
+        // poll connection for active
+        spawn_local(ping_pong(addr, conn.clone(), ping_response.clone()));
+
+        // receiver
+        spawn_local(receive_loop(
+            client_manager,
+            handle,
+            addr,
+            conn,
+            conns,
+            tx,
+            ping_response.clone(),
+        ));
+        return Ok(());
+    }
+    connecting.lock().await.remove(&handle);
+    Err(LanMouseConnectionError::NotConnected)
+}
+
+async fn ping_pong(
+    addr: SocketAddr,
+    conn: Arc<dyn Conn + Send + Sync>,
+    ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
+) {
+    loop {
+        let (buf, len) = ProtoEvent::Ping.into();
+        if let Err(e) = conn.send(&buf[..len]).await {
+            log::warn!("{addr}: send error `{e}`, closing connection");
+            let _ = conn.close().await;
+            break;
+        }
+        log::trace!("PING >->->->->- {addr}");
+
+        tokio::time::sleep(Duration::from_millis(500)).await;
+
+        if !ping_response.borrow_mut().remove(&addr) {
+            log::warn!("{addr} did not respond, closing connection");
+            let _ = conn.close().await;
+            return;
+        }
+    }
+}
+
+async fn receive_loop(
+    client_manager: ClientManager,
+    handle: ClientHandle,
+    addr: SocketAddr,
+    conn: Arc<dyn Conn + Send + Sync>,
+    conns: Rc<Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>>,
+    tx: Sender<(ClientHandle, ProtoEvent)>,
+    ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
+) {
+    let mut buf = [0u8; MAX_EVENT_SIZE];
+    while conn.recv(&mut buf).await.is_ok() {
+        if let Ok(event) = buf.try_into() {
+            log::trace!("{addr} <==<==<== {event}");
+            match event {
+                ProtoEvent::Pong(b) => {
+                    client_manager.set_active_addr(handle, Some(addr));
+                    client_manager.set_alive(handle, b);
+                    ping_response.borrow_mut().insert(addr);
+                }
+                event => tx.send((handle, event)).expect("channel closed"),
+            }
+        }
+    }
+    log::warn!("recv error");
+    disconnect(&client_manager, handle, addr, &conns).await;
+}
+
+async fn disconnect(
+    client_manager: &ClientManager,
+    handle: ClientHandle,
+    addr: SocketAddr,
+    conns: &Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>,
+) {
+    log::warn!("client ({handle}) @ {addr} connection closed");
+    conns.lock().await.remove(&addr);
+    client_manager.set_active_addr(handle, None);
+    let active: Vec<SocketAddr> = conns.lock().await.keys().copied().collect();
+    log::info!("active connections: {active:?}");
+}

src/crypto.rs

@@ -0,0 +1,71 @@
+use std::fs;
+use std::io::{self, BufWriter, Read, Write};
+use std::path::Path;
+use std::{fs::File, io::BufReader};
+
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+
+use sha2::{Digest, Sha256};
+use thiserror::Error;
+use webrtc_dtls::crypto::Certificate;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    #[error(transparent)]
+    Dtls(#[from] webrtc_dtls::Error),
+}
+
+pub fn generate_fingerprint(cert: &[u8]) -> String {
+    let mut hash = Sha256::new();
+    hash.update(cert);
+    let bytes = hash
+        .finalize()
+        .iter()
+        .map(|x| format!("{x:02x}"))
+        .collect::<Vec<_>>();
+    bytes.join(":").to_lowercase()
+}
+
+pub fn certificate_fingerprint(cert: &Certificate) -> String {
+    let certificate = cert.certificate.first().expect("certificate missing");
+    generate_fingerprint(certificate)
+}
+
+/// load certificate from file
+pub fn load_certificate(path: &Path) -> Result<Certificate, Error> {
+    let f = File::open(path)?;
+
+    let mut reader = BufReader::new(f);
+    let mut pem = String::new();
+    reader.read_to_string(&mut pem)?;
+    Ok(Certificate::from_pem(pem.as_str())?)
+}
+
+pub(crate) fn load_or_generate_key_and_cert(path: &Path) -> Result<Certificate, Error> {
+    if path.exists() && path.is_file() {
+        Ok(load_certificate(path)?)
+    } else {
+        generate_key_and_cert(path)
+    }
+}
+
+pub(crate) fn generate_key_and_cert(path: &Path) -> Result<Certificate, Error> {
+    let cert = Certificate::generate_self_signed(["ignored".to_owned()])?;
+    let serialized = cert.serialize_pem();
+    let parent = path.parent().expect("is a path");
+    fs::create_dir_all(parent)?;
+    let f = File::create(path)?;
+    #[cfg(unix)]
+    {
+        let mut perm = f.metadata()?.permissions();
+        perm.set_mode(0o400); /* r-- --- --- */
+        f.set_permissions(perm)?;
+    }
+    /* FIXME windows permissions */
+    let mut writer = BufWriter::new(f);
+    writer.write_all(serialized.as_bytes())?;
+    Ok(cert)
+}

src/dns.rs

@@ -1,63 +1,117 @@
-use local_channel::mpsc::Receiver;
-use std::net::IpAddr;
+use std::{collections::HashMap, net::IpAddr};
+
+use local_channel::mpsc::{channel, Receiver, Sender};
+use tokio::task::{spawn_local, JoinHandle};
 
 use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
+use tokio_util::sync::CancellationToken;
 
-use crate::server::Server;
 use lan_mouse_ipc::ClientHandle;
 
 pub(crate) struct DnsResolver {
+    cancellation_token: CancellationToken,
+    task: Option<JoinHandle<()>>,
+    request_tx: Sender<DnsRequest>,
+    event_rx: Receiver<DnsEvent>,
+}
+
+struct DnsRequest {
+    handle: ClientHandle,
+    hostname: String,
+}
+
+pub(crate) enum DnsEvent {
+    Resolving(ClientHandle),
+    Resolved(ClientHandle, String, Result<Vec<IpAddr>, ResolveError>),
+}
+
+struct DnsTask {
     resolver: TokioAsyncResolver,
-    dns_request: Receiver<ClientHandle>,
+    request_rx: Receiver<DnsRequest>,
+    event_tx: Sender<DnsEvent>,
+    cancellation_token: CancellationToken,
+    active_tasks: HashMap<ClientHandle, JoinHandle<()>>,
 }
 
 impl DnsResolver {
-    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
+    pub(crate) fn new() -> Result<Self, ResolveError> {
         let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
-        Ok(Self {
+        let (request_tx, request_rx) = channel();
+        let (event_tx, event_rx) = channel();
+        let cancellation_token = CancellationToken::new();
+        let dns_task = DnsTask {
+            active_tasks: Default::default(),
             resolver,
-            dns_request,
+            request_rx,
+            event_tx,
+            cancellation_token: cancellation_token.clone(),
+        };
+        let task = Some(spawn_local(dns_task.run()));
+        Ok(Self {
+            cancellation_token,
+            task,
+            event_rx,
+            request_tx,
         })
     }
 
-    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) fn resolve(&self, handle: ClientHandle, hostname: String) {
+        let request = DnsRequest { handle, hostname };
+        self.request_tx.send(request).expect("channel closed");
     }
 
-    pub(crate) async fn run(mut self, server: Server) {
+    pub(crate) async fn event(&mut self) -> DnsEvent {
+        self.event_rx.recv().await.expect("channel closed")
+    }
+
+    pub(crate) async fn terminate(&mut self) {
+        self.cancellation_token.cancel();
+        self.task.take().expect("task").await.expect("join error");
+    }
+}
+
+impl DnsTask {
+    async fn run(mut self) {
+        let cancellation_token = self.cancellation_token.clone();
         tokio::select! {
-            _ = server.cancelled() => {},
-            _ = self.do_dns(&server) => {},
+            _ = self.do_dns() => {},
+            _ = cancellation_token.cancelled() => {},
         }
     }
 
-    async fn do_dns(&mut self, server: &Server) {
-        loop {
-            let handle = self.dns_request.recv().await.expect("channel closed");
+    async fn do_dns(&mut self) {
+        while let Some(dns_request) = self.request_rx.recv().await {
+            let DnsRequest { handle, hostname } = dns_request;
 
-            /* 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![]
+            /* abort previous dns task */
+            let previous_task = self.active_tasks.remove(&handle);
+            if let Some(task) = previous_task {
+                if !task.is_finished() {
+                    task.abort();
                 }
-            };
+            }
 
-            server.update_dns_ips(handle, ips);
-            server.set_resolving(handle, false);
+            self.event_tx
+                .send(DnsEvent::Resolving(handle))
+                .expect("channel closed");
+
+            /* spawn task for dns request */
+            let event_tx = self.event_tx.clone();
+            let resolver = self.resolver.clone();
+            let cancellation_token = self.cancellation_token.clone();
+
+            let task = tokio::task::spawn_local(async move {
+                tokio::select! {
+                    ips = resolver.lookup_ip(&hostname) => {
+                       let ips = ips.map(|ips| ips.iter().collect::<Vec<_>>());
+                       event_tx
+                           .send(DnsEvent::Resolved(handle, hostname, ips))
+                           .expect("channel closed");
+                    }
+                    _ = cancellation_token.cancelled() => {},
+                }
+            });
+            self.active_tasks.insert(handle, task);
         }
     }
 }

src/emulation.rs

@@ -0,0 +1,407 @@
+use crate::listen::{LanMouseListener, ListenerCreationError};
+use futures::StreamExt;
+use input_emulation::{EmulationHandle, InputEmulation, InputEmulationError};
+use input_event::Event;
+use lan_mouse_proto::{Position, ProtoEvent};
+use local_channel::mpsc::{channel, Receiver, Sender};
+use std::{
+    cell::Cell,
+    collections::HashMap,
+    net::SocketAddr,
+    rc::Rc,
+    time::{Duration, Instant},
+};
+use tokio::{
+    select,
+    task::{spawn_local, JoinHandle},
+};
+
+/// emulation handling events received from a listener
+pub(crate) struct Emulation {
+    task: JoinHandle<()>,
+    request_tx: Sender<EmulationRequest>,
+    event_rx: Receiver<EmulationEvent>,
+}
+
+pub(crate) enum EmulationEvent {
+    /// new connection
+    Connected {
+        /// address of the connection
+        addr: SocketAddr,
+        /// position of the connection
+        pos: lan_mouse_ipc::Position,
+        /// certificate fingerprint of the connection
+        fingerprint: String,
+    },
+    /// connection closed
+    Disconnected { addr: SocketAddr },
+    /// the port of the listener has changed
+    PortChanged(Result<u16, ListenerCreationError>),
+    /// emulation was disabled
+    EmulationDisabled,
+    /// emulation was enabled
+    EmulationEnabled,
+    /// capture should be released
+    ReleaseNotify,
+}
+
+enum EmulationRequest {
+    Reenable,
+    Release(SocketAddr),
+    ChangePort(u16),
+    Terminate,
+}
+
+impl Emulation {
+    pub(crate) fn new(
+        backend: Option<input_emulation::Backend>,
+        listener: LanMouseListener,
+    ) -> Self {
+        let emulation_proxy = EmulationProxy::new(backend);
+        let (request_tx, request_rx) = channel();
+        let (event_tx, event_rx) = channel();
+        let emulation_task = ListenTask {
+            listener,
+            emulation_proxy,
+            request_rx,
+            event_tx,
+        };
+        let task = spawn_local(emulation_task.run());
+        Self {
+            task,
+            request_tx,
+            event_rx,
+        }
+    }
+
+    pub(crate) fn send_leave_event(&self, addr: SocketAddr) {
+        self.request_tx
+            .send(EmulationRequest::Release(addr))
+            .expect("channel closed");
+    }
+
+    pub(crate) fn reenable(&self) {
+        self.request_tx
+            .send(EmulationRequest::Reenable)
+            .expect("channel closed");
+    }
+
+    pub(crate) fn request_port_change(&self, port: u16) {
+        self.request_tx
+            .send(EmulationRequest::ChangePort(port))
+            .expect("channel closed")
+    }
+
+    pub(crate) async fn event(&mut self) -> EmulationEvent {
+        self.event_rx.recv().await.expect("channel closed")
+    }
+
+    /// wait for termination
+    pub(crate) async fn terminate(&mut self) {
+        log::debug!("terminating emulation");
+        self.request_tx
+            .send(EmulationRequest::Terminate)
+            .expect("channel closed");
+        if let Err(e) = (&mut self.task).await {
+            log::warn!("{e}");
+        }
+    }
+}
+
+struct ListenTask {
+    listener: LanMouseListener,
+    emulation_proxy: EmulationProxy,
+    request_rx: Receiver<EmulationRequest>,
+    event_tx: Sender<EmulationEvent>,
+}
+
+impl ListenTask {
+    async fn run(mut self) {
+        let mut interval = tokio::time::interval(Duration::from_secs(5));
+        let mut last_response = HashMap::new();
+        loop {
+            select! {
+                e = self.listener.next() =>  {
+                    let (event, addr) = match e {
+                        Some(e) => e,
+                        None => break,
+                    };
+                    log::trace!("{event} <-<-<-<-<- {addr}");
+                    last_response.insert(addr, Instant::now());
+                    match event {
+                        ProtoEvent::Enter(pos) => {
+                            if let Some(fingerprint) = self.listener.get_certificate_fingerprint(addr).await {
+                                log::info!("releasing capture: {addr} entered this device");
+                                self.event_tx.send(EmulationEvent::ReleaseNotify).expect("channel closed");
+                                self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                                self.event_tx.send(EmulationEvent::Connected{addr, pos: to_ipc_pos(pos), fingerprint}).expect("channel closed");
+                            }
+                        }
+                        ProtoEvent::Leave(_) => {
+                            self.emulation_proxy.remove(addr);
+                            self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                        }
+                        ProtoEvent::Input(event) => self.emulation_proxy.consume(event, addr),
+                        ProtoEvent::Ping => self.listener.reply(addr, ProtoEvent::Pong(self.emulation_proxy.emulation_active.get())).await,
+                        _ => {}
+                    }
+                }
+                event = self.emulation_proxy.event() => {
+                    self.event_tx.send(event).expect("channel closed");
+                }
+                request = self.request_rx.recv() => match request.expect("channel closed") {
+                    // reenable emulation
+                    EmulationRequest::Reenable => self.emulation_proxy.reenable(),
+                    // notify the other end that we hit a barrier (should release capture)
+                    EmulationRequest::Release(addr) => self.listener.reply(addr, ProtoEvent::Leave(0)).await,
+                    EmulationRequest::ChangePort(port) => {
+                        self.listener.request_port_change(port);
+                        let result = self.listener.port_changed().await;
+                        self.event_tx.send(EmulationEvent::PortChanged(result)).expect("channel closed");
+                    }
+                    EmulationRequest::Terminate => break,
+                },
+                _ = interval.tick() => {
+                    last_response.retain(|&addr,instant| {
+                        if instant.elapsed() > Duration::from_secs(1) {
+                            log::warn!("releasing keys: {addr} not responding!");
+                            self.emulation_proxy.remove(addr);
+                            self.event_tx.send(EmulationEvent::Disconnected { addr }).expect("channel closed");
+                            false
+                        } else {
+                            true
+                        }
+                    });
+                }
+            }
+        }
+        self.listener.terminate().await;
+        self.emulation_proxy.terminate().await;
+    }
+}
+
+/// proxy handling the actual input emulation,
+/// discarding events when it is disabled
+pub(crate) struct EmulationProxy {
+    emulation_active: Rc<Cell<bool>>,
+    exit_requested: Rc<Cell<bool>>,
+    request_tx: Sender<ProxyRequest>,
+    event_rx: Receiver<EmulationEvent>,
+    task: JoinHandle<()>,
+}
+
+enum ProxyRequest {
+    Input(Event, SocketAddr),
+    Remove(SocketAddr),
+    Terminate,
+    Reenable,
+}
+
+impl EmulationProxy {
+    fn new(backend: Option<input_emulation::Backend>) -> Self {
+        let (request_tx, request_rx) = channel();
+        let (event_tx, event_rx) = channel();
+        let emulation_active = Rc::new(Cell::new(false));
+        let exit_requested = Rc::new(Cell::new(false));
+        let emulation_task = EmulationTask {
+            backend,
+            exit_requested: exit_requested.clone(),
+            request_rx,
+            event_tx,
+            handles: Default::default(),
+            next_id: 0,
+        };
+        let task = spawn_local(emulation_task.run());
+        Self {
+            emulation_active,
+            exit_requested,
+            request_tx,
+            task,
+            event_rx,
+        }
+    }
+
+    async fn event(&mut self) -> EmulationEvent {
+        let event = self.event_rx.recv().await.expect("channel closed");
+        if let EmulationEvent::EmulationEnabled = event {
+            self.emulation_active.replace(true);
+        }
+        if let EmulationEvent::EmulationDisabled = event {
+            self.emulation_active.replace(false);
+        }
+        event
+    }
+
+    fn consume(&self, event: Event, addr: SocketAddr) {
+        // ignore events if emulation is currently disabled
+        if self.emulation_active.get() {
+            self.request_tx
+                .send(ProxyRequest::Input(event, addr))
+                .expect("channel closed");
+        }
+    }
+
+    fn remove(&self, addr: SocketAddr) {
+        self.request_tx
+            .send(ProxyRequest::Remove(addr))
+            .expect("channel closed");
+    }
+
+    fn reenable(&self) {
+        self.request_tx
+            .send(ProxyRequest::Reenable)
+            .expect("channel closed");
+    }
+
+    async fn terminate(&mut self) {
+        self.exit_requested.replace(true);
+        self.request_tx
+            .send(ProxyRequest::Terminate)
+            .expect("channel closed");
+        let _ = (&mut self.task).await;
+    }
+}
+
+struct EmulationTask {
+    backend: Option<input_emulation::Backend>,
+    exit_requested: Rc<Cell<bool>>,
+    request_rx: Receiver<ProxyRequest>,
+    event_tx: Sender<EmulationEvent>,
+    handles: HashMap<SocketAddr, EmulationHandle>,
+    next_id: EmulationHandle,
+}
+
+impl EmulationTask {
+    async fn run(mut self) {
+        loop {
+            if let Err(e) = self.do_emulation().await {
+                log::warn!("input emulation exited: {e}");
+            }
+            if self.exit_requested.get() {
+                break;
+            }
+            // wait for reenable request
+            loop {
+                match self.request_rx.recv().await.expect("channel closed") {
+                    ProxyRequest::Reenable => break,
+                    ProxyRequest::Terminate => return,
+                    ProxyRequest::Input(..) => { /* emulation inactive => ignore */ }
+                    ProxyRequest::Remove(..) => { /* emulation inactive => ignore */ }
+                }
+            }
+        }
+    }
+
+    async fn do_emulation(&mut self) -> Result<(), InputEmulationError> {
+        log::info!("creating input emulation ...");
+        let mut emulation = tokio::select! {
+            r = InputEmulation::new(self.backend) => r?,
+            // allow termination event while requesting input emulation
+            _ = wait_for_termination(&mut self.request_rx) => return Ok(()),
+        };
+
+        // used to send enabled and disabled events
+        let _emulation_guard = DropGuard::new(
+            self.event_tx.clone(),
+            EmulationEvent::EmulationEnabled,
+            EmulationEvent::EmulationDisabled,
+        );
+
+        // create active handles
+        if let Err(e) = self.create_clients(&mut emulation).await {
+            emulation.terminate().await;
+            return Err(e);
+        }
+
+        let res = self.do_emulation_session(&mut emulation).await;
+        // FIXME replace with async drop when stabilized
+        emulation.terminate().await;
+        res
+    }
+
+    async fn create_clients(
+        &mut self,
+        emulation: &mut InputEmulation,
+    ) -> Result<(), InputEmulationError> {
+        for handle in self.handles.values() {
+            tokio::select! {
+                _ = emulation.create(*handle) => {},
+                _ = wait_for_termination(&mut self.request_rx) => return Ok(()),
+            }
+        }
+        Ok(())
+    }
+
+    async fn do_emulation_session(
+        &mut self,
+        emulation: &mut InputEmulation,
+    ) -> Result<(), InputEmulationError> {
+        loop {
+            tokio::select! {
+                e = self.request_rx.recv() => match e.expect("channel closed") {
+                    ProxyRequest::Input(event, addr) => {
+                        let handle = match self.handles.get(&addr) {
+                            Some(&handle) => handle,
+                            None => {
+                                let handle = self.next_id;
+                                self.next_id += 1;
+                                emulation.create(handle).await;
+                                self.handles.insert(addr, handle);
+                                handle
+                            }
+                        };
+                        emulation.consume(event, handle).await?;
+                    },
+                    ProxyRequest::Remove(addr) => {
+                        if let Some(handle) = self.handles.remove(&addr) {
+                            emulation.destroy(handle).await;
+                        }
+                    }
+                    ProxyRequest::Terminate => break Ok(()),
+                    ProxyRequest::Reenable => continue,
+                },
+            }
+        }
+    }
+}
+
+fn to_ipc_pos(pos: Position) -> lan_mouse_ipc::Position {
+    match pos {
+        Position::Left => lan_mouse_ipc::Position::Left,
+        Position::Right => lan_mouse_ipc::Position::Right,
+        Position::Top => lan_mouse_ipc::Position::Top,
+        Position::Bottom => lan_mouse_ipc::Position::Bottom,
+    }
+}
+
+async fn wait_for_termination(rx: &mut Receiver<ProxyRequest>) {
+    loop {
+        match rx.recv().await.expect("channel closed") {
+            ProxyRequest::Terminate => return,
+            ProxyRequest::Input(_, _) => continue,
+            ProxyRequest::Remove(_) => continue,
+            ProxyRequest::Reenable => continue,
+        }
+    }
+}
+
+struct DropGuard<T> {
+    tx: Sender<T>,
+    on_drop: Option<T>,
+}
+
+impl<T> DropGuard<T> {
+    fn new(tx: Sender<T>, on_new: T, on_drop: T) -> Self {
+        tx.send(on_new).expect("channel closed");
+        let on_drop = Some(on_drop);
+        Self { tx, on_drop }
+    }
+}
+
+impl<T> Drop for DropGuard<T> {
+    fn drop(&mut self) {
+        self.tx
+            .send(self.on_drop.take().expect("item"))
+            .expect("channel closed");
+    }
+}

src/lib.rs

@@ -1,7 +1,11 @@
+mod capture;
+pub mod capture_test;
 pub mod client;
 pub mod config;
-pub mod dns;
-pub mod server;
-
-pub mod capture_test;
+mod connect;
+mod crypto;
+mod dns;
+mod emulation;
 pub mod emulation_test;
+mod listen;
+pub mod service;

src/listen.rs

@@ -0,0 +1,224 @@
+use futures::{Stream, StreamExt};
+use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
+use local_channel::mpsc::{channel, Receiver, Sender};
+use rustls::pki_types::CertificateDer;
+use std::{
+    collections::HashMap,
+    net::SocketAddr,
+    rc::Rc,
+    sync::{Arc, RwLock},
+    time::Duration,
+};
+use thiserror::Error;
+use tokio::{
+    sync::Mutex,
+    task::{spawn_local, JoinHandle},
+};
+use webrtc_dtls::{
+    config::{ClientAuthType::RequireAnyClientCert, Config, ExtendedMasterSecretType},
+    conn::DTLSConn,
+    crypto::Certificate,
+    listener::listen,
+};
+use webrtc_util::{conn::Listener, Conn, Error};
+
+use crate::crypto;
+
+#[derive(Error, Debug)]
+pub enum ListenerCreationError {
+    #[error(transparent)]
+    WebrtcUtil(#[from] webrtc_util::Error),
+    #[error(transparent)]
+    WebrtcDtls(#[from] webrtc_dtls::Error),
+}
+
+type ArcConn = Arc<dyn Conn + Send + Sync>;
+
+pub(crate) struct LanMouseListener {
+    listen_rx: Receiver<(ProtoEvent, SocketAddr)>,
+    listen_tx: Sender<(ProtoEvent, SocketAddr)>,
+    listen_task: JoinHandle<()>,
+    conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
+    request_port_change: Sender<u16>,
+    port_changed: Receiver<Result<u16, ListenerCreationError>>,
+}
+
+type VerifyPeerCertificateFn = Arc<
+    dyn (Fn(&[Vec<u8>], &[CertificateDer<'static>]) -> Result<(), webrtc_dtls::Error>)
+        + Send
+        + Sync,
+>;
+
+impl LanMouseListener {
+    pub(crate) async fn new(
+        port: u16,
+        cert: Certificate,
+        authorized_keys: Arc<RwLock<HashMap<String, String>>>,
+    ) -> Result<Self, ListenerCreationError> {
+        let (listen_tx, listen_rx) = channel();
+        let (request_port_change, mut request_port_change_rx) = channel();
+        let (port_changed_tx, port_changed) = channel();
+
+        let authorized = authorized_keys.clone();
+        let verify_peer_certificate: Option<VerifyPeerCertificateFn> = Some(Arc::new(
+            move |certs: &[Vec<u8>], _chains: &[CertificateDer<'static>]| {
+                assert!(certs.len() == 1);
+                let fingerprints = certs
+                    .iter()
+                    .map(|c| crypto::generate_fingerprint(c))
+                    .collect::<Vec<_>>();
+                if authorized
+                    .read()
+                    .expect("lock")
+                    .contains_key(&fingerprints[0])
+                {
+                    Ok(())
+                } else {
+                    Err(webrtc_dtls::Error::ErrVerifyDataMismatch)
+                }
+            },
+        ));
+        let cfg = Config {
+            certificates: vec![cert.clone()],
+            extended_master_secret: ExtendedMasterSecretType::Require,
+            client_auth: RequireAnyClientCert,
+            verify_peer_certificate,
+            ..Default::default()
+        };
+
+        let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
+        let mut listener = listen(listen_addr, cfg.clone()).await?;
+
+        let conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>> = Rc::new(Mutex::new(Vec::new()));
+
+        let conns_clone = conns.clone();
+        let tx = listen_tx.clone();
+        let listen_task: JoinHandle<()> = spawn_local(async move {
+            loop {
+                let sleep = tokio::time::sleep(Duration::from_secs(2));
+                tokio::select! {
+                    /* workaround for https://github.com/webrtc-rs/webrtc/issues/614 */
+                    _ = sleep => continue,
+                    c = listener.accept() => match c {
+                        Ok((conn, addr)) => {
+                            log::info!("dtls client connected, ip: {addr}");
+                            let mut conns = conns_clone.lock().await;
+                            conns.push((addr, conn.clone()));
+                            spawn_local(read_loop(conns_clone.clone(), addr, conn, tx.clone()));
+                        },
+                        Err(e) => log::warn!("accept: {e}"),
+                    },
+                    port = request_port_change_rx.recv() => {
+                        let port = port.expect("channel closed");
+                        let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
+                        match listen(listen_addr, cfg.clone()).await {
+                            Ok(new_listener) => {
+                                let _ = listener.close().await;
+                                listener = new_listener;
+                                port_changed_tx.send(Ok(port)).expect("channel closed");
+                            }
+                            Err(e) => {
+                                log::warn!("unable to change port: {e}");
+                                port_changed_tx.send(Err(e.into())).expect("channel closed");
+                            }
+                        };
+                    },
+                };
+            }
+        });
+
+        Ok(Self {
+            conns,
+            listen_rx,
+            listen_tx,
+            listen_task,
+            port_changed,
+            request_port_change,
+        })
+    }
+
+    pub(crate) fn request_port_change(&mut self, port: u16) {
+        self.request_port_change.send(port).expect("channel closed");
+    }
+
+    pub(crate) async fn port_changed(&mut self) -> Result<u16, ListenerCreationError> {
+        self.port_changed.recv().await.expect("channel closed")
+    }
+
+    pub(crate) async fn terminate(&mut self) {
+        self.listen_task.abort();
+        let conns = self.conns.lock().await;
+        for (_, conn) in conns.iter() {
+            let _ = conn.close().await;
+        }
+        self.listen_tx.close();
+    }
+
+    pub(crate) async fn reply(&self, addr: SocketAddr, event: ProtoEvent) {
+        log::trace!("reply {event} >=>=>=>=>=> {addr}");
+        let (buf, len): ([u8; MAX_EVENT_SIZE], usize) = event.into();
+        let conns = self.conns.lock().await;
+        for (a, conn) in conns.iter() {
+            if *a == addr {
+                let _ = conn.send(&buf[..len]).await;
+            }
+        }
+    }
+
+    pub(crate) async fn get_certificate_fingerprint(&self, addr: SocketAddr) -> Option<String> {
+        if let Some(conn) = self
+            .conns
+            .lock()
+            .await
+            .iter()
+            .find(|(a, _)| *a == addr)
+            .map(|(_, c)| c.clone())
+        {
+            let conn: &DTLSConn = conn.as_any().downcast_ref().expect("dtls conn");
+            let certs = conn.connection_state().await.peer_certificates;
+            let cert = certs.first()?;
+            let fingerprint = crypto::generate_fingerprint(cert);
+            Some(fingerprint)
+        } else {
+            None
+        }
+    }
+}
+
+impl Stream for LanMouseListener {
+    type Item = (ProtoEvent, SocketAddr);
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        self.listen_rx.poll_next_unpin(cx)
+    }
+}
+
+async fn read_loop(
+    conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
+    addr: SocketAddr,
+    conn: ArcConn,
+    dtls_tx: Sender<(ProtoEvent, SocketAddr)>,
+) -> Result<(), Error> {
+    let mut b = [0u8; MAX_EVENT_SIZE];
+
+    while conn.recv(&mut b).await.is_ok() {
+        match b.try_into() {
+            Ok(event) => dtls_tx.send((event, addr)).expect("channel closed"),
+            Err(e) => {
+                log::warn!("error receiving event: {e}");
+                break;
+            }
+        }
+    }
+    log::info!("dtls client disconnected {:?}", addr);
+    let mut conns = conns.lock().await;
+    let index = conns
+        .iter()
+        .position(|(a, _)| *a == addr)
+        .expect("connection not found");
+    conns.remove(index);
+    Ok(())
+}

src/main.rs

@@ -5,9 +5,9 @@ use lan_mouse::{
     capture_test,
     config::{Config, ConfigError, Frontend},
     emulation_test,
-    server::{Server, ServiceError},
+    service::{Service, ServiceError},
 };
-use lan_mouse_ipc::IpcError;
+use lan_mouse_ipc::{IpcError, IpcListenerCreationError};
 use std::{
     future::Future,
     io,
@@ -32,7 +32,7 @@ enum LanMouseError {
     Emulation(#[from] InputEmulationError),
 }
 
-pub fn main() {
+fn main() {
     // init logging
     let env = Env::default().filter_or("LAN_MOUSE_LOG_LEVEL", "info");
     env_logger::init_from_env(env);
@@ -46,16 +46,18 @@ pub fn main() {
 fn run() -> Result<(), LanMouseError> {
     // parse config file + cli args
     let config = Config::new()?;
-    log::debug!("{config:?}");
-    log::info!("release bind: {:?}", config.release_bind);
-
     if config.test_capture {
         run_async(capture_test::run(config))?;
     } else if config.test_emulation {
         run_async(emulation_test::run(config))?;
     } else if config.daemon {
         // if daemon is specified we run the service
-        run_async(run_service(config))?;
+        match run_async(run_service(config)) {
+            Err(LanMouseError::Service(ServiceError::IpcListen(
+                IpcListenerCreationError::AlreadyRunning,
+            ))) => log::info!("service already running!"),
+            r => r?,
+        }
     } else {
         //  otherwise start the service as a child process and
         //  run a frontend
@@ -100,8 +102,10 @@ fn start_service() -> Result<Child, io::Error> {
 }
 
 async fn run_service(config: Config) -> Result<(), ServiceError> {
+    log::info!("using config: {:?}", config.path);
     log::info!("Press {:?} to release the mouse", config.release_bind);
-    Server::new(config).run().await?;
+    let mut service = Service::new(config).await?;
+    service.run().await?;
     log::info!("service exited!");
     Ok(())
 }

src/server.rs

@@ -1,562 +0,0 @@
-use capture_task::CaptureRequest;
-use emulation_task::EmulationRequest;
-use futures::StreamExt;
-use hickory_resolver::error::ResolveError;
-use local_channel::mpsc::{channel, Sender};
-use log;
-use std::{
-    cell::{Cell, RefCell},
-    collections::{HashSet, VecDeque},
-    io,
-    net::{IpAddr, SocketAddr},
-    rc::Rc,
-};
-use thiserror::Error;
-use tokio::{join, signal, sync::Notify};
-use tokio_util::sync::CancellationToken;
-
-use crate::{client::ClientManager, config::Config, dns::DnsResolver};
-
-use lan_mouse_ipc::{
-    AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
-    ListenerCreationError, Position, Status,
-};
-
-mod capture_task;
-mod emulation_task;
-mod network_task;
-mod ping_task;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum State {
-    /// Currently sending events to another device
-    Sending,
-    /// Currently receiving events from other devices
-    Receiving,
-    /// Entered the deadzone of another device but waiting
-    /// for acknowledgement (Leave event) from the device
-    AwaitAck,
-}
-
-#[derive(Debug, Error)]
-pub enum ServiceError {
-    #[error(transparent)]
-    Dns(#[from] ResolveError),
-    #[error(transparent)]
-    Listen(#[from] ListenerCreationError),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-}
-
-#[derive(Clone)]
-pub struct Server {
-    active_client: Rc<Cell<Option<ClientHandle>>>,
-    pub(crate) client_manager: Rc<RefCell<ClientManager>>,
-    port: Rc<Cell<u16>>,
-    state: Rc<Cell<State>>,
-    release_bind: Vec<input_event::scancode::Linux>,
-    notifies: Rc<Notifies>,
-    config: Rc<Config>,
-    pending_frontend_events: Rc<RefCell<VecDeque<FrontendEvent>>>,
-    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,
-    cancel: CancellationToken,
-}
-
-impl Server {
-    pub fn new(config: Config) -> Self {
-        let active_client = Rc::new(Cell::new(None));
-        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() {
-            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())),
-            capture_status: Default::default(),
-            emulation_status: Default::default(),
-        }
-    }
-
-    pub async fn run(&mut self) -> Result<(), ServiceError> {
-        // create frontend communication adapter, exit if already running
-        let mut frontend = match AsyncFrontendListener::new().await {
-            Ok(f) => f,
-            Err(ListenerCreationError::AlreadyRunning) => {
-                log::info!("service already running, exiting");
-                return Ok(());
-            }
-            e => e?,
-        };
-
-        let (capture_tx, capture_rx) = channel(); /* requests for input capture */
-        let (emulation_tx, emulation_rx) = channel(); /* emulation requests */
-        let (udp_recv_tx, udp_recv_rx) = channel(); /* udp receiver */
-        let (udp_send_tx, udp_send_rx) = channel(); /* udp sender */
-        let (dns_tx, dns_rx) = channel(); /* dns requests */
-
-        let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
-        let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
-        let emulation =
-            emulation_task::new(self.clone(), emulation_rx, udp_recv_rx, udp_send_tx.clone());
-        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 ping = ping_task::new(
-            self.clone(),
-            udp_send_tx.clone(),
-            emulation_tx.clone(),
-            capture_tx.clone(),
-        );
-
-        for handle in self.active_clients() {
-            dns_tx.send(handle).expect("channel closed");
-        }
-
-        loop {
-            tokio::select! {
-                request = frontend.next() => {
-                    let request = match request {
-                        Some(Ok(r)) => r,
-                        Some(Err(e)) => {
-                            log::error!("error receiving request: {e}");
-                            continue;
-                        }
-                        None => break,
-                    };
-                    log::debug!("handle frontend request: {request:?}");
-                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request, &dns_tx);
-                }
-                _ = 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.cancelled() => break,
-                r = signal::ctrl_c() => {
-                    r.expect("failed to wait for CTRL+C");
-                    break;
-                }
-            }
-        }
-
-        log::info!("terminating service");
-
-        self.cancel();
-        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) {
-        log::info!("received capture enable request");
-        self.notifies.capture.notify_waiters()
-    }
-
-    async fn capture_enabled(&self) {
-        self.notifies.capture.notified().await
-    }
-
-    fn notify_emulation(&self) {
-        log::info!("received emulation enable request");
-        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) {
-        self.notify_frontend(FrontendEvent::Changed(handle));
-    }
-
-    fn active_clients(&self) -> Vec<ClientHandle> {
-        self.client_manager
-            .borrow()
-            .get_client_states()
-            .filter(|(_, (_, s))| s.active)
-            .map(|(h, _)| h)
-            .collect()
-    }
-
-    fn handle_request(
-        &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        event: FrontendRequest,
-        dns: &Sender<ClientHandle>,
-    ) -> bool {
-        log::debug!("frontend: {event:?}");
-        match event {
-            FrontendRequest::EnableCapture => self.notify_capture(),
-            FrontendRequest::EnableEmulation => self.notify_emulation(),
-            FrontendRequest::Create => {
-                self.add_client();
-            }
-            FrontendRequest::Activate(handle, active) => {
-                if active {
-                    self.activate_client(capture, emulate, handle);
-                } else {
-                    self.deactivate_client(capture, emulate, handle);
-                }
-            }
-            FrontendRequest::ChangePort(port) => self.request_port_change(port),
-            FrontendRequest::Delete(handle) => {
-                self.remove_client(capture, emulate, handle);
-                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),
-            FrontendRequest::UpdateHostname(handle, host) => {
-                self.update_hostname(handle, host, dns)
-            }
-            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
-            FrontendRequest::UpdatePosition(handle, pos) => {
-                self.update_pos(handle, capture, emulate, pos)
-            }
-            FrontendRequest::ResolveDns(handle) => dns.send(handle).expect("channel closed"),
-            FrontendRequest::Sync => {
-                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));
-            }
-        };
-        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));
-    }
-
-    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
-    }
-
-    fn deactivate_client(
-        &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        handle: ClientHandle,
-    ) {
-        match self.client_manager.borrow_mut().get_mut(handle) {
-            None => return,
-            Some((_, s)) if !s.active => return,
-            Some((_, s)) => s.active = false,
-        };
-
-        let _ = capture.send(CaptureRequest::Destroy(handle));
-        let _ = emulate.send(EmulationRequest::Destroy(handle));
-        self.client_updated(handle);
-        log::info!("deactivated client {handle}");
-    }
-
-    fn activate_client(
-        &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        handle: ClientHandle,
-    ) {
-        /* deactivate potential other client at this position */
-        let pos = match self.client_manager.borrow().get(handle) {
-            None => return,
-            Some((_, s)) if s.active => return,
-            Some((client, _)) => client.pos,
-        };
-
-        let other = self.client_manager.borrow_mut().find_client(pos);
-        if let Some(other) = other {
-            self.deactivate_client(capture, emulate, other);
-        }
-
-        /* 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, to_capture_pos(pos)));
-        let _ = emulate.send(EmulationRequest::Create(handle));
-
-        self.client_updated(handle);
-
-        log::info!("activated client {handle} ({pos})");
-    }
-
-    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));
-            let _ = emulate.send(EmulationRequest::Destroy(handle));
-        }
-    }
-
-    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);
-        self.client_updated(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);
-        self.client_updated(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>,
-        dns: &Sender<ClientHandle>,
-    ) {
-        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.active_addr = None;
-            s.dns_ips.clear();
-            drop(client_manager);
-            self.update_ips(handle);
-            dns.send(handle).expect("channel closed");
-        }
-        self.client_updated(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));
-        }
-    }
-
-    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;
-            if changed {
-                log::info!("update pos {handle} {} -> {}", c.pos, pos);
-            }
-            c.pos = pos;
-            (changed, s.active)
-        };
-
-        // update state in event input emulator & input capture
-        if changed {
-            self.deactivate_client(capture, emulate, handle);
-            if active {
-                self.activate_client(capture, emulate, handle);
-            }
-        }
-    }
-
-    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: ClientHandle) -> 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<ClientHandle>) {
-        log::debug!("active client => {handle:?}");
-        self.active_client.replace(handle);
-    }
-
-    fn active_addr(&self, handle: ClientHandle) -> Option<SocketAddr> {
-        self.client_manager
-            .borrow()
-            .get(handle)
-            .and_then(|(_, s)| s.active_addr)
-    }
-}
-
-fn to_capture_pos(pos: Position) -> input_capture::Position {
-    match pos {
-        Position::Left => input_capture::Position::Left,
-        Position::Right => input_capture::Position::Right,
-        Position::Top => input_capture::Position::Top,
-        Position::Bottom => input_capture::Position::Bottom,
-    }
-}

src/server/capture_task.rs

@@ -1,206 +0,0 @@
-use futures::StreamExt;
-use lan_mouse_proto::ProtoEvent;
-use local_channel::mpsc::{Receiver, Sender};
-use std::net::SocketAddr;
-
-use tokio::{process::Command, task::JoinHandle};
-
-use input_capture::{
-    self, CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
-};
-
-use crate::server::State;
-use lan_mouse_ipc::{ClientHandle, Status};
-
-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<(ProtoEvent, 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<(ProtoEvent, 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<(ProtoEvent, 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, to_capture_pos(pos)).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<(ProtoEvent, SocketAddr)>,
-    event: (CaptureHandle, CaptureEvent),
-) -> Result<(), CaptureError> {
-    let (handle, event) = event;
-    log::trace!("({handle}) {event:?}");
-
-    // capture started
-    if event == CaptureEvent::Begin {
-        // wait for remote to acknowlegde enter
-        server.set_state(State::AwaitAck);
-        server.set_active(Some(handle));
-        // restart ping timer to release capture if unreachable
-        server.restart_ping_timer();
-        // spawn enter hook cmd
-        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 => match event {
-                CaptureEvent::Begin => ProtoEvent::Enter(0),
-                CaptureEvent::Input(e) => ProtoEvent::Input(e),
-            },
-            /* send additional enter events until acknowleged */
-            State::AwaitAck => ProtoEvent::Enter(0),
-            /* released capture */
-            State::Receiving => ProtoEvent::Leave(0),
-        };
-        sender_tx.send((event, addr)).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}"),
-        }
-    });
-}
-
-fn to_capture_pos(pos: lan_mouse_ipc::Position) -> input_capture::Position {
-    match pos {
-        lan_mouse_ipc::Position::Left => input_capture::Position::Left,
-        lan_mouse_ipc::Position::Right => input_capture::Position::Right,
-        lan_mouse_ipc::Position::Top => input_capture::Position::Top,
-        lan_mouse_ipc::Position::Bottom => input_capture::Position::Bottom,
-    }
-}

src/server/emulation_task.rs

@@ -1,188 +0,0 @@
-use local_channel::mpsc::{Receiver, Sender};
-use std::net::SocketAddr;
-
-use lan_mouse_proto::ProtoEvent;
-use tokio::task::JoinHandle;
-
-use lan_mouse_ipc::ClientHandle;
-
-use crate::{client::ClientManager, server::State};
-use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
-use lan_mouse_ipc::Status;
-
-use super::{network_task::NetworkError, 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<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
-) -> JoinHandle<()> {
-    let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx);
-    tokio::task::spawn_local(emulation_task)
-}
-
-async fn emulation_task(
-    server: Server,
-    mut rx: Receiver<EmulationRequest>,
-    mut udp_rx: Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
-) {
-    loop {
-        if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_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<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-) -> 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).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<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-) -> 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_incoming_event(server, 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_incoming_event(
-    server: &Server,
-    emulate: &mut InputEmulation,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-    last_ignored: &mut Option<SocketAddr>,
-    event: (ProtoEvent, 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) {
-        (ProtoEvent::Pong, _) => { /* ignore pong events */ }
-        (ProtoEvent::Ping, addr) => {
-            let _ = sender_tx.send((ProtoEvent::Pong, addr));
-        }
-        (ProtoEvent::Leave(_), _) => emulate.release_keys(handle).await?,
-        (ProtoEvent::Ack(_), _) => server.set_state(State::Sending),
-        (ProtoEvent::Enter(_), _) => {
-            server.set_state(State::Receiving);
-            sender_tx
-                .send((ProtoEvent::Ack(0), addr))
-                .expect("no channel")
-        }
-        (ProtoEvent::Input(e), _) => {
-            if let State::Receiving = server.get_state() {
-                log::trace!("{event} => emulate");
-                emulate.consume(e, 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();
-                }
-            }
-        }
-    }
-    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/network_task.rs

@@ -1,99 +0,0 @@
-use local_channel::mpsc::{Receiver, Sender};
-use std::{io, net::SocketAddr};
-
-use thiserror::Error;
-use tokio::{net::UdpSocket, task::JoinHandle};
-
-use super::Server;
-use lan_mouse_proto::{ProtoEvent, ProtocolError};
-
-pub(crate) async fn new(
-    server: Server,
-    udp_recv_tx: Sender<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    udp_send_rx: Receiver<(ProtoEvent, 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?;
-
-    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! {
-                _ = 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 */
-            }
-        }
-    }))
-}
-
-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<(ProtoEvent, SocketAddr), NetworkError>>,
-) {
-    loop {
-        let event = receive_event(socket).await;
-        receiver_tx.send(event).expect("channel closed");
-    }
-}
-
-async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(ProtoEvent, 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<(ProtoEvent, SocketAddr), NetworkError> {
-    let mut buf = [0u8; lan_mouse_proto::MAX_EVENT_SIZE];
-    let (_len, src) = socket.recv_from(&mut buf).await?;
-    let event = ProtoEvent::try_from(buf)?;
-    Ok((event, src))
-}
-
-fn send_event(sock: &UdpSocket, e: ProtoEvent, addr: SocketAddr) -> Result<usize, NetworkError> {
-    log::trace!("{:20} ------>->->-> {addr}", e.to_string());
-    let (data, len): ([u8; lan_mouse_proto::MAX_EVENT_SIZE], usize) = e.into();
-    // When udp blocks, we dont want to block the event loop.
-    // Dropping events is better than potentially crashing the input capture.
-    Ok(sock.try_send_to(&data[..len], addr)?)
-}

src/server/ping_task.rs

@@ -1,138 +0,0 @@
-use std::{net::SocketAddr, time::Duration};
-
-use lan_mouse_proto::ProtoEvent;
-use local_channel::mpsc::Sender;
-use tokio::task::JoinHandle;
-
-use lan_mouse_ipc::ClientHandle;
-
-use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State};
-
-const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);
-
-pub(crate) fn new(
-    server: Server,
-    sender_ch: Sender<(ProtoEvent, SocketAddr)>,
-    emulate_notify: Sender<EmulationRequest>,
-    capture_notify: Sender<CaptureRequest>,
-) -> JoinHandle<()> {
-    // timer task
-    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<(ProtoEvent, SocketAddr)>,
-    emulate_notify: Sender<EmulationRequest>,
-    capture_notify: Sender<CaptureRequest>,
-) {
-    loop {
-        // wait for wake up signal
-        server.ping_timer_notified().await;
-        loop {
-            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()
-                        .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()
-                };
-
-                // get relevant socket addrs for clients
-                let ping_addrs: Vec<SocketAddr> = {
-                    ping_clients
-                        .iter()
-                        .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()
-                };
-
-                // 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((ProtoEvent::Ping, addr)).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));
-                }
-            } 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);
-                }
-            }
-        }
-    }
-}

src/service.rs

@@ -0,0 +1,513 @@
+use crate::{
+    capture::{Capture, CaptureType, ICaptureEvent},
+    client::ClientManager,
+    config::Config,
+    connect::LanMouseConnection,
+    crypto,
+    dns::{DnsEvent, DnsResolver},
+    emulation::{Emulation, EmulationEvent},
+    listen::{LanMouseListener, ListenerCreationError},
+};
+use futures::StreamExt;
+use hickory_resolver::error::ResolveError;
+use lan_mouse_ipc::{
+    AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
+    IpcError, IpcListenerCreationError, Position, Status,
+};
+use log;
+use std::{
+    collections::{HashMap, HashSet, VecDeque},
+    io,
+    net::{IpAddr, SocketAddr},
+    sync::{Arc, RwLock},
+};
+use thiserror::Error;
+use tokio::{process::Command, signal, sync::Notify};
+
+#[derive(Debug, Error)]
+pub enum ServiceError {
+    #[error(transparent)]
+    Dns(#[from] ResolveError),
+    #[error(transparent)]
+    IpcListen(#[from] IpcListenerCreationError),
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    #[error(transparent)]
+    ListenError(#[from] ListenerCreationError),
+    #[error("failed to load certificate: `{0}`")]
+    Certificate(#[from] crypto::Error),
+}
+
+pub struct Service {
+    /// input capture
+    capture: Capture,
+    /// input emulation
+    emulation: Emulation,
+    /// dns resolver
+    resolver: DnsResolver,
+    /// frontend listener
+    frontend_listener: AsyncFrontendListener,
+    /// authorized public key sha256 fingerprints
+    authorized_keys: Arc<RwLock<HashMap<String, String>>>,
+    /// (outgoing) client information
+    client_manager: ClientManager,
+    /// current port
+    port: u16,
+    /// the public key fingerprint for (D)TLS
+    public_key_fingerprint: String,
+    /// notify for pending frontend events
+    frontend_event_pending: Notify,
+    /// frontend events queued for sending
+    pending_frontend_events: VecDeque<FrontendEvent>,
+    /// status of input capture (enabled / disabled)
+    capture_status: Status,
+    /// status of input emulation (enabled / disabled)
+    emulation_status: Status,
+    /// keep track of registered connections to avoid duplicate barriers
+    incoming_conns: HashSet<SocketAddr>,
+    /// map from capture handle to connection info
+    incoming_conn_info: HashMap<ClientHandle, Incoming>,
+    next_trigger_handle: u64,
+}
+
+#[derive(Debug)]
+struct Incoming {
+    fingerprint: String,
+    addr: SocketAddr,
+    pos: Position,
+}
+
+impl Service {
+    pub async fn new(config: Config) -> Result<Self, ServiceError> {
+        let client_manager = ClientManager::default();
+        for client in config.get_clients() {
+            let config = ClientConfig {
+                hostname: client.hostname,
+                fix_ips: client.ips.into_iter().collect(),
+                port: client.port,
+                pos: client.pos,
+                cmd: client.enter_hook,
+            };
+            let state = ClientState {
+                active: client.active,
+                ips: HashSet::from_iter(config.fix_ips.iter().cloned()),
+                ..Default::default()
+            };
+            let handle = client_manager.add_client();
+            client_manager.set_config(handle, config);
+            client_manager.set_state(handle, state);
+        }
+
+        // load certificate
+        let cert = crypto::load_or_generate_key_and_cert(&config.cert_path)?;
+        let public_key_fingerprint = crypto::certificate_fingerprint(&cert);
+
+        // create frontend communication adapter, exit if already running
+        let frontend_listener = AsyncFrontendListener::new().await?;
+
+        let authorized_keys = Arc::new(RwLock::new(config.authorized_fingerprints.clone()));
+        // listener + connection
+        let listener =
+            LanMouseListener::new(config.port, cert.clone(), authorized_keys.clone()).await?;
+        let conn = LanMouseConnection::new(cert.clone(), client_manager.clone());
+
+        // input capture + emulation
+        let capture_backend = config.capture_backend.map(|b| b.into());
+        let capture = Capture::new(capture_backend, conn, config.release_bind.clone());
+        let emulation_backend = config.emulation_backend.map(|b| b.into());
+        let emulation = Emulation::new(emulation_backend, listener);
+
+        // create dns resolver
+        let resolver = DnsResolver::new()?;
+
+        let port = config.port;
+        let service = Self {
+            capture,
+            emulation,
+            frontend_listener,
+            resolver,
+            authorized_keys,
+            public_key_fingerprint,
+            client_manager,
+            frontend_event_pending: Default::default(),
+            port,
+            pending_frontend_events: Default::default(),
+            capture_status: Default::default(),
+            emulation_status: Default::default(),
+            incoming_conn_info: Default::default(),
+            incoming_conns: Default::default(),
+            next_trigger_handle: 0,
+        };
+        Ok(service)
+    }
+
+    pub async fn run(&mut self) -> Result<(), ServiceError> {
+        for handle in self.client_manager.active_clients() {
+            // small hack: `activate_client()` checks, if the client
+            // is already active in client_manager and does not create a
+            // capture barrier in that case so we have to deactivate it first
+            self.client_manager.deactivate_client(handle);
+            self.activate_client(handle);
+        }
+
+        loop {
+            tokio::select! {
+                request = self.frontend_listener.next() => self.handle_frontend_request(request),
+                _ = self.frontend_event_pending.notified() => self.handle_frontend_pending().await,
+                event = self.emulation.event() => self.handle_emulation_event(event),
+                event = self.capture.event() => self.handle_capture_event(event),
+                event = self.resolver.event() => self.handle_resolver_event(event),
+                r = signal::ctrl_c() => break r.expect("failed to wait for CTRL+C"),
+            }
+        }
+
+        log::info!("terminating service ...");
+        log::debug!("terminating capture ...");
+        self.capture.terminate().await;
+        log::debug!("terminating emulation ...");
+        self.emulation.terminate().await;
+        log::debug!("terminating dns resolver ...");
+        self.resolver.terminate().await;
+
+        Ok(())
+    }
+
+    fn handle_frontend_request(&mut self, request: Option<Result<FrontendRequest, IpcError>>) {
+        let request = match request.expect("frontend listener closed") {
+            Ok(r) => r,
+            Err(e) => return log::error!("error receiving request: {e}"),
+        };
+        match request {
+            FrontendRequest::Activate(handle, active) => self.set_client_active(handle, active),
+            FrontendRequest::AuthorizeKey(desc, fp) => self.add_authorized_key(desc, fp),
+            FrontendRequest::ChangePort(port) => self.change_port(port),
+            FrontendRequest::Create => self.add_client(),
+            FrontendRequest::Delete(handle) => self.remove_client(handle),
+            FrontendRequest::EnableCapture => self.capture.reenable(),
+            FrontendRequest::EnableEmulation => self.emulation.reenable(),
+            FrontendRequest::Enumerate() => self.enumerate(),
+            FrontendRequest::GetState(handle) => self.broadcast_client(handle),
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
+            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, pos),
+            FrontendRequest::ResolveDns(handle) => self.resolve(handle),
+            FrontendRequest::Sync => self.sync_frontend(),
+            FrontendRequest::RemoveAuthorizedKey(key) => self.remove_authorized_key(key),
+        }
+    }
+
+    async fn handle_frontend_pending(&mut self) {
+        while let Some(event) = self.pending_frontend_events.pop_front() {
+            self.frontend_listener.broadcast(event).await;
+        }
+    }
+
+    fn handle_emulation_event(&mut self, event: EmulationEvent) {
+        match event {
+            EmulationEvent::Connected {
+                addr,
+                pos,
+                fingerprint,
+            } => {
+                // check if already registered
+                if !self.incoming_conns.contains(&addr) {
+                    self.add_incoming(addr, pos, fingerprint.clone());
+                    self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
+                } else {
+                    self.update_incoming(addr, pos, fingerprint);
+                }
+            }
+            EmulationEvent::Disconnected { addr } => {
+                if let Some(addr) = self.remove_incoming(addr) {
+                    self.notify_frontend(FrontendEvent::IncomingDisconnected(addr));
+                }
+            }
+            EmulationEvent::PortChanged(port) => match port {
+                Ok(port) => {
+                    self.port = port;
+                    self.notify_frontend(FrontendEvent::PortChanged(port, None));
+                }
+                Err(e) => self
+                    .notify_frontend(FrontendEvent::PortChanged(self.port, Some(format!("{e}")))),
+            },
+            EmulationEvent::EmulationDisabled => {
+                self.emulation_status = Status::Disabled;
+                self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
+            }
+            EmulationEvent::EmulationEnabled => {
+                self.emulation_status = Status::Enabled;
+                self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
+            }
+            EmulationEvent::ReleaseNotify => self.capture.release(),
+        }
+    }
+
+    fn handle_capture_event(&mut self, event: ICaptureEvent) {
+        match event {
+            ICaptureEvent::CaptureBegin(handle) => {
+                // we entered the capture zone for an incoming connection
+                // => notify it that its capture should be released
+                if let Some(incoming) = self.incoming_conn_info.get(&handle) {
+                    self.emulation.send_leave_event(incoming.addr);
+                }
+            }
+            ICaptureEvent::CaptureDisabled => {
+                self.capture_status = Status::Disabled;
+                self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status));
+            }
+            ICaptureEvent::CaptureEnabled => {
+                self.capture_status = Status::Enabled;
+                self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status));
+            }
+            ICaptureEvent::ClientEntered(handle) => {
+                log::info!("entering client {handle} ...");
+                self.spawn_hook_command(handle);
+            }
+        }
+    }
+
+    fn handle_resolver_event(&mut self, event: DnsEvent) {
+        let handle = match event {
+            DnsEvent::Resolving(handle) => {
+                self.client_manager.set_resolving(handle, true);
+                handle
+            }
+            DnsEvent::Resolved(handle, hostname, ips) => {
+                self.client_manager.set_resolving(handle, false);
+                if let Err(e) = &ips {
+                    log::warn!("could not resolve {hostname}: {e}");
+                }
+                let ips = ips.unwrap_or_default();
+                self.client_manager.set_dns_ips(handle, ips);
+                handle
+            }
+        };
+        self.notify_frontend(FrontendEvent::Changed(handle));
+    }
+
+    fn resolve(&self, handle: ClientHandle) {
+        if let Some(hostname) = self.client_manager.get_hostname(handle) {
+            self.resolver.resolve(handle, hostname);
+        }
+    }
+
+    fn sync_frontend(&mut self) {
+        self.enumerate();
+        self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
+        self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status));
+        self.notify_frontend(FrontendEvent::PortChanged(self.port, None));
+        self.notify_frontend(FrontendEvent::PublicKeyFingerprint(
+            self.public_key_fingerprint.clone(),
+        ));
+        let keys = self.authorized_keys.read().expect("lock").clone();
+        self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
+    }
+
+    const ENTER_HANDLE_BEGIN: u64 = u64::MAX / 2 + 1;
+
+    fn add_incoming(&mut self, addr: SocketAddr, pos: Position, fingerprint: String) {
+        let handle = Self::ENTER_HANDLE_BEGIN + self.next_trigger_handle;
+        self.next_trigger_handle += 1;
+        self.capture.create(handle, pos, CaptureType::EnterOnly);
+        self.incoming_conns.insert(addr);
+        self.incoming_conn_info.insert(
+            handle,
+            Incoming {
+                fingerprint,
+                addr,
+                pos,
+            },
+        );
+    }
+
+    fn update_incoming(&mut self, addr: SocketAddr, pos: Position, fingerprint: String) {
+        let incoming = self
+            .incoming_conn_info
+            .iter_mut()
+            .find(|(_, i)| i.addr == addr)
+            .map(|(_, i)| i)
+            .expect("no such client");
+        let mut changed = false;
+        if incoming.fingerprint != fingerprint {
+            incoming.fingerprint = fingerprint.clone();
+            changed = true;
+        }
+        if incoming.pos != pos {
+            incoming.pos = pos;
+            changed = true;
+        }
+        if changed {
+            self.remove_incoming(addr);
+            self.add_incoming(addr, pos, fingerprint.clone());
+            self.notify_frontend(FrontendEvent::IncomingDisconnected(addr));
+            self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
+        }
+    }
+
+    fn remove_incoming(&mut self, addr: SocketAddr) -> Option<SocketAddr> {
+        let handle = self
+            .incoming_conn_info
+            .iter()
+            .find(|(_, incoming)| incoming.addr == addr)
+            .map(|(k, _)| *k)?;
+        self.capture.destroy(handle);
+        self.incoming_conns.remove(&addr);
+        self.incoming_conn_info
+            .remove(&handle)
+            .map(|incoming| incoming.addr)
+    }
+
+    fn notify_frontend(&mut self, event: FrontendEvent) {
+        self.pending_frontend_events.push_back(event);
+        self.frontend_event_pending.notify_one();
+    }
+
+    fn add_authorized_key(&mut self, desc: String, fp: String) {
+        self.authorized_keys.write().expect("lock").insert(fp, desc);
+        let keys = self.authorized_keys.read().expect("lock").clone();
+        self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
+    }
+
+    fn remove_authorized_key(&mut self, fp: String) {
+        self.authorized_keys.write().expect("lock").remove(&fp);
+        let keys = self.authorized_keys.read().expect("lock").clone();
+        self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
+    }
+
+    fn enumerate(&mut self) {
+        let clients = self.client_manager.get_client_states();
+        self.notify_frontend(FrontendEvent::Enumerate(clients));
+    }
+
+    fn add_client(&mut self) {
+        let handle = self.client_manager.add_client();
+        log::info!("added client {handle}");
+        let (c, s) = self.client_manager.get_state(handle).unwrap();
+        self.notify_frontend(FrontendEvent::Created(handle, c, s));
+    }
+
+    fn set_client_active(&mut self, handle: ClientHandle, active: bool) {
+        if active {
+            self.activate_client(handle);
+        } else {
+            self.deactivate_client(handle);
+        }
+    }
+
+    fn deactivate_client(&mut self, handle: ClientHandle) {
+        log::debug!("deactivating client {handle}");
+        if self.client_manager.deactivate_client(handle) {
+            self.capture.destroy(handle);
+            self.notify_frontend(FrontendEvent::Changed(handle));
+            log::info!("deactivated client {handle}");
+        }
+    }
+
+    fn activate_client(&mut self, handle: ClientHandle) {
+        log::debug!("activating client");
+
+        /* resolve dns on activate */
+        self.resolve(handle);
+
+        /* deactivate potential other client at this position */
+        let Some(pos) = self.client_manager.get_pos(handle) else {
+            return;
+        };
+
+        if let Some(other) = self.client_manager.client_at(pos) {
+            if other != handle {
+                self.deactivate_client(other);
+            }
+        }
+
+        /* activate the client */
+        if self.client_manager.activate_client(handle) {
+            /* notify capture and frontends */
+            self.capture.create(handle, pos, CaptureType::Default);
+            self.notify_frontend(FrontendEvent::Changed(handle));
+            log::info!("activated client {handle} ({pos})");
+        }
+    }
+
+    fn change_port(&mut self, port: u16) {
+        if self.port != port {
+            self.emulation.request_port_change(port);
+        } else {
+            self.notify_frontend(FrontendEvent::PortChanged(self.port, None));
+        }
+    }
+
+    fn remove_client(&mut self, handle: ClientHandle) {
+        if self
+            .client_manager
+            .remove_client(handle)
+            .map(|(_, s)| s.active)
+            .unwrap_or(false)
+        {
+            self.capture.destroy(handle);
+        }
+        self.notify_frontend(FrontendEvent::Deleted(handle));
+    }
+
+    fn update_fix_ips(&mut self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
+        self.client_manager.set_fix_ips(handle, fix_ips);
+        self.notify_frontend(FrontendEvent::Changed(handle));
+    }
+
+    fn update_hostname(&mut self, handle: ClientHandle, hostname: Option<String>) {
+        if self.client_manager.set_hostname(handle, hostname.clone()) {
+            self.resolve(handle);
+        }
+        self.notify_frontend(FrontendEvent::Changed(handle));
+    }
+
+    fn update_port(&mut self, handle: ClientHandle, port: u16) {
+        self.client_manager.set_port(handle, port);
+        self.notify_frontend(FrontendEvent::Changed(handle));
+    }
+
+    fn update_pos(&mut self, handle: ClientHandle, pos: Position) {
+        // update state in event input emulator & input capture
+        if self.client_manager.set_pos(handle, pos) {
+            self.deactivate_client(handle);
+            self.activate_client(handle);
+        }
+        self.notify_frontend(FrontendEvent::Changed(handle));
+    }
+
+    fn broadcast_client(&mut self, handle: ClientHandle) {
+        let event = self
+            .client_manager
+            .get_state(handle)
+            .map(|(c, s)| FrontendEvent::State(handle, c, s))
+            .unwrap_or(FrontendEvent::NoSuchClient(handle));
+        self.notify_frontend(event);
+    }
+
+    fn spawn_hook_command(&self, handle: ClientHandle) {
+        let Some(cmd) = self.client_manager.get_enter_cmd(handle) 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}"),
+            }
+        });
+    }
+}