extract frontend crate

2026-03-07 20:09:59 +03:00 · 2024-09-04 16:59:23 +02:00
90 changed files with 4533 additions and 8743 deletions
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -55,9 +55,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
@@ -84,60 +82,36 @@ jobs:
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: brew install gtk4 libadwaita
    - 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
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-    - 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: target/release/bundle/osx/lan-mouse-macos-intel.zip
+        path: lan-mouse-macos-intel

  macos-aarch64-release-build:
    runs-on: macos-14
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: brew install gtk4 libadwaita
    - 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
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-    - 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: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
+        path: lan-mouse-macos-aarch64

  pre-release:
    name: "Pre Release"
-    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
+    needs: [windows-release-build, linux-release-build, macos-release-build]
    runs-on: "ubuntu-latest"
    steps:
    - name: Download build artifacts
@@ -151,6 +125,6 @@ jobs:
        title: "Development Build"
        files: |
          lan-mouse-linux/lan-mouse
-          lan-mouse-macos-intel/lan-mouse-macos-intel.zip
-          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
+          lan-mouse-macos-intel/lan-mouse-macos-intel
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
          lan-mouse-windows/lan-mouse-windows.zip
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -66,9 +66,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
@@ -98,7 +96,7 @@ jobs:
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: brew install gtk4 libadwaita
    - name: Build
      run: cargo build --verbose
    - name: Run tests
@@ -107,30 +105,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
-        scripts/copy-macos-dylib.sh
-    - 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 (Intel)
-        path: target/debug/bundle/osx/Lan Mouse macOS (Intel).zip
+        name: lan-mouse-macos
+        path: target/debug/lan-mouse

  build-macos-aarch64:
    runs-on: macos-14
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: brew install gtk4 libadwaita
    - name: Build
      run: cargo build --verbose
    - name: Run tests
@@ -139,20 +125,8 @@ 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
-        scripts/copy-macos-dylib.sh
-    - 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 (ARM)
-        path: target/debug/bundle/osx/Lan Mouse macOS (ARM).zip
+        name: lan-mouse-macos-aarch64
+        path: target/debug/lan-mouse
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -3,7 +3,7 @@ name: "Tagged Release"
 on:
  push:
    tags:
-      - v**
+      - "v*"

 jobs:
  linux-release-build:
@@ -51,9 +51,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
@@ -80,71 +78,47 @@ jobs:
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: brew install gtk4 libadwaita
    - 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
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-    - 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.zip
-        path: target/release/bundle/osx/lan-mouse-macos-intel.zip
+        name: lan-mouse-macos-intel
+        path: lan-mouse-macos-intel

  macos-aarch64-release-build:
    runs-on: macos-14
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: brew install gtk4 libadwaita
    - 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
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-    - 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.zip
-        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
+        name: lan-mouse-macos-aarch64
+        path: lan-mouse-macos-aarch64

  tagged-release:
    name: "Tagged Release"
-    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
+    needs: [windows-release-build, linux-release-build, macos-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.zip
-          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
+          lan-mouse-macos-intel/lan-mouse-macos-intel
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
          lan-mouse-windows/lan-mouse-windows.zip
--- a/.gitignore
+++ b/.gitignore
@@ -4,11 +4,4 @@
 .vs/
 .vscode/
 .direnv/
-result
-*.pem
-*.csr
-extfile.conf
-
-# flatpak files
-.flatpak-builder
-repo
+result
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,31 +12,25 @@ members = [
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.10.0"
+version = "0.9.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"

 [profile.release]
-codegen-units = 1
-lto = "fat"
 strip = true
-panic = "abort"
-
-[build-dependencies]
-shadow-rs = "1.2.0"
+lto = "fat"

 [dependencies]
-input-event = { path = "input-event", version = "0.3.0" }
-input-emulation = { path = "input-emulation", version = "0.3.0", default-features = false }
-input-capture = { path = "input-capture", version = "0.3.0", default-features = false }
-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 = "1.2.0", features = ["metadata"] }
+input-event = { path = "input-event", version = "0.2.1" }
+input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
+input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
+lan-mouse-cli = { path = "lan-mouse-cli", version = "0.1.0" }
+lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.1.0", optional = true }
+lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.1.0" }
+lan-mouse-proto = { path = "lan-mouse-proto", version = "0.1.0" }

-hickory-resolver = "0.25.2"
+hickory-resolver = "0.24.1"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4.20"
@@ -55,42 +49,17 @@ tokio = { version = "1.32.0", features = [
 futures = "0.3.28"
 clap = { version = "4.4.11", features = ["derive"] }
 slab = "0.4.9"
-thiserror = "2.0.0"
+thiserror = "1.0.61"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"
-webrtc-dtls = { version = "0.12.0", features = ["pem"] }
-webrtc-util = "0.11.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"

 [features]
-default = [
-    "gtk",
-    "layer_shell_capture",
-    "x11_capture",
-    "libei_capture",
-    "wlroots_emulation",
-    "libei_emulation",
-    "rdp_emulation",
-    "x11_emulation",
-]
+default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
+wayland = ["input-capture/wayland", "input-emulation/wayland"]
+x11 = ["input-capture/x11", "input-emulation/x11"]
+xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
+libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
 gtk = ["dep:lan-mouse-gtk"]
-layer_shell_capture = ["input-capture/layer_shell"]
-x11_capture = ["input-capture/x11"]
-libei_capture = ["input-event/libei", "input-capture/libei"]
-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"
--- a/README.md
+++ b/README.md
@@ -1,64 +1,78 @@
 # Lan Mouse
-Lan Mouse is a *cross-platform* mouse and keyboard sharing software similar to universal-control on Apple devices.
-It allows for using multiple PCs via a single set of mouse and keyboard.
+Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices.
+It allows for using multiple pcs with a single set of mouse and keyboard.
 This is also known as a Software KVM switch.

-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 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.
-
-***blazingly fast™*** because it's written in rust.
+The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).

 - _Now with a gtk frontend_

 <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="/screenshots/dark.png?raw=true">
-    <source media="(prefers-color-scheme: light)" srcset="/screenshots/light.png?raw=true">
-    <img alt="Screenshot of Lan-Mouse" srcset="/screenshots/dark.png">
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
+    <source media="(prefers-color-scheme: light)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/d6318340-f811-4e16-9d6e-d1b79883c709">
+    <img alt="Screenshot of Lan-Mouse" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
 </picture>


-## Encryption
+Goal of this project is to be an open-source replacement for proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/).
+
+Focus lies on performance and a clean, manageable implementation that can easily be expanded to support additional backends like e.g. Android, iOS, ... .
+
+***blazingly fast™*** because it's written in rust.
+
+For an alternative (with slightly different goals) you may check out [Input Leap](https://github.com/input-leap).
+
+
+> [!WARNING]
+> Since this tool has gained a bit of popularity over the past couple of days:
+>
+> All network traffic is currently **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 for now
+> and I take no responsibility for any leakage of data!

-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

-Most current desktop environments and operating systems are fully supported, this includes
- GNOME >= 45
- KDE Plasma >= 6.1
- Most wlroots based compositors, including Sway (>= 1.8), Hyprland and Wayfire
- Windows
- MacOS
+The following table shows support for input emulation (to emulate events received from other clients) and
+input capture (to send events *to* other clients) on different operating systems:

-
-### Caveats / Known Issues
+| OS / Desktop Environment  | input emulation          | input capture                        |
+|---------------------------|--------------------------|--------------------------------------|
+| Wayland (wlroots)         | :heavy_check_mark:       | :heavy_check_mark:                   |
+| Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:                   |
+| Wayland (Gnome)           | :heavy_check_mark:       | :heavy_check_mark: (starting at GNOME 45) |
+| Windows                   | :heavy_check_mark:       | :heavy_check_mark:                   |
+| X11                       | :heavy_check_mark:       | WIP                                  |
+| MacOS                     | :heavy_check_mark:       | WIP                                  |

 > [!Important]
-> - **X11** currently only has support for input emulation, i.e. can only be used on the receiving end.
+> Gnome -> Sway only partially works (modifier events are not handled correctly)
+
+> [!Important]
+> **Wayfire**
 >
-> - **Sway / wlroots**: Wlroots based compositors without libei support on the receiving end currently do not handle modifier events on the client side.
-> This results in CTRL / SHIFT / ALT / SUPER keys not working with a sending device that is NOT using the `layer-shell` backend
->
-> - **Wayfire**: If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
+> If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
 > Otherwise input capture will not work.
->
-> - **Windows**: The mouse cursor will be invisible when sending input to a Windows system if
+
+> [!Important]
+> The mouse cursor will be invisible when sending input to a Windows system if
 > there is no real mouse connected to the machine.

-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
+### Install via cargo
+```sh
+cargo install lan-mouse
+```

-<details>
-    <summary>Arch Linux</summary>
+### Download from Releases
+Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
+
+For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
+
+### Arch Linux

 Lan Mouse can be installed from the [official repositories](https://archlinux.org/packages/extra/x86_64/lan-mouse/):

@@ -66,59 +80,39 @@ Lan Mouse can be installed from the [official repositories](https://archlinux.or
 pacman -S lan-mouse
 ```

-The prerelease version (following `main`) is available on the AUR:
+It is also available on the AUR:

 ```sh
+# git version (includes latest changes)
 paru -S lan-mouse-git
+
+# alternatively
+paru -S lan-mouse-bin
 ```
-</details>
-
-
-<details>
-    <summary>Nix (OS)</summary>

+### Nix
 - nixpkgs: [search.nixos.org](https://search.nixos.org/packages?channel=unstable&show=lan-mouse&from=0&size=50&sort=relevance&type=packages&query=lan-mouse)
 - flake: [README.md](./nix/README.md)
-</details>
-
-<details>
-    <summary>Fedora</summary>
-You can install Lan Mouse from the [Terra Repository](https://terra.fyralabs.com).


-After enabling Terra:
+### Manual Installation

+First make sure to [install the necessary dependencies](#installing-dependencies).
+
+Build in release mode:
 ```sh
-dnf install lan-mouse
+cargo build --release
 ```
-</details>

-<details>
-    <summary>MacOS</summary>
-
- Download the package for your Mac (Intel or ARM) from the releases page
- Unzip it
- Remove the quarantine with `xattr -rd com.apple.quarantine "Lan Mouse.app"`
- Launch the app
- Grant accessibility permissions in System Preferences
-
-</details>
-
-
-<details>
-    <summary>Manual Installation</summary>
-
-First make sure to [install the necessary dependencies](#installing-dependencies-for-development--compiling-from-source).
-
-Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
-For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies-for-development--compiling-from-source).
-
-Alternatively, the `lan-mouse` binary can be compiled from source (see below).
-
-### Installing desktop file, app icon and firewall rules (optional)
+Run directly:
 ```sh
-# install lan-mouse (replace path/to/ with the correct path)
-sudo cp path/to/lan-mouse /usr/local/bin/
+cargo run --release
+```
+
+Install the files:
+```sh
+# install lan-mouse
+sudo cp target/release/lan-mouse /usr/local/bin/

 # install app icon
 sudo mkdir -p /usr/local/share/icons/hicolor/scalable/apps
@@ -136,62 +130,33 @@ sudo cp firewall/lan-mouse.xml /etc/firewalld/services
 # -> enable the service in firewalld settings
 ```

-Instead of downloading from the releases, the `lan-mouse` binary
-can be easily compiled via cargo or nix:
+### Conditional Compilation

-### Compiling and installing manually:
-```sh
-# compile in release mode
-cargo build --release
+Currently only x11, wayland, windows and MacOS are supported backends.
+Depending on the toolchain used, support for other platforms is omitted
+automatically (it does not make sense to build a Windows `.exe` with
+support for x11 and wayland backends).

-# install lan-mouse
-sudo cp target/release/lan-mouse /usr/local/bin/
-```
+However one might still want to omit support for e.g. wayland, x11 or libei on
+a Linux system.

-### Compiling and installing via cargo:
-```sh
-# will end up in ~/.cargo/bin
-cargo install lan-mouse
-```
-
-### Compiling and installing via nix:
-```sh
-# you can find the executable in result/bin/lan-mouse
-nix-build
-```
-### Conditional compilation
-Support for other platforms is omitted automatically based on the active
-rust toolchain.
-
-Additionally, available backends and frontends can be configured manually via
+This is possible through
 [cargo features](https://doc.rust-lang.org/cargo/reference/features.html).

-E.g. if only support for sway is needed, the following command produces
-an executable with support for only the `layer-shell` capture backend
-and `wlroots` emulation backend:
+E.g. if only wayland support is needed, the following command produces
+an executable with just support for wayland:
 ```sh
-cargo build --no-default-features --features layer_shell_capture,wlroots_emulation
+cargo build --no-default-features --features wayland
 ```
 For a detailed list of available features, checkout the [Cargo.toml](./Cargo.toml)
-</details>


-
-
-## Installing Dependencies for Development / Compiling from Source
+## Installing Dependencies
 <details>
    <summary>MacOS</summary>

 ```sh
-# Install dependencies
-brew install libadwaita pkg-config imagemagick
-cargo install cargo-bundle
-# Create the macOS icon file
-scripts/makeicns.sh
-# Create the .app bundle
-cargo bundle
-# Copy all dynamic libraries into the bundle, and update the bundle to find them there
-scripts/copy-macos-dylib.sh
+brew install libadwaita
 ```
 </details>

@@ -218,24 +183,12 @@ sudo pacman -S libadwaita gtk libx11 libxtst
 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
-```
-</details>
-
 <details>
    <summary>Windows</summary>

+> [!NOTE]
+> This is only necessary when building lan-mouse from source. The windows release comes with precompiled gtk dlls.
+
 - First install [Rust](https://www.rust-lang.org/tools/install).

 - Then follow the instructions at [gtk-rs.org](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation_windows.html)
@@ -266,60 +219,47 @@ python -m pipx ensurepath
 pipx install gvsbuild

 # build gtk + libadwaita
-gvsbuild build gtk4 libadwaita librsvg adwaita-icon-theme
+gvsbuild build gtk4 libadwaita librsvg
 ```

 - **Make sure to add the directory** `C:\gtk-build\gtk\x64\release\bin`
 [**to the `PATH` environment variable**]((https://learn.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14))). Otherwise the project will fail to build.

 To avoid building GTK from source, it is possible to disable
-the gtk frontend (see conditional compilation).
+the gtk frontend (see conditional compilation below).
 </details>

 ## Usage
-<details>
-    <summary>Gtk Frontend</summary>
-
+### Gtk Frontend
 By default the gtk frontend will open when running `lan-mouse`.

-To connect a device you want to control, simply click the `Add` button and enter the hostname
-of the device.
+To add a new connection, simply click the `Add` button on *both* devices,
+enter the corresponding hostname and activate it.

-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:..."
+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.

-Authorized devices can be persisted using the configuration file (see [Configuration](#configuration)).
+### Command Line Interface
+The cli interface can be enabled using `--frontend cli` as commandline arguments.
+Type `help` to list the available commands.

-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>
-    <summary>Command Line Interface</summary>
-
-The cli interface can be accessed by passing `cli` as a commandline argument.
-Use
+E.g.:
 ```sh
-lan-mouse cli help
+$ cargo run --release -- --frontend cli
+(...)
+> connect <host> left|right|top|bottom
+(...)
+> list
+(...)
+> activate 0
 ```
- to list the available commands and
-```sh
-lan-mouse cli <cmd> help
-```
-for information on how to use a specific command.

-</details>
-
-<details>
-    <summary>Daemon Mode</summary>
-
-Lan Mouse can be launched in daemon mode to keep it running in the background (e.g. for use in a systemd-service).
-
-To do so, use the `daemon` subcommand:
+### Daemon
+Lan Mouse can be launched in daemon mode to keep it running in the background.
+To do so, add `--daemon` to the commandline args:

 ```sh
-lan-mouse daemon
+$ cargo run --release -- --daemon
 ```

 In order to start lan-mouse with a graphical session automatically,
@@ -332,7 +272,6 @@ cp service/lan-mouse.service ~/.config/systemd/user
 systemctl --user daemon-reload
 systemctl --user enable --now lan-mouse.service
 ```
-</details>

 ## Configuration
 To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.
@@ -343,7 +282,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 [input-event/src/scancode.rs#L172](input-event/src/scancode.rs#L176).
+> to their names in [src/scancode.rs#L172](src/scancode.rs#L172).
 > This is bound to change

 ```toml
@@ -354,16 +293,12 @@ release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]

 # optional port (defaults to 4242)
 port = 4242
-
-# 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"
+# # optional frontend -> defaults to gtk if available
+# # possible values are "cli" and "gtk" 
+# frontend = "gtk"

 # define a client on the right side with host name "iridium"
-[[clients]]
-# position (left | right | top | bottom)
-position = "right"
+[right]
 # hostname
 hostname = "iridium"
 # activate this client immediately when lan-mouse is started
@@ -372,8 +307,7 @@ activate_on_startup = true
 ips = ["192.168.178.156"]

 # define a client on the left side with IP address 192.168.178.189
-[[clients]]
-position = "left"
+[left]
 # The hostname is optional: When no hostname is specified,
 # at least one ip address needs to be specified.
 hostname = "thorium"
@@ -393,57 +327,109 @@ Where `left` can be either `left`, `right`, `top` or `bottom`.
 - [x] Liveness tracking: Automatically release keys, when server offline
 - [x] MacOS KeyCode Translation
 - [x] Libei Input Capture
- [x] MacOS Input Capture
- [x] Windows Input Capture
- [x] Encryption
 - [ ] X11 Input Capture
+- [ ] Windows Input Capture
+- [ ] MacOS Input Capture
 - [ ] Latency measurement and visualization
 - [ ] Bandwidth usage measurement and visualization
 - [ ] Clipboard support
+- [ ] *Encryption*
+
+## Protocol
+Currently *all* mouse and keyboard events are sent via **UDP** for performance reasons.
+Each event is sent as one single datagram, currently without any acknowledgement to guarantee 0% packet loss.
+This means, any packet that is lost results in a discarded mouse / key event, which is ignored for now.
+
+**UDP** also has the additional benefit that no reconnection logic is required.
+Any client can just go offline and it will simply start working again as soon as it comes back online.
+
+Additionally a tcp server is hosted for data that needs to be sent reliably (e.g. the keymap from the server or clipboard contents in the future) can be requested via a tcp connection.
+
+## Bandwidth considerations
+The most bandwidth is taken up by mouse events. A typical office mouse has a polling rate of 125Hz
+while gaming mice typically have a much higher polling rate of 1000Hz.
+A mouse Event consists of 21 Bytes:
+- 1 Byte for the event type enum,
+- 4 Bytes (u32) for the timestamp,
+- 8 Bytes (f64) for dx,
+- 8 Bytes (f64) for dy.
+
+Additionally the IP header with 20 Bytes and the udp header with 8 Bytes take up another 28 Byte.
+So in total there is 49 * 1000 Bytes/s for a 1000Hz gaming mouse.
+This makes for a bandwidth requirement of 392 kbit/s in total _even_ for a high end gaming mouse.
+So bandwidth is a non-issue.
+
+Larger data chunks, like the keymap are offered by the server via tcp listening on the same port.
+This way we dont need to implement any congestion control and leave this up to tcp.
+In the future this can be used for e.g. clipboard contents as well.
+
+## Packets per Second
+While on LAN the performance is great,
+some WIFI cards seem to struggle with the amount of packets per second,
+particularly on high-end gaming mice with 1000Hz+ polling rates.
+
+The plan is to implement a way of accumulating packets and sending them as
+one single key event to reduce the packet rate (basically reducing the polling
+rate artificially).
+
+The way movement data is currently sent is also quite wasteful since even a 16bit integer
+is likely enough to represent even the fastest possible mouse movement.
+A different encoding that is more efficient for smaller values like
+[Protocol Buffers](https://protobuf.dev/programming-guides/encoding/)
+would be a better choice for the future and could also help for WIFI connections.
+
+## Security
+Sending key and mouse event data over the local network might not be the biggest security concern but in any public network or business environment it's *QUITE* a problem to basically broadcast your keystrokes.
+- There should be an encryption layer below the application to enable a secure link.
+- The encryption keys could be generated by the graphical frontend.


-## Detailed OS Support
+## Wayland support
+### Input Emulation (for receiving events)
+On wayland input-emulation is in an early/unstable state as of writing this.

-In order to use a device for sending events, an **input-capture** backend is required, while receiving events requires
-a supported **input-emulation** *and* **input-capture** backend.
+For this reason a suitable backend is chosen based on the active desktop environment / compositor.

-A suitable backend is chosen automatically based on the active desktop environment / compositor.
+Different compositors have different ways of enabling input emulation:

-The following sections detail the emulation and capture backends provided by lan-mouse and their support in desktop environments / operating systems.
+#### Wlroots
+Most wlroots-based compositors like Hyprland and Sway support the following
+unstable wayland protocols for keyboard and mouse emulation:
+- [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1)
+- [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1)

-### Input Emulation Support
+#### KDE
+KDE also has a protocol for input emulation ([kde-fake-input](https://wayland.app/protocols/kde-fake-input)),
+it is however not exposed to third party applications.

-| 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: |
+The recommended way to emulate input on KDE is the
+[freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop).

- `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.
- `xdp`: This backend uses the [freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop) and is supported on GNOME and Plasma.
- `x11`: Backend for X11 sessions.
- `windows`: Backend for Windows.
- `macos`: Backend for MacOS.
+#### Gnome
+Gnome uses [libei](https://gitlab.freedesktop.org/libinput/libei) for input emulation and capture,
+which has the goal to become the general approach for emulating and capturing Input on Wayland.

+### Input capture

+To capture mouse and keyboard input, a few things are necessary:
+- Displaying an immovable surface at screen edges
+- Locking the mouse in place
+- (optionally but highly recommended) reading unaccelerated mouse input

-### Input Capture Support
+|  Required Protocols  (Event Emitting)  | Sway               | Kwin                 | Gnome                |
+|----------------------------------------|--------------------|----------------------|----------------------|
+| pointer-constraints-unstable-v1        | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| relative-pointer-unstable-v1           | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| keyboard-shortcuts-inhibit-unstable-v1 | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| wlr-layer-shell-unstable-v1            | :heavy_check_mark: | :heavy_check_mark:   | :x:                  |

-| 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 |
+The [zwlr\_virtual\_pointer\_manager\_v1](wlr-virtual-pointer-unstable-v1) is required
+to display surfaces on screen edges and used to display the immovable window on
+both wlroots based compositors and KDE.
+
+Gnome unfortunately does not support this protocol
+and [likely won't ever support it](https://gitlab.gnome.org/GNOME/gnome-shell/-/issues/1141).
+
+~In order for layershell surfaces to be able to lock the pointer using the pointer\_constraints protocol [this patch](https://github.com/swaywm/sway/pull/7178) needs to be applied to sway.~
+(this works natively on sway versions >= 1.8)

- `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)
--- a/build-aux/de.feschber.LanMouse.yml
+++ b/build-aux/de.feschber.LanMouse.yml
@@ -1,50 +0,0 @@
-# yaml-language-server: $schema=https://raw.githubusercontent.com/flatpak/flatpak-builder/refs/heads/main/data/flatpak-manifest.schema.json
-app-id: de.feschber.LanMouse
-runtime: org.gnome.Platform
-runtime-version: "48"
-sdk: org.gnome.Sdk
-sdk-extensions:
-  - org.freedesktop.Sdk.Extension.rust-stable
-  - org.freedesktop.Sdk.Extension.llvm20
-command: /app/bin/lan-mouse
-build-options:
-  append-path: "/usr/lib/sdk/rust-stable/bin:/usr/lib/sdk/llvm20/bin"
-  env:
-    "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER": "clang"
-    "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS": "-C link-arg=-fuse-ld=/usr/lib/sdk/rust-stable/bin/mold"
-    "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER": "clang"
-    "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUSTFLAGS": "-C link-arg=-fuse-ld=/usr/lib/sdk/rust-stable/bin/mold"
-    build-args:
-      "--share=network"
-    prepend-ld-library-path:
-      "/usr/lib/sdk/llvm19/lib"
-
-finish-args:
-  - "--socket=wayland"
-  - "--socket=fallback-x11"
-  - "--device=dri"
-  - "--socket=session-bus"
-  - "--share=network"
-  - "--filesystem=xdg-config"
-  - "--env=RUST_BACKTRACE=1"
-  - "--env=RUST_LOG=lan-mouse=debug"
-  - "--env=GTK_PATH=/app/lib/gtk-4.0"
-
-modules:
-  - name: lan-mouse
-    buildsystem: simple
-    build-options:
-      build-args:
-        - "--share=network"
-      append-path: /usr/lib/sdk/rust-stable/bin
-      env:
-        CARGO_HOME: /run/build/lan-mouse/cargo
-    build-commands:
-      - cargo fetch --manifest-path Cargo.toml --verbose
-      - cargo build
-      - install -Dm0755 target/debug/lan-mouse /app/bin/lan-mouse
-      - install -Dm0644 lan-mouse-gtk/resources/de.feschber.LanMouse.svg ${FLATPAK_DEST}/share/icons/hicolor/scalable/apps/${FLATPAK_ID}.svg
-      - install -Dm0644 de.feschber.LanMouse.desktop ${FLATPAK_DEST}/share/applications/${FLATPAK_ID}.desktop
-    sources:
-      - type: dir
-        path: ..
--- a/build.rs
+++ b/build.rs
@@ -1,8 +1,15 @@
-use shadow_rs::ShadowBuilder;
+use std::process::Command;

 fn main() {
-    ShadowBuilder::builder()
-        .deny_const(Default::default())
-        .build()
-        .expect("shadow build");
+    // 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}");
 }
--- a/config.toml
+++ b/config.toml
@@ -1,30 +1,24 @@
 # example configuration

-# configure release bind
+# capture_backend = "LayerShell"
+
+# release bind
 release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]

 # optional port (defaults to 4242)
 port = 4242
-
-# 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"
+# optional frontend -> defaults to gtk if available
+# frontend = "gtk"

 # define a client on the right side with host name "iridium"
-[[clients]]
-# position (left | right | top | bottom)
-position = "right"
+[right]
 # hostname
 hostname = "iridium"
-# activate this client immediately when lan-mouse is started
-activate_on_startup = true
 # optional list of (known) ip addresses
 ips = ["192.168.178.156"]

 # define a client on the left side with IP address 192.168.178.189
-[[clients]]
-position = "left"
+[left]
 # The hostname is optional: When no hostname is specified,
 # at least one ip address needs to be specified.
 hostname = "thorium"
--- a/de.feschber.LanMouse.yml
+++ b/de.feschber.LanMouse.yml
@@ -0,0 +1,14 @@
+app-id: de.feschber.LanMouse
+runtime: org.freedesktop.Platform
+runtime-version: '22.08'
+sdk: org.freedesktop.Sdk
+command: target/release/lan-mouse
+modules:
+  - name: hello
+    buildsystem: simple
+    build-commands:
+      - cargo build --release
+      - install -D lan-mouse /app/bin/lan-mouse
+    sources:
+      - type: file
+        path: target/release/lan-mouse
--- a/default.nix
+++ b/default.nix
@@ -1,3 +0,0 @@
-{ pkgs ? import <nixpkgs> { }
-}:
-pkgs.callPackage nix/default.nix { }
--- a/dylibs/.gitignore
+++ b/dylibs/.gitignore
@@ -1 +0,0 @@
-*
--- a/flake.lock
+++ b/flake.lock
@@ -1,12 +1,30 @@
 {
  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1705309234,
+        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1752687322,
-        "narHash": "sha256-RKwfXA4OZROjBTQAl9WOZQFm7L8Bo93FQwSJpAiSRvo=",
+        "lastModified": 1716293225,
+        "narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "6e987485eb2c77e5dcc5af4e3c70843711ef9251",
+        "rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
        "type": "github"
      },
      "original": {
@@ -24,16 +42,17 @@
    },
    "rust-overlay": {
      "inputs": {
+        "flake-utils": "flake-utils",
        "nixpkgs": [
          "nixpkgs"
        ]
      },
      "locked": {
-        "lastModified": 1752806774,
-        "narHash": "sha256-4cHeoR2roN7d/3J6gT+l6o7J2hTrBIUiCwVdDNMeXzE=",
+        "lastModified": 1716257780,
+        "narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "3c90219b3ba1c9790c45a078eae121de48a39c55",
+        "rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
        "type": "github"
      },
      "original": {
@@ -41,6 +60,21 @@
        "repo": "rust-overlay",
        "type": "github"
      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
    }
  },
  "root": "root",
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-capture"
 description = "cross-platform input-capture library used by lan-mouse"
-version = "0.3.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -10,10 +10,10 @@ repository = "https://github.com/feschber/lan-mouse"
 futures = "0.3.28"
 futures-core = "0.3.30"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.3.0" }
+input-event = { path = "../input-event", version = "0.2.1" }
 memmap = "0.7"
 tempfile = "3.8"
-thiserror = "2.0.0"
+thiserror = "1.0.61"
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
@@ -40,21 +40,21 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.9", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.5.0", features = ["tokio"], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.25.0", features = ["highsierra"] }
-core-foundation = "0.10.0"
+core-graphics = { version = "0.23", features = ["highsierra"] }
+core-foundation = "0.9.4"
 core-foundation-sys = "0.8.6"
 libc = "0.2.155"
-keycode = "1.0.0"
-bitflags = "2.6.0"
+keycode = "0.4.0"
+bitflags = "2.5.0"

 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.61.2", features = [
+windows = { version = "0.58.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
@@ -65,8 +65,8 @@ windows = { version = "0.61.2", features = [
 ] }

 [features]
-default = ["layer_shell", "x11", "libei"]
-layer_shell = [
+default = ["wayland", "x11", "libei"]
+wayland = [
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
--- a/input-capture/src/dummy.rs
+++ b/input-capture/src/dummy.rs
@@ -8,7 +8,7 @@ use futures_core::Stream;
 use input_event::PointerEvent;
 use tokio::time::{self, Instant, Interval};

-use super::{Capture, CaptureError, CaptureEvent, Position};
+use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};

 pub struct DummyInputCapture {
    start: Option<Instant>,
@@ -34,11 +34,11 @@ impl Default for DummyInputCapture {

 #[async_trait]
 impl Capture for DummyInputCapture {
-    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }

-    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, _handle: CaptureHandle) -> Result<(), CaptureError> {
        Ok(())
    }

@@ -55,7 +55,7 @@ const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;

 impl Stream for DummyInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let current = ready!(self.interval.poll_tick(cx));
@@ -81,6 +81,6 @@ impl Stream for DummyInputCapture {
                }))
            }
        };
-        Poll::Ready(Some(Ok((Position::Left, event))))
+        Poll::Ready(Some(Ok((0, event))))
    }
 }
--- a/input-capture/src/error.rs
+++ b/input-capture/src/error.rs
@@ -8,9 +8,9 @@ pub enum InputCaptureError {
    Capture(#[from] CaptureError),
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use std::io;
-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
    globals::{BindError, GlobalError},
@@ -19,10 +19,26 @@ use wayland_client::{

 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use ashpd::desktop::ResponseError;
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::{EiConvertEventStreamError, HandshakeError};

 #[cfg(target_os = "macos")]
 use core_graphics::base::CGError;

+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("error in libei stream: {inner:?}")]
+pub struct ReisConvertEventStreamError {
+    inner: EiConvertEventStreamError,
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl From<EiConvertEventStreamError> for ReisConvertEventStreamError {
+    fn from(e: EiConvertEventStreamError) -> Self {
+        Self { inner: e }
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum CaptureError {
    #[error("activation stream closed unexpectedly")]
@@ -32,8 +48,11 @@ pub enum CaptureError {
    #[error("io error: `{0}`")]
    Io(#[from] std::io::Error),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei error: `{0}`")]
-    Reis(#[from] reis::Error),
+    #[error("error in libei stream: `{0}`")]
+    Reis(#[from] ReisConvertEventStreamError),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei handshake failed: `{0}`")]
+    Handshake(#[from] HandshakeError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error(transparent)]
    Portal(#[from] ashpd::Error),
@@ -64,7 +83,7 @@ pub enum CaptureCreationError {
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("error creating input-capture-portal backend: `{0}`")]
    Libei(#[from] LibeiCaptureCreationError),
-    #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("error creating layer-shell capture backend: `{0}`")]
    LayerShell(#[from] LayerShellCaptureCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -74,7 +93,7 @@ pub enum CaptureCreationError {
    #[error("error creating windows capture backend")]
    Windows,
    #[cfg(target_os = "macos")]
-    #[error("error creating macos capture backend: `{0}`")]
+    #[error("error creating macos capture backend")]
    MacOS(#[from] MacosCaptureCreationError),
 }

@@ -102,7 +121,7 @@ pub enum LibeiCaptureCreationError {
    Ashpd(#[from] ashpd::Error),
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("{protocol} protocol not supported: {inner}")]
 pub struct WaylandBindError {
@@ -110,14 +129,14 @@ pub struct WaylandBindError {
    protocol: &'static str,
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
        Self { inner, protocol }
    }
 }

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LayerShellCaptureCreationError {
    #[error(transparent)]
@@ -146,9 +165,6 @@ pub enum X11InputCaptureCreationError {
 pub enum MacosCaptureCreationError {
    #[error("event source creation failed!")]
    EventSourceCreation,
-    #[cfg(target_os = "macos")]
-    #[error("event tap creation failed")]
-    EventTapCreation,
    #[error("failed to set CG Cursor property")]
    CGCursorProperty,
    #[cfg(target_os = "macos")]
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -1,9 +1,4 @@
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    fmt::Display,
-    mem::swap,
-    task::{ready, Poll},
-};
+use std::{collections::HashSet, fmt::Display, task::Poll};

 use async_trait::async_trait;
 use futures::StreamExt;
@@ -21,8 +16,8 @@ mod libei;
 #[cfg(target_os = "macos")]
 mod macos;

-#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
-mod layer_shell;
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+mod wayland;

 #[cfg(windows)]
 mod windows;
@@ -79,7 +74,7 @@ impl Display for Position {
            Position::Top => "top",
            Position::Bottom => "bottom",
        };
-        write!(f, "{pos}")
+        write!(f, "{}", pos)
    }
 }

@@ -87,7 +82,7 @@ impl Display for Position {
 pub enum Backend {
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    InputCapturePortal,
-    #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    LayerShell,
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
@@ -103,7 +98,7 @@ impl Display for Backend {
        match self {
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::InputCapturePortal => write!(f, "input-capture-portal"),
-            #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::LayerShell => write!(f, "layer-shell"),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => write!(f, "X11"),
@@ -117,52 +112,19 @@ impl Display for Backend {
 }

 pub struct InputCapture {
-    /// capture backend
    capture: Box<dyn Capture>,
-    /// keys pressed by active capture
    pressed_keys: HashSet<scancode::Linux>,
-    /// map from position to ids
-    position_map: HashMap<Position, Vec<CaptureHandle>>,
-    /// map from id to position
-    id_map: HashMap<CaptureHandle, Position>,
-    /// pending events
-    pending: VecDeque<(CaptureHandle, CaptureEvent)>,
 }

 impl InputCapture {
    /// create a new client with the given id
    pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
-        assert!(!self.id_map.contains_key(&id));
-
-        self.id_map.insert(id, pos);
-
-        if let Some(v) = self.position_map.get_mut(&pos) {
-            v.push(id);
-            Ok(())
-        } else {
-            self.position_map.insert(pos, vec![id]);
-            self.capture.create(pos).await
-        }
+        self.capture.create(id, pos).await
    }

    /// destroy the client with the given id, if it exists
    pub async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
-        let pos = self
-            .id_map
-            .remove(&id)
-            .expect("no position for this handle");
-
-        log::debug!("destroying capture {id} @ {pos}");
-        let remaining = self.position_map.get_mut(&pos).expect("id vector");
-        remaining.retain(|&i| i != id);
-
-        log::debug!("remaining ids @ {pos}: {remaining:?}");
-        if remaining.is_empty() {
-            log::debug!("destroying capture @ {pos} - no remaining ids");
-            self.position_map.remove(&pos);
-            self.capture.destroy(pos).await?;
-        }
-        Ok(())
+        self.capture.destroy(id).await
    }

    /// release mouse
@@ -181,9 +143,6 @@ impl InputCapture {
        let capture = create(backend).await?;
        Ok(Self {
            capture,
-            id_map: Default::default(),
-            pending: Default::default(),
-            position_map: Default::default(),
            pressed_keys: HashSet::new(),
        })
    }
@@ -211,65 +170,29 @@ impl Stream for InputCapture {
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> Poll<Option<Self::Item>> {
-        if let Some(e) = self.pending.pop_front() {
-            return Poll::Ready(Some(Ok(e)));
-        }
-
-        // ready
-        let event = ready!(self.capture.poll_next_unpin(cx));
-
-        // stream closed
-        let event = match event {
-            Some(e) => e,
-            None => return Poll::Ready(None),
-        };
-
-        // error occurred
-        let (pos, event) = match event {
-            Ok(e) => e,
-            Err(e) => return Poll::Ready(Some(Err(e))),
-        };
-
-        // handle key presses
-        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })) = event {
-            self.update_pressed_keys(key, state);
-        }
-
-        let len = self
-            .position_map
-            .get(&pos)
-            .map(|ids| ids.len())
-            .unwrap_or(0);
-
-        match len {
-            0 => Poll::Pending,
-            1 => Poll::Ready(Some(Ok((
-                self.position_map.get(&pos).expect("no id")[0],
-                event,
-            )))),
-            _ => {
-                let mut position_map = HashMap::new();
-                swap(&mut self.position_map, &mut position_map);
+        match self.capture.poll_next_unpin(cx) {
+            Poll::Ready(e) => {
+                if let Some(Ok((
+                    _,
+                    CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })),
+                ))) = e
                {
-                    for &id in position_map.get(&pos).expect("position") {
-                        self.pending.push_back((id, event));
-                    }
+                    self.update_pressed_keys(key, state);
                }
-                swap(&mut self.position_map, &mut position_map);
-
-                Poll::Ready(Some(Ok(self.pending.pop_front().expect("event"))))
+                Poll::Ready(e)
            }
+            Poll::Pending => Poll::Pending,
        }
    }
 }

 #[async_trait]
-trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + Unpin {
+trait Capture: Stream<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>> + Unpin {
    /// create a new client with the given id
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError>;
+    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;

    /// destroy the client with the given id, if it exists
-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError>;
+    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError>;

    /// release mouse
    async fn release(&mut self) -> Result<(), CaptureError>;
@@ -281,14 +204,14 @@ trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + U
 async fn create_backend(
    backend: Backend,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
+    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
    CaptureCreationError,
 > {
    match backend {
        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
-        #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
-        Backend::LayerShell => Ok(Box::new(layer_shell::LayerShellInputCapture::new()?)),
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
        #[cfg(windows)]
@@ -302,7 +225,7 @@ async fn create_backend(
 async fn create(
    backend: Option<Backend>,
 ) -> Result<
-    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
+    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
    CaptureCreationError,
 > {
    if let Some(backend) = backend {
@@ -316,7 +239,7 @@ async fn create(
    for backend in [
        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
        Backend::InputCapturePortal,
-        #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
        Backend::LayerShell,
        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
        Backend::X11,
--- a/input-capture/src/libei.rs
+++ b/input-capture/src/libei.rs
@@ -1,9 +1,6 @@
 use ashpd::{
    desktop::{
-        input_capture::{
-            Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
-            Zones,
-        },
+        input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
        Session,
    },
    enumflags2::BitFlags,
@@ -11,15 +8,14 @@ use ashpd::{
 use async_trait::async_trait;
 use futures::{FutureExt, StreamExt};
 use reis::{
-    ei::{self, handshake::ContextType},
-    event::{Connection, DeviceCapability, EiEvent},
-    tokio::EiConvertEventStream,
+    ei,
+    event::{DeviceCapability, EiEvent},
+    tokio::{EiConvertEventStream, EiEventStream},
 };
 use std::{
    cell::Cell,
    collections::HashMap,
    io,
-    num::NonZeroU32,
    os::unix::net::UnixStream,
    pin::Pin,
    rc::Rc,
@@ -36,14 +32,15 @@ use tokio::{
 use tokio_util::sync::CancellationToken;

 use futures_core::Stream;
+use once_cell::sync::Lazy;

 use input_event::Event;

 use crate::CaptureEvent;

 use super::{
-    error::{CaptureError, LibeiCaptureCreationError},
-    Capture as LanMouseInputCapture, Position,
+    error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
+    Capture as LanMouseInputCapture, CaptureHandle, Position,
 };

 /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
@@ -53,21 +50,37 @@ use super::{
 /// events that necessitate restarting the capture session
 #[derive(Clone, Copy, Debug)]
 enum LibeiNotifyEvent {
-    Create(Position),
-    Destroy(Position),
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
 }

 #[allow(dead_code)]
 pub struct LibeiInputCapture<'a> {
    input_capture: Pin<Box<InputCapture<'a>>>,
    capture_task: JoinHandle<Result<(), CaptureError>>,
-    event_rx: Receiver<(Position, CaptureEvent)>,
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
    notify_capture: Sender<LibeiNotifyEvent>,
    notify_release: Arc<Notify>,
    cancellation_token: CancellationToken,
    terminated: bool,
 }

+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
 /// returns (start pos, end pos), inclusive
 fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
    let (x, y) = (r.x_offset(), r.y_offset());
@@ -104,37 +117,35 @@ impl From<ICBarrier> for Barrier {

 fn select_barriers(
    zones: &Zones,
-    clients: &[Position],
-    next_barrier_id: &mut NonZeroU32,
-) -> (Vec<ICBarrier>, HashMap<BarrierID, Position>) {
-    let mut pos_for_barrier = HashMap::new();
+    clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+) -> (Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>) {
+    let mut client_for_barrier = HashMap::new();
    let mut barriers: Vec<ICBarrier> = vec![];

-    for pos in clients {
+    for (handle, pos) in clients {
        let mut client_barriers = zones
            .regions()
            .iter()
            .map(|r| {
                let id = *next_barrier_id;
-                *next_barrier_id = next_barrier_id
-                    .checked_add(1)
-                    .expect("barrier id out of range");
+                *next_barrier_id = id + 1;
                let position = pos_to_barrier(r, *pos);
-                pos_for_barrier.insert(id, *pos);
+                client_for_barrier.insert(id, *handle);
                ICBarrier::new(id, position)
            })
            .collect();
        barriers.append(&mut client_barriers);
    }
-    (barriers, pos_for_barrier)
+    (barriers, client_for_barrier)
 }

 async fn update_barriers(
    input_capture: &InputCapture<'_>,
    session: &Session<'_, InputCapture<'_>>,
-    active_clients: &[Position],
-    next_barrier_id: &mut NonZeroU32,
-) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> {
+    active_clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>), ashpd::Error> {
    let zones = input_capture.zones(session).await?.response()?;
    log::debug!("zones: {zones:?}");

@@ -153,11 +164,11 @@ async fn update_barriers(

 async fn create_session<'a>(
    input_capture: &'a InputCapture<'a>,
-) -> std::result::Result<(Session<'a, InputCapture<'a>>, BitFlags<Capabilities>), ashpd::Error> {
+) -> std::result::Result<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>), ashpd::Error> {
    log::debug!("creating input capture session");
    input_capture
        .create_session(
-            None,
+            &ashpd::WindowIdentifier::default(),
            Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
        )
        .await
@@ -166,7 +177,7 @@ async fn create_session<'a>(
 async fn connect_to_eis(
    input_capture: &InputCapture<'_>,
    session: &Session<'_, InputCapture<'_>>,
-) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> {
+) -> Result<(ei::Context, EiConvertEventStream), CaptureError> {
    log::debug!("connect_to_eis");
    let fd = input_capture.connect_to_eis(session).await?;

@@ -176,32 +187,39 @@ async fn connect_to_eis(

    // create ei context
    let context = ei::Context::new(stream)?;
-    let (conn, event_stream) = context
-        .handshake_tokio("de.feschber.LanMouse", ContextType::Receiver)
-        .await?;
+    let mut event_stream = EiEventStream::new(context.clone())?;
+    let response = reis::tokio::ei_handshake(
+        &mut event_stream,
+        "de.feschber.LanMouse",
+        ei::handshake::ContextType::Receiver,
+        &INTERFACES,
+    )
+    .await?;
+    let event_stream = EiConvertEventStream::new(event_stream, response.serial);

-    Ok((context, conn, event_stream))
+    Ok((context, event_stream))
 }

 async fn libei_event_handler(
    mut ei_event_stream: EiConvertEventStream,
    context: ei::Context,
-    event_tx: Sender<(Position, CaptureEvent)>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
    release_session: Arc<Notify>,
-    current_pos: Rc<Cell<Option<Position>>>,
+    current_client: Rc<Cell<Option<CaptureHandle>>>,
 ) -> Result<(), CaptureError> {
    loop {
        let ei_event = ei_event_stream
            .next()
            .await
-            .ok_or(CaptureError::EndOfStream)??;
+            .ok_or(CaptureError::EndOfStream)?
+            .map_err(ReisConvertEventStreamError::from)?;
        log::trace!("from ei: {ei_event:?}");
-        let client = current_pos.get();
+        let client = current_client.get();
        handle_ei_event(ei_event, client, &context, &event_tx, &release_session).await?;
    }
 }

-impl LibeiInputCapture<'_> {
+impl<'a> LibeiInputCapture<'a> {
    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
        let input_capture = Box::pin(InputCapture::new().await?);
        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
@@ -242,15 +260,15 @@ async fn do_capture(
    mut capture_event: Receiver<LibeiNotifyEvent>,
    notify_release: Arc<Notify>,
    session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
-    event_tx: Sender<(Position, CaptureEvent)>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
    cancellation_token: CancellationToken,
 ) -> Result<(), CaptureError> {
    let mut session = session.map(|s| s.0);

    /* safety: libei_task does not outlive Self */
    let input_capture = unsafe { &*input_capture };
-    let mut active_clients: Vec<Position> = vec![];
-    let mut next_barrier_id = NonZeroU32::new(1).expect("id must be non-zero");
+    let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
+    let mut next_barrier_id = 1u32;

    let mut zones_changed = input_capture.receive_zones_changed().await?;

@@ -323,8 +341,8 @@ async fn do_capture(
        // update clients if requested
        if let Some(event) = capture_event_occured.take() {
            match event {
-                LibeiNotifyEvent::Create(p) => active_clients.push(p),
-                LibeiNotifyEvent::Destroy(p) => active_clients.retain(|&pos| pos != p),
+                LibeiNotifyEvent::Create(c, p) => active_clients.push((c, p)),
+                LibeiNotifyEvent::Destroy(c) => active_clients.retain(|(h, _)| *h != c),
            }
        }

@@ -338,21 +356,21 @@ async fn do_capture(
 async fn do_capture_session(
    input_capture: &InputCapture<'_>,
    session: &mut Session<'_, InputCapture<'_>>,
-    event_tx: &Sender<(Position, CaptureEvent)>,
-    active_clients: &[Position],
-    next_barrier_id: &mut NonZeroU32,
+    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
+    active_clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
    notify_release: &Notify,
    cancel: (CancellationToken, CancellationToken),
 ) -> Result<(), CaptureError> {
    let (cancel_session, cancel_update) = cancel;
    // current client
-    let current_pos = Rc::new(Cell::new(None));
+    let current_client = Rc::new(Cell::new(None));

    // connect to eis server
-    let (context, _conn, ei_event_stream) = connect_to_eis(input_capture, session).await?;
+    let (context, ei_event_stream) = connect_to_eis(input_capture, session).await?;

    // set barriers
-    let (barriers, pos_for_barrier_id) =
+    let (barriers, client_for_barrier_id) =
        update_barriers(input_capture, session, active_clients, next_barrier_id).await?;

    log::debug!("enabling session");
@@ -364,7 +382,7 @@ async fn do_capture_session(
    // async event task
    let cancel_ei_handler = CancellationToken::new();
    let event_chan = event_tx.clone();
-    let pos = current_pos.clone();
+    let client = current_client.clone();
    let cancel_session_clone = cancel_session.clone();
    let release_session_clone = release_session.clone();
    let cancel_ei_handler_clone = cancel_ei_handler.clone();
@@ -375,7 +393,7 @@ async fn do_capture_session(
                context,
                event_chan,
                release_session_clone,
-                pos,
+                client,
            ) => {
                log::debug!("libei exited: {r:?} cancelling session task");
                cancel_session_clone.cancel();
@@ -397,17 +415,17 @@ async fn do_capture_session(

                    // get barrier id from activation
                    let barrier_id = match activated.barrier_id() {
-                        Some(ActivatedBarrier::Barrier(id)) => id,
+                        Some(bid) => bid,
                        // workaround for KDE plasma not reporting barrier ids
-                        Some(ActivatedBarrier::UnknownBarrier) | None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
+                        None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
                    };

                    // find client corresponding to barrier
-                    let pos = *pos_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
-                    current_pos.replace(Some(pos));
+                    let client = *client_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
+                    current_client.replace(Some(client));

                    // client entered => send event
-                    event_tx.send((pos, CaptureEvent::Begin)).await.expect("no channel");
+                    event_tx.send((client, CaptureEvent::Begin)).await.expect("no channel");

                    tokio::select! {
                        _ = notify_release.notified() => { /* capture release */
@@ -423,7 +441,7 @@ async fn do_capture_session(
                        },
                    }

-                    release_capture(input_capture, session, activated, pos).await?;
+                    release_capture(input_capture, session, activated, client, active_clients).await?;

                }
                _ = notify_release.notified() => { /* capture release -> we are not capturing anyway, so ignore */
@@ -466,7 +484,8 @@ async fn release_capture<'a>(
    input_capture: &InputCapture<'a>,
    session: &Session<'a, InputCapture<'a>>,
    activated: Activated,
-    current_pos: Position,
+    current_client: CaptureHandle,
+    active_clients: &[(CaptureHandle, Position)],
 ) -> Result<(), CaptureError> {
    if let Some(activation_id) = activated.activation_id() {
        log::debug!("releasing input capture {activation_id}");
@@ -475,7 +494,13 @@ async fn release_capture<'a>(
        .cursor_position()
        .expect("compositor did not report cursor position!");
    log::debug!("client entered @ ({x}, {y})");
-    let (dx, dy) = match current_pos {
+    let pos = active_clients
+        .iter()
+        .filter(|(c, _)| *c == current_client)
+        .map(|(_, p)| p)
+        .next()
+        .unwrap(); // FIXME
+    let (dx, dy) = match pos {
        // offset cursor position to not enter again immediately
        Position::Left => (1., 0.),
        Position::Right => (-1., 0.),
@@ -529,9 +554,9 @@ static ALL_CAPABILITIES: &[DeviceCapability] = &[

 async fn handle_ei_event(
    ei_event: EiEvent,
-    current_client: Option<Position>,
+    current_client: Option<CaptureHandle>,
    context: &ei::Context,
-    event_tx: &Sender<(Position, CaptureEvent)>,
+    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
    release_session: &Notify,
 ) -> Result<(), CaptureError> {
    match ei_event {
@@ -550,9 +575,9 @@ async fn handle_ei_event(
            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
        }
        _ => {
-            if let Some(pos) = current_client {
+            if let Some(handle) = current_client {
                for event in Event::from_ei_event(ei_event) {
-                    event_tx.send((pos, CaptureEvent::Input(event))).await.expect("no channel");
+                    event_tx.send((handle, CaptureEvent::Input(event))).await.expect("no channel");
                }
            }
        }
@@ -561,19 +586,19 @@ async fn handle_ei_event(
 }

 #[async_trait]
-impl LanMouseInputCapture for LibeiInputCapture<'_> {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
+impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
        let _ = self
            .notify_capture
-            .send(LibeiNotifyEvent::Create(pos))
+            .send(LibeiNotifyEvent::Create(handle, pos))
            .await;
        Ok(())
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
        let _ = self
            .notify_capture
-            .send(LibeiNotifyEvent::Destroy(pos))
+            .send(LibeiNotifyEvent::Destroy(handle))
            .await;
        Ok(())
    }
@@ -587,18 +612,14 @@ impl LanMouseInputCapture for LibeiInputCapture<'_> {
        self.cancellation_token.cancel();
        let task = &mut self.capture_task;
        log::debug!("waiting for capture to terminate...");
-        let res = if !task.is_finished() {
-            task.await.expect("libei task panic")
-        } else {
-            Ok(())
-        };
-        self.terminated = true;
+        let res = task.await.expect("libei task panic");
        log::debug!("done!");
+        self.terminated = true;
        res
    }
 }

-impl Drop for LibeiInputCapture<'_> {
+impl<'a> Drop for LibeiInputCapture<'a> {
    fn drop(&mut self) {
        if !self.terminated {
            /* this workaround is needed until async drop is stabilized */
@@ -607,8 +628,8 @@ impl Drop for LibeiInputCapture<'_> {
    }
 }

-impl Stream for LibeiInputCapture<'_> {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+impl<'a> Stream for LibeiInputCapture<'a> {
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match self.capture_task.poll_unpin(cx) {
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -1,4 +1,6 @@
-use super::{error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
+use super::{
+    error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle, Position,
+};
 use async_trait::async_trait;
 use bitflags::bitflags;
 use core_foundation::base::{kCFAllocatorDefault, CFRelease};
@@ -10,7 +12,7 @@ use core_graphics::base::{kCGErrorSuccess, CGError};
 use core_graphics::display::{CGDisplay, CGPoint};
 use core_graphics::event::{
    CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
-    CGEventTapProxy, CGEventType, CallbackResult, EventField,
+    CGEventTapProxy, CGEventType, EventField,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use futures_core::Stream;
@@ -18,14 +20,14 @@ use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
-use std::collections::HashSet;
+use std::collections::HashMap;
 use std::ffi::{c_char, CString};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{ready, Context, Poll};
 use std::thread::{self};
-use tokio::sync::mpsc::{self, Receiver, Sender};
-use tokio::sync::{oneshot, Mutex};
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::Mutex;

 #[derive(Debug, Default)]
 struct Bounds {
@@ -37,44 +39,44 @@ struct Bounds {

 #[derive(Debug)]
 struct InputCaptureState {
-    active_clients: Lazy<HashSet<Position>>,
-    current_pos: Option<Position>,
+    client_for_pos: Lazy<HashMap<Position, CaptureHandle>>,
+    current_client: Option<(CaptureHandle, Position)>,
    bounds: Bounds,
 }

 #[derive(Debug)]
 enum ProducerEvent {
    Release,
-    Create(Position),
-    Destroy(Position),
-    Grab(Position),
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+    Grab((CaptureHandle, Position)),
    EventTapDisabled,
 }

 impl InputCaptureState {
    fn new() -> Result<Self, MacosCaptureCreationError> {
        let mut res = Self {
-            active_clients: Lazy::new(HashSet::new),
-            current_pos: None,
+            client_for_pos: Lazy::new(HashMap::new),
+            current_client: None,
            bounds: Bounds::default(),
        };
        res.update_bounds()?;
        Ok(res)
    }

-    fn crossed(&mut self, event: &CGEvent) -> Option<Position> {
+    fn crossed(&mut self, event: &CGEvent) -> Option<(CaptureHandle, Position)> {
        let location = event.location();
        let relative_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X);
        let relative_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y);

-        for &position in self.active_clients.iter() {
-            if (position == Position::Left && (location.x + relative_x) <= self.bounds.xmin)
-                || (position == Position::Right && (location.x + relative_x) >= self.bounds.xmax)
-                || (position == Position::Top && (location.y + relative_y) <= self.bounds.ymin)
-                || (position == Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
+        for (position, client) in self.client_for_pos.iter() {
+            if (position == &Position::Left && (location.x + relative_x) <= self.bounds.xmin)
+                || (position == &Position::Right && (location.x + relative_x) >= self.bounds.xmax)
+                || (position == &Position::Top && (location.y + relative_y) <= self.bounds.ymin)
+                || (position == &Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
            {
-                log::debug!("Crossed barrier into position: {position:?}");
-                return Some(position);
+                log::debug!("Crossed barrier into client: {client}, {position:?}");
+                return Some((*client, *position));
            }
        }
        None
@@ -100,7 +102,7 @@ impl InputCaptureState {
    // to the edge of the screen, the cursor will be hidden but we dont want it to appear in a
    // random location when we exit the client
    fn reset_mouse_position(&self, event: &CGEvent) -> Result<(), CaptureError> {
-        if let Some(pos) = self.current_pos {
+        if let Some((_, pos)) = self.current_client {
            let location = event.location();
            let edge_offset = 1.0;

@@ -144,31 +146,40 @@ impl InputCaptureState {
        log::debug!("handling event: {producer_event:?}");
        match producer_event {
            ProducerEvent::Release => {
-                if self.current_pos.is_some() {
+                if self.current_client.is_some() {
                    CGDisplay::show_cursor(&CGDisplay::main())
                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_pos = None;
+                    self.current_client = None;
                }
            }
-            ProducerEvent::Grab(pos) => {
-                if self.current_pos.is_none() {
+            ProducerEvent::Grab(client) => {
+                if self.current_client.is_none() {
                    CGDisplay::hide_cursor(&CGDisplay::main())
                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_pos = Some(pos);
+                    self.current_client = Some(client);
                }
            }
-            ProducerEvent::Create(p) => {
-                self.active_clients.insert(p);
+            ProducerEvent::Create(c, p) => {
+                self.client_for_pos.insert(p, c);
            }
-            ProducerEvent::Destroy(p) => {
-                if let Some(current) = self.current_pos {
-                    if current == p {
-                        CGDisplay::show_cursor(&CGDisplay::main())
-                            .map_err(CaptureError::CoreGraphics)?;
-                        self.current_pos = None;
-                    };
+            ProducerEvent::Destroy(c) => {
+                for pos in [
+                    Position::Left,
+                    Position::Right,
+                    Position::Top,
+                    Position::Bottom,
+                ] {
+                    if let Some((current_c, _)) = self.current_client {
+                        if current_c == c {
+                            CGDisplay::show_cursor(&CGDisplay::main())
+                                .map_err(CaptureError::CoreGraphics)?;
+                            self.current_client = None;
+                        };
+                    }
+                    if self.client_for_pos.get(&pos).copied() == Some(c) {
+                        self.client_for_pos.remove(&pos);
+                    }
                }
-                self.active_clients.remove(&p);
            }
            ProducerEvent::EventTapDisabled => return Err(CaptureError::EventTapDisabled),
        };
@@ -322,11 +333,12 @@ fn get_events(
    Ok(())
 }

-fn create_event_tap<'a>(
+fn event_tap_thread(
    client_state: Arc<Mutex<InputCaptureState>>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
-    event_tx: Sender<(Position, CaptureEvent)>,
-) -> Result<CGEventTap<'a>, MacosCaptureCreationError> {
+    exit: tokio::sync::oneshot::Sender<Result<(), &'static str>>,
+) {
    let cg_events_of_interest: Vec<CGEventType> = vec![
        CGEventType::LeftMouseDown,
        CGEventType::LeftMouseUp,
@@ -344,11 +356,15 @@ fn create_event_tap<'a>(
        CGEventType::FlagsChanged,
    ];

-    let event_tap_callback =
-        move |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
+    let tap = CGEventTap::new(
+        CGEventTapLocation::Session,
+        CGEventTapPlacement::HeadInsertEventTap,
+        CGEventTapOptions::Default,
+        cg_events_of_interest,
+        |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
            log::trace!("Got event from tap: {event_type:?}");
            let mut state = client_state.blocking_lock();
-            let mut pos = None;
+            let mut client = None;
            let mut res_events = vec![];

            if matches!(
@@ -364,8 +380,8 @@ fn create_event_tap<'a>(
            }

            // Are we in a client?
-            if let Some(current_pos) = state.current_pos {
-                pos = Some(current_pos);
+            if let Some((current_client, _)) = state.current_client {
+                client = Some(current_client);
                get_events(&event_type, cg_ev, &mut res_events).unwrap_or_else(|e| {
                    log::error!("Failed to get events: {e}");
                });
@@ -379,39 +395,32 @@ fn create_event_tap<'a>(
            }
            // Did we cross a barrier?
            else if matches!(event_type, CGEventType::MouseMoved) {
-                if let Some(new_pos) = state.crossed(cg_ev) {
-                    pos = Some(new_pos);
+                if let Some((new_client, pos)) = state.crossed(cg_ev) {
+                    client = Some(new_client);
                    res_events.push(CaptureEvent::Begin);
                    notify_tx
-                        .blocking_send(ProducerEvent::Grab(new_pos))
+                        .blocking_send(ProducerEvent::Grab((new_client, pos)))
                        .expect("Failed to send notification");
                }
            }

-            if let Some(pos) = pos {
+            if let Some(client) = client {
                res_events.iter().for_each(|e| {
-                    // error must be ignored, since the event channel
-                    // may already be closed when the InputCapture instance is dropped.
-                    let _ = event_tx.blocking_send((pos, *e));
+                    event_tx
+                        .blocking_send((client, *e))
+                        .expect("Failed to send event");
                });
-                // Returning Drop should stop the event from being processed
+                // Returning None should stop the event from being processed
                // but core fundation still returns the event
                cg_ev.set_type(CGEventType::Null);
            }
-            CallbackResult::Replace(cg_ev.to_owned())
-        };
-
-    let tap = CGEventTap::new(
-        CGEventTapLocation::Session,
-        CGEventTapPlacement::HeadInsertEventTap,
-        CGEventTapOptions::Default,
-        cg_events_of_interest,
-        event_tap_callback,
+            Some(cg_ev.to_owned())
+        },
    )
-    .map_err(|_| MacosCaptureCreationError::EventTapCreation)?;
+    .expect("Failed creating tap");

    let tap_source: CFRunLoopSource = tap
-        .mach_port()
+        .mach_port
        .create_runloop_source(0)
        .expect("Failed creating loop source");

@@ -419,47 +428,22 @@ fn create_event_tap<'a>(
        CFRunLoop::get_current().add_source(&tap_source, kCFRunLoopCommonModes);
    }

-    Ok(tap)
-}
-
-fn event_tap_thread(
-    client_state: Arc<Mutex<InputCaptureState>>,
-    event_tx: Sender<(Position, CaptureEvent)>,
-    notify_tx: Sender<ProducerEvent>,
-    ready: std::sync::mpsc::Sender<Result<CFRunLoop, MacosCaptureCreationError>>,
-    exit: oneshot::Sender<()>,
-) {
-    let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
-        Err(e) => {
-            ready.send(Err(e)).expect("channel closed");
-            return;
-        }
-        Ok(tap) => {
-            let run_loop = CFRunLoop::get_current();
-            ready.send(Ok(run_loop)).expect("channel closed");
-            tap
-        }
-    };
-    log::debug!("running CFRunLoop...");
    CFRunLoop::run_current();
-    log::debug!("event tap thread exiting!...");

-    let _ = exit.send(());
+    let _ = exit.send(Err("tap thread exited"));
 }

 pub struct MacOSInputCapture {
-    event_rx: Receiver<(Position, CaptureEvent)>,
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
    notify_tx: Sender<ProducerEvent>,
-    run_loop: CFRunLoop,
 }

 impl MacOSInputCapture {
    pub async fn new() -> Result<Self, MacosCaptureCreationError> {
        let state = Arc::new(Mutex::new(InputCaptureState::new()?));
-        let (event_tx, event_rx) = mpsc::channel(32);
-        let (notify_tx, mut notify_rx) = mpsc::channel(32);
-        let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-        let (tap_exit_tx, mut tap_exit_rx) = oneshot::channel();
+        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
+        let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
+        let (tap_exit_tx, mut tap_exit_rx) = tokio::sync::oneshot::channel();

        unsafe {
            configure_cf_settings()?;
@@ -473,67 +457,55 @@ impl MacOSInputCapture {
                event_tap_thread_state,
                event_tx,
                event_tap_notify,
-                ready_tx,
                tap_exit_tx,
            )
        });

-        // wait for event tap creation result
-        let run_loop = ready_rx.recv().expect("channel closed")?;
-
        let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
            loop {
                tokio::select! {
                    producer_event = notify_rx.recv() => {
-                        let Some(producer_event) = producer_event else {
-                            break;
-                        };
+                        let producer_event = producer_event.expect("channel closed");
                        let mut state = state.lock().await;
                        state.handle_producer_event(producer_event).await.unwrap_or_else(|e| {
                            log::error!("Failed to handle producer event: {e}");
                        })
                    }

-                    _ = &mut tap_exit_rx => {
-                        break;
+                    res = &mut tap_exit_rx => {
+                        if let Err(e) = res.expect("channel closed") {
+                            log::error!("Tap thread failed: {:?}", e);
+                            break;
+                        }
                    }
                }
            }
-            // show cursor
-            let _ = CGDisplay::show_cursor(&CGDisplay::main());
        });

        Ok(Self {
            event_rx,
            notify_tx,
-            run_loop,
        })
    }
 }

-impl Drop for MacOSInputCapture {
-    fn drop(&mut self) {
-        self.run_loop.stop();
-    }
-}
-
 #[async_trait]
 impl Capture for MacOSInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
-            log::debug!("creating capture, {pos}");
-            let _ = notify_tx.send(ProducerEvent::Create(pos)).await;
+            log::debug!("creating client {id}, {pos}");
+            let _ = notify_tx.send(ProducerEvent::Create(id, pos)).await;
            log::debug!("done !");
        });
        Ok(())
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
        let notify_tx = self.notify_tx.clone();
        tokio::task::spawn_local(async move {
-            log::debug!("destroying capture {pos}");
-            let _ = notify_tx.send(ProducerEvent::Destroy(pos)).await;
+            log::debug!("destroying client {id}");
+            let _ = notify_tx.send(ProducerEvent::Destroy(id)).await;
            log::debug!("done !");
        });
        Ok(())
@@ -554,7 +526,7 @@ impl Capture for MacOSInputCapture {
 }

 impl Stream for MacOSInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match ready!(self.event_rx.poll_recv(cx)) {
--- a/input-capture/src/layer_shell.rs
+++ b/input-capture/src/layer_shell.rs
@@ -1,9 +1,8 @@
 use async_trait::async_trait;
 use futures_core::Stream;
 use std::{
-    collections::{HashSet, VecDeque},
+    collections::VecDeque,
    env,
-    fmt::{self, Display},
    io::{self, ErrorKind},
    os::fd::{AsFd, RawFd},
    pin::Pin,
@@ -47,15 +46,13 @@ use wayland_protocols_wlr::layer_shell::v1::client::{
 use wayland_client::{
    backend::{ReadEventsGuard, WaylandError},
    delegate_noop,
-    globals::{registry_queue_init, Global, GlobalList, GlobalListContents},
+    globals::{registry_queue_init, GlobalListContents},
    protocol::{
        wl_buffer, wl_compositor,
        wl_keyboard::{self, WlKeyboard},
        wl_output::{self, WlOutput},
        wl_pointer::{self, WlPointer},
-        wl_region,
-        wl_registry::{self, WlRegistry},
-        wl_seat, wl_shm, wl_shm_pool,
+        wl_region, wl_registry, wl_seat, wl_shm, wl_shm_pool,
        wl_surface::WlSurface,
    },
    Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
@@ -67,7 +64,7 @@ use crate::{CaptureError, CaptureEvent};

 use super::{
    error::{LayerShellCaptureCreationError, WaylandBindError},
-    Capture, Position,
+    Capture, CaptureHandle, Position,
 };

 struct Globals {
@@ -78,56 +75,41 @@ struct Globals {
    seat: wl_seat::WlSeat,
    shm: wl_shm::WlShm,
    layer_shell: ZwlrLayerShellV1,
+    outputs: Vec<WlOutput>,
    xdg_output_manager: ZxdgOutputManagerV1,
 }

-#[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)]
+#[derive(Debug, Clone)]
 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>,
    rel_pointer: Option<ZwpRelativePointerV1>,
    shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    active_windows: Vec<Arc<Window>>,
-    focused: Option<Arc<Window>>,
-    global_list: GlobalList,
-    globals: Globals,
+    client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
+    focused: Option<(Arc<Window>, CaptureHandle)>,
+    g: Globals,
    wayland_fd: RawFd,
    read_guard: Option<ReadEventsGuard>,
    qh: QueueHandle<Self>,
-    pending_events: VecDeque<(Position, CaptureEvent)>,
-    outputs: Vec<Output>,
+    pending_events: VecDeque<(CaptureHandle, CaptureEvent)>,
+    output_info: Vec<(WlOutput, OutputInfo)>,
    scroll_discrete_pending: bool,
 }

@@ -142,7 +124,7 @@ impl AsRawFd for Inner {
    }
 }

-pub struct LayerShellInputCapture(AsyncFd<Inner>);
+pub struct WaylandInputCapture(AsyncFd<Inner>);

 struct Window {
    buffer: wl_buffer::WlBuffer,
@@ -160,7 +142,7 @@ impl Window {
        size: (i32, i32),
    ) -> Window {
        log::debug!("creating window output: {output:?}, size: {size:?}");
-        let g = &state.globals;
+        let g = &state.g;

        let (width, height) = match pos {
            Position::Left | Position::Right => (1, size.1 as u32),
@@ -221,36 +203,41 @@ impl Drop for Window {
    }
 }

-fn get_edges(outputs: &[Output], pos: Position) -> Vec<(Output, i32)> {
+fn get_edges(outputs: &[(WlOutput, OutputInfo)], pos: Position) -> Vec<(WlOutput, i32)> {
    outputs
        .iter()
-        .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,
-                    },
-                )
-            })
+        .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,
+                },
+            )
        })
        .collect()
 }

-fn get_output_configuration(state: &State, pos: Position) -> Vec<Output> {
+fn get_output_configuration(state: &State, pos: Position) -> Vec<(WlOutput, OutputInfo)> {
    // get all output edges corresponding to the position
-    let edges = get_edges(&state.outputs, pos);
-    let opposite_edges = get_edges(&state.outputs, pos.opposite());
+    let edges = get_edges(&state.output_info, pos);
+    log::debug!("edges: {edges:?}");
+    let opposite_edges = get_edges(&state.output_info, pos.opposite());

    // remove those edges that are at the same position
    // as an opposite edge of a different output
-    edges
+    let outputs: Vec<WlOutput> = 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()
 }

@@ -269,39 +256,39 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
    }
 }

-impl LayerShellInputCapture {
+impl WaylandInputCapture {
    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
        let conn = Connection::connect_to_env()?;
-        let (global_list, mut queue) = registry_queue_init::<State>(&conn)?;
+        let (g, mut queue) = registry_queue_init::<State>(&conn)?;

        let qh = queue.handle();

-        let compositor: wl_compositor::WlCompositor = global_list
+        let compositor: wl_compositor::WlCompositor = g
            .bind(&qh, 4..=5, ())
            .map_err(|e| WaylandBindError::new(e, "wl_compositor 4..=5"))?;
-        let xdg_output_manager: ZxdgOutputManagerV1 = global_list
+        let xdg_output_manager: ZxdgOutputManagerV1 = g
            .bind(&qh, 1..=3, ())
            .map_err(|e| WaylandBindError::new(e, "xdg_output_manager 1..=3"))?;
-        let shm: wl_shm::WlShm = global_list
+        let shm: wl_shm::WlShm = g
            .bind(&qh, 1..=1, ())
            .map_err(|e| WaylandBindError::new(e, "wl_shm"))?;
-        let layer_shell: ZwlrLayerShellV1 = global_list
+        let layer_shell: ZwlrLayerShellV1 = g
            .bind(&qh, 3..=4, ())
            .map_err(|e| WaylandBindError::new(e, "wlr_layer_shell 3..=4"))?;
-        let seat: wl_seat::WlSeat = global_list
+        let seat: wl_seat::WlSeat = g
            .bind(&qh, 7..=8, ())
            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;

-        let pointer_constraints: ZwpPointerConstraintsV1 = global_list
+        let pointer_constraints: ZwpPointerConstraintsV1 = g
            .bind(&qh, 1..=1, ())
            .map_err(|e| WaylandBindError::new(e, "zwp_pointer_constraints_v1"))?;
-        let relative_pointer_manager: ZwpRelativePointerManagerV1 = global_list
+        let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
            .bind(&qh, 1..=1, ())
            .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
        let shortcut_inhibit_manager: Result<
            ZwpKeyboardShortcutsInhibitManagerV1,
            WaylandBindError,
-        > = global_list
+        > = g
            .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
@@ -310,42 +297,66 @@ impl LayerShellInputCapture {
                to the client");
        }
        let shortcut_inhibit_manager = shortcut_inhibit_manager.ok();
+        let outputs = vec![];

-        let mut state = State {
-            active_positions: Default::default(),
-            pointer: None,
-            keyboard: None,
-            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: queue.as_fd().as_raw_fd(),
-            read_guard: None,
-            pending_events: VecDeque::new(),
-            outputs: vec![],
-            scroll_discrete_pending: false,
+        let g = Globals {
+            compositor,
+            shm,
+            layer_shell,
+            seat,
+            pointer_constraints,
+            relative_pointer_manager,
+            shortcut_inhibit_manager,
+            outputs,
+            xdg_output_manager,
        };

-        for global in state.global_list.contents().clone_list() {
-            state.register_global(global);
-        }
-
        // flush outgoing events
        queue.flush()?;

+        let wayland_fd = queue.as_fd().as_raw_fd();
+
+        let mut state = State {
+            pointer: None,
+            keyboard: None,
+            g,
+            pointer_lock: None,
+            rel_pointer: None,
+            shortcut_inhibitor: None,
+            client_for_window: Vec::new(),
+            focused: None,
+            qh,
+            wayland_fd,
+            read_guard: None,
+            pending_events: VecDeque::new(),
+            output_info: vec![],
+            scroll_discrete_pending: false,
+        };
+
+        // dispatch registry to () again, in order to read all wl_outputs
+        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());
+        }
+
+        // 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);
+        }
+
        let read_guard = loop {
            match queue.prepare_read() {
                Some(r) => break r,
@@ -359,71 +370,29 @@ impl LayerShellInputCapture {

        let inner = AsyncFd::new(Inner { queue, state })?;

-        Ok(LayerShellInputCapture(inner))
+        Ok(WaylandInputCapture(inner))
    }

-    fn add_client(&mut self, pos: Position) {
-        self.0.get_mut().state.add_client(pos);
+    fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
+        self.0.get_mut().state.add_client(handle, pos);
    }

-    fn delete_client(&mut self, pos: Position) {
+    fn delete_client(&mut self, handle: CaptureHandle) {
        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);
+        while let Some(i) = inner
+            .state
+            .client_for_window
+            .iter()
+            .position(|(_, c)| *c == handle)
+        {
+            inner.state.client_for_window.remove(i);
            inner.state.focused = None;
        }
    }
 }

 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,
@@ -431,7 +400,7 @@ impl State {
        serial: u32,
        qh: &QueueHandle<State>,
    ) {
-        let window = self.focused.as_ref().unwrap();
+        let (window, _) = self.focused.as_ref().unwrap();

        // hide the cursor
        pointer.set_cursor(serial, None, 0, 0);
@@ -444,7 +413,7 @@ impl State {

        // lock pointer
        if self.pointer_lock.is_none() {
-            self.pointer_lock = Some(self.globals.pointer_constraints.lock_pointer(
+            self.pointer_lock = Some(self.g.pointer_constraints.lock_pointer(
                surface,
                pointer,
                None,
@@ -456,7 +425,7 @@ impl State {

        // request relative input
        if self.rel_pointer.is_none() {
-            self.rel_pointer = Some(self.globals.relative_pointer_manager.get_relative_pointer(
+            self.rel_pointer = Some(self.g.relative_pointer_manager.get_relative_pointer(
                pointer,
                qh,
                (),
@@ -464,21 +433,17 @@ impl State {
        }

        // capture modifier keys
-        if let Some(shortcut_inhibit_manager) = &self.globals.shortcut_inhibit_manager {
+        if let Some(shortcut_inhibit_manager) = &self.g.shortcut_inhibit_manager {
            if self.shortcut_inhibitor.is_none() {
-                self.shortcut_inhibitor = Some(shortcut_inhibit_manager.inhibit_shortcuts(
-                    surface,
-                    &self.globals.seat,
-                    qh,
-                    (),
-                ));
+                self.shortcut_inhibitor =
+                    Some(shortcut_inhibit_manager.inhibit_shortcuts(surface, &self.g.seat, qh, ()));
            }
        }
    }

    fn ungrab(&mut self) {
        // get focused client
-        let window = match self.focused.as_ref() {
+        let (window, _client) = match self.focused.as_ref() {
            Some(focused) => focused,
            None => return,
        };
@@ -508,41 +473,27 @@ impl State {
        }
    }

-    fn add_client(&mut self, pos: Position) {
-        self.active_positions.insert(pos);
+    fn add_client(&mut self, client: CaptureHandle, pos: Position) {
        let outputs = get_output_configuration(self, pos);

-        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);
-            }
+        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.client_for_window.push((window, client));
        });
    }

    fn update_windows(&mut self) {
-        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);
+        log::debug!("updating windows");
+        log::debug!("output info: {:?}", self.output_info);
+        let clients: Vec<_> = self
+            .client_for_window
+            .drain(..)
+            .map(|(w, c)| (c, w.pos))
+            .collect();
+        for (client, pos) in clients {
+            self.add_client(client, pos);
        }
    }
 }
@@ -582,17 +533,17 @@ impl Inner {
        match self.queue.dispatch_pending(&mut self.state) {
            Ok(_) => {}
            Err(DispatchError::Backend(WaylandError::Io(e))) => {
-                log::error!("Wayland Error: {e}");
+                log::error!("Wayland Error: {}", e);
            }
            Err(DispatchError::Backend(e)) => {
-                panic!("backend error: {e}");
+                panic!("backend error: {}", e);
            }
            Err(DispatchError::BadMessage {
                sender_id,
                interface,
                opcode,
            }) => {
-                panic!("bad message {sender_id}, {interface} , {opcode}");
+                panic!("bad message {}, {} , {}", sender_id, interface, opcode);
            }
        }
    }
@@ -615,15 +566,15 @@ impl Inner {
 }

 #[async_trait]
-impl Capture for LayerShellInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.add_client(pos);
+impl Capture for WaylandInputCapture {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        self.add_client(handle, pos);
        let inner = self.0.get_mut();
        Ok(inner.flush_events()?)
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.delete_client(pos);
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        self.delete_client(handle);
        let inner = self.0.get_mut();
        Ok(inner.flush_events()?)
    }
@@ -640,8 +591,8 @@ impl Capture for LayerShellInputCapture {
    }
 }

-impl Stream for LayerShellInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+impl Stream for WaylandInputCapture {
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
@@ -706,16 +657,10 @@ impl Dispatch<wl_seat::WlSeat, ()> for State {
            capabilities: WEnum::Value(capabilities),
        } = event
        {
-            if capabilities.contains(wl_seat::Capability::Pointer) {
-                if let Some(p) = state.pointer.take() {
-                    p.release();
-                }
+            if capabilities.contains(wl_seat::Capability::Pointer) && state.pointer.is_none() {
                state.pointer.replace(seat.get_pointer(qh, ()));
            }
-            if capabilities.contains(wl_seat::Capability::Keyboard) {
-                if let Some(k) = state.keyboard.take() {
-                    k.release();
-                }
+            if capabilities.contains(wl_seat::Capability::Keyboard) && state.keyboard.is_none() {
                seat.get_keyboard(qh, ());
            }
        }
@@ -740,20 +685,23 @@ impl Dispatch<WlPointer, ()> for State {
            } => {
                // get client corresponding to the focused surface
                {
-                    if let Some(window) = app.active_windows.iter().find(|w| w.surface == surface) {
-                        app.focused = Some(window.clone());
+                    if let Some((window, client)) = app
+                        .client_for_window
+                        .iter()
+                        .find(|(w, _c)| w.surface == surface)
+                    {
+                        app.focused = Some((window.clone(), *client));
                        app.grab(&surface, pointer, serial, qh);
                    } else {
                        return;
                    }
                }
-                let pos = app
-                    .active_windows
+                let (_, client) = app
+                    .client_for_window
                    .iter()
-                    .find(|w| w.surface == surface)
-                    .map(|w| w.pos)
+                    .find(|(w, _c)| w.surface == surface)
                    .unwrap();
-                app.pending_events.push_back((pos, CaptureEvent::Begin));
+                app.pending_events.push_back((*client, CaptureEvent::Begin));
            }
            wl_pointer::Event::Leave { .. } => {
                /* There are rare cases, where when a window is opened in
@@ -774,9 +722,9 @@ impl Dispatch<WlPointer, ()> for State {
                button,
                state,
            } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                app.pending_events.push_back((
-                    window.pos,
+                    *client,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                        time,
                        button,
@@ -785,7 +733,7 @@ impl Dispatch<WlPointer, ()> for State {
                ));
            }
            wl_pointer::Event::Axis { time, axis, value } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                if app.scroll_discrete_pending {
                    // each axisvalue120 event is coupled with
                    // a corresponding axis event, which needs to
@@ -793,7 +741,7 @@ impl Dispatch<WlPointer, ()> for State {
                    app.scroll_discrete_pending = false;
                } else {
                    app.pending_events.push_back((
-                        window.pos,
+                        *client,
                        CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
                            time,
                            axis: u32::from(axis) as u8,
@@ -803,17 +751,17 @@ impl Dispatch<WlPointer, ()> for State {
                }
            }
            wl_pointer::Event::AxisValue120 { axis, value120 } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                app.scroll_discrete_pending = true;
                app.pending_events.push_back((
-                    window.pos,
+                    *client,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::AxisDiscrete120 {
                        axis: u32::from(axis) as u8,
                        value: value120,
                    })),
                ));
            }
-            wl_pointer::Event::Frame => {
+            wl_pointer::Event::Frame {} => {
                // TODO properly handle frame events
                // we simply insert a frame event on the client side
                // after each event for now
@@ -832,7 +780,10 @@ impl Dispatch<WlKeyboard, ()> for State {
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
-        let window = &app.focused;
+        let (_window, client) = match &app.focused {
+            Some(focused) => (Some(&focused.0), Some(&focused.1)),
+            None => (None, None),
+        };
        match event {
            wl_keyboard::Event::Key {
                serial: _,
@@ -840,9 +791,9 @@ impl Dispatch<WlKeyboard, ()> for State {
                key,
                state,
            } => {
-                if let Some(window) = window {
+                if let Some(client) = client {
                    app.pending_events.push_back((
-                        window.pos,
+                        *client,
                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
                            time,
                            key,
@@ -858,9 +809,9 @@ impl Dispatch<WlKeyboard, ()> for State {
                mods_locked,
                group,
            } => {
-                if let Some(window) = window {
+                if let Some(client) = client {
                    app.pending_events.push_back((
-                        window.pos,
+                        *client,
                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Modifiers {
                            depressed: mods_depressed,
                            latched: mods_latched,
@@ -892,10 +843,10 @@ 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;
+            if let Some((_window, client)) = &app.focused {
+                let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
                app.pending_events.push_back((
-                    window.pos,
+                    *client,
                    CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { time, dx, dy })),
                ));
            }
@@ -913,10 +864,10 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
        _: &QueueHandle<Self>,
    ) {
        if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
-            if let Some(window) = app
-                .active_windows
+            if let Some((window, _client)) = app
+                .client_for_window
                .iter()
-                .find(|w| &w.layer_surface == layer_surface)
+                .find(|(w, _c)| &w.layer_surface == layer_surface)
            {
                // client corresponding to the layer_surface
                let surface = &window.surface;
@@ -930,89 +881,94 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
 }

 // delegate wl_registry events to App itself
-impl Dispatch<WlRegistry, GlobalListContents> for State {
+impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
    fn event(
-        state: &mut Self,
-        _registry: &WlRegistry,
-        event: <WlRegistry as wayland_client::Proxy>::Event,
+        _state: &mut Self,
+        _proxy: &wl_registry::WlRegistry,
+        _event: <wl_registry::WlRegistry as wayland_client::Proxy>::Event,
        _data: &GlobalListContents,
        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<wl_registry::WlRegistry, ()> for State {
+    fn event(
+        state: &mut Self,
+        registry: &wl_registry::WlRegistry,
+        event: <wl_registry::WlRegistry as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        qh: &QueueHandle<Self>,
    ) {
        match event {
            wl_registry::Event::Global {
                name,
                interface,
-                version,
+                version: _,
            } => {
-                state.register_global(Global {
-                    name,
-                    interface,
-                    version,
-                });
-            }
-            wl_registry::Event::GlobalRemove { name } => {
-                state.deregister_global(name);
+                if interface.as_str() == "wl_output" {
+                    log::debug!("wl_output global");
+                    state
+                        .g
+                        .outputs
+                        .push(registry.bind::<WlOutput, _, _>(name, 4, qh, ()))
+                }
            }
+            wl_registry::Event::GlobalRemove { .. } => {}
            _ => {}
        }
    }
 }

-impl Dispatch<ZxdgOutputV1, u32> for State {
+impl Dispatch<ZxdgOutputV1, WlOutput> for State {
    fn event(
        state: &mut Self,
        _: &ZxdgOutputV1,
        event: <ZxdgOutputV1 as wayland_client::Proxy>::Event,
-        name: &u32,
+        wl_output: &WlOutput,
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
-        let output = state
-            .outputs
-            .iter_mut()
-            .find(|o| o.global.name == *name)
-            .expect("output");
+        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
+            }
+        };

-        log::debug!("xdg_output {name} - {event:?}");
        match event {
            zxdg_output_v1::Event::LogicalPosition { x, y } => {
-                output.pending_info.position = (x, y);
-                output.has_xdg_info = true;
+                output_info.position = (x, y);
            }
            zxdg_output_v1::Event::LogicalSize { 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);
+                output_info.size = (width, height);
            }
+            zxdg_output_v1::Event::Done => {}
            zxdg_output_v1::Event::Name { name } => {
-                output.pending_info.name = name;
-                output.has_xdg_info = true;
+                output_info.name = name;
            }
-            zxdg_output_v1::Event::Description { description } => {
-                output.pending_info.description = description;
-                output.has_xdg_info = true;
-            }
-            _ => todo!(),
+            zxdg_output_v1::Event::Description { .. } => {}
+            _ => {}
        }
    }
 }

-impl Dispatch<WlOutput, u32> for State {
+impl Dispatch<WlOutput, ()> for State {
    fn event(
        state: &mut Self,
-        _wl_output: &WlOutput,
+        _proxy: &WlOutput,
        event: <WlOutput as wayland_client::Proxy>::Event,
-        name: &u32,
+        _data: &(),
        _conn: &Connection,
        _qhandle: &QueueHandle<Self>,
    ) {
-        log::debug!("wl_output {name} - {event:?}");
        if let wl_output::Event::Done = event {
-            state.update_output_info(*name);
+            state.update_windows();
        }
    }
 }
--- a/input-capture/src/windows.rs
+++ b/input-capture/src/windows.rs
@@ -1,36 +1,94 @@
 use async_trait::async_trait;
 use core::task::{Context, Poll};
-use event_thread::EventThread;
 use futures::Stream;
-use std::pin::Pin;
+use once_cell::unsync::Lazy;

+use std::collections::HashMap;
+use std::ptr::{addr_of, addr_of_mut};
+
+use futures::executor::block_on;
+use std::default::Default;
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::{mpsc, Mutex};
 use std::task::ready;
-use tokio::sync::mpsc::{channel, Receiver};
+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 super::{Capture, CaptureError, CaptureEvent, Position};
+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,
+};

-mod display_util;
-mod event_thread;
+use input_event::{
+    scancode::{self, Linux},
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+};
+
+use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
+
+enum Request {
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+}

 pub struct WindowsInputCapture {
-    event_rx: Receiver<(Position, CaptureEvent)>,
-    event_thread: EventThread,
+    event_rx: Receiver<(CaptureHandle, 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!();
+    }
 }

 #[async_trait]
 impl Capture for WindowsInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.event_thread.create(pos);
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        unsafe {
+            {
+                let mut requests = REQUEST_BUFFER.lock().unwrap();
+                requests.push(Request::Create(handle, pos));
+            }
+            signal_message_thread(EventType::Request);
+        }
        Ok(())
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.event_thread.destroy(pos);
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        unsafe {
+            {
+                let mut requests = REQUEST_BUFFER.lock().unwrap();
+                requests.push(Request::Destroy(handle));
+            }
+            signal_message_thread(EventType::Request);
+        }
        Ok(())
    }

    async fn release(&mut self) -> Result<(), CaptureError> {
-        self.event_thread.release_capture();
+        unsafe { signal_message_thread(EventType::Release) };
        Ok(())
    }

@@ -39,19 +97,524 @@ impl Capture for WindowsInputCapture {
    }
 }

+static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
+static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
+static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
+static mut EVENT_TX: Option<Sender<(CaptureHandle, 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 */
+    let Some(client) = CLIENT_FOR_POS.get(&pos) else {
+        return ret;
+    };
+
+    /* update active client and entry point */
+    ACTIVE_CLIENT.replace(*client);
+    ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);
+
+    /* notify main thread */
+    log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
+    send_blocking(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(client) = ACTIVE_CLIENT else {
+        return LRESULT(1);
+    };
+
+    /* convert to lan-mouse event */
+    let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
+        return LRESULT(1);
+    };
+    let event = (client, 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"),
+        }
+    }
+}
+
+fn message_thread(ready_tx: mpsc::Sender<()>) {
+    unsafe {
+        set_event_tid(GetCurrentThreadId());
+        ready_tx.send(()).expect("channel closed");
+        let mouse_proc: HOOKPROC = Some(mouse_proc);
+        let kybrd_proc: HOOKPROC = Some(kybrd_proc);
+        let window_proc: WNDPROC = Some(window_proc);
+
+        /* register hooks */
+        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
+        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
+
+        let instance = GetModuleHandleW(None).unwrap();
+        let window_class: WNDCLASSW = WNDCLASSW {
+            lpfnWndProc: window_proc,
+            hInstance: instance.into(),
+            lpszClassName: w!("lan-mouse-message-window-class"),
+            ..Default::default()
+        };
+
+        let ret = RegisterClassW(&window_class);
+        if ret == 0 {
+            panic!("RegisterClassW");
+        }
+
+        /* window is used ro receive WM_DISPLAYCHANGE messages */
+        CreateWindowExW(
+            Default::default(),
+            w!("lan-mouse-message-window-class"),
+            w!("lan-mouse-msg-window"),
+            WINDOW_STYLE::default(),
+            0,
+            0,
+            0,
+            0,
+            HWND::default(),
+            HMENU::default(),
+            instance,
+            None,
+        )
+        .expect("CreateWindowExW");
+
+        /* run message loop */
+        loop {
+            // mouse / keybrd proc do not actually return a message
+            let Some(msg) = get_msg() else {
+                break;
+            };
+            if msg.hwnd.0.is_null() {
+                /* messages sent via PostThreadMessage */
+                match msg.wParam.0 {
+                    x if x == EventType::Exit as usize => break,
+                    x if x == EventType::Release as usize => {
+                        ACTIVE_CLIENT.take();
+                    }
+                    x if x == EventType::Request as usize => {
+                        let requests = {
+                            let mut res = vec![];
+                            let mut requests = REQUEST_BUFFER.lock().unwrap();
+                            for request in requests.drain(..) {
+                                res.push(request);
+                            }
+                            res
+                        };
+
+                        for request in requests {
+                            update_clients(request)
+                        }
+                    }
+                    _ => {}
+                }
+            } else {
+                /* other messages for window_procs */
+                let _ = TranslateMessage(&msg);
+                DispatchMessageW(&msg);
+            }
+        }
+    }
+}
+
+fn update_clients(request: Request) {
+    match request {
+        Request::Create(handle, pos) => {
+            unsafe { CLIENT_FOR_POS.insert(pos, handle) };
+        }
+        Request::Destroy(handle) => unsafe {
+            for pos in [
+                Position::Left,
+                Position::Right,
+                Position::Top,
+                Position::Bottom,
+            ] {
+                if ACTIVE_CLIENT == Some(handle) {
+                    ACTIVE_CLIENT.take();
+                }
+                if CLIENT_FOR_POS.get(&pos).copied() == Some(handle) {
+                    CLIENT_FOR_POS.remove(&pos);
+                }
+            }
+        },
+    }
+}
+
 impl WindowsInputCapture {
    pub(crate) fn new() -> Self {
-        let (event_tx, event_rx) = channel(10);
-        let event_thread = EventThread::new(event_tx);
-        Self {
-            event_thread,
-            event_rx,
+        unsafe {
+            let (tx, rx) = channel(10);
+            EVENT_TX.replace(tx);
+            let (ready_tx, ready_rx) = mpsc::channel();
+            let msg_thread = Some(thread::spawn(|| message_thread(ready_tx)));
+            /* wait for thread to set its id */
+            ready_rx.recv().expect("channel closed");
+            Self {
+                msg_thread,
+                event_rx: rx,
+            }
        }
    }
 }

 impl Stream for WindowsInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match ready!(self.event_rx.poll_recv(cx)) {
            None => Poll::Ready(None),
@@ -59,3 +622,10 @@ 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();
+    }
+}
--- a/input-capture/src/windows/display_util.rs
+++ b/input-capture/src/windows/display_util.rs
@@ -1,99 +0,0 @@
-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))
-}
--- a/input-capture/src/windows/event_thread.rs
+++ b/input-capture/src/windows/event_thread.rs
@@ -1,553 +0,0 @@
-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, 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, 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_MOUSEHWHEEL, 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), None, 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, None, 0).unwrap();
-        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, None, 0).unwrap();
-    }
-
-    let instance = unsafe { GetModuleHandleW(None).unwrap() };
-    let instance = instance.into();
-    let window_class: WNDCLASSW = WNDCLASSW {
-        lpfnWndProc: window_proc,
-        hInstance: instance,
-        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,
-            None,
-            None,
-            Some(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(None, 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(None, 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
-                .contains(DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
-            {
-                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 },
-            })
-        }
-        WPARAM(p) if p == WM_MOUSEHWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
-            axis: 1, // Horizontal
-            value: mouse_low_level.mouseData as i32 >> 16,
-        }),
-        w => {
-            log::warn!("unknown mouse event: {w:?}");
-            None
-        }
-    }
-}
--- a/input-capture/src/x11.rs
+++ b/input-capture/src/x11.rs
@@ -3,7 +3,10 @@ use std::task::Poll;
 use async_trait::async_trait;
 use futures_core::Stream;

-use super::{error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
+use super::{
+    error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle,
+    Position,
+};

 pub struct X11InputCapture {}

@@ -15,11 +18,11 @@ impl X11InputCapture {

 #[async_trait]
 impl Capture for X11InputCapture {
-    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
        Ok(())
    }

-    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
        Ok(())
    }

@@ -33,7 +36,7 @@ impl Capture for X11InputCapture {
 }

 impl Stream for X11InputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;

    fn poll_next(
        self: std::pin::Pin<&mut Self>,
--- a/input-emulation/Cargo.toml
+++ b/input-emulation/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-emulation"
 description = "cross-platform input emulation library used by lan-mouse"
-version = "0.3.0"
+version = "0.2.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -10,8 +10,8 @@ repository = "https://github.com/feschber/lan-mouse"
 async-trait = "0.1.80"
 futures = "0.3.28"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.3.0" }
-thiserror = "2.0.0"
+input-event = { path = "../input-event", version = "0.2.1" }
+thiserror = "1.0.61"
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
@@ -25,7 +25,6 @@ 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",
@@ -39,18 +38,17 @@ wayland-protocols-misc = { version = "0.3.1", features = [
    "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.9", default-features = false, features = [
    "tokio",
 ], optional = true }
-reis = { version = "0.5.0", features = ["tokio"], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
-bitflags = "2.6.0"
-core-graphics = { version = "0.25.0", features = ["highsierra"] }
-keycode = "1.0.0"
+core-graphics = { version = "0.23", features = ["highsierra"] }
+keycode = "0.4.0"

 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.61.2", features = [
+windows = { version = "0.58.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
@@ -61,13 +59,13 @@ windows = { version = "0.61.2", features = [
 ] }

 [features]
-default = ["wlroots", "x11", "remote_desktop_portal", "libei"]
-wlroots = [
+default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
+wayland = [
    "dep:wayland-client",
    "dep:wayland-protocols",
    "dep:wayland-protocols-wlr",
    "dep:wayland-protocols-misc",
 ]
 x11 = ["dep:x11"]
-remote_desktop_portal = ["dep:ashpd"]
+xdg_desktop_portal = ["dep:ashpd"]
 libei = ["dep:reis", "dep:ashpd"]
--- a/input-emulation/src/error.rs
+++ b/input-emulation/src/error.rs
@@ -6,35 +6,53 @@ pub enum InputEmulationError {
    Emulate(#[from] EmulationError),
 }

-#[cfg(all(
-    unix,
-    any(feature = "remote_desktop_portal", feature = "libei"),
-    not(target_os = "macos")
-))]
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use ashpd::{desktop::ResponseError, Error::Response};
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::EiConvertEventStreamError;
 use std::io;
 use thiserror::Error;

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
    globals::{BindError, GlobalError},
    ConnectError, DispatchError,
 };

+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::HandshakeError;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+#[error("error in libei stream: {inner:?}")]
+pub struct ReisConvertStreamError {
+    inner: EiConvertEventStreamError,
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl From<EiConvertEventStreamError> for ReisConvertStreamError {
+    fn from(e: EiConvertEventStreamError) -> Self {
+        Self { inner: e }
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum EmulationError {
    #[error("event stream closed")]
    EndOfStream,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei error: `{0}`")]
-    Libei(#[from] reis::Error),
-    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+    #[error("libei error flushing events: `{0}`")]
+    Libei(#[from] reis::event::Error),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("")]
+    LibeiConvertStream(#[from] ReisConvertStreamError),
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wayland error: `{0}`")]
    Wayland(#[from] wayland_client::backend::WaylandError),
    #[cfg(all(
        unix,
-        any(feature = "remote_desktop_portal", feature = "libei"),
+        any(feature = "xdg_desktop_portal", feature = "libei"),
        not(target_os = "macos")
    ))]
    #[error("xdg-desktop-portal: `{0}`")]
@@ -45,13 +63,13 @@ pub enum EmulationError {

 #[derive(Debug, Error)]
 pub enum EmulationCreationError {
-    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wlroots backend: `{0}`")]
    Wlroots(#[from] WlrootsEmulationCreationError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei backend: `{0}`")]
    Libei(#[from] LibeiEmulationCreationError),
-    #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
    #[error("xdg-desktop-portal: `{0}`")]
    Xdp(#[from] XdpEmulationCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -79,7 +97,7 @@ impl EmulationCreationError {
        ) {
            return true;
        }
-        #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
        if matches!(
            self,
            EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
@@ -92,7 +110,7 @@ impl EmulationCreationError {
    }
 }

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum WlrootsEmulationCreationError {
    #[error(transparent)]
@@ -109,7 +127,7 @@ pub enum WlrootsEmulationCreationError {
    Io(#[from] std::io::Error),
 }

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("wayland protocol \"{protocol}\" not supported: {inner}")]
 pub struct WaylandBindError {
@@ -117,7 +135,7 @@ pub struct WaylandBindError {
    protocol: &'static str,
 }

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
        Self { inner, protocol }
@@ -132,10 +150,10 @@ pub enum LibeiEmulationCreationError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
-    Reis(#[from] reis::Error),
+    Handshake(#[from] HandshakeError),
 }

-#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum XdpEmulationCreationError {
    #[error(transparent)]
--- a/input-emulation/src/lib.rs
+++ b/input-emulation/src/lib.rs
@@ -14,10 +14,10 @@ mod windows;
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 mod x11;

-#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 mod wlroots;

-#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 mod xdg_desktop_portal;

 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
@@ -34,11 +34,11 @@ pub type EmulationHandle = u64;

 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Backend {
-    #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    Wlroots,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    Libei,
-    #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
    Xdp,
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
@@ -52,11 +52,11 @@ pub enum Backend {
 impl Display for Backend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::Wlroots => write!(f, "wlroots"),
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei => write!(f, "libei"),
-            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp => write!(f, "xdg-desktop-portal"),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => write!(f, "X11"),
@@ -78,13 +78,13 @@ pub struct InputEmulation {
 impl InputEmulation {
    async fn with_backend(backend: Backend) -> Result<InputEmulation, EmulationCreationError> {
        let emulation: Box<dyn Emulation> = match backend {
-            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::Wlroots => Box::new(wlroots::WlrootsEmulation::new()?),
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei => Box::new(libei::LibeiEmulation::new().await?),
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11 => Box::new(x11::X11Emulation::new()?),
-            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp => Box::new(xdg_desktop_portal::DesktopPortalEmulation::new().await?),
            #[cfg(windows)]
            Backend::Windows => Box::new(windows::WindowsEmulation::new()?),
@@ -109,11 +109,11 @@ impl InputEmulation {
        }

        for backend in [
-            #[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            Backend::Wlroots,
            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            Backend::Libei,
-            #[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            Backend::Xdp,
            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            Backend::X11,
--- a/input-emulation/src/libei.rs
+++ b/input-emulation/src/libei.rs
@@ -1,18 +1,23 @@
 use futures::{future, StreamExt};
+use once_cell::sync::Lazy;
 use std::{
+    collections::HashMap,
    io,
    os::{fd::OwnedFd, unix::net::UnixStream},
    sync::{
-        atomic::{AtomicBool, Ordering},
+        atomic::{AtomicBool, AtomicU32, Ordering},
        Arc, Mutex, RwLock,
    },
    time::{SystemTime, UNIX_EPOCH},
 };
 use tokio::task::JoinHandle;

-use ashpd::desktop::{
-    remote_desktop::{DeviceType, RemoteDesktop},
-    PersistMode, Session,
+use ashpd::{
+    desktop::{
+        remote_desktop::{DeviceType, RemoteDesktop},
+        PersistMode, Session,
+    },
+    WindowIdentifier,
 };
 use async_trait::async_trait;

@@ -21,16 +26,32 @@ use reis::{
        self, button::ButtonState, handshake::ContextType, keyboard::KeyState, Button, Keyboard,
        Pointer, Scroll,
    },
-    event::{self, Connection, DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
-    tokio::EiConvertEventStream,
+    event::{DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
+    tokio::{ei_handshake, EiConvertEventStream, EiEventStream},
 };

 use input_event::{Event, KeyboardEvent, PointerEvent};

-use crate::error::EmulationError;
+use crate::error::{EmulationError, ReisConvertStreamError};

 use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};

+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
 #[derive(Clone, Default)]
 struct Devices {
    pointer: Arc<RwLock<Option<(ei::Device, ei::Pointer)>>>,
@@ -41,11 +62,11 @@ struct Devices {

 pub(crate) struct LibeiEmulation<'a> {
    context: ei::Context,
-    conn: event::Connection,
    devices: Devices,
    ei_task: JoinHandle<()>,
    error: Arc<Mutex<Option<EmulationError>>>,
    libei_error: Arc<AtomicBool>,
+    serial: AtomicU32,
    _remote_desktop: RemoteDesktop<'a>,
    session: Session<'a, RemoteDesktop<'a>>,
 }
@@ -68,27 +89,35 @@ async fn get_ei_fd<'a>(
        .await?;

    log::info!("requesting permission for input emulation");
-    let _devices = remote_desktop.start(&session, None).await?.response()?;
+    let _devices = remote_desktop
+        .start(&session, &WindowIdentifier::default())
+        .await?
+        .response()?;

    let fd = remote_desktop.connect_to_eis(&session).await?;
    Ok((remote_desktop, session, fd))
 }

-impl LibeiEmulation<'_> {
+impl<'a> LibeiEmulation<'a> {
    pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
        let (_remote_desktop, session, eifd) = get_ei_fd().await?;
        let stream = UnixStream::from(eifd);
        stream.set_nonblocking(true)?;
        let context = ei::Context::new(stream)?;
-        let (conn, events) = context
-            .handshake_tokio("de.feschber.LanMouse", ContextType::Sender)
-            .await?;
+        let mut events = EiEventStream::new(context.clone())?;
+        let handshake = ei_handshake(
+            &mut events,
+            "de.feschber.LanMouse",
+            ContextType::Sender,
+            &INTERFACES,
+        )
+        .await?;
+        let events = EiConvertEventStream::new(events, handshake.serial);
        let devices = Devices::default();
        let libei_error = Arc::new(AtomicBool::default());
        let error = Arc::new(Mutex::new(None));
        let ei_handler = ei_task(
            events,
-            conn.clone(),
            context.clone(),
            devices.clone(),
            libei_error.clone(),
@@ -96,27 +125,29 @@ impl LibeiEmulation<'_> {
        );
        let ei_task = tokio::task::spawn_local(ei_handler);

+        let serial = AtomicU32::new(handshake.serial);
+
        Ok(Self {
            context,
-            conn,
            devices,
            ei_task,
            error,
            libei_error,
+            serial,
            _remote_desktop,
            session,
        })
    }
 }

-impl Drop for LibeiEmulation<'_> {
+impl<'a> Drop for LibeiEmulation<'a> {
    fn drop(&mut self) {
        self.ei_task.abort();
    }
 }

 #[async_trait]
-impl Emulation for LibeiEmulation<'_> {
+impl<'a> Emulation for LibeiEmulation<'a> {
    async fn consume(
        &mut self,
        event: Event,
@@ -138,7 +169,7 @@ impl Emulation for LibeiEmulation<'_> {
                    let pointer_device = self.devices.pointer.read().unwrap();
                    if let Some((d, p)) = pointer_device.as_ref() {
                        p.motion_relative(dx as f32, dy as f32);
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                PointerEvent::Button {
@@ -155,7 +186,7 @@ impl Emulation for LibeiEmulation<'_> {
                                _ => ButtonState::Press,
                            },
                        );
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                PointerEvent::Axis {
@@ -169,7 +200,7 @@ impl Emulation for LibeiEmulation<'_> {
                            0 => s.scroll(0., value as f32),
                            _ => s.scroll(value as f32, 0.),
                        }
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                PointerEvent::AxisDiscrete120 { axis, value } => {
@@ -179,7 +210,7 @@ impl Emulation for LibeiEmulation<'_> {
                            0 => s.scroll_discrete(0, value),
                            _ => s.scroll_discrete(value, 0),
                        }
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
            },
@@ -198,7 +229,7 @@ impl Emulation for LibeiEmulation<'_> {
                                _ => KeyState::Press,
                            },
                        );
-                        d.frame(self.conn.serial(), now);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
                KeyboardEvent::Modifiers { .. } => {}
@@ -221,7 +252,6 @@ impl Emulation for LibeiEmulation<'_> {

 async fn ei_task(
    mut events: EiConvertEventStream,
-    _conn: Connection,
    context: ei::Context,
    devices: Devices,
    libei_error: Arc<AtomicBool>,
@@ -246,7 +276,11 @@ async fn ei_event_handler(
    devices: &Devices,
 ) -> Result<(), EmulationError> {
    loop {
-        let event = events.next().await.ok_or(EmulationError::EndOfStream)??;
+        let event = events
+            .next()
+            .await
+            .ok_or(EmulationError::EndOfStream)?
+            .map_err(ReisConvertStreamError::from)?;
        const CAPABILITIES: &[DeviceCapability] = &[
            DeviceCapability::Pointer,
            DeviceCapability::PointerAbsolute,
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -1,23 +1,15 @@
 use super::{error::EmulationError, Emulation, EmulationHandle};
 use async_trait::async_trait;
-use bitflags::bitflags;
-use core_graphics::base::CGFloat;
-use core_graphics::display::{
-    CGDirectDisplayID, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
-};
+use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
 use core_graphics::event::{
-    CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField,
-    ScrollEventUnit,
+    CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};
 use keycode::{KeyMap, KeyMapping};
-use std::cell::Cell;
 use std::ops::{Index, IndexMut};
-use std::rc::Rc;
-use std::sync::Arc;
 use std::time::Duration;
-use tokio::{sync::Notify, task::JoinHandle};
+use tokio::task::AbortHandle;

 use super::error::MacOSEmulationCreationError;

@@ -26,10 +18,8 @@ const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);

 pub(crate) struct MacOSEmulation {
    event_source: CGEventSource,
-    repeat_task: Option<JoinHandle<()>>,
+    repeat_task: Option<AbortHandle>,
    button_state: ButtonState,
-    modifier_state: Rc<Cell<XMods>>,
-    notify_repeat_task: Arc<Notify>,
 }

 struct ButtonState {
@@ -75,8 +65,6 @@ impl MacOSEmulation {
            event_source,
            button_state,
            repeat_task: None,
-            notify_repeat_task: Arc::new(Notify::new()),
-            modifier_state: Rc::new(Cell::new(XMods::empty())),
        })
    }

@@ -88,40 +76,25 @@ impl MacOSEmulation {
    async fn spawn_repeat_task(&mut self, key: u16) {
        // there can only be one repeating key and it's
        // always the last to be pressed
-        self.cancel_repeat_task().await;
+        self.kill_repeat_task();
        let event_source = self.event_source.clone();
-        let notify = self.notify_repeat_task.clone();
-        let modifiers = self.modifier_state.clone();
        let repeat_task = tokio::task::spawn_local(async move {
-            let stop = tokio::select! {
-                _ = tokio::time::sleep(DEFAULT_REPEAT_DELAY) => false,
-                _ = notify.notified() => true,
-            };
-            if !stop {
-                loop {
-                    key_event(event_source.clone(), key, 1, modifiers.get());
-                    tokio::select! {
-                        _ = tokio::time::sleep(DEFAULT_REPEAT_INTERVAL) => {},
-                        _ = notify.notified() => break,
-                    }
-                }
+            tokio::time::sleep(DEFAULT_REPEAT_DELAY).await;
+            loop {
+                key_event(event_source.clone(), key, 1);
+                tokio::time::sleep(DEFAULT_REPEAT_INTERVAL).await;
            }
-            // release key when cancelled
-            update_modifiers(&modifiers, key as u32, 0);
-            key_event(event_source.clone(), key, 0, modifiers.get());
        });
-        self.repeat_task = Some(repeat_task);
+        self.repeat_task = Some(repeat_task.abort_handle());
    }
-
-    async fn cancel_repeat_task(&mut self) {
+    fn kill_repeat_task(&mut self) {
        if let Some(task) = self.repeat_task.take() {
-            self.notify_repeat_task.notify_waiters();
-            let _ = task.await;
+            task.abort();
        }
    }
 }

-fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods) {
+fn key_event(event_source: CGEventSource, key: u16, state: u8) {
    let event = match CGEvent::new_keyboard_event(event_source, key, state != 0) {
        Ok(e) => e,
        Err(_) => {
@@ -129,92 +102,7 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods)
            return;
        }
    };
-    event.set_flags(to_cgevent_flags(modifiers));
    event.post(CGEventTapLocation::HID);
-    log::trace!("key event: {key} {state}");
-}
-
-fn modifier_event(event_source: CGEventSource, depressed: XMods) {
-    let Ok(event) = CGEvent::new(event_source) else {
-        log::warn!("could not create CGEvent");
-        return;
-    };
-    let flags = to_cgevent_flags(depressed);
-    event.set_type(CGEventType::FlagsChanged);
-    event.set_flags(flags);
-    event.post(CGEventTapLocation::HID);
-    log::trace!("modifiers updated: {depressed:?}");
-}
-
-fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
-    let mut displays: [CGDirectDisplayID; 16] = [0; 16];
-    let mut display_count: u32 = 0;
-    let rect = CGRect::new(&CGPoint::new(x, y), &CGSize::new(0.0, 0.0));
-
-    let error = unsafe {
-        CGGetDisplaysWithRect(
-            rect,
-            1,
-            displays.as_mut_ptr(),
-            &mut display_count as *mut u32,
-        )
-    };
-
-    if error != 0 {
-        log::warn!("error getting displays at point ({x}, {y}): {error}");
-        return Option::None;
-    }
-
-    if display_count == 0 {
-        log::debug!("no displays found at point ({x}, {y})");
-        return Option::None;
-    }
-
-    displays.first().copied()
-}
-
-fn get_display_bounds(display: CGDirectDisplayID) -> (CGFloat, CGFloat, CGFloat, CGFloat) {
-    unsafe {
-        let bounds = CGDisplayBounds(display);
-        let min_x = bounds.origin.x;
-        let max_x = bounds.origin.x + bounds.size.width;
-        let min_y = bounds.origin.y;
-        let max_y = bounds.origin.y + bounds.size.height;
-        (min_x as f64, min_y as f64, max_x as f64, max_y as f64)
-    }
-}
-
-fn clamp_to_screen_space(
-    current_x: CGFloat,
-    current_y: CGFloat,
-    dx: CGFloat,
-    dy: CGFloat,
-) -> (CGFloat, CGFloat) {
-    // Check which display the mouse is currently on
-    // Determine what the location of the mouse would be after applying the move
-    // Get the display at the new location
-    // If the point is not on a display
-    //   Clamp the mouse to the current display
-    // Else If the point is on a display
-    //   Clamp the mouse to the new display
-    let current_display = match get_display_at_point(current_x, current_y) {
-        Some(display) => display,
-        None => {
-            log::warn!("could not get current display!");
-            return (current_x, current_y);
-        }
-    };
-
-    let new_x = current_x + dx;
-    let new_y = current_y + dy;
-
-    let final_display = get_display_at_point(new_x, new_y).unwrap_or(current_display);
-    let (min_x, min_y, max_x, max_y) = get_display_bounds(final_display);
-
-    (
-        new_x.clamp(min_x, max_x - 1.),
-        new_y.clamp(min_y, max_y - 1.),
-    )
 }

 #[async_trait]
@@ -227,6 +115,16 @@ impl Emulation for MacOSEmulation {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
                PointerEvent::Motion { time: _, dx, dy } => {
+                    // FIXME secondary displays?
+                    let (min_x, min_y, max_x, max_y) = unsafe {
+                        let display = CGMainDisplayID();
+                        let bounds = CGDisplayBounds(display);
+                        let min_x = bounds.origin.x;
+                        let max_x = bounds.origin.x + bounds.size.width;
+                        let min_y = bounds.origin.y;
+                        let max_y = bounds.origin.y + bounds.size.height;
+                        (min_x as f64, min_y as f64, max_x as f64, max_y as f64)
+                    };
                    let mut mouse_location = match self.get_mouse_location() {
                        Some(l) => l,
                        None => {
@@ -235,11 +133,8 @@ impl Emulation for MacOSEmulation {
                        }
                    };

-                    let (new_mouse_x, new_mouse_y) =
-                        clamp_to_screen_space(mouse_location.x, mouse_location.y, dx, dy);
-
-                    mouse_location.x = new_mouse_x;
-                    mouse_location.y = new_mouse_y;
+                    mouse_location.x = (mouse_location.x + dx).clamp(min_x, max_x - 1.);
+                    mouse_location.y = (mouse_location.y + dy).clamp(min_y, max_y - 1.);

                    let mut event_type = CGEventType::MouseMoved;
                    if self.button_state.left {
@@ -384,25 +279,11 @@ impl Emulation for MacOSEmulation {
                    match state {
                        // pressed
                        1 => self.spawn_repeat_task(code).await,
-                        _ => self.cancel_repeat_task().await,
+                        _ => self.kill_repeat_task(),
                    }
-                    update_modifiers(&self.modifier_state, key, state);
-                    key_event(
-                        self.event_source.clone(),
-                        code,
-                        state,
-                        self.modifier_state.get(),
-                    );
-                }
-                KeyboardEvent::Modifiers {
-                    depressed,
-                    latched,
-                    locked,
-                    group,
-                } => {
-                    set_modifiers(&self.modifier_state, depressed, latched, locked, group);
-                    modifier_event(self.event_source.clone(), self.modifier_state.get());
+                    key_event(self.event_source.clone(), code, state)
                }
+                KeyboardEvent::Modifiers { .. } => {}
            },
        }
        // FIXME
@@ -415,81 +296,3 @@ impl Emulation for MacOSEmulation {

    async fn terminate(&mut self) {}
 }
-
-fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
-    if let Ok(key) = scancode::Linux::try_from(key) {
-        let mask = match key {
-            scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
-            scancode::Linux::KeyCapsLock => XMods::LockMask,
-            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(),
-        };
-        // unchanged
-        if mask.is_empty() {
-            return false;
-        }
-        let mut mods = modifiers.get();
-        match state {
-            1 => mods.insert(mask),
-            _ => mods.remove(mask),
-        }
-        modifiers.set(mods);
-        true
-    } else {
-        false
-    }
-}
-
-fn set_modifiers(
-    active_modifiers: &Cell<XMods>,
-    depressed: u32,
-    latched: u32,
-    locked: u32,
-    group: u32,
-) {
-    let depressed = XMods::from_bits(depressed).unwrap_or_default();
-    let _latched = XMods::from_bits(latched).unwrap_or_default();
-    let _locked = XMods::from_bits(locked).unwrap_or_default();
-    let _group = XMods::from_bits(group).unwrap_or_default();
-
-    // we only care about the depressed modifiers for now
-    active_modifiers.replace(depressed);
-}
-
-fn to_cgevent_flags(depressed: XMods) -> CGEventFlags {
-    let mut flags = CGEventFlags::empty();
-    if depressed.contains(XMods::ShiftMask) {
-        flags |= CGEventFlags::CGEventFlagShift;
-    }
-    if depressed.contains(XMods::LockMask) {
-        flags |= CGEventFlags::CGEventFlagAlphaShift;
-    }
-    if depressed.contains(XMods::ControlMask) {
-        flags |= CGEventFlags::CGEventFlagControl;
-    }
-    if depressed.contains(XMods::Mod1Mask) {
-        flags |= CGEventFlags::CGEventFlagAlternate;
-    }
-    if depressed.contains(XMods::Mod4Mask) {
-        flags |= CGEventFlags::CGEventFlagCommand;
-    }
-    flags
-}
-
-// 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);
-    }
-}
--- a/input-emulation/src/wlroots.rs
+++ b/input-emulation/src/wlroots.rs
@@ -2,17 +2,14 @@ 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;

 use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
-use wayland_client::protocol::wl_pointer::{Axis, AxisSource, ButtonState};
+use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
 use wayland_protocols_wlr::virtual_pointer::v1::client::{
    zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
@@ -31,7 +28,7 @@ use wayland_client::{
    Connection, Dispatch, EventQueue, QueueHandle,
 };

-use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};

 use super::error::WaylandBindError;
 use super::EmulationHandle;
@@ -105,11 +102,7 @@ impl State {
            panic!("no keymap");
        }

-        let vinput = VirtualInput {
-            pointer,
-            keyboard,
-            modifiers: Arc::new(Mutex::new(XMods::empty())),
-        };
+        let vinput = VirtualInput { pointer, keyboard };

        self.input_for_client.insert(client, vinput);
    }
@@ -163,13 +156,13 @@ impl Emulation for WlrootsEmulation {
    async fn create(&mut self, handle: EmulationHandle) {
        self.state.add_client(handle);
        if let Err(e) = self.queue.flush() {
-            log::error!("{e}");
+            log::error!("{}", e);
        }
    }
    async fn destroy(&mut self, handle: EmulationHandle) {
        self.state.destroy_client(handle);
        if let Err(e) = self.queue.flush() {
-            log::error!("{e}");
+            log::error!("{}", e);
        }
    }
    async fn terminate(&mut self) {
@@ -180,16 +173,10 @@ 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 {
@@ -210,8 +197,7 @@ impl VirtualInput {
                    PointerEvent::AxisDiscrete120 { axis, value } => {
                        let axis: Axis = (axis as u32).try_into()?;
                        self.pointer
-                            .axis_discrete(now, axis, value as f64 / 8., value / 120);
-                        self.pointer.axis_source(AxisSource::Wheel);
+                            .axis_discrete(0, axis, value as f64 / 6., value / 120);
                        self.pointer.frame();
                    }
                }
@@ -220,17 +206,6 @@ 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,
@@ -238,10 +213,6 @@ 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);
                }
@@ -302,74 +273,3 @@ 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!("{key:#?} is not a modifier 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)
-    }
-}
--- a/input-emulation/src/x11.rs
+++ b/input-emulation/src/x11.rs
@@ -23,7 +23,7 @@ impl X11Emulation {
    pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
        let display = unsafe {
            match xlib::XOpenDisplay(ptr::null()) {
-                d if std::ptr::eq(d, ptr::null_mut::<xlib::Display>()) => {
+                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
                    Err(X11EmulationCreationError::OpenDisplay)
                }
                display => Ok(display),
--- a/input-emulation/src/xdg_desktop_portal.rs
+++ b/input-emulation/src/xdg_desktop_portal.rs
@@ -4,6 +4,7 @@ use ashpd::{
        PersistMode, Session,
    },
    zbus::AsyncDrop,
+    WindowIdentifier,
 };
 use async_trait::async_trait;

@@ -42,7 +43,10 @@ impl<'a> DesktopPortalEmulation<'a> {
            .await?;

        log::info!("requesting permission for input emulation");
-        let _devices = proxy.start(&session, None).await?.response()?;
+        let _devices = proxy
+            .start(&session, &WindowIdentifier::default())
+            .await?
+            .response()?;

        log::debug!("started session");
        let session = session;
@@ -52,7 +56,7 @@ impl<'a> DesktopPortalEmulation<'a> {
 }

 #[async_trait]
-impl Emulation for DesktopPortalEmulation<'_> {
+impl<'a> Emulation for DesktopPortalEmulation<'a> {
    async fn consume(
        &mut self,
        event: input_event::Event,
@@ -141,8 +145,9 @@ impl Emulation for DesktopPortalEmulation<'_> {
    }
 }

-impl AsyncDrop for DesktopPortalEmulation<'_> {
+impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {
    #[doc = r" Perform the async cleanup."]
+    #[must_use]
    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
    fn async_drop<'async_trait>(
        self,
--- a/input-event/Cargo.toml
+++ b/input-event/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "input-event"
 description = "cross-platform input-event types for input-capture / input-emulation"
-version = "0.3.0"
+version = "0.2.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -11,10 +11,10 @@ futures-core = "0.3.30"
 log = "0.4.22"
 num_enum = "0.7.2"
 serde = { version = "1.0", features = ["derive"] }
-thiserror = "2.0.0"
+thiserror = "1.0.61"

 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-reis = { version = "0.5.0", optional = true }
+reis = { version = "0.2.0", optional = true }

 [features]
 default = ["libei"]
--- a/input-event/src/lib.rs
+++ b/input-event/src/lib.rs
@@ -112,8 +112,8 @@ impl Display for KeyboardEvent {
 impl Display for Event {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            Event::Pointer(p) => write!(f, "{p}"),
-            Event::Keyboard(k) => write!(f, "{k}"),
+            Event::Pointer(p) => write!(f, "{}", p),
+            Event::Keyboard(k) => write!(f, "{}", k),
        }
    }
 }
--- a/lan-mouse-cli/Cargo.toml
+++ b/lan-mouse-cli/Cargo.toml
@@ -1,16 +1,14 @@
 [package]
 name = "lan-mouse-cli"
 description = "CLI Frontend for lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"

 [dependencies]
 futures = "0.3.30"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
-clap = { version = "4.4.11", features = ["derive"] }
-thiserror = "2.0.0"
+lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
 tokio = { version = "1.32.0", features = [
    "io-util",
    "io-std",
--- a/lan-mouse-cli/src/command.rs
+++ b/lan-mouse-cli/src/command.rs
@@ -0,0 +1,153 @@
+use std::{
+    fmt::Display,
+    str::{FromStr, SplitWhitespace},
+};
+
+use lan_mouse_ipc::{ClientHandle, Position};
+
+pub(super) enum CommandType {
+    NoCommand,
+    Help,
+    Connect,
+    Disconnect,
+    Activate,
+    Deactivate,
+    List,
+    SetHost,
+    SetPort,
+}
+
+#[derive(Debug)]
+pub(super) struct InvalidCommand {
+    cmd: String,
+}
+
+impl Display for InvalidCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "invalid command: \"{}\"", self.cmd)
+    }
+}
+
+impl FromStr for CommandType {
+    type Err = InvalidCommand;
+
+    fn from_str(s: &str) -> std::prelude::v1::Result<Self, Self::Err> {
+        match s {
+            "connect" => Ok(Self::Connect),
+            "disconnect" => Ok(Self::Disconnect),
+            "activate" => Ok(Self::Activate),
+            "deactivate" => Ok(Self::Deactivate),
+            "list" => Ok(Self::List),
+            "set-host" => Ok(Self::SetHost),
+            "set-port" => Ok(Self::SetPort),
+            "help" => Ok(Self::Help),
+            _ => Err(InvalidCommand { cmd: s.to_string() }),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum Command {
+    None,
+    Help,
+    Connect(Position, String, Option<u16>),
+    Disconnect(ClientHandle),
+    Activate(ClientHandle),
+    Deactivate(ClientHandle),
+    List,
+    SetHost(ClientHandle, String),
+    SetPort(ClientHandle, Option<u16>),
+}
+
+impl CommandType {
+    pub(super) fn usage(&self) -> &'static str {
+        match self {
+            CommandType::Help => "help",
+            CommandType::NoCommand => "",
+            CommandType::Connect => "connect left|right|top|bottom <host> [<port>]",
+            CommandType::Disconnect => "disconnect <id>",
+            CommandType::Activate => "activate <id>",
+            CommandType::Deactivate => "deactivate <id>",
+            CommandType::List => "list",
+            CommandType::SetHost => "set-host <id> <host>",
+            CommandType::SetPort => "set-port <id> <host>",
+        }
+    }
+}
+
+pub(super) enum CommandParseError {
+    Usage(CommandType),
+    Invalid(InvalidCommand),
+}
+
+impl Display for CommandParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Usage(cmd) => write!(f, "usage: {}", cmd.usage()),
+            Self::Invalid(cmd) => write!(f, "{}", cmd),
+        }
+    }
+}
+
+impl FromStr for Command {
+    type Err = CommandParseError;
+
+    fn from_str(cmd: &str) -> Result<Self, Self::Err> {
+        let mut args = cmd.split_whitespace();
+        let cmd_type: CommandType = match args.next() {
+            Some(c) => c.parse().map_err(CommandParseError::Invalid),
+            None => Ok(CommandType::NoCommand),
+        }?;
+        match cmd_type {
+            CommandType::Help => Ok(Command::Help),
+            CommandType::NoCommand => Ok(Command::None),
+            CommandType::Connect => parse_connect_cmd(args),
+            CommandType::Disconnect => parse_disconnect_cmd(args),
+            CommandType::Activate => parse_activate_cmd(args),
+            CommandType::Deactivate => parse_deactivate_cmd(args),
+            CommandType::List => Ok(Command::List),
+            CommandType::SetHost => parse_set_host(args),
+            CommandType::SetPort => parse_set_port(args),
+        }
+    }
+}
+
+fn parse_connect_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Connect);
+    let pos = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    let host = args.next().ok_or(USAGE)?.to_string();
+    let port = args.next().and_then(|p| p.parse().ok());
+    Ok(Command::Connect(pos, host, port))
+}
+
+fn parse_disconnect_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Disconnect);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::Disconnect(id))
+}
+
+fn parse_activate_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Activate);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::Activate(id))
+}
+
+fn parse_deactivate_cmd(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::Deactivate);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::Deactivate(id))
+}
+
+fn parse_set_host(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::SetHost);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    let host = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    Ok(Command::SetHost(id, host))
+}
+
+fn parse_set_port(mut args: SplitWhitespace<'_>) -> Result<Command, CommandParseError> {
+    const USAGE: CommandParseError = CommandParseError::Usage(CommandType::SetPort);
+    let id = args.next().ok_or(USAGE)?.parse().map_err(|_| USAGE)?;
+    let port = args.next().and_then(|p| p.parse().ok());
+    Ok(Command::SetPort(id, port))
+}
--- a/lan-mouse-cli/src/lib.rs
+++ b/lan-mouse-cli/src/lib.rs
@@ -1,167 +1,301 @@
-use clap::{Args, Parser, Subcommand};
 use futures::StreamExt;
-
-use std::{net::IpAddr, time::Duration};
-use thiserror::Error;
-
-use lan_mouse_ipc::{
-    connect_async, ClientHandle, ConnectionError, FrontendEvent, FrontendRequest, IpcError,
-    Position,
+use tokio::{
+    io::{AsyncBufReadExt, BufReader},
+    task::LocalSet,
 };

-#[derive(Debug, Error)]
-pub enum CliError {
-    /// is the service running?
-    #[error("could not connect: `{0}` - is the service running?")]
-    ServiceNotRunning(#[from] ConnectionError),
-    #[error("error communicating with service: {0}")]
-    Ipc(#[from] IpcError),
-}
+use std::io::{self, Write};

-#[derive(Parser, Clone, Debug, PartialEq, Eq)]
-#[command(name = "lan-mouse-cli", about = "LanMouse CLI interface")]
-pub struct CliArgs {
-    #[command(subcommand)]
-    command: CliSubcommand,
-}
+use self::command::{Command, CommandType};

-#[derive(Args, Clone, Debug, PartialEq, Eq)]
-struct Client {
-    #[arg(long)]
-    hostname: Option<String>,
-    #[arg(long)]
-    port: Option<u16>,
-    #[arg(long)]
-    ips: Option<Vec<IpAddr>>,
-    #[arg(long)]
-    enter_hook: Option<String>,
-}
+use lan_mouse_ipc::{
+    AsyncFrontendEventReader, AsyncFrontendRequestWriter, ClientConfig, ClientHandle, ClientState,
+    FrontendEvent, FrontendRequest, IpcError, DEFAULT_PORT,
+};

-#[derive(Clone, Subcommand, Debug, PartialEq, Eq)]
-enum CliSubcommand {
-    /// add a new client
-    AddClient(Client),
-    /// remove an existing client
-    RemoveClient { id: ClientHandle },
-    /// activate a client
-    Activate { id: ClientHandle },
-    /// deactivate a client
-    Deactivate { id: ClientHandle },
-    /// list configured clients
-    List,
-    /// change hostname
-    SetHost {
-        id: ClientHandle,
-        host: Option<String>,
-    },
-    /// change port
-    SetPort { id: ClientHandle, port: u16 },
-    /// set position
-    SetPosition { id: ClientHandle, pos: Position },
-    /// set ips
-    SetIps { id: ClientHandle, ips: Vec<IpAddr> },
-    /// re-enable capture
-    EnableCapture,
-    /// re-enable emulation
-    EnableEmulation,
-    /// authorize a public key
-    AuthorizeKey {
-        description: String,
-        sha256_fingerprint: String,
-    },
-    /// deauthorize a public key
-    RemoveAuthorizedKey { sha256_fingerprint: String },
-}
+mod command;

-pub async fn run(args: CliArgs) -> Result<(), CliError> {
-    execute(args.command).await?;
+pub fn run() -> Result<(), IpcError> {
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+    runtime.block_on(LocalSet::new().run_until(async move {
+        let (rx, tx) = lan_mouse_ipc::connect_async().await?;
+        let mut cli = Cli::new(rx, tx);
+        cli.run().await
+    }))?;
    Ok(())
 }

-async fn execute(cmd: CliSubcommand) -> Result<(), CliError> {
-    let (mut rx, mut tx) = connect_async(Some(Duration::from_millis(500))).await?;
-    match cmd {
-        CliSubcommand::AddClient(Client {
-            hostname,
-            port,
-            ips,
-            enter_hook,
-        }) => {
-            tx.request(FrontendRequest::Create).await?;
-            while let Some(e) = rx.next().await {
-                if let FrontendEvent::Created(handle, _, _) = e? {
-                    if let Some(hostname) = hostname {
-                        tx.request(FrontendRequest::UpdateHostname(handle, Some(hostname)))
-                            .await?;
-                    }
-                    if let Some(port) = port {
-                        tx.request(FrontendRequest::UpdatePort(handle, port))
-                            .await?;
-                    }
-                    if let Some(ips) = ips {
-                        tx.request(FrontendRequest::UpdateFixIps(handle, ips))
-                            .await?;
-                    }
-                    if let Some(enter_hook) = enter_hook {
-                        tx.request(FrontendRequest::UpdateEnterHook(handle, Some(enter_hook)))
-                            .await?;
-                    }
-                    break;
-                }
-            }
-        }
-        CliSubcommand::RemoveClient { id } => tx.request(FrontendRequest::Delete(id)).await?,
-        CliSubcommand::Activate { id } => tx.request(FrontendRequest::Activate(id, true)).await?,
-        CliSubcommand::Deactivate { id } => {
-            tx.request(FrontendRequest::Activate(id, false)).await?
-        }
-        CliSubcommand::List => {
-            tx.request(FrontendRequest::Enumerate()).await?;
-            while let Some(e) = rx.next().await {
-                if let FrontendEvent::Enumerate(clients) = e? {
-                    for (handle, config, state) in clients {
-                        let host = config.hostname.unwrap_or("unknown".to_owned());
-                        let port = config.port;
-                        let pos = config.pos;
-                        let active = state.active;
-                        let ips = state.ips;
-                        println!(
-                            "id {handle}: {host}:{port} ({pos}) active: {active}, ips: {ips:?}"
-                        );
-                    }
-                    break;
-                }
-            }
-        }
-        CliSubcommand::SetHost { id, host } => {
-            tx.request(FrontendRequest::UpdateHostname(id, host))
-                .await?
-        }
-        CliSubcommand::SetPort { id, port } => {
-            tx.request(FrontendRequest::UpdatePort(id, port)).await?
-        }
-        CliSubcommand::SetPosition { id, pos } => {
-            tx.request(FrontendRequest::UpdatePosition(id, pos)).await?
-        }
-        CliSubcommand::SetIps { id, ips } => {
-            tx.request(FrontendRequest::UpdateFixIps(id, ips)).await?
-        }
-        CliSubcommand::EnableCapture => tx.request(FrontendRequest::EnableCapture).await?,
-        CliSubcommand::EnableEmulation => tx.request(FrontendRequest::EnableEmulation).await?,
-        CliSubcommand::AuthorizeKey {
-            description,
-            sha256_fingerprint,
-        } => {
-            tx.request(FrontendRequest::AuthorizeKey(
-                description,
-                sha256_fingerprint,
-            ))
-            .await?
-        }
-        CliSubcommand::RemoveAuthorizedKey { sha256_fingerprint } => {
-            tx.request(FrontendRequest::RemoveAuthorizedKey(sha256_fingerprint))
-                .await?
+struct Cli {
+    clients: Vec<(ClientHandle, ClientConfig, ClientState)>,
+    rx: AsyncFrontendEventReader,
+    tx: AsyncFrontendRequestWriter,
+}
+
+impl Cli {
+    fn new(rx: AsyncFrontendEventReader, tx: AsyncFrontendRequestWriter) -> Cli {
+        Self {
+            clients: vec![],
+            rx,
+            tx,
        }
    }
+
+    async fn run(&mut self) -> Result<(), IpcError> {
+        let stdin = tokio::io::stdin();
+        let stdin = BufReader::new(stdin);
+        let mut stdin = stdin.lines();
+
+        /* initial state sync */
+        self.clients = loop {
+            match self.rx.next().await {
+                Some(Ok(e)) => {
+                    if let FrontendEvent::Enumerate(clients) = e {
+                        break clients;
+                    }
+                }
+                Some(Err(e)) => return Err(e),
+                None => return Ok(()),
+            }
+        };
+
+        loop {
+            prompt()?;
+            tokio::select! {
+                line = stdin.next_line() => {
+                    let Some(line) = line? else {
+                        break Ok(());
+                    };
+                    let cmd: Command = match line.parse() {
+                        Ok(cmd) => cmd,
+                        Err(e) => {
+                            eprintln!("{e}");
+                            continue;
+                        }
+                    };
+                    self.execute(cmd).await?;
+                }
+                event = self.rx.next() => {
+                    if let Some(event) = event {
+                        self.handle_event(event?);
+                    }
+                }
+            }
+        }
+    }
+
+    async fn update_client(&mut self, handle: ClientHandle) -> Result<(), IpcError> {
+        self.tx.request(FrontendRequest::GetState(handle)).await?;
+        while let Some(Ok(event)) = self.rx.next().await {
+            self.handle_event(event.clone());
+            if let FrontendEvent::State(_, _, _) | FrontendEvent::NoSuchClient(_) = event {
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    async fn execute(&mut self, cmd: Command) -> Result<(), IpcError> {
+        match cmd {
+            Command::None => {}
+            Command::Connect(pos, host, port) => {
+                let request = FrontendRequest::Create;
+                self.tx.request(request).await?;
+                let handle = loop {
+                    if let Some(Ok(event)) = self.rx.next().await {
+                        match event {
+                            FrontendEvent::Created(h, c, s) => {
+                                self.clients.push((h, c, s));
+                                break h;
+                            }
+                            _ => {
+                                self.handle_event(event);
+                                continue;
+                            }
+                        }
+                    }
+                };
+                for request in [
+                    FrontendRequest::UpdateHostname(handle, Some(host.clone())),
+                    FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT)),
+                    FrontendRequest::UpdatePosition(handle, pos),
+                ] {
+                    self.tx.request(request).await?;
+                }
+                self.update_client(handle).await?;
+            }
+            Command::Disconnect(id) => {
+                self.tx.request(FrontendRequest::Delete(id)).await?;
+                loop {
+                    if let Some(Ok(event)) = self.rx.next().await {
+                        self.handle_event(event.clone());
+                        if let FrontendEvent::Deleted(_) = event {
+                            self.handle_event(event);
+                            break;
+                        }
+                    }
+                }
+            }
+            Command::Activate(id) => {
+                self.tx.request(FrontendRequest::Activate(id, true)).await?;
+                self.update_client(id).await?;
+            }
+            Command::Deactivate(id) => {
+                self.tx
+                    .request(FrontendRequest::Activate(id, false))
+                    .await?;
+                self.update_client(id).await?;
+            }
+            Command::List => {
+                self.tx.request(FrontendRequest::Enumerate()).await?;
+                while let Some(e) = self.rx.next().await {
+                    let event = e?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Enumerate(_) = event {
+                        break;
+                    }
+                }
+            }
+            Command::SetHost(handle, host) => {
+                let request = FrontendRequest::UpdateHostname(handle, Some(host.clone()));
+                self.tx.request(request).await?;
+                self.update_client(handle).await?;
+            }
+            Command::SetPort(handle, port) => {
+                let request = FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT));
+                self.tx.request(request).await?;
+                self.update_client(handle).await?;
+            }
+            Command::Help => {
+                for cmd_type in [
+                    CommandType::List,
+                    CommandType::Connect,
+                    CommandType::Disconnect,
+                    CommandType::Activate,
+                    CommandType::Deactivate,
+                    CommandType::SetHost,
+                    CommandType::SetPort,
+                ] {
+                    eprintln!("{}", cmd_type.usage());
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn find_mut(
+        &mut self,
+        handle: ClientHandle,
+    ) -> Option<&mut (ClientHandle, ClientConfig, ClientState)> {
+        self.clients.iter_mut().find(|(h, _, _)| *h == handle)
+    }
+
+    fn remove(
+        &mut self,
+        handle: ClientHandle,
+    ) -> Option<(ClientHandle, ClientConfig, ClientState)> {
+        let idx = self.clients.iter().position(|(h, _, _)| *h == handle);
+        idx.map(|i| self.clients.swap_remove(i))
+    }
+
+    fn handle_event(&mut self, event: FrontendEvent) {
+        match event {
+            FrontendEvent::Created(h, c, s) => {
+                eprint!("client added ({h}): ");
+                print_config(&c);
+                eprint!(" ");
+                print_state(&s);
+                eprintln!();
+                self.clients.push((h, c, s));
+            }
+            FrontendEvent::NoSuchClient(h) => {
+                eprintln!("no such client: {h}");
+            }
+            FrontendEvent::State(h, c, s) => {
+                if let Some((_, config, state)) = self.find_mut(h) {
+                    let old_host = config.hostname.clone().unwrap_or("\"\"".into());
+                    let new_host = c.hostname.clone().unwrap_or("\"\"".into());
+                    if old_host != new_host {
+                        eprintln!(
+                            "client {h}: hostname updated ({} -> {})",
+                            old_host, new_host
+                        );
+                    }
+                    if config.port != c.port {
+                        eprintln!("client {h} changed port: {} -> {}", config.port, c.port);
+                    }
+                    if config.fix_ips != c.fix_ips {
+                        eprintln!("client {h} ips updated: {:?}", c.fix_ips)
+                    }
+                    *config = c;
+                    if state.active ^ s.active {
+                        eprintln!(
+                            "client {h} {}",
+                            if s.active { "activated" } else { "deactivated" }
+                        );
+                    }
+                    *state = s;
+                }
+            }
+            FrontendEvent::Deleted(h) => {
+                if let Some((h, c, _)) = self.remove(h) {
+                    eprint!("client {h} removed (");
+                    print_config(&c);
+                    eprintln!(")");
+                }
+            }
+            FrontendEvent::PortChanged(p, e) => {
+                if let Some(e) = e {
+                    eprintln!("failed to change port: {e}");
+                } else {
+                    eprintln!("changed port to {p}");
+                }
+            }
+            FrontendEvent::Enumerate(clients) => {
+                self.clients = clients;
+                self.print_clients();
+            }
+            FrontendEvent::Error(e) => {
+                eprintln!("ERROR: {e}");
+            }
+            FrontendEvent::CaptureStatus(s) => {
+                eprintln!("capture status: {s:?}")
+            }
+            FrontendEvent::EmulationStatus(s) => {
+                eprintln!("emulation status: {s:?}")
+            }
+        }
+    }
+
+    fn print_clients(&mut self) {
+        for (h, c, s) in self.clients.iter() {
+            eprint!("client {h}: ");
+            print_config(c);
+            eprint!(" ");
+            print_state(s);
+            eprintln!();
+        }
+    }
+}
+
+fn prompt() -> io::Result<()> {
+    eprint!("lan-mouse > ");
+    std::io::stderr().flush()?;
    Ok(())
 }
+
+fn print_config(c: &ClientConfig) {
+    eprint!(
+        "{}:{} ({}), ips: {:?}",
+        c.hostname.clone().unwrap_or("(no hostname)".into()),
+        c.port,
+        c.pos,
+        c.fix_ips
+    );
+}
+
+fn print_state(s: &ClientState) {
+    eprint!("active: {}, dns: {:?}", s.active, s.ips);
+}
--- a/lan-mouse-gtk/Cargo.toml
+++ b/lan-mouse-gtk/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse-gtk"
 description = "GTK4 / Libadwaita Frontend for lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -12,8 +12,7 @@ adw = { package = "libadwaita", version = "0.7.0", features = ["v1_1"] }
 async-channel = { version = "2.1.1" }
 hostname = "0.4.0"
 log = "0.4.20"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
-thiserror = "2.0.0"
+lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }

 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }
--- a/lan-mouse-gtk/resources/authorization_window.ui
+++ b/lan-mouse-gtk/resources/authorization_window.ui
@@ -1,102 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<interface>
-  <requires lib="gtk" version="4.0"/>
-  <requires lib="libadwaita" version="1.0"/>
-  <template class="AuthorizationWindow" parent="AdwWindow">
-    <property name="modal">True</property>
-    <property name="width-request">180</property>
-    <property name="default-width">180</property>
-    <property name="height-request">180</property>
-    <property name="default-height">180</property>
-    <property name="title" translatable="yes">Unauthorized Device</property>
-    <property name="content">
-      <object class="GtkBox">
-        <property name="orientation">vertical</property>
-        <property name="vexpand">True</property>
-        <child type="top">
-          <object class="AdwHeaderBar">
-            <style>
-              <class name="flat"/>
-            </style>
-          </object>
-        </child>
-        <child>
-          <object class="GtkBox">
-            <property name="orientation">vertical</property>
-            <property name="spacing">30</property>
-            <property name="margin-start">30</property>
-            <property name="margin-end">30</property>
-            <property name="margin-top">30</property>
-            <property name="margin-bottom">30</property>
-            <child>
-              <object class="GtkLabel">
-                <property name="label">An unauthorized Device is trying to connect. Do you want to authorize this Device?</property>
-                <property name="width-request">100</property>
-                <property name="wrap">word-wrap</property>
-              </object>
-            </child>
-            <child>
-              <object class="AdwPreferencesGroup">
-                <property name="title">sha256 fingerprint</property>
-                <child>
-                  <object class="AdwActionRow">
-                    <property name="child">
-                      <object class="GtkLabel" id="fingerprint">
-                        <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-                        <property name="vexpand">True</property>
-                        <property name="hexpand">False</property>
-                        <property name="wrap">True</property>
-                        <property name="wrap-mode">word-char</property>
-                        <property name="justify">center</property>
-                        <property name="xalign">0.5</property>
-                        <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="width-chars">64</property>
-                      </object>
-                    </property>
-                  </object>
-                </child>
-              </object>
-            </child>
-          </object>
-        </child>
-        <child>
-          <object class="GtkBox">
-            <property name="margin-start">30</property>
-            <property name="margin-end">30</property>
-            <property name="margin-top">30</property>
-            <property name="margin-bottom">30</property>
-            <property name="orientation">horizontal</property>
-            <property name="spacing">30</property>
-            <property name="hexpand">True</property>
-            <property name="vexpand">True</property>
-            <property name="valign">end</property>
-            <child>
-              <object class="GtkButton" id="cancel_button">
-                <signal name="clicked" handler="handle_cancel" swapped="true"/>
-                <property name="label" translatable="yes">Cancel</property>
-                <property name="can-shrink">True</property>
-                <property name="height-request">50</property>
-                <property name="hexpand">True</property>
-              </object>
-            </child>
-            <child>
-              <object class="GtkButton" id="confirm_button">
-                <signal name="clicked" handler="handle_confirm" swapped="true"/>
-                <property name="label" translatable="yes">Authorize</property>
-                <property name="can-shrink">True</property>
-                <property name="height-request">50</property>
-                <property name="hexpand">True</property>
-                <style>
-                  <class name="destructive-action"/>
-                </style>
-              </object>
-            </child>
-          </object>
-        </child>
-      </object>
-    </property>
-  </template>
-</interface>
--- a/lan-mouse-gtk/resources/client_row.ui
+++ b/lan-mouse-gtk/resources/client_row.ui
@@ -5,6 +5,7 @@
 		<!-- enabled -->
 		<child type="prefix">
 			<object class="GtkSwitch" id="enable_switch">
+				<signal name="state_set" handler="handle_client_set_state" swapped="true"/>
 				<property name="valign">center</property>
 				<property name="halign">end</property>
 				<property name="tooltip-text" translatable="yes">enable</property>
--- a/lan-mouse-gtk/resources/fingerprint_window.ui
+++ b/lan-mouse-gtk/resources/fingerprint_window.ui
@@ -1,101 +0,0 @@
-<?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>
--- a/lan-mouse-gtk/resources/key_row.ui
+++ b/lan-mouse-gtk/resources/key_row.ui
@@ -1,16 +0,0 @@
-<?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>
--- a/lan-mouse-gtk/resources/resources.gresource.xml
+++ b/lan-mouse-gtk/resources/resources.gresource.xml
@@ -2,10 +2,7 @@
 <gresources>
  <gresource prefix="/de/feschber/LanMouse">
    <file compressed="true" preprocess="xml-stripblanks">window.ui</file>
-    <file compressed="true" preprocess="xml-stripblanks">authorization_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>
--- a/lan-mouse-gtk/resources/window.ui
+++ b/lan-mouse-gtk/resources/window.ui
@@ -121,31 +121,7 @@
                        -->
                        <child>
                          <object class="AdwActionRow">
-                            <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>
+                            <property name="title">port</property>
                            <child>
                              <object class="GtkEntry" id="port_entry">
                                <property name="max-width-chars">5</property>
@@ -184,14 +160,20 @@
                          </object>
                        </child>
                        <child>
-                          <object class="AdwActionRow" id="fingerprint_row">
-                            <property name="title">certificate fingerprint</property>
-                            <property name="icon-name">auth-fingerprint-symbolic</property>
+                          <object class="AdwActionRow">
+                            <property name="title">hostname</property>
                            <child>
-                              <object class="GtkButton" id="copy-fingerprint-button">
+                              <object class="GtkLabel" id="hostname_label">
+                                <property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
+                                <property name="use-markup">true</property>
+                                <property name="valign">center</property>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkButton" id="copy-hostname-button">
                                <property name="icon-name">edit-copy-symbolic</property>
                                <property name="valign">center</property>
-                                <signal name="clicked" handler="handle_copy_fingerprint" swapped="true"/>
+                                <signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
                              </object>
                            </child>
                          </object>
@@ -231,39 +213,6 @@
                        </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>
--- a/lan-mouse-gtk/src/authorization_window.rs
+++ b/lan-mouse-gtk/src/authorization_window.rs
@@ -1,19 +0,0 @@
-mod imp;
-
-use glib::Object;
-use gtk::{gio, glib, subclass::prelude::ObjectSubclassIsExt};
-
-glib::wrapper! {
-    pub struct AuthorizationWindow(ObjectSubclass<imp::AuthorizationWindow>)
-    @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 AuthorizationWindow {
-    pub(crate) fn new(fingerprint: &str) -> Self {
-        let window: Self = Object::builder().build();
-        window.imp().set_fingerprint(fingerprint);
-        window
-    }
-}
--- a/lan-mouse-gtk/src/authorization_window/imp.rs
+++ b/lan-mouse-gtk/src/authorization_window/imp.rs
@@ -1,75 +0,0 @@
-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, Label,
-};
-
-#[derive(CompositeTemplate, Default)]
-#[template(resource = "/de/feschber/LanMouse/authorization_window.ui")]
-pub struct AuthorizationWindow {
-    #[template_child]
-    pub fingerprint: TemplateChild<Label>,
-    #[template_child]
-    pub cancel_button: TemplateChild<Button>,
-    #[template_child]
-    pub confirm_button: TemplateChild<Button>,
-}
-
-#[glib::object_subclass]
-impl ObjectSubclass for AuthorizationWindow {
-    const NAME: &'static str = "AuthorizationWindow";
-    const ABSTRACT: bool = false;
-
-    type Type = super::AuthorizationWindow;
-    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 AuthorizationWindow {
-    #[template_callback]
-    fn handle_confirm(&self, _button: Button) {
-        let fp = self.fingerprint.text().as_str().trim().to_owned();
-        self.obj().emit_by_name("confirm-clicked", &[&fp])
-    }
-
-    #[template_callback]
-    fn handle_cancel(&self, _: Button) {
-        self.obj().emit_by_name("cancel-clicked", &[])
-    }
-
-    pub(super) fn set_fingerprint(&self, fingerprint: &str) {
-        self.fingerprint.set_text(fingerprint);
-    }
-}
-
-impl ObjectImpl for AuthorizationWindow {
-    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()])
-                    .build(),
-                Signal::builder("cancel-clicked").build(),
-            ]
-        })
-    }
-}
-
-impl WidgetImpl for AuthorizationWindow {}
-impl WindowImpl for AuthorizationWindow {}
-impl ApplicationWindowImpl for AuthorizationWindow {}
-impl AdwWindowImpl for AuthorizationWindow {}
--- a/lan-mouse-gtk/src/client_object/imp.rs
+++ b/lan-mouse-gtk/src/client_object/imp.rs
@@ -13,7 +13,7 @@ use super::ClientData;
 #[properties(wrapper_type = super::ClientObject)]
 pub struct ClientObject {
    #[property(name = "handle", get, set, type = ClientHandle, member = handle)]
-    #[property(name = "hostname", get, set, type = Option<String>, member = hostname)]
+    #[property(name = "hostname", get, set, type = String, member = hostname)]
    #[property(name = "port", get, set, type = u32, member = port, maximum = u16::MAX as u32)]
    #[property(name = "active", get, set, type = bool, member = active)]
    #[property(name = "position", get, set, type = String, member = position)]
--- a/lan-mouse-gtk/src/client_row.rs
+++ b/lan-mouse-gtk/src/client_row.rs
@@ -4,7 +4,7 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};

-use lan_mouse_ipc::{Position, DEFAULT_PORT};
+use lan_mouse_ipc::DEFAULT_PORT;

 use super::ClientObject;

@@ -15,32 +15,25 @@ glib::wrapper! {
 }

 impl ClientRow {
-    pub fn new(client_object: &ClientObject) -> Self {
-        let client_row: Self = Object::builder().build();
-        client_row
-            .imp()
-            .client_object
-            .borrow_mut()
-            .replace(client_object.clone());
-        client_row
+    pub fn new(_client_object: &ClientObject) -> Self {
+        Object::builder().build()
    }

    pub fn bind(&self, client_object: &ClientObject) {
        let mut bindings = self.imp().bindings.borrow_mut();

-        // bind client active to switch state
        let active_binding = client_object
            .bind_property("active", &self.imp().enable_switch.get(), "state")
+            .bidirectional()
            .sync_create()
            .build();

-        // bind client active to switch position
        let switch_position_binding = client_object
            .bind_property("active", &self.imp().enable_switch.get(), "active")
+            .bidirectional()
            .sync_create()
            .build();

-        // bind hostname to hostname edit field
        let hostname_binding = client_object
            .bind_property("hostname", &self.imp().hostname.get(), "text")
            .transform_to(|_, v: Option<String>| {
@@ -50,48 +43,72 @@ impl ClientRow {
                    Some("".to_string())
                }
            })
+            .transform_from(|_, v: String| {
+                if v.as_str().trim() == "" {
+                    Some(None)
+                } else {
+                    Some(Some(v))
+                }
+            })
+            .bidirectional()
            .sync_create()
            .build();

-        // bind hostname to title
        let title_binding = client_object
            .bind_property("hostname", self, "title")
-            .transform_to(|_, v: Option<String>| v.or(Some("<span font_style=\"italic\" font_weight=\"light\" foreground=\"darkgrey\">no hostname!</span>".to_string())))
-            .sync_create()
-            .build();
-
-        // bind port to port edit field
-        let port_binding = client_object
-            .bind_property("port", &self.imp().port.get(), "text")
-            .transform_to(|_, v: u32| {
-                if v == DEFAULT_PORT as u32 {
-                    Some("".to_string())
+            .transform_to(|_, v: Option<String>| {
+                if let Some(hostname) = v {
+                    Some(hostname)
                } else {
-                    Some(v.to_string())
+                    Some("<span font_style=\"italic\" font_weight=\"light\" foreground=\"darkgrey\">no hostname!</span>".to_string())
                }
            })
            .sync_create()
            .build();

-        // bind port to subtitle
+        let port_binding = client_object
+            .bind_property("port", &self.imp().port.get(), "text")
+            .transform_from(|_, v: String| {
+                if v.is_empty() {
+                    Some(DEFAULT_PORT as u32)
+                } else {
+                    Some(v.parse::<u16>().unwrap_or(DEFAULT_PORT) as u32)
+                }
+            })
+            .transform_to(|_, v: u32| {
+                if v == 4242 {
+                    Some("".to_string())
+                } else {
+                    Some(v.to_string())
+                }
+            })
+            .bidirectional()
+            .sync_create()
+            .build();
+
        let subtitle_binding = client_object
            .bind_property("port", self, "subtitle")
            .sync_create()
            .build();

-        // bind position to selected position
        let position_binding = client_object
            .bind_property("position", &self.imp().position.get(), "selected")
+            .transform_from(|_, v: u32| match v {
+                1 => Some("right"),
+                2 => Some("top"),
+                3 => Some("bottom"),
+                _ => Some("left"),
+            })
            .transform_to(|_, v: String| match v.as_str() {
-                "right" => Some(1u32),
+                "right" => Some(1),
                "top" => Some(2u32),
                "bottom" => Some(3u32),
                _ => Some(0u32),
            })
+            .bidirectional()
            .sync_create()
            .build();

-        // bind resolving status to spinner visibility
        let resolve_binding = client_object
            .bind_property(
                "resolving",
@@ -101,7 +118,6 @@ impl ClientRow {
            .sync_create()
            .build();

-        // bind ips to tooltip-text
        let ip_binding = client_object
            .bind_property("ips", &self.imp().dns_button.get(), "tooltip-text")
            .transform_to(|_, ips: Vec<String>| {
@@ -130,24 +146,4 @@ impl ClientRow {
            binding.unbind();
        }
    }
-
-    pub fn set_active(&self, active: bool) {
-        self.imp().set_active(active);
-    }
-
-    pub fn set_hostname(&self, hostname: Option<String>) {
-        self.imp().set_hostname(hostname);
-    }
-
-    pub fn set_port(&self, port: u16) {
-        self.imp().set_port(port);
-    }
-
-    pub fn set_position(&self, pos: Position) {
-        self.imp().set_pos(pos);
-    }
-
-    pub fn set_dns_state(&self, resolved: bool) {
-        self.imp().set_dns_state(resolved);
-    }
 }
--- a/lan-mouse-gtk/src/client_row/imp.rs
+++ b/lan-mouse-gtk/src/client_row/imp.rs
@@ -3,14 +3,11 @@ use std::cell::RefCell;
 use adw::subclass::prelude::*;
 use adw::{prelude::*, ActionRow, ComboRow};
 use glib::{subclass::InitializingObject, Binding};
+use gtk::glib::clone;
 use gtk::glib::subclass::Signal;
-use gtk::glib::{clone, SignalHandlerId};
-use gtk::{glib, Button, CompositeTemplate, Entry, Switch};
-use lan_mouse_ipc::Position;
+use gtk::{glib, Button, CompositeTemplate, Switch};
 use std::sync::OnceLock;

-use crate::client_object::ClientObject;
-
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/client_row.ui")]
 pub struct ClientRow {
@@ -31,11 +28,6 @@ pub struct ClientRow {
    #[template_child]
    pub dns_loading_indicator: TemplateChild<gtk::Spinner>,
    pub bindings: RefCell<Vec<Binding>>,
-    hostname_change_handler: RefCell<Option<SignalHandlerId>>,
-    port_change_handler: RefCell<Option<SignalHandlerId>>,
-    position_change_handler: RefCell<Option<SignalHandlerId>>,
-    set_state_handler: RefCell<Option<SignalHandlerId>>,
-    pub client_object: RefCell<Option<ClientObject>>,
 }

 #[glib::object_subclass]
@@ -67,61 +59,17 @@ impl ObjectImpl for ClientRow {
                row.handle_client_delete(button);
            }
        ));
-        let handler = self.hostname.connect_changed(clone!(
-            #[weak(rename_to = row)]
-            self,
-            move |entry| {
-                row.handle_hostname_changed(entry);
-            }
-        ));
-        self.hostname_change_handler.replace(Some(handler));
-        let handler = self.port.connect_changed(clone!(
-            #[weak(rename_to = row)]
-            self,
-            move |entry| {
-                row.handle_port_changed(entry);
-            }
-        ));
-        self.port_change_handler.replace(Some(handler));
-        let handler = self.position.connect_selected_notify(clone!(
-            #[weak(rename_to = row)]
-            self,
-            move |position| {
-                row.handle_position_changed(position);
-            }
-        ));
-        self.position_change_handler.replace(Some(handler));
-        let handler = self.enable_switch.connect_state_set(clone!(
-            #[weak(rename_to = row)]
-            self,
-            #[upgrade_or]
-            glib::Propagation::Proceed,
-            move |switch, state| {
-                row.handle_activate_switch(state, switch);
-                glib::Propagation::Proceed
-            }
-        ));
-        self.set_state_handler.replace(Some(handler));
    }

    fn signals() -> &'static [glib::subclass::Signal] {
        static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
        SIGNALS.get_or_init(|| {
            vec![
-                Signal::builder("request-activate")
+                Signal::builder("request-dns").build(),
+                Signal::builder("request-update")
                    .param_types([bool::static_type()])
                    .build(),
                Signal::builder("request-delete").build(),
-                Signal::builder("request-dns").build(),
-                Signal::builder("request-hostname-change")
-                    .param_types([String::static_type()])
-                    .build(),
-                Signal::builder("request-port-change")
-                    .param_types([u32::static_type()])
-                    .build(),
-                Signal::builder("request-position-change")
-                    .param_types([u32::static_type()])
-                    .build(),
            ]
        })
    }
@@ -130,97 +78,22 @@ impl ObjectImpl for ClientRow {
 #[gtk::template_callbacks]
 impl ClientRow {
    #[template_callback]
-    fn handle_activate_switch(&self, state: bool, _switch: &Switch) -> bool {
-        self.obj().emit_by_name::<()>("request-activate", &[&state]);
+    fn handle_client_set_state(&self, state: bool, _switch: &Switch) -> bool {
+        log::debug!("state change -> requesting update");
+        self.obj().emit_by_name::<()>("request-update", &[&state]);
        true // dont run default handler
    }

    #[template_callback]
-    fn handle_request_dns(&self, _: &Button) {
+    fn handle_request_dns(&self, _: Button) {
        self.obj().emit_by_name::<()>("request-dns", &[]);
    }

    #[template_callback]
    fn handle_client_delete(&self, _button: &Button) {
+        log::debug!("delete button pressed -> requesting delete");
        self.obj().emit_by_name::<()>("request-delete", &[]);
    }
-
-    fn handle_port_changed(&self, port_entry: &Entry) {
-        if let Ok(port) = port_entry.text().parse::<u16>() {
-            self.obj()
-                .emit_by_name::<()>("request-port-change", &[&(port as u32)]);
-        }
-    }
-
-    fn handle_hostname_changed(&self, hostname_entry: &Entry) {
-        self.obj()
-            .emit_by_name::<()>("request-hostname-change", &[&hostname_entry.text()]);
-    }
-
-    fn handle_position_changed(&self, position: &ComboRow) {
-        self.obj()
-            .emit_by_name("request-position-change", &[&position.selected()])
-    }
-
-    pub(super) fn set_hostname(&self, hostname: Option<String>) {
-        let position = self.hostname.position();
-        let handler = self.hostname_change_handler.borrow();
-        let handler = handler.as_ref().expect("signal handler");
-        self.hostname.block_signal(handler);
-        self.client_object
-            .borrow_mut()
-            .as_mut()
-            .expect("client object")
-            .set_property("hostname", hostname);
-        self.hostname.unblock_signal(handler);
-        self.hostname.set_position(position);
-    }
-
-    pub(super) fn set_port(&self, port: u16) {
-        let position = self.port.position();
-        let handler = self.port_change_handler.borrow();
-        let handler = handler.as_ref().expect("signal handler");
-        self.port.block_signal(handler);
-        self.client_object
-            .borrow_mut()
-            .as_mut()
-            .expect("client object")
-            .set_port(port as u32);
-        self.port.unblock_signal(handler);
-        self.port.set_position(position);
-    }
-
-    pub(super) fn set_pos(&self, pos: Position) {
-        let handler = self.position_change_handler.borrow();
-        let handler = handler.as_ref().expect("signal handler");
-        self.position.block_signal(handler);
-        self.client_object
-            .borrow_mut()
-            .as_mut()
-            .expect("client object")
-            .set_position(pos.to_string());
-        self.position.unblock_signal(handler);
-    }
-
-    pub(super) fn set_active(&self, active: bool) {
-        let handler = self.set_state_handler.borrow();
-        let handler = handler.as_ref().expect("signal handler");
-        self.enable_switch.block_signal(handler);
-        self.client_object
-            .borrow_mut()
-            .as_mut()
-            .expect("client object")
-            .set_active(active);
-        self.enable_switch.unblock_signal(handler);
-    }
-
-    pub(super) fn set_dns_state(&self, resolved: bool) {
-        if resolved {
-            self.dns_button.set_css_classes(&["success"])
-        } else {
-            self.dns_button.set_css_classes(&["warning"])
-        }
-    }
 }

 impl WidgetImpl for ClientRow {}
--- a/lan-mouse-gtk/src/fingerprint_window.rs
+++ b/lan-mouse-gtk/src/fingerprint_window.rs
@@ -1,22 +0,0 @@
-mod imp;
-
-use glib::Object;
-use gtk::{gio, glib, prelude::ObjectExt, subclass::prelude::ObjectSubclassIsExt};
-
-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(fingerprint: Option<String>) -> Self {
-        let window: Self = Object::builder().build();
-        if let Some(fp) = fingerprint {
-            window.imp().fingerprint.set_property("text", fp);
-            window.imp().fingerprint.set_property("editable", false);
-        }
-        window
-    }
-}
--- a/lan-mouse-gtk/src/fingerprint_window/imp.rs
+++ b/lan-mouse-gtk/src/fingerprint_window/imp.rs
@@ -1,64 +0,0 @@
-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 {}
--- a/lan-mouse-gtk/src/key_object.rs
+++ b/lan-mouse-gtk/src/key_object.rs
@@ -1,25 +0,0 @@
-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()
-    }
-}
--- a/lan-mouse-gtk/src/key_object/imp.rs
+++ b/lan-mouse-gtk/src/key_object/imp.rs
@@ -1,24 +0,0 @@
-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 {}
--- a/lan-mouse-gtk/src/key_row.rs
+++ b/lan-mouse-gtk/src/key_row.rs
@@ -1,48 +0,0 @@
-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::ActionRow,
-    @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();
-        }
-    }
-}
--- a/lan-mouse-gtk/src/key_row/imp.rs
+++ b/lan-mouse-gtk/src/key_row/imp.rs
@@ -1,68 +0,0 @@
-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 {}
--- a/lan-mouse-gtk/src/lib.rs
+++ b/lan-mouse-gtk/src/lib.rs
@@ -1,9 +1,5 @@
-mod authorization_window;
 mod client_object;
 mod client_row;
-mod fingerprint_window;
-mod key_object;
-mod key_row;
 mod window;

 use std::{env, process, str};
@@ -13,21 +9,14 @@ use window::Window;
 use lan_mouse_ipc::FrontendEvent;

 use adw::Application;
-use gtk::{gdk::Display, glib::clone, prelude::*, IconTheme};
+use gtk::{
+    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
+};
 use gtk::{gio, glib, prelude::ApplicationExt};

 use self::client_object::ClientObject;
-use self::key_object::KeyObject;

-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum GtkError {
-    #[error("gtk frontend exited with non zero exit code: {0}")]
-    NonZeroExitCode(i32),
-}
-
-pub fn run() -> Result<(), GtkError> {
+pub fn run() -> glib::ExitCode {
    log::debug!("running gtk frontend");
    #[cfg(windows)]
    let ret = std::thread::Builder::new()
@@ -40,10 +29,13 @@ pub fn run() -> Result<(), GtkError> {
    #[cfg(not(windows))]
    let ret = gtk_main();

-    match ret {
-        glib::ExitCode::SUCCESS => Ok(()),
-        e => Err(GtkError::NonZeroExitCode(e.value())),
+    if ret == glib::ExitCode::FAILURE {
+        log::error!("frontend exited with failure");
+    } else {
+        log::info!("frontend exited successfully");
    }
+
+    ret
 }

 fn gtk_main() -> glib::ExitCode {
@@ -53,11 +45,7 @@ fn gtk_main() -> glib::ExitCode {
        .application_id("de.feschber.LanMouse")
        .build();

-    app.connect_startup(|app| {
-        load_icons();
-        setup_actions(app);
-        setup_menu(app);
-    });
+    app.connect_startup(|_| load_icons());
    app.connect_activate(build_ui);

    let args: Vec<&'static str> = vec![];
@@ -70,33 +58,6 @@ 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,39 +93,41 @@ fn build_ui(app: &Application) {
                let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
                match notify {
                    FrontendEvent::Created(handle, client, state) => {
-                        window.new_client(handle, client, state)
+                        window.new_client(handle, client, state);
+                    }
+                    FrontendEvent::Deleted(client) => {
+                        window.delete_client(client);
                    }
-                    FrontendEvent::Deleted(client) => window.delete_client(client),
                    FrontendEvent::State(handle, config, state) => {
                        window.update_client_config(handle, config);
                        window.update_client_state(handle, state);
                    }
                    FrontendEvent::NoSuchClient(_) => {}
-                    FrontendEvent::Error(e) => window.show_toast(e.as_str()),
-                    FrontendEvent::Enumerate(clients) => window.update_client_list(clients),
-                    FrontendEvent::PortChanged(port, msg) => window.update_port(port, msg),
-                    FrontendEvent::CaptureStatus(s) => window.set_capture(s.into()),
-                    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::ConnectionAttempt { fingerprint } => {
-                        window.request_authorization(&fingerprint);
+                    FrontendEvent::Error(e) => {
+                        window.show_toast(e.as_str());
                    }
-                    FrontendEvent::DeviceConnected {
-                        fingerprint: _,
-                        addr,
-                    } => {
-                        window.show_toast(format!("device connected: {addr}").as_str());
+                    FrontendEvent::Enumerate(clients) => {
+                        for (handle, client, state) in clients {
+                            if window.client_idx(handle).is_some() {
+                                window.update_client_config(handle, client);
+                                window.update_client_state(handle, state);
+                            } else {
+                                window.new_client(handle, client, state);
+                            }
+                        }
                    }
-                    FrontendEvent::DeviceEntered {
-                        fingerprint: _,
-                        addr,
-                        pos,
-                    } => {
-                        window.show_toast(format!("device entered: {addr} ({pos})").as_str());
+                    FrontendEvent::PortChanged(port, msg) => {
+                        match msg {
+                            None => window.show_toast(format!("port changed: {port}").as_str()),
+                            Some(msg) => window.show_toast(msg.as_str()),
+                        }
+                        window.imp().set_port(port);
                    }
-                    FrontendEvent::IncomingDisconnected(addr) => {
-                        window.show_toast(format!("{addr} disconnected").as_str());
+                    FrontendEvent::CaptureStatus(s) => {
+                        window.set_capture(s.into());
+                    }
+                    FrontendEvent::EmulationStatus(s) => {
+                        window.set_emulation(s.into());
                    }
                }
            }
--- a/lan-mouse-gtk/src/window.rs
+++ b/lan-mouse-gtk/src/window.rs
@@ -1,14 +1,12 @@
 mod imp;

-use std::collections::HashMap;
-
 use adw::prelude::*;
 use adw::subclass::prelude::*;
 use glib::{clone, Object};
 use gtk::{
    gio,
    glib::{self, closure_local},
-    NoSelection,
+    ListBox, NoSelection,
 };

 use lan_mouse_ipc::{
@@ -16,11 +14,6 @@ use lan_mouse_ipc::{
    DEFAULT_PORT,
 };

-use crate::{
-    authorization_window::AuthorizationWindow, fingerprint_window::FingerprintWindow,
-    key_object::KeyObject, key_row::KeyRow,
-};
-
 use super::{client_object::ClientObject, client_row::ClientRow};

 glib::wrapper! {
@@ -31,7 +24,7 @@ glib::wrapper! {
 }

 impl Window {
-    pub(super) fn new(app: &adw::Application, conn: FrontendRequestWriter) -> Self {
+    pub(crate) fn new(app: &adw::Application, conn: FrontendRequestWriter) -> Self {
        let window: Self = Object::builder().property("application", app).build();
        window
            .imp()
@@ -41,7 +34,7 @@ impl Window {
        window
    }

-    fn clients(&self) -> gio::ListStore {
+    pub fn clients(&self) -> gio::ListStore {
        self.imp()
            .clients
            .borrow()
@@ -49,63 +42,10 @@ impl Window {
            .expect("Could not get clients")
    }

-    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 row_by_idx(&self, idx: i32) -> Option<ClientRow> {
-        self.imp()
-            .client_list
-            .get()
-            .row_at_index(idx)
-            .map(|o| o.downcast().expect("expected ClientRow"))
-    }
-
-    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));
@@ -123,57 +63,16 @@ impl Window {
                        .expect("Expected object of type `ClientObject`.");
                    let row = window.create_client_row(client_object);
                    row.connect_closure(
-                        "request-hostname-change",
-                        false,
-                        closure_local!(
-                            #[strong]
-                            window,
-                            move |row: ClientRow, hostname: String| {
-                                log::debug!("request-hostname-change");
-                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    let hostname = Some(hostname).filter(|s| !s.is_empty());
-                                    /* changed in response to FrontendEvent
-                                     * -> do not request additional update */
-                                    window.request(FrontendRequest::UpdateHostname(
-                                        client.handle(),
-                                        hostname,
-                                    ));
-                                }
-                            }
-                        ),
-                    );
-                    row.connect_closure(
-                        "request-port-change",
-                        false,
-                        closure_local!(
-                            #[strong]
-                            window,
-                            move |row: ClientRow, port: u32| {
-                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    window.request(FrontendRequest::UpdatePort(
-                                        client.handle(),
-                                        port as u16,
-                                    ));
-                                }
-                            }
-                        ),
-                    );
-                    row.connect_closure(
-                        "request-activate",
+                        "request-update",
                        false,
                        closure_local!(
                            #[strong]
                            window,
                            move |row: ClientRow, active: bool| {
                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    log::debug!(
-                                        "request: {} client",
-                                        if active { "activating" } else { "deactivating" }
-                                    );
-                                    window.request(FrontendRequest::Activate(
-                                        client.handle(),
-                                        active,
-                                    ));
+                                    window.request_client_activate(&client, active);
+                                    window.request_client_update(&client);
+                                    window.request_client_state(&client);
                                }
                            }
                        ),
@@ -186,7 +85,7 @@ impl Window {
                            window,
                            move |row: ClientRow| {
                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    window.request(FrontendRequest::Delete(client.handle()));
+                                    window.request_client_delete(&client);
                                }
                            }
                        ),
@@ -199,31 +98,9 @@ impl Window {
                            window,
                            move |row: ClientRow| {
                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    window.request(FrontendRequest::ResolveDns(
-                                        client.get_data().handle,
-                                    ));
-                                }
-                            }
-                        ),
-                    );
-                    row.connect_closure(
-                        "request-position-change",
-                        false,
-                        closure_local!(
-                            #[strong]
-                            window,
-                            move |row: ClientRow, pos_idx: u32| {
-                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    let position = match pos_idx {
-                                        0 => Position::Left,
-                                        1 => Position::Right,
-                                        2 => Position::Top,
-                                        _ => Position::Bottom,
-                                    };
-                                    window.request(FrontendRequest::UpdatePosition(
-                                        client.handle(),
-                                        position,
-                                    ));
+                                    window.request_client_update(&client);
+                                    window.request_dns(&client);
+                                    window.request_client_state(&client);
                                }
                            }
                        ),
@@ -234,15 +111,10 @@ impl Window {
        );
    }

-    fn setup_icon(&self) {
-        self.set_icon_name(Some("de.feschber.LanMouse"));
-    }
-
    /// 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
-    fn update_placeholder_visibility(&self) {
-        let visible = self.clients().n_items() == 0;
+    pub fn set_placeholder_visible(&self, visible: bool) {
        let placeholder = self.imp().client_placeholder.get();
        self.imp().client_list.set_placeholder(match visible {
            true => Some(&placeholder),
@@ -250,13 +122,8 @@ impl Window {
        });
    }

-    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"));
    }

    fn create_client_row(&self, client_object: &ClientObject) -> ClientRow {
@@ -265,52 +132,24 @@ impl Window {
        row
    }

-    fn create_key_row(&self, key_object: &KeyObject) -> KeyRow {
-        let row = KeyRow::new();
-        row.bind(key_object);
-        row
-    }
-
-    pub(super) fn new_client(
-        &self,
-        handle: ClientHandle,
-        client: ClientConfig,
-        state: ClientState,
-    ) {
+    pub fn new_client(&self, handle: ClientHandle, client: ClientConfig, state: ClientState) {
        let client = ClientObject::new(handle, client, state.clone());
        self.clients().append(&client);
-        self.update_placeholder_visibility();
+        self.set_placeholder_visible(false);
        self.update_dns_state(handle, !state.ips.is_empty());
    }

-    pub(super) fn update_client_list(
-        &self,
-        clients: Vec<(ClientHandle, ClientConfig, ClientState)>,
-    ) {
-        for (handle, client, state) in clients {
-            if self.client_idx(handle).is_some() {
-                self.update_client_config(handle, client);
-                self.update_client_state(handle, state);
+    pub fn client_idx(&self, handle: ClientHandle) -> Option<usize> {
+        self.clients().iter::<ClientObject>().position(|c| {
+            if let Ok(c) = c {
+                c.handle() == handle
            } else {
-                self.new_client(handle, client, state);
+                false
            }
-        }
+        })
    }

-    pub(super) fn update_port(&self, port: u16, msg: Option<String>) {
-        if let Some(msg) = msg {
-            self.show_toast(msg.as_str());
-        }
-        self.imp().set_port(port);
-    }
-
-    fn client_idx(&self, handle: ClientHandle) -> Option<usize> {
-        self.clients()
-            .iter::<ClientObject>()
-            .position(|c| c.ok().map(|c| c.handle() == handle).unwrap_or_default())
-    }
-
-    pub(super) fn delete_client(&self, handle: ClientHandle) {
+    pub fn delete_client(&self, handle: ClientHandle) {
        let Some(idx) = self.client_idx(handle) else {
            log::warn!("could not find client with handle {handle}");
            return;
@@ -318,35 +157,50 @@ impl Window {

        self.clients().remove(idx as u32);
        if self.clients().n_items() == 0 {
-            self.update_placeholder_visibility();
+            self.set_placeholder_visible(true);
        }
    }

-    pub(super) fn update_client_config(&self, handle: ClientHandle, client: ClientConfig) {
-        let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+    pub fn update_client_config(&self, handle: ClientHandle, client: ClientConfig) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
            return;
        };
-        row.set_hostname(client.hostname);
-        row.set_port(client.port);
-        row.set_position(client.pos);
+        let client_object = self.clients().item(idx as u32).unwrap();
+        let client_object: &ClientObject = client_object.downcast_ref().unwrap();
+        let data = client_object.get_data();
+
+        /* only change if it actually has changed, otherwise
+         * the update signal is triggered */
+        if data.hostname != client.hostname {
+            client_object.set_hostname(client.hostname.unwrap_or("".into()));
+        }
+        if data.port != client.port as u32 {
+            client_object.set_port(client.port as u32);
+        }
+        if data.position != client.pos.to_string() {
+            client_object.set_position(client.pos.to_string());
+        }
    }

-    pub(super) fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
-        let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
-            return;
-        };
-        let Some(client_object) = self.client_object_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+    pub fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
            return;
        };
+        let client_object = self.clients().item(idx as u32).unwrap();
+        let client_object: &ClientObject = client_object.downcast_ref().unwrap();
+        let data = client_object.get_data();

-        /* activation state */
-        row.set_active(state.active);
+        if state.active != data.active {
+            client_object.set_active(state.active);
+            log::debug!("set active to {}", state.active);
+        }

-        /* dns state */
-        client_object.set_resolving(state.resolving);
+        if state.resolving != data.resolving {
+            client_object.set_resolving(state.resolving);
+            log::debug!("resolving {}: {}", data.handle, state.resolving);
+        }

        self.update_dns_state(handle, !state.ips.is_empty());
        let ips = state
@@ -357,23 +211,22 @@ impl Window {
        client_object.set_ips(ips);
    }

-    fn client_object_for_handle(&self, handle: ClientHandle) -> Option<ClientObject> {
-        self.client_idx(handle)
-            .and_then(|i| self.client_by_idx(i as u32))
-    }
-
-    fn row_for_handle(&self, handle: ClientHandle) -> Option<ClientRow> {
-        self.client_idx(handle)
-            .and_then(|i| self.row_by_idx(i as i32))
-    }
-
-    fn update_dns_state(&self, handle: ClientHandle, resolved: bool) {
-        if let Some(client_row) = self.row_for_handle(handle) {
-            client_row.set_dns_state(resolved);
+    pub fn update_dns_state(&self, handle: ClientHandle, resolved: bool) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
+            return;
+        };
+        let list_box: ListBox = self.imp().client_list.get();
+        let row = list_box.row_at_index(idx as i32).unwrap();
+        let client_row: ClientRow = row.downcast().expect("expected ClientRow Object");
+        if resolved {
+            client_row.imp().dns_button.set_css_classes(&["success"])
+        } else {
+            client_row.imp().dns_button.set_css_classes(&["warning"])
        }
    }

-    fn request_port_change(&self) {
+    pub fn request_port_change(&self) {
        let port = self
            .imp()
            .port_entry
@@ -385,45 +238,51 @@ impl Window {
        self.request(FrontendRequest::ChangePort(port));
    }

-    fn request_capture(&self) {
+    pub fn request_capture(&self) {
        self.request(FrontendRequest::EnableCapture);
    }

-    fn request_emulation(&self) {
+    pub fn request_emulation(&self) {
        self.request(FrontendRequest::EnableEmulation);
    }

-    fn request_client_create(&self) {
+    pub fn request_client_state(&self, client: &ClientObject) {
+        self.request(FrontendRequest::GetState(client.handle()));
+    }
+
+    pub fn request_client_create(&self) {
        self.request(FrontendRequest::Create);
    }

-    fn open_fingerprint_dialog(&self, fp: Option<String>) {
-        let window = FingerprintWindow::new(fp);
-        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_dns(&self, client: &ClientObject) {
+        self.request(FrontendRequest::ResolveDns(client.get_data().handle));
    }

-    fn request_fingerprint_add(&self, desc: String, fp: String) {
-        self.request(FrontendRequest::AuthorizeKey(desc, fp));
+    pub fn request_client_update(&self, client: &ClientObject) {
+        let handle = client.handle();
+        let data = client.get_data();
+        let position = Position::try_from(data.position.as_str()).expect("invalid position");
+        let hostname = data.hostname;
+        let port = data.port as u16;
+
+        for event in [
+            FrontendRequest::UpdateHostname(handle, hostname),
+            FrontendRequest::UpdatePosition(handle, position),
+            FrontendRequest::UpdatePort(handle, port),
+        ] {
+            self.request(event);
+        }
    }

-    fn request_fingerprint_remove(&self, fp: String) {
-        self.request(FrontendRequest::RemoveAuthorizedKey(fp));
+    pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
+        self.request(FrontendRequest::Activate(client.handle(), active));
    }

-    fn request(&self, request: FrontendRequest) {
+    pub fn request_client_delete(&self, client: &ClientObject) {
+        self.request(FrontendRequest::Delete(client.handle()));
+    }
+
+    pub fn request(&self, request: FrontendRequest) {
        let mut requester = self.imp().frontend_request_writer.borrow_mut();
        let requester = requester.as_mut().unwrap();
        if let Err(e) = requester.request(request) {
@@ -431,18 +290,18 @@ impl Window {
        };
    }

-    pub(super) fn show_toast(&self, msg: &str) {
+    pub fn show_toast(&self, msg: &str) {
        let toast = adw::Toast::new(msg);
        let toast_overlay = &self.imp().toast_overlay;
        toast_overlay.add_toast(toast);
    }

-    pub(super) fn set_capture(&self, active: bool) {
+    pub fn set_capture(&self, active: bool) {
        self.imp().capture_active.replace(active);
        self.update_capture_emulation_status();
    }

-    pub(super) fn set_emulation(&self, active: bool) {
+    pub fn set_emulation(&self, active: bool) {
        self.imp().emulation_active.replace(active);
        self.update_capture_emulation_status();
    }
@@ -456,45 +315,4 @@ impl Window {
            .capture_emulation_group
            .set_visible(!capture || !emulation);
    }
-
-    pub(super) 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(super) fn set_pk_fp(&self, fingerprint: &str) {
-        self.imp().fingerprint_row.set_subtitle(fingerprint);
-    }
-
-    pub(super) fn request_authorization(&self, fingerprint: &str) {
-        let window = AuthorizationWindow::new(fingerprint);
-        window.set_transient_for(Some(self));
-        window.connect_closure(
-            "confirm-clicked",
-            false,
-            closure_local!(
-                #[strong(rename_to = parent)]
-                self,
-                move |w: AuthorizationWindow, fp: String| {
-                    w.close();
-                    parent.open_fingerprint_dialog(Some(fp));
-                }
-            ),
-        );
-        window.connect_closure(
-            "cancel-clicked",
-            false,
-            closure_local!(move |w: AuthorizationWindow| {
-                w.close();
-            }),
-        );
-        window.present();
-    }
 }
--- a/lan-mouse-gtk/src/window/imp.rs
+++ b/lan-mouse-gtk/src/window/imp.rs
@@ -4,17 +4,13 @@ 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, Image, Label, ListBox};
+use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, 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]
@@ -26,8 +22,6 @@ 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>,
@@ -41,10 +35,7 @@ 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>,
@@ -78,45 +69,25 @@ impl Window {
    }

    #[template_callback]
-    fn handle_copy_hostname(&self, _: &Button) {
+    fn handle_copy_hostname(&self, button: &Button) {
        if let Ok(hostname) = hostname::get() {
            let display = gdk::Display::default().unwrap();
            let clipboard = display.clipboard();
            clipboard.set_text(hostname.to_str().expect("hostname: invalid utf8"));
-            let icon = self.hostname_copy_icon.clone();
-            icon.set_icon_name(Some("emblem-ok-symbolic"));
-            icon.set_css_classes(&["success"]);
+            button.set_icon_name("emblem-ok-symbolic");
+            button.set_css_classes(&["success"]);
            glib::spawn_future_local(clone!(
                #[weak]
-                icon,
+                button,
                async move {
                    glib::timeout_future_seconds(1).await;
-                    icon.set_icon_name(Some("edit-copy-symbolic"));
-                    icon.set_css_classes(&[]);
+                    button.set_icon_name("edit-copy-symbolic");
+                    button.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);
@@ -147,11 +118,6 @@ impl Window {
        self.obj().request_capture();
    }

-    #[template_callback]
-    fn handle_add_cert_fingerprint(&self, _button: &Button) {
-        self.obj().open_fingerprint_dialog(None);
-    }
-
    pub fn set_port(&self, port: u16) {
        self.port.set(port);
        if port == DEFAULT_PORT {
@@ -175,7 +141,6 @@ impl ObjectImpl for Window {
        let obj = self.obj();
        obj.setup_icon();
        obj.setup_clients();
-        obj.setup_authorized();
    }
 }

--- a/lan-mouse-ipc/Cargo.toml
+++ b/lan-mouse-ipc/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse-ipc"
 description = "library for communication between lan-mouse service and frontends"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"
@@ -11,6 +11,6 @@ futures = "0.3.30"
 log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.107"
-thiserror = "2.0.0"
+thiserror = "1.0.63"
 tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
 tokio-stream = { version = "0.1.15", features = ["io-util"] }
--- a/lan-mouse-ipc/src/connect_async.rs
+++ b/lan-mouse-ipc/src/connect_async.rs
@@ -1,6 +1,7 @@
 use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
 use std::{
    cmp::min,
+    io,
    task::{ready, Poll},
    time::Duration,
 };
@@ -46,7 +47,7 @@ impl Stream for AsyncFrontendEventReader {
 }

 impl AsyncFrontendRequestWriter {
-    pub async fn request(&mut self, request: FrontendRequest) -> Result<(), IpcError> {
+    pub async fn request(&mut self, request: FrontendRequest) -> Result<(), io::Error> {
        let mut json = serde_json::to_string(&request).unwrap();
        log::debug!("requesting: {json}");
        json.push('\n');
@@ -56,16 +57,8 @@ impl AsyncFrontendRequestWriter {
 }

 pub async fn connect_async(
-    timeout: Option<Duration>,
 ) -> Result<(AsyncFrontendEventReader, AsyncFrontendRequestWriter), ConnectionError> {
-    let stream = if let Some(duration) = timeout {
-        tokio::select! {
-            s = wait_for_service() => s?,
-            _ = tokio::time::sleep(duration) => return Err(ConnectionError::Timeout),
-        }
-    } else {
-        wait_for_service().await?
-    };
+    let stream = wait_for_service().await?;
    #[cfg(unix)]
    let (rx, tx): (ReadHalf<UnixStream>, WriteHalf<UnixStream>) = tokio::io::split(stream);
    #[cfg(windows)]
--- a/lan-mouse-ipc/src/lib.rs
+++ b/lan-mouse-ipc/src/lib.rs
@@ -1,5 +1,5 @@
 use std::{
-    collections::{HashMap, HashSet},
+    collections::HashSet,
    env::VarError,
    fmt::Display,
    io,
@@ -30,12 +30,10 @@ pub enum ConnectionError {
    SocketPath(#[from] SocketPathError),
    #[error(transparent)]
    Io(#[from] io::Error),
-    #[error("connection timed out")]
-    Timeout,
 }

 #[derive(Debug, Error)]
-pub enum IpcListenerCreationError {
+pub enum ListenerCreationError {
    #[error("could not determine socket-path: `{0}`")]
    SocketPath(#[from] SocketPathError),
    #[error("service already running!")]
@@ -53,13 +51,12 @@ pub enum IpcError {
    #[error(transparent)]
    Connection(#[from] ConnectionError),
    #[error(transparent)]
-    Listen(#[from] IpcListenerCreationError),
+    Listen(#[from] ListenerCreationError),
 }

 pub const DEFAULT_PORT: u16 = 4242;

 #[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
 pub enum Position {
    #[default]
    Left,
@@ -68,17 +65,6 @@ 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 {
@@ -164,7 +150,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 available for emulation
+    /// tracks whether or not the client is responding to pings
    pub alive: bool,
    /// ips from dns
    pub dns_ips: Vec<IpAddr>,
@@ -198,25 +184,6 @@ 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),
-    /// new device connected
-    DeviceConnected {
-        addr: SocketAddr,
-        fingerprint: String,
-    },
-    /// incoming device entered the screen
-    DeviceEntered {
-        fingerprint: String,
-        addr: SocketAddr,
-        pos: Position,
-    },
-    /// incoming disconnected
-    IncomingDisconnected(SocketAddr),
-    /// failed connection attempt (approval for fingerprint required)
-    ConnectionAttempt { fingerprint: String },
 }

 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
@@ -241,21 +208,17 @@ pub enum FrontendRequest {
    UpdatePosition(ClientHandle, Position),
    /// update fix-ips
    UpdateFixIps(ClientHandle, Vec<IpAddr>),
+    /// request the state of the given client
+    GetState(ClientHandle),
    /// request reenabling input capture
    EnableCapture,
    /// request reenabling input emulation
    EnableEmulation,
    /// synchronize all state
    Sync,
-    /// authorize fingerprint (description, fingerprint)
-    AuthorizeKey(String, String),
-    /// remove fingerprint (fingerprint)
-    RemoveAuthorizedKey(String),
-    /// change the hook command
-    UpdateEnterHook(u64, Option<String>),
 }

-#[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
 pub enum Status {
    #[default]
    Disabled,
--- a/lan-mouse-ipc/src/listen.rs
+++ b/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, IpcListenerCreationError};
+use crate::{FrontendEvent, FrontendRequest, IpcError, ListenerCreationError};

 pub struct AsyncFrontendListener {
    #[cfg(windows)]
@@ -40,18 +40,18 @@ pub struct AsyncFrontendListener {
 }

 impl AsyncFrontendListener {
-    pub async fn new() -> Result<Self, IpcListenerCreationError> {
+    pub async fn new() -> Result<Self, ListenerCreationError> {
        #[cfg(unix)]
        let (socket_path, listener) = {
            let socket_path = crate::default_socket_path()?;

-            log::debug!("remove socket: {socket_path:?}");
+            log::debug!("remove socket: {:?}", socket_path);
            if socket_path.exists() {
                // try to connect to see if some other instance
                // of lan-mouse is already running
                match UnixStream::connect(&socket_path).await {
                    // connected -> lan-mouse is already running
-                    Ok(_) => return Err(IpcListenerCreationError::AlreadyRunning),
+                    Ok(_) => return Err(ListenerCreationError::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(IpcListenerCreationError::AlreadyRunning)
+                    return Err(ListenerCreationError::AlreadyRunning)
                }
-                Err(e) => return Err(IpcListenerCreationError::Bind(e)),
+                Err(e) => return Err(ListenerCreationError::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(IpcListenerCreationError::AlreadyRunning)
+                return Err(ListenerCreationError::AlreadyRunning)
            }
-            Err(e) => return Err(IpcListenerCreationError::Bind(e)),
+            Err(e) => return Err(ListenerCreationError::Bind(e)),
        };

        let adapter = Self {
--- a/lan-mouse-proto/Cargo.toml
+++ b/lan-mouse-proto/Cargo.toml
@@ -1,13 +1,13 @@
 [package]
 name = "lan-mouse-proto"
 description = "network protocol for lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/feschber/lan-mouse"

 [dependencies]
 num_enum = "0.7.2"
-thiserror = "2.0.0"
-input-event = { path = "../input-event", version = "0.3.0" }
+thiserror = "1.0.61"
+input-event = { path = "../input-event", version = "0.2.1" }
 paste = "1.0"
--- a/lan-mouse-proto/src/lib.rs
+++ b/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, Formatter},
+    fmt::{Debug, Display},
    mem::size_of,
 };
 use thiserror::Error;
@@ -18,39 +18,14 @@ 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 at the given position
+    /// notify a client that the cursor entered its region
    /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
-    Enter(Position),
+    Enter(u32),
    /// notify a client that the cursor left its region
    /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
    Leave(u32),
@@ -61,25 +36,19 @@ pub enum ProtoEvent {
    /// Ping event for tracking unresponsive clients.
    /// A client has to respond with [`ProtoEvent::Pong`].
    Ping,
-    /// Response to [`ProtoEvent::Ping`], true if emulation is enabled / available
-    Pong(bool),
+    /// Response to [`ProtoEvent::Ping`]
+    Pong,
 }

 impl Display for ProtoEvent {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::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(alive) => {
-                write!(
-                    f,
-                    "pong: {}",
-                    if *alive { "alive" } else { "not available" }
-                )
-            }
+            ProtoEvent::Pong => write!(f, "pong"),
        }
    }
 }
@@ -116,7 +85,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,
@@ -170,8 +139,8 @@ impl TryFrom<[u8; MAX_EVENT_SIZE]> for ProtoEvent {
                },
            ))),
            EventType::Ping => Ok(Self::Ping),
-            EventType::Pong => Ok(Self::Pong(decode_u8(&mut buf)? != 0)),
-            EventType::Enter => Ok(Self::Enter(decode_u8(&mut buf)?.try_into()?)),
+            EventType::Pong => Ok(Self::Pong),
+            EventType::Enter => Ok(Self::Enter(decode_u32(&mut buf)?)),
            EventType::Leave => Ok(Self::Leave(decode_u32(&mut buf)?)),
            EventType::Ack => Ok(Self::Ack(decode_u32(&mut buf)?)),
        }
@@ -234,8 +203,8 @@ impl From<ProtoEvent> for ([u8; MAX_EVENT_SIZE], usize) {
                    },
                },
                ProtoEvent::Ping => {}
-                ProtoEvent::Pong(alive) => encode_u8(buf, len, alive as u8),
-                ProtoEvent::Enter(pos) => encode_u8(buf, len, pos as u8),
+                ProtoEvent::Pong => {}
+                ProtoEvent::Enter(serial) => encode_u32(buf, len, serial),
                ProtoEvent::Leave(serial) => encode_u32(buf, len, serial),
                ProtoEvent::Ack(serial) => encode_u32(buf, len, serial),
            }
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -44,9 +44,6 @@ rustPlatform.buildRustPackage {
  postInstall = ''
    wrapProgram "$out/bin/lan-mouse" \
      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
-
-    install -Dm444 *.desktop -t $out/share/applications
-    install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps
  '';

  meta = with lib; {
--- a/nix/hm-module.nix
+++ b/nix/hm-module.nix
@@ -52,7 +52,7 @@ in {
      };
      Service = {
        Type = "simple";
-        ExecStart = "${cfg.package}/bin/lan-mouse daemon";
+        ExecStart = "${cfg.package}/bin/lan-mouse --daemon";
      };
      Install.WantedBy = [
        (lib.mkIf config.wayland.windowManager.hyprland.systemd.enable "hyprland-session.target")
@@ -65,7 +65,7 @@ in {
      config = {
        ProgramArguments = [
          "${cfg.package}/bin/lan-mouse"
-          "daemon"
+          "--daemon"
        ];
        KeepAlive = true;
      };
--- a/screenshots/dark.png
+++ b/screenshots/dark.png
--- a/screenshots/light.png
+++ b/screenshots/light.png
--- a/scripts/copy-macos-dylib.sh
+++ b/scripts/copy-macos-dylib.sh
@@ -1,93 +0,0 @@
-#!/bin/sh
-set -eu
-
-homebrew_path=""
-exec_path="target/debug/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-
-usage() {
-    cat <<EOF
-$0: Copy all Homebrew libraries into the macOS app bundle.
-USAGE: $0 [-h] [-b homebrew_path] [exec_path]
-
-OPTIONS:
-  -h, --help    Show this help message and exit
-  -b            Path to Homebrew installation (default: $homebrew_path)
-  exec_path     Path to the main executable in the app bundle
-                (default: get from `brew --prefix`)
-
-When macOS apps are linked to dynamic libraries (.dylib files),
-the fully qualified path to the library is embedded in the binary.
-If the libraries come from Homebrew, that means that Homebrew must be present
-and the libraries must be installed in the same location on the user's machine.
-
-This script copies all of the Homebrew libraries that an executable links to into the app bundle
-and tells all the binaries in the bundle to look for them there.
-EOF
-}
-
-# Gather command-line arguments
-while test $# -gt 0; do
-    case "$1" in
-        -h | --help ) usage; exit 0;;
-        -b | --homebrew ) homebrew_path="$1"; shift 2;;
-        * ) exec_path="$1"; shift;;
-    esac
-done
-
-if [ -z "$homebrew_path" ]; then
-    homebrew_path="$(brew --prefix)"
-fi
-
-# Path to the .app bundle
-bundle_path=$(dirname "$(dirname "$(dirname "$exec_path")")")
-# Path to the Frameworks directory
-fwks_path="$bundle_path/Contents/Frameworks"
-mkdir -p "$fwks_path"
-
-# Copy and fix references for a binary (executable or dylib)
-#
-# This function will:
-# - Copy any referenced dylibs from /opt/homebrew to the Frameworks directory
-# - Update the binary to reference the local copy instead
-# - Add the Frameworks directory to the binary's RPATH
-# - Recursively process the copied dylibs
-fix_references() {
-  local bin="$1"
-
-  # Get all Homebrew libraries referenced by the binary
-  libs=$(otool -L "$bin" | awk -v homebrew="$homebrew_path" '$0 ~ homebrew {print $1}')
-
-  echo "$libs" | while IFS= read -r old_path; do
-    local base_name="$(basename "$old_path")"
-    local dest="$fwks_path/$base_name"
-
-    if [ ! -e "$dest" ]; then
-      echo "Copying $old_path -> $dest"
-      cp -f "$old_path" "$dest"
-      # Ensure the copied dylib is writable so that xattr -rd /path/to/Lan\ Mouse.app works.
-      chmod 644 "$dest"
-
-      echo "Updating $dest to have install_name of @rpath/$base_name..."
-      install_name_tool -id "@rpath/$base_name" "$dest"
-
-      # Recursively process this dylib
-      fix_references "$dest"
-    fi
-
-    echo "Updating $bin to reference @rpath/$base_name..."
-    install_name_tool -change "$old_path" "@rpath/$base_name" "$bin"
-  done
-}
-
-fix_references "$exec_path"
-
-# Ensure the main executable has our Frameworks path in its RPATH
-if ! otool -l "$exec_path" | grep -q "@executable_path/../Frameworks"; then
-  echo "Adding RPATH to $exec_path"
-  install_name_tool -add_rpath "@executable_path/../Frameworks" "$exec_path"
-fi
-
-# Se-sign the .app
-codesign --force --deep --sign - "$bundle_path"
-
-echo "Done!"
--- a/scripts/makeicns.sh
+++ b/scripts/makeicns.sh
@@ -1,42 +0,0 @@
-#!/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"
--- a/service/lan-mouse.service
+++ b/service/lan-mouse.service
@@ -6,7 +6,7 @@ After=graphical-session.target
 BindsTo=graphical-session.target

 [Service]
-ExecStart=/usr/bin/lan-mouse daemon
+ExecStart=/usr/bin/lan-mouse --daemon
 Restart=on-failure

 [Install]
--- a/src/capture.rs
+++ b/src/capture.rs
@@ -1,418 +0,0 @@
-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");
-    }
-}
--- a/src/capture_test.rs
+++ b/src/capture_test.rs
@@ -1,21 +1,29 @@
 use crate::config::Config;
-use clap::Args;
 use futures::StreamExt;
 use input_capture::{self, CaptureError, CaptureEvent, InputCapture, InputCaptureError, Position};
 use input_event::{Event, KeyboardEvent};
+use tokio::task::LocalSet;

-#[derive(Args, Clone, Debug, Eq, PartialEq)]
-pub struct TestCaptureArgs {}
-
-pub async fn run(config: Config, _args: TestCaptureArgs) -> Result<(), InputCaptureError> {
+pub fn run() -> Result<(), InputCaptureError> {
    log::info!("running input capture test");
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()
+        .unwrap();
+
+    let config = Config::new().unwrap();
+
+    runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))
+}
+
+async fn input_capture_test(config: Config) -> Result<(), InputCaptureError> {
    log::info!("creating input capture");
-    let backend = config.capture_backend().map(|b| b.into());
+    let backend = config.capture_backend.map(|b| b.into());
    loop {
        let mut input_capture = InputCapture::new(backend).await?;
        log::info!("creating clients");
        input_capture.create(0, Position::Left).await?;
-        input_capture.create(4, Position::Left).await?;
        input_capture.create(1, Position::Right).await?;
        input_capture.create(2, Position::Top).await?;
        input_capture.create(3, Position::Bottom).await?;
@@ -33,13 +41,12 @@ async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError
            .await
            .ok_or(CaptureError::EndOfStream)??;
        let pos = match client {
-            0 | 4 => Position::Left,
+            0 => Position::Left,
            1 => Position::Right,
            2 => Position::Top,
-            3 => Position::Bottom,
-            _ => panic!(),
+            _ => Position::Bottom,
        };
-        log::info!("position: {client} ({pos}), event: {event}");
+        log::info!("position: {pos}, event: {event}");
        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key: 1, .. })) = event {
            input_capture.release().await?;
            break Ok(());
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,63 +1,18 @@
-use std::{
-    cell::RefCell,
-    collections::HashSet,
-    net::{IpAddr, SocketAddr},
-    rc::Rc,
-};
+use std::net::SocketAddr;

 use slab::Slab;

 use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState, Position};

-#[derive(Clone, Default)]
+#[derive(Default)]
 pub struct ClientManager {
-    clients: Rc<RefCell<Slab<(ClientConfig, ClientState)>>>,
+    clients: Slab<(ClientConfig, ClientState)>,
 }

 impl ClientManager {
    /// add a new client to this manager
-    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,
-        }
+    pub fn add_client(&mut self) -> ClientHandle {
+        self.clients.insert(Default::default()) as ClientHandle
    }

    /// find a client by its address
@@ -65,7 +20,6 @@ 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()) {
@@ -77,10 +31,8 @@ impl ClientManager {
            .map(|p| p as ClientHandle)
    }

-    /// get the client at the given position
-    pub fn client_at(&self, pos: Position) -> Option<ClientHandle> {
+    pub fn find_client(&self, pos: Position) -> Option<ClientHandle> {
        self.clients
-            .borrow()
            .iter()
            .find_map(|(k, (c, s))| {
                if s.active && c.pos == pos {
@@ -92,183 +44,31 @@ 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(&self, client: ClientHandle) -> Option<(ClientConfig, ClientState)> {
+    pub fn remove_client(&mut self, client: ClientHandle) -> Option<(ClientConfig, ClientState)> {
        // remove id from occupied ids
-        self.clients.borrow_mut().try_remove(client as usize)
+        self.clients.try_remove(client 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 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 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()
+    /// 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)
    }

-    /// 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(
+        &self,
+    ) -> impl Iterator<Item = (ClientHandle, &(ClientConfig, ClientState))> {
+        self.clients.iter().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,
-        }
-    }
-
-    /// update the enter hook command of the client
-    pub(crate) fn set_enter_hook(&self, handle: ClientHandle, enter_hook: Option<String>) {
-        if let Some((c, _s)) = self.clients.borrow_mut().get_mut(handle as usize) {
-            c.cmd = enter_hook;
-        }
-    }
-
-    /// 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())
+    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))
    }
 }
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,18 +1,13 @@
-use crate::capture_test::TestCaptureArgs;
-use crate::emulation_test::TestEmulationArgs;
-use clap::{Parser, Subcommand, ValueEnum};
+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;

-use lan_mouse_cli::CliArgs;
 use lan_mouse_ipc::{Position, DEFAULT_PORT};

 use input_event::scancode::{
@@ -20,69 +15,64 @@ use input_event::scancode::{
    Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
 };

-use shadow_rs::shadow;
-
-shadow!(build);
-
-const CONFIG_FILE_NAME: &str = "config.toml";
-const CERT_FILE_NAME: &str = "lan-mouse.pem";
-
-fn default_path() -> Result<PathBuf, VarError> {
-    #[cfg(unix)]
-    let default_path = {
-        let xdg_config_home =
-            env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
-        format!("{xdg_config_home}/lan-mouse/")
-    };
-
-    #[cfg(not(unix))]
-    let default_path = {
-        let app_data =
-            env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
-        format!("{app_data}\\lan-mouse\\")
-    };
-    Ok(PathBuf::from(default_path))
-}
-
 #[derive(Serialize, Deserialize, Debug)]
-struct ConfigToml {
-    capture_backend: Option<CaptureBackend>,
-    emulation_backend: Option<EmulationBackend>,
-    port: Option<u16>,
-    release_bind: Option<Vec<scancode::Linux>>,
-    cert_path: Option<PathBuf>,
-    clients: Option<Vec<TomlClient>>,
-    authorized_fingerprints: Option<HashMap<String, String>>,
+pub struct ConfigToml {
+    pub capture_backend: Option<CaptureBackend>,
+    pub emulation_backend: Option<EmulationBackend>,
+    pub port: Option<u16>,
+    pub frontend: Option<Frontend>,
+    pub release_bind: Option<Vec<scancode::Linux>>,
+    pub left: Option<TomlClient>,
+    pub right: Option<TomlClient>,
+    pub top: Option<TomlClient>,
+    pub bottom: Option<TomlClient>,
 }

-#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct TomlClient {
-    hostname: Option<String>,
-    host_name: Option<String>,
-    ips: Option<Vec<IpAddr>>,
-    port: Option<u16>,
-    position: Option<Position>,
-    activate_on_startup: Option<bool>,
-    enter_hook: Option<String>,
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+pub struct TomlClient {
+    pub capture_backend: Option<CaptureBackend>,
+    pub hostname: Option<String>,
+    pub host_name: Option<String>,
+    pub ips: Option<Vec<IpAddr>>,
+    pub port: Option<u16>,
+    pub activate_on_startup: Option<bool>,
+    pub enter_hook: Option<String>,
 }

 impl ConfigToml {
-    fn new(path: &Path) -> Result<ConfigToml, ConfigError> {
+    pub fn new(path: &str) -> 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=build::CLAP_LONG_VERSION, about, long_about = None)]
-struct Args {
+#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None)]
+struct CliArgs {
    /// the listen port for lan-mouse
    #[arg(short, long)]
    port: Option<u16>,

+    /// the frontend to use [cli | gtk]
+    #[arg(short, long)]
+    frontend: Option<Frontend>,
+
    /// non-default config file location
    #[arg(short, long)]
-    config: Option<PathBuf>,
+    config: Option<String>,
+
+    /// run only the service as a daemon without the frontend
+    #[arg(short, long)]
+    daemon: bool,
+
+    /// test input capture
+    #[arg(long)]
+    test_capture: bool,
+
+    /// test input emulation
+    #[arg(long)]
+    test_emulation: bool,

    /// capture backend override
    #[arg(long)]
@@ -91,57 +81,31 @@ struct Args {
    /// emulation backend override
    #[arg(long)]
    emulation_backend: Option<EmulationBackend>,
-
-    /// path to non-default certificate location
-    #[arg(long)]
-    cert_path: Option<PathBuf>,
-
-    /// subcommands
-    #[command(subcommand)]
-    command: Option<Command>,
-}
-
-#[derive(Subcommand, Clone, Debug, Eq, PartialEq)]
-pub enum Command {
-    /// test input emulation
-    TestEmulation(TestEmulationArgs),
-    /// test input capture
-    TestCapture(TestCaptureArgs),
-    /// Lan Mouse commandline interface
-    Cli(CliArgs),
-    /// run in daemon mode
-    Daemon,
 }

 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum CaptureBackend {
-    #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
-    #[serde(rename = "input-capture-portal")]
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    InputCapturePortal,
-    #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
-    #[serde(rename = "layer-shell")]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    LayerShell,
-    #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
-    #[serde(rename = "x11")]
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
    #[cfg(windows)]
-    #[serde(rename = "windows")]
    Windows,
    #[cfg(target_os = "macos")]
-    #[serde(rename = "macos")]
    MacOs,
-    #[serde(rename = "dummy")]
    Dummy,
 }

 impl Display for CaptureBackend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            CaptureBackend::InputCapturePortal => write!(f, "input-capture-portal"),
-            #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            CaptureBackend::LayerShell => write!(f, "layer-shell"),
-            #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            CaptureBackend::X11 => write!(f, "X11"),
            #[cfg(windows)]
            CaptureBackend::Windows => write!(f, "windows"),
@@ -155,11 +119,11 @@ impl Display for CaptureBackend {
 impl From<CaptureBackend> for input_capture::Backend {
    fn from(backend: CaptureBackend) -> Self {
        match backend {
-            #[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            CaptureBackend::InputCapturePortal => Self::InputCapturePortal,
-            #[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            CaptureBackend::LayerShell => Self::LayerShell,
-            #[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            CaptureBackend::X11 => Self::X11,
            #[cfg(windows)]
            CaptureBackend::Windows => Self::Windows,
@@ -172,38 +136,31 @@ impl From<CaptureBackend> for input_capture::Backend {

 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum EmulationBackend {
-    #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
-    #[serde(rename = "wlroots")]
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    Wlroots,
-    #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
-    #[serde(rename = "libei")]
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    Libei,
-    #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
-    #[serde(rename = "xdp")]
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
    Xdp,
-    #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
-    #[serde(rename = "x11")]
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
    X11,
    #[cfg(windows)]
-    #[serde(rename = "windows")]
    Windows,
    #[cfg(target_os = "macos")]
-    #[serde(rename = "macos")]
    MacOs,
-    #[serde(rename = "dummy")]
    Dummy,
 }

 impl From<EmulationBackend> for input_emulation::Backend {
    fn from(backend: EmulationBackend) -> Self {
        match backend {
-            #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            EmulationBackend::Wlroots => Self::Wlroots,
-            #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            EmulationBackend::Libei => Self::Libei,
-            #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            EmulationBackend::Xdp => Self::Xdp,
-            #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            EmulationBackend::X11 => Self::X11,
            #[cfg(windows)]
            EmulationBackend::Windows => Self::Windows,
@@ -217,13 +174,13 @@ impl From<EmulationBackend> for input_emulation::Backend {
 impl Display for EmulationBackend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
            EmulationBackend::Wlroots => write!(f, "wlroots"),
-            #[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
            EmulationBackend::Libei => write!(f, "libei"),
-            #[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
            EmulationBackend::Xdp => write!(f, "xdg-desktop-portal"),
-            #[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
            EmulationBackend::X11 => write!(f, "X11"),
            #[cfg(windows)]
            EmulationBackend::Windows => write!(f, "windows"),
@@ -234,16 +191,33 @@ impl Display for EmulationBackend {
    }
 }

+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
+pub enum Frontend {
+    Gtk,
+    Cli,
+}
+
+impl Default for Frontend {
+    fn default() -> Self {
+        if cfg!(feature = "gtk") {
+            Self::Gtk
+        } else {
+            Self::Cli
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Config {
-    /// command line arguments
-    args: Args,
-    /// path to the certificate file used
-    cert_path: PathBuf,
-    /// path to the config file used
-    config_path: PathBuf,
-    /// the (optional) toml config and it's path
-    config_toml: Option<ConfigToml>,
+    pub capture_backend: Option<CaptureBackend>,
+    pub emulation_backend: Option<EmulationBackend>,
+    pub frontend: Frontend,
+    pub port: u16,
+    pub clients: Vec<(TomlClient, Position)>,
+    pub daemon: bool,
+    pub release_bind: Vec<scancode::Linux>,
+    pub test_capture: bool,
+    pub test_emulation: bool,
 }

 pub struct ConfigClient {
@@ -255,25 +229,6 @@ pub struct ConfigClient {
    pub enter_hook: Option<String>,
 }

-impl From<TomlClient> for ConfigClient {
-    fn from(toml: TomlClient) -> Self {
-        let active = toml.activate_on_startup.unwrap_or(false);
-        let enter_hook = toml.enter_hook;
-        let hostname = toml.hostname;
-        let ips = HashSet::from_iter(toml.ips.into_iter().flatten());
-        let port = toml.port.unwrap_or(DEFAULT_PORT);
-        let pos = toml.position.unwrap_or_default();
-        Self {
-            ips,
-            hostname,
-            port,
-            pos,
-            active,
-            enter_hook,
-        }
-    }
-}
-
 #[derive(Debug, Error)]
 pub enum ConfigError {
    #[error(transparent)]
@@ -289,99 +244,116 @@ const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =

 impl Config {
    pub fn new() -> Result<Self, ConfigError> {
-        let args = Args::parse();
+        let args = CliArgs::parse();
+        let config_file = "config.toml";
+        #[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}")
+        };
+
+        #[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}")
+        };

        // --config <file> overrules default location
-        let config_path = args
-            .config
-            .clone()
-            .unwrap_or(default_path()?.join(CONFIG_FILE_NAME));
+        let config_path = args.config.unwrap_or(config_path);

-        let config_toml = match ConfigToml::new(&config_path) {
+        let config_toml = match ConfigToml::new(config_path.as_str()) {
            Err(e) => {
-                log::warn!("{config_path:?}: {e}");
+                log::warn!("{config_path}: {e}");
                log::warn!("Continuing without config file ...");
                None
            }
            Ok(c) => Some(c),
        };

-        // --cert-path <file> overrules default location
-        let cert_path = args
-            .cert_path
-            .clone()
-            .or(config_toml.as_ref().and_then(|c| c.cert_path.clone()))
-            .unwrap_or(default_path()?.join(CERT_FILE_NAME));
+        let frontend_arg = args.frontend;
+        let frontend_cfg = config_toml.as_ref().and_then(|c| c.frontend);
+        let frontend = frontend_arg.or(frontend_cfg).unwrap_or_default();
+
+        let port = args
+            .port
+            .or(config_toml.as_ref().and_then(|c| c.port))
+            .unwrap_or(DEFAULT_PORT);
+
+        log::debug!("{config_toml:?}");
+        let release_bind = config_toml
+            .as_ref()
+            .and_then(|c| c.release_bind.clone())
+            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()));
+
+        let capture_backend = args
+            .capture_backend
+            .or(config_toml.as_ref().and_then(|c| c.capture_backend));
+
+        let emulation_backend = args
+            .emulation_backend
+            .or(config_toml.as_ref().and_then(|c| c.emulation_backend));
+
+        let mut clients: Vec<(TomlClient, Position)> = vec![];
+
+        if let Some(config_toml) = config_toml {
+            if let Some(c) = config_toml.right {
+                clients.push((c, Position::Right))
+            }
+            if let Some(c) = config_toml.left {
+                clients.push((c, Position::Left))
+            }
+            if let Some(c) = config_toml.top {
+                clients.push((c, Position::Top))
+            }
+            if let Some(c) = config_toml.bottom {
+                clients.push((c, Position::Bottom))
+            }
+        }
+
+        let daemon = args.daemon;
+        let test_capture = args.test_capture;
+        let test_emulation = args.test_emulation;

        Ok(Config {
-            args,
-            cert_path,
-            config_path,
-            config_toml,
+            capture_backend,
+            emulation_backend,
+            daemon,
+            frontend,
+            clients,
+            port,
+            release_bind,
+            test_capture,
+            test_emulation,
        })
    }

-    /// the command to run
-    pub fn command(&self) -> Option<Command> {
-        self.args.command.clone()
-    }
-
-    pub fn config_path(&self) -> &Path {
-        &self.config_path
-    }
-
-    /// public key fingerprints authorized for connection
-    pub fn authorized_fingerprints(&self) -> HashMap<String, String> {
-        self.config_toml
-            .as_ref()
-            .and_then(|c| c.authorized_fingerprints.clone())
-            .unwrap_or_default()
-    }
-
-    /// path to certificate
-    pub fn cert_path(&self) -> &Path {
-        &self.cert_path
-    }
-
-    /// optional input-capture backend override
-    pub fn capture_backend(&self) -> Option<CaptureBackend> {
-        self.args
-            .capture_backend
-            .or(self.config_toml.as_ref().and_then(|c| c.capture_backend))
-    }
-
-    /// optional input-emulation backend override
-    pub fn emulation_backend(&self) -> Option<EmulationBackend> {
-        self.args
-            .emulation_backend
-            .or(self.config_toml.as_ref().and_then(|c| c.emulation_backend))
-    }
-
-    /// the port to use (initially)
-    pub fn port(&self) -> u16 {
-        self.args
-            .port
-            .or(self.config_toml.as_ref().and_then(|c| c.port))
-            .unwrap_or(DEFAULT_PORT)
-    }
-
-    /// list of configured clients
-    pub fn clients(&self) -> Vec<ConfigClient> {
-        self.config_toml
-            .as_ref()
-            .map(|c| c.clients.clone())
-            .unwrap_or_default()
-            .into_iter()
-            .flatten()
-            .map(From::<TomlClient>::from)
+    pub fn get_clients(&self) -> Vec<ConfigClient> {
+        self.clients
+            .iter()
+            .map(|(c, pos)| {
+                let port = c.port.unwrap_or(DEFAULT_PORT);
+                let ips: HashSet<IpAddr> = if let Some(ips) = c.ips.as_ref() {
+                    HashSet::from_iter(ips.iter().cloned())
+                } else {
+                    HashSet::new()
+                };
+                let hostname = match &c.hostname {
+                    Some(h) => Some(h.clone()),
+                    None => c.host_name.clone(),
+                };
+                let active = c.activate_on_startup.unwrap_or(false);
+                let enter_hook = c.enter_hook.clone();
+                ConfigClient {
+                    ips,
+                    hostname,
+                    port,
+                    pos: *pos,
+                    active,
+                    enter_hook,
+                }
+            })
            .collect()
    }
-
-    /// release bind for returning control to the host
-    pub fn release_bind(&self) -> Vec<scancode::Linux> {
-        self.config_toml
-            .as_ref()
-            .and_then(|c| c.release_bind.clone())
-            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()))
-    }
 }
--- a/src/connect.rs
+++ b/src/connect.rs
@@ -1,281 +0,0 @@
-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:?}");
-}
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -1,71 +0,0 @@
-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)
-}
--- a/src/dns.rs
+++ b/src/dns.rs
@@ -1,117 +1,63 @@
-use std::{collections::HashMap, net::IpAddr};
+use local_channel::mpsc::Receiver;
+use std::net::IpAddr;

-use local_channel::mpsc::{channel, Receiver, Sender};
-use tokio::task::{spawn_local, JoinHandle};
-
-use hickory_resolver::{ResolveError, TokioResolver};
-use tokio_util::sync::CancellationToken;
+use hickory_resolver::{error::ResolveError, TokioAsyncResolver};

+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: TokioResolver,
-    request_rx: Receiver<DnsRequest>,
-    event_tx: Sender<DnsEvent>,
-    cancellation_token: CancellationToken,
-    active_tasks: HashMap<ClientHandle, JoinHandle<()>>,
+    resolver: TokioAsyncResolver,
+    dns_request: Receiver<ClientHandle>,
 }

 impl DnsResolver {
-    pub(crate) fn new() -> Result<Self, ResolveError> {
-        let resolver = TokioResolver::builder_tokio()?.build();
-        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,
-            request_rx,
-            event_tx,
-            cancellation_token: cancellation_token.clone(),
-        };
-        let task = Some(spawn_local(dns_task.run()));
+    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
+        let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
        Ok(Self {
-            cancellation_token,
-            task,
-            event_rx,
-            request_tx,
+            resolver,
+            dns_request,
        })
    }

-    pub(crate) fn resolve(&self, handle: ClientHandle, hostname: String) {
-        let request = DnsRequest { handle, hostname };
-        self.request_tx.send(request).expect("channel closed");
+    async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
+        let response = self.resolver.lookup_ip(host).await?;
+        for ip in response.iter() {
+            log::info!("{host}: adding ip {ip}");
+        }
+        Ok(response.iter().collect())
    }

-    pub(crate) async fn 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();
+    pub(crate) async fn run(mut self, server: Server) {
        tokio::select! {
-            _ = self.do_dns() => {},
-            _ = cancellation_token.cancelled() => {},
+            _ = server.cancelled() => {},
+            _ = self.do_dns(&server) => {},
        }
    }

-    async fn do_dns(&mut self) {
-        while let Some(dns_request) = self.request_rx.recv().await {
-            let DnsRequest { handle, hostname } = dns_request;
+    async fn do_dns(&mut self, server: &Server) {
+        loop {
+            let handle = self.dns_request.recv().await.expect("channel closed");

-            /* abort previous dns task */
-            let previous_task = self.active_tasks.remove(&handle);
-            if let Some(task) = previous_task {
-                if !task.is_finished() {
-                    task.abort();
+            /* 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![]
                }
-            }
+            };

-            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);
+            server.update_dns_ips(handle, ips);
+            server.set_resolving(handle, false);
        }
    }
 }
--- a/src/emulation.rs
+++ b/src/emulation.rs
@@ -1,421 +0,0 @@
-use crate::listen::{LanMouseListener, ListenEvent, 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 {
-    Connected {
-        addr: SocketAddr,
-        fingerprint: String,
-    },
-    ConnectionAttempt {
-        fingerprint: String,
-    },
-    /// new connection
-    Entered {
-        /// 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() => {match e {
-                    Some(ListenEvent::Msg { event, addr }) => {
-                        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::Entered{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,
-                            _ => {}
-                        }
-                    }
-                    Some(ListenEvent::Accept { addr, fingerprint }) => {
-                        self.event_tx.send(EmulationEvent::Connected { addr, fingerprint }).expect("channel closed");
-                    }
-                    Some(ListenEvent::Rejected { fingerprint }) => {
-                        self.event_tx.send(EmulationEvent::ConnectionAttempt { fingerprint }).expect("channel closed");
-                    }
-                    None => break
-                }}
-                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");
-    }
-}
--- a/src/emulation_test.rs
+++ b/src/emulation_test.rs
@@ -1,30 +1,30 @@
 use crate::config::Config;
-use clap::Args;
 use input_emulation::{InputEmulation, InputEmulationError};
 use input_event::{Event, PointerEvent};
 use std::f64::consts::PI;
 use std::time::{Duration, Instant};
+use tokio::task::LocalSet;
+
+pub fn run() -> Result<(), InputEmulationError> {
+    log::info!("running input emulation test");
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()
+        .unwrap();
+
+    let config = Config::new().unwrap();
+
+    runtime.block_on(LocalSet::new().run_until(input_emulation_test(config)))
+}

 const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;

-#[derive(Args, Clone, Debug, Eq, PartialEq)]
-pub struct TestEmulationArgs {
-    #[arg(long)]
-    mouse: bool,
-    #[arg(long)]
-    keyboard: bool,
-    #[arg(long)]
-    scroll: bool,
-}
-
-pub async fn run(config: Config, _args: TestEmulationArgs) -> Result<(), InputEmulationError> {
-    log::info!("running input emulation test");
-
-    let backend = config.emulation_backend().map(|b| b.into());
+async fn input_emulation_test(config: Config) -> Result<(), InputEmulationError> {
+    let backend = config.emulation_backend.map(|b| b.into());
    let mut emulation = InputEmulation::new(backend).await?;
    emulation.create(0).await;
-
    let start = Instant::now();
    let mut offset = (0, 0);
    loop {
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,11 +1,7 @@
-mod capture;
-pub mod capture_test;
 pub mod client;
 pub mod config;
-mod connect;
-mod crypto;
-mod dns;
-mod emulation;
+pub mod dns;
+pub mod server;
+
+pub mod capture_test;
 pub mod emulation_test;
-mod listen;
-pub mod service;
--- a/src/listen.rs
+++ b/src/listen.rs
@@ -1,275 +0,0 @@
-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, VecDeque},
-    net::SocketAddr,
-    rc::Rc,
-    sync::{Arc, Mutex, RwLock},
-    time::Duration,
-};
-use thiserror::Error;
-use tokio::{
-    sync::Mutex as AsyncMutex,
-    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) enum ListenEvent {
-    Msg {
-        event: ProtoEvent,
-        addr: SocketAddr,
-    },
-    Accept {
-        addr: SocketAddr,
-        fingerprint: String,
-    },
-    Rejected {
-        fingerprint: String,
-    },
-}
-
-pub(crate) struct LanMouseListener {
-    listen_rx: Receiver<ListenEvent>,
-    listen_tx: Sender<ListenEvent>,
-    listen_task: JoinHandle<()>,
-    conns: Rc<AsyncMutex<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 connection_attempts: Arc<Mutex<VecDeque<String>>> = Default::default();
-
-        let authorized = authorized_keys.clone();
-        let verify_peer_certificate: Option<VerifyPeerCertificateFn> = {
-            let connection_attempts = connection_attempts.clone();
-            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 {
-                        let fingerprint = fingerprints.into_iter().next().expect("fingerprint");
-                        connection_attempts
-                            .lock()
-                            .expect("lock")
-                            .push_back(fingerprint);
-                        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<AsyncMutex<Vec<(SocketAddr, ArcConn)>>> =
-            Rc::new(AsyncMutex::new(Vec::new()));
-
-        let conns_clone = conns.clone();
-        let listen_task: JoinHandle<()> = {
-            let listen_tx = listen_tx.clone();
-            let connection_attempts = connection_attempts.clone();
-            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()));
-                                let dtls_conn: &DTLSConn = conn.as_any().downcast_ref().expect("dtls conn");
-                                let certs = dtls_conn.connection_state().await.peer_certificates;
-                                let cert = certs.first().expect("cert");
-                                let fingerprint = crypto::generate_fingerprint(cert);
-                                listen_tx.send(ListenEvent::Accept { addr, fingerprint }).expect("channel closed");
-                                spawn_local(read_loop(conns_clone.clone(), addr, conn, listen_tx.clone()));
-                            },
-                            Err(e) => {
-                                if let Error::Std(ref e) = e {
-                                    if let Some(e) = e.0.downcast_ref::<webrtc_dtls::Error>() {
-                                        match e {
-                                            webrtc_dtls::Error::ErrVerifyDataMismatch => {
-                                                if let Some(fingerprint) = connection_attempts.lock().expect("lock").pop_front() {
-                                                    listen_tx.send(ListenEvent::Rejected { fingerprint }).expect("channel closed");
-                                                }
-                                            }
-                                            _ => log::warn!("accept: {e}"),
-                                        }
-                                    } else {
-                                        log::warn!("accept: {e:?}");
-                                    }
-                                } else {
-                                    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 = ListenEvent;
-
-    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<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
-    addr: SocketAddr,
-    conn: ArcConn,
-    dtls_tx: Sender<ListenEvent>,
-) -> 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(ListenEvent::Msg { 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(())
-}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,24 +1,37 @@
 use env_logger::Env;
-use input_capture::InputCaptureError;
-use input_emulation::InputEmulationError;
 use lan_mouse::{
    capture_test,
-    config::{self, Command, Config, ConfigError},
+    config::{Config, ConfigError, Frontend},
    emulation_test,
-    service::{Service, ServiceError},
+    server::{Server, ServiceError},
 };
-use lan_mouse_cli::CliError;
-#[cfg(feature = "gtk")]
-use lan_mouse_gtk::GtkError;
-use lan_mouse_ipc::{IpcError, IpcListenerCreationError};
+use lan_mouse_ipc::IpcError;
 use std::{
-    future::Future,
    io,
-    process::{self, Child},
+    process::{self, Child, Command},
 };
 use thiserror::Error;
 use tokio::task::LocalSet;

+pub fn main() {
+    // init logging
+    let env = Env::default().filter_or("LAN_MOUSE_LOG_LEVEL", "info");
+    env_logger::init_from_env(env);
+
+    if let Err(e) = run() {
+        log::error!("{e}");
+        process::exit(1);
+    }
+}
+
+fn start_service() -> Result<Child, io::Error> {
+    let child = Command::new(std::env::current_exe()?)
+        .args(std::env::args().skip(1))
+        .arg("--daemon")
+        .spawn()?;
+    Ok(child)
+}
+
 #[derive(Debug, Error)]
 enum LanMouseError {
    #[error(transparent)]
@@ -29,85 +42,42 @@ enum LanMouseError {
    Config(#[from] ConfigError),
    #[error(transparent)]
    Io(#[from] io::Error),
-    #[error(transparent)]
-    Capture(#[from] InputCaptureError),
-    #[error(transparent)]
-    Emulation(#[from] InputEmulationError),
-    #[cfg(feature = "gtk")]
-    #[error(transparent)]
-    Gtk(#[from] GtkError),
-    #[error(transparent)]
-    Cli(#[from] CliError),
-}
-
-fn main() {
-    // init logging
-    let env = Env::default().filter_or("LAN_MOUSE_LOG_LEVEL", "info");
-    env_logger::init_from_env(env);
-
-    if let Err(e) = run() {
-        log::error!("{e}");
-        process::exit(1);
-    }
 }

 fn run() -> Result<(), LanMouseError> {
-    let config = config::Config::new()?;
-    match config.command() {
-        Some(command) => match command {
-            Command::TestEmulation(args) => run_async(emulation_test::run(config, args))?,
-            Command::TestCapture(args) => run_async(capture_test::run(config, args))?,
-            Command::Cli(cli_args) => run_async(lan_mouse_cli::run(cli_args))?,
-            Command::Daemon => {
-                // if daemon is specified we run the service
-                match run_async(run_service(config)) {
-                    Err(LanMouseError::Service(ServiceError::IpcListen(
-                        IpcListenerCreationError::AlreadyRunning,
-                    ))) => log::info!("service already running!"),
-                    r => r?,
-                }
-            }
-        },
-        None => {
-            //  otherwise start the service as a child process and
-            //  run a frontend
-            #[cfg(feature = "gtk")]
-            {
-                let mut service = start_service()?;
-                let res = lan_mouse_gtk::run();
-                #[cfg(unix)]
-                {
-                    // on unix we give the service a chance to terminate gracefully
-                    let pid = service.id() as libc::pid_t;
-                    unsafe {
-                        libc::kill(pid, libc::SIGINT);
-                    }
-                    service.wait()?;
-                }
-                service.kill()?;
-                res?;
-            }
-            #[cfg(not(feature = "gtk"))]
-            {
-                // run daemon if gtk is diabled
-                match run_async(run_service(config)) {
-                    Err(LanMouseError::Service(ServiceError::IpcListen(
-                        IpcListenerCreationError::AlreadyRunning,
-                    ))) => log::info!("service already running!"),
-                    r => r?,
-                }
+    // parse config file + cli args
+    let config = Config::new()?;
+    log::debug!("{config:?}");
+    log::info!("release bind: {:?}", config.release_bind);
+
+    if config.test_capture {
+        capture_test::run().unwrap();
+    } else if config.test_emulation {
+        emulation_test::run().unwrap();
+    } else if config.daemon {
+        // if daemon is specified we run the service
+        run_service(config)?;
+    } else {
+        //  otherwise start the service as a child process and
+        //  run a frontend
+        let mut service = start_service()?;
+        run_frontend(&config)?;
+        #[cfg(unix)]
+        {
+            // on unix we give the service a chance to terminate gracefully
+            let pid = service.id() as libc::pid_t;
+            unsafe {
+                libc::kill(pid, libc::SIGINT);
            }
+            service.wait()?;
        }
+        service.kill()?;
    }

    Ok(())
 }

-fn run_async<F, E>(f: F) -> Result<(), LanMouseError>
-where
-    F: Future<Output = Result<(), E>>,
-    LanMouseError: From<E>,
-{
+fn run_service(config: Config) -> Result<(), ServiceError> {
    // create single threaded tokio runtime
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_io()
@@ -115,24 +85,30 @@ where
        .build()?;

    // run async event loop
-    Ok(runtime.block_on(LocalSet::new().run_until(f))?)
-}
+    runtime.block_on(LocalSet::new().run_until(async {
+        // run main loop
+        log::info!("Press {:?} to release the mouse", config.release_bind);

-fn start_service() -> Result<Child, io::Error> {
-    let child = process::Command::new(std::env::current_exe()?)
-        .args(std::env::args().skip(1))
-        .arg("daemon")
-        .spawn()?;
-    Ok(child)
-}
+        let mut server = Server::new(config);
+        server.run().await?;

-async fn run_service(config: Config) -> Result<(), ServiceError> {
-    let release_bind = config.release_bind();
-    let config_path = config.config_path().to_owned();
-    let mut service = Service::new(config).await?;
-    log::info!("using config: {config_path:?}");
-    log::info!("Press {release_bind:?} to release the mouse");
-    service.run().await?;
-    log::info!("service exited!");
+        log::debug!("service exiting");
+        Result::<(), ServiceError>::Ok(())
+    }))?;
+    Ok(())
+}
+
+fn run_frontend(config: &Config) -> Result<(), IpcError> {
+    match config.frontend {
+        #[cfg(feature = "gtk")]
+        Frontend::Gtk => {
+            lan_mouse_gtk::run();
+        }
+        #[cfg(not(feature = "gtk"))]
+        Frontend::Gtk => panic!("gtk frontend requested but feature not enabled!"),
+        Frontend::Cli => {
+            lan_mouse_cli::run()?;
+        }
+    };
    Ok(())
 }
--- a/src/server.rs
+++ b/src/server.rs
@@ -0,0 +1,584 @@
+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>>>,
+    pending_dns_requests: Rc<RefCell<VecDeque<ClientHandle>>>,
+    capture_status: Rc<Cell<Status>>,
+    emulation_status: Rc<Cell<Status>>,
+}
+
+#[derive(Default)]
+struct Notifies {
+    capture: Notify,
+    emulation: Notify,
+    ping: Notify,
+    port_changed: Notify,
+    frontend_event_pending: Notify,
+    dns_request_pending: Notify,
+    cancel: CancellationToken,
+}
+
+impl Server {
+    pub fn new(config: Config) -> Self {
+        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())),
+            pending_dns_requests: 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 */
+
+        // udp task
+        let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
+
+        // input capture
+        let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
+
+        // input emulation
+        let emulation =
+            emulation_task::new(self.clone(), emulation_rx, udp_recv_rx, udp_send_tx.clone());
+
+        // create dns resolver
+        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() {
+            self.request_dns(handle);
+        }
+
+        log::info!("running service");
+
+        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!("received frontend request: {request:?}");
+                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request).await;
+                    log::debug!("handled frontend request");
+                }
+                _ = self.notifies.frontend_event_pending.notified() => {
+                    while let Some(event) = {
+                        /* need to drop borrow before next iteration! */
+                        let event = self.pending_frontend_events.borrow_mut().pop_front();
+                        event
+                    } {
+                        frontend.broadcast(event).await;
+                    }
+                },
+                _ = self.notifies.dns_request_pending.notified() => {
+                    while let Some(request) = {
+                        /* need to drop borrow before next iteration! */
+                        let request = self.pending_dns_requests.borrow_mut().pop_front();
+                        request
+                    } {
+                        dns_tx.send(request).expect("channel closed");
+                    }
+                }
+                _ = 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) {
+        self.notifies.capture.notify_waiters()
+    }
+
+    async fn capture_enabled(&self) {
+        self.notifies.capture.notified().await
+    }
+
+    fn notify_emulation(&self) {
+        self.notifies.emulation.notify_waiters()
+    }
+
+    async fn emulation_notified(&self) {
+        self.notifies.emulation.notified().await
+    }
+
+    fn restart_ping_timer(&self) {
+        self.notifies.ping.notify_waiters()
+    }
+
+    async fn ping_timer_notified(&self) {
+        self.notifies.ping.notified().await
+    }
+
+    fn request_port_change(&self, port: u16) {
+        self.port.replace(port);
+        self.notifies.port_changed.notify_one();
+    }
+
+    fn notify_port_changed(&self, port: u16, msg: Option<String>) {
+        self.port.replace(port);
+        self.notify_frontend(FrontendEvent::PortChanged(port, msg));
+    }
+
+    pub(crate) fn client_updated(&self, handle: ClientHandle) {
+        let state = self.client_manager.borrow().get(handle).cloned();
+        if let Some((config, state)) = state {
+            self.notify_frontend(FrontendEvent::State(handle, config, state));
+        }
+    }
+
+    fn active_clients(&self) -> Vec<ClientHandle> {
+        self.client_manager
+            .borrow()
+            .get_client_states()
+            .filter(|(_, (_, s))| s.active)
+            .map(|(h, _)| h)
+            .collect()
+    }
+
+    fn request_dns(&self, handle: ClientHandle) {
+        self.pending_dns_requests.borrow_mut().push_back(handle);
+        self.notifies.dns_request_pending.notify_one();
+    }
+
+    async fn handle_request(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        event: FrontendRequest,
+    ) -> bool {
+        log::debug!("frontend: {event:?}");
+        match event {
+            FrontendRequest::EnableCapture => {
+                log::info!("received capture enable request");
+                self.notify_capture();
+            }
+            FrontendRequest::EnableEmulation => {
+                log::info!("received emulation enable request");
+                self.notify_emulation();
+            }
+            FrontendRequest::Create => {
+                let handle = self.add_client().await;
+                self.request_dns(handle);
+            }
+            FrontendRequest::Activate(handle, active) => {
+                if active {
+                    self.activate_client(capture, emulate, handle).await;
+                } else {
+                    self.deactivate_client(capture, emulate, handle).await;
+                }
+            }
+            FrontendRequest::ChangePort(port) => self.request_port_change(port),
+            FrontendRequest::Delete(handle) => {
+                self.remove_client(capture, emulate, handle).await;
+                self.notify_frontend(FrontendEvent::Deleted(handle));
+            }
+            FrontendRequest::Enumerate() => self.enumerate(),
+            FrontendRequest::GetState(handle) => self.broadcast_client(handle),
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
+                self.update_fix_ips(handle, fix_ips);
+                self.request_dns(handle);
+            }
+            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
+            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
+            FrontendRequest::UpdatePosition(handle, pos) => {
+                self.update_pos(handle, capture, emulate, pos).await;
+            }
+            FrontendRequest::ResolveDns(handle) => self.request_dns(handle),
+            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));
+    }
+
+    async fn add_client(&self) -> ClientHandle {
+        let handle = self.client_manager.borrow_mut().add_client();
+        log::info!("added client {handle}");
+        let (c, s) = self.client_manager.borrow().get(handle).unwrap().clone();
+        self.notify_frontend(FrontendEvent::Created(handle, c, s));
+        handle
+    }
+
+    async fn deactivate_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        log::debug!("deactivating client {handle}");
+        match self.client_manager.borrow_mut().get_mut(handle) {
+            Some((_, s)) => s.active = false,
+            None => return,
+        };
+
+        let _ = capture.send(CaptureRequest::Destroy(handle));
+        let _ = emulate.send(EmulationRequest::Destroy(handle));
+        log::debug!("deactivating client {handle} done");
+    }
+
+    async fn activate_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        log::debug!("activating client");
+        /* deactivate potential other client at this position */
+        let pos = match self.client_manager.borrow().get(handle) {
+            Some((client, _)) => client.pos,
+            None => return,
+        };
+
+        let other = self.client_manager.borrow_mut().find_client(pos);
+        if let Some(other) = other {
+            if other != handle {
+                self.deactivate_client(capture, emulate, other).await;
+            }
+        }
+
+        /* activate the client */
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.active = true;
+        } else {
+            return;
+        };
+
+        /* notify emulation, capture and frontends */
+        let _ = capture.send(CaptureRequest::Create(handle, to_capture_pos(pos)));
+        let _ = emulate.send(EmulationRequest::Create(handle));
+        log::debug!("activating client {handle} done");
+    }
+
+    async fn remove_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        let Some(active) = self
+            .client_manager
+            .borrow_mut()
+            .remove_client(handle)
+            .map(|(_, s)| s.active)
+        else {
+            return;
+        };
+
+        if active {
+            let _ = capture.send(CaptureRequest::Destroy(handle));
+            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);
+    }
+
+    pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.dns_ips = dns_ips;
+        };
+        self.update_ips(handle);
+    }
+
+    fn update_ips(&self, handle: ClientHandle) {
+        if let Some((c, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.ips = c
+                .fix_ips
+                .iter()
+                .cloned()
+                .chain(s.dns_ips.iter().cloned())
+                .collect::<HashSet<_>>();
+        }
+    }
+
+    fn update_hostname(&self, handle: ClientHandle, hostname: Option<String>) {
+        let mut client_manager = self.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        // hostname changed
+        if c.hostname != hostname {
+            c.hostname = hostname;
+            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
+            s.active_addr = None;
+            self.request_dns(handle);
+        }
+    }
+
+    fn update_port(&self, handle: ClientHandle, port: u16) {
+        let mut client_manager = self.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        if c.port != port {
+            c.port = port;
+            s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
+        }
+    }
+
+    async fn update_pos(
+        &self,
+        handle: ClientHandle,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        pos: Position,
+    ) {
+        let (changed, active) = {
+            let mut client_manager = self.client_manager.borrow_mut();
+            let Some((c, s)) = client_manager.get_mut(handle) else {
+                return;
+            };
+
+            let changed = c.pos != pos;
+            c.pos = pos;
+            (changed, s.active)
+        };
+
+        // update state in event input emulator & input capture
+        if changed {
+            if active {
+                let _ = capture.send(CaptureRequest::Destroy(handle));
+                let _ = emulate.send(EmulationRequest::Destroy(handle));
+            }
+            let _ = capture.send(CaptureRequest::Create(handle, to_capture_pos(pos)));
+            let _ = emulate.send(EmulationRequest::Create(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: u64) -> Option<String> {
+        self.client_manager
+            .borrow_mut()
+            .get_mut(handle)
+            .and_then(|(c, _)| c.hostname.clone())
+    }
+
+    fn get_state(&self) -> State {
+        self.state.get()
+    }
+
+    fn set_state(&self, state: State) {
+        log::debug!("state => {state:?}");
+        self.state.replace(state);
+    }
+
+    fn set_active(&self, handle: Option<u64>) {
+        log::debug!("active client => {handle:?}");
+        self.active_client.replace(handle);
+    }
+
+    fn active_addr(&self, handle: u64) -> Option<SocketAddr> {
+        self.client_manager
+            .borrow()
+            .get(handle)
+            .and_then(|(_, s)| s.active_addr)
+    }
+}
+
+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,
+    }
+}
--- a/src/server/capture_task.rs
+++ b/src/server/capture_task.rs
@@ -0,0 +1,206 @@
+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,
+    }
+}
--- a/src/server/emulation_task.rs
+++ b/src/server/emulation_task.rs
@@ -0,0 +1,188 @@
+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)
+}
--- a/src/server/network_task.rs
+++ b/src/server/network_task.rs
@@ -0,0 +1,99 @@
+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)?)
+}
--- a/src/server/ping_task.rs
+++ b/src/server/ping_task.rs
@@ -0,0 +1,138 @@
+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);
+                }
+            }
+        }
+    }
+}
--- a/src/service.rs
+++ b/src/service.rs
@@ -1,539 +0,0 @@
-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::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.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()));
-        // 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());
-        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> {
-        let active = self.client_manager.active_clients();
-        for handle in active.iter() {
-            // 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);
-        }
-
-        for handle in active {
-            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::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),
-            FrontendRequest::UpdateEnterHook(handle, enter_hook) => {
-                self.update_enter_hook(handle, enter_hook)
-            }
-        }
-    }
-
-    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::ConnectionAttempt { fingerprint } => {
-                self.notify_frontend(FrontendEvent::ConnectionAttempt { fingerprint });
-            }
-            EmulationEvent::Entered {
-                addr,
-                pos,
-                fingerprint,
-            } => {
-                // check if already registered
-                if !self.incoming_conns.contains(&addr) {
-                    self.add_incoming(addr, pos, fingerprint.clone());
-                    self.notify_frontend(FrontendEvent::DeviceEntered {
-                        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(),
-            EmulationEvent::Connected { addr, fingerprint } => {
-                self.notify_frontend(FrontendEvent::DeviceConnected { addr, fingerprint });
-            }
-        }
-    }
-
-    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.broadcast_client(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::DeviceEntered {
-                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.broadcast_client(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.broadcast_client(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.broadcast_client(handle);
-    }
-
-    fn update_hostname(&mut self, handle: ClientHandle, hostname: Option<String>) {
-        log::info!("hostname changed: {hostname:?}");
-        if self.client_manager.set_hostname(handle, hostname.clone()) {
-            self.resolve(handle);
-        }
-        self.broadcast_client(handle);
-    }
-
-    fn update_port(&mut self, handle: ClientHandle, port: u16) {
-        self.client_manager.set_port(handle, port);
-        self.broadcast_client(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.broadcast_client(handle);
-    }
-
-    fn update_enter_hook(&mut self, handle: ClientHandle, enter_hook: Option<String>) {
-        self.client_manager.set_enter_hook(handle, enter_hook);
-        self.broadcast_client(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}"),
-            }
-        });
-    }
-}