chore: Release lan-mouse version 0.7.3

fix dns resolving
Create FUNDING.yml
2026-03-07 20:09:59 +03:00 · 2024-03-22 12:46:57 +01:00 · 2024-03-22 12:40:05 +01:00 · 2024-03-22 10:09:00 +01:00 · 2024-03-21 23:04:20 +01:00 · 2024-03-21 20:26:57 +01:00
51 changed files with 1981 additions and 1098 deletions
--- a/.envrc
+++ b/.envrc
@@ -0,0 +1 @@
+use flake
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: [feschber]
--- a/.github/workflows/cachix.yml
+++ b/.github/workflows/cachix.yml
@@ -0,0 +1,24 @@
+name: Binary Cache
+
+on: [push, pull_request, workflow_dispatch]
+jobs:
+  nix:
+    name: "Build"
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - uses: DeterminateSystems/nix-installer-action@main
+      with:
+        logger: pretty
+    - uses: DeterminateSystems/magic-nix-cache-action@main
+    - uses: cachix/cachix-action@v14
+      with:
+        name: lan-mouse
+        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+
+    - name: Build lan-mouse
+      run: nix build --print-build-logs
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -13,7 +13,7 @@ jobs:
  linux-release-build:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: install dependencies
      run: |
        sudo apt-get update
@@ -22,7 +22,7 @@ jobs:
    - name: Release Build
      run: cargo build --release
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: lan-mouse-linux
        path: target/release/lan-mouse
@@ -62,7 +62,7 @@ jobs:
        gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
        Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
        Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: Release Build
      run: cargo build --release
    - name: Create Archive
@@ -72,7 +72,7 @@ jobs:
        Copy-Item -Path "target\release\lan-mouse.exe" -Destination "lan-mouse-windows"
        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows.zip
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: lan-mouse-windows
        path: lan-mouse-windows.zip
@@ -80,7 +80,7 @@ jobs:
  macos-release-build:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: install dependencies
      run: brew install gtk4 libadwaita
    - name: Release Build
@@ -88,18 +88,34 @@ jobs:
        cargo build --release
        cp target/release/lan-mouse lan-mouse-macos-intel
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
-        name: lan-mouse-macos
+        name: lan-mouse-macos-intel
        path: lan-mouse-macos-intel

+  macos-aarch64-release-build:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Release Build
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-macos-aarch64
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-aarch64
+        path: lan-mouse-macos-aarch64
+
  pre-release:
    name: "Pre Release"
    needs: [windows-release-build, linux-release-build, macos-release-build]
    runs-on: "ubuntu-latest"
    steps:
    - name: Download build artifacts
-      uses: actions/download-artifact@v3
+      uses: actions/download-artifact@v4
    - name: Create Release
      uses: "marvinpinto/action-automatic-releases@latest"
      with:
@@ -109,5 +125,6 @@ jobs:
        title: "Development Build"
        files: |
          lan-mouse-linux/lan-mouse
-          lan-mouse-macos/lan-mouse-macos-intel
+          lan-mouse-macos-intel/lan-mouse-macos-intel
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
          lan-mouse-windows/lan-mouse-windows.zip
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -15,7 +15,7 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: install dependencies
      run: |
        sudo apt-get update
@@ -30,7 +30,7 @@ jobs:
    - name: Clippy
      run: cargo clippy --all-features --all-targets -- --deny warnings
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: lan-mouse
        path: target/debug/lan-mouse
@@ -40,7 +40,7 @@ jobs:
    runs-on: windows-latest

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - uses: actions/setup-python@v5
      with:
        python-version: '3.11'
@@ -84,7 +84,7 @@ jobs:
    - name: Copy Gtk Dlls
      run: Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "target\\debug"
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: lan-mouse-windows
        path: |
@@ -94,7 +94,7 @@ jobs:
  build-macos:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: install dependencies
      run: brew install gtk4 libadwaita
    - name: Build
@@ -106,7 +106,27 @@ jobs:
    - name: Clippy
      run: cargo clippy --all-features --all-targets -- --deny warnings
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: lan-mouse-macos
        path: target/debug/lan-mouse
+
+  build-macos-aarch64:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-aarch64
+        path: target/debug/lan-mouse
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -9,7 +9,7 @@ jobs:
  linux-release-build:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: install dependencies
      run: |
        sudo apt-get update
@@ -18,7 +18,7 @@ jobs:
    - name: Release Build
      run: cargo build --release
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: lan-mouse-linux
        path: target/release/lan-mouse
@@ -58,7 +58,7 @@ jobs:
        gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
        Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
        Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: Release Build
      run: cargo build --release
    - name: Create Archive
@@ -68,7 +68,7 @@ jobs:
        Copy-Item -Path "target\release\lan-mouse.exe" -Destination "lan-mouse-windows"
        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows.zip
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: lan-mouse-windows
        path: lan-mouse-windows.zip
@@ -76,7 +76,7 @@ jobs:
  macos-release-build:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: install dependencies
      run: brew install gtk4 libadwaita
    - name: Release Build
@@ -84,18 +84,34 @@ jobs:
        cargo build --release
        cp target/release/lan-mouse lan-mouse-macos-intel
    - name: Upload build artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
-        name: lan-mouse-macos
+        name: lan-mouse-macos-intel
        path: lan-mouse-macos-intel

+  macos-aarch64-release-build:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Release Build
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-macos-aarch64
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-macos-aarch64
+        path: lan-mouse-macos-aarch64
+
  tagged-release:
    name: "Tagged Release"
    needs: [windows-release-build, linux-release-build, macos-release-build]
    runs-on: "ubuntu-latest"
    steps:
    - name: Download build artifacts
-      uses: actions/download-artifact@v3
+      uses: actions/download-artifact@v4
    - name: "Create Release"
      uses: "marvinpinto/action-automatic-releases@latest"
      with:
@@ -103,5 +119,6 @@ jobs:
        prerelease: false
        files: |
          lan-mouse-linux/lan-mouse
-          lan-mouse-macos/lan-mouse-macos-intel
+          lan-mouse-macos-intel/lan-mouse-macos-intel
+          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64
          lan-mouse-windows/lan-mouse-windows.zip
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
 /target
 .gdbinit
 .idea/
-.vs/
+.vs/
+.vscode/
+.direnv/
+result
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.6.0"
+version = "0.7.3"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/ferdinandschober/lan-mouse"
@@ -20,17 +20,18 @@ toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 anyhow = "1.0.71"
 log = "0.4.20"
-env_logger = "0.10.0"
+env_logger = "0.11.3"
 serde_json = "1.0.107"
 tokio = {version = "1.32.0", features = ["io-util", "macros", "net", "rt", "sync", "signal"] }
 async-trait = "0.1.73"
 futures-core = "0.3.28"
 futures = "0.3.28"
 clap = { version="4.4.11", features = ["derive"] }
-gtk = { package = "gtk4", version = "0.7.2", features = ["v4_2"], optional = true }
-adw = { package = "libadwaita", version = "0.5.2", features = ["v1_1"], optional = true }
+gtk = { package = "gtk4", version = "0.8.1", features = ["v4_2"], optional = true }
+adw = { package = "libadwaita", version = "0.6.0", features = ["v1_1"], optional = true }
 async-channel = { version = "2.1.1", optional = true }
 keycode = "0.4.0"
+once_cell = "1.19.0"

 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
@@ -41,17 +42,17 @@ wayland-protocols = { version="0.31.0", features=["client", "staging", "unstable
 wayland-protocols-wlr = { version="0.2.0", features=["client"], optional = true }
 wayland-protocols-misc = { version="0.2.0", features=["client"], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.6.2", default-features = false, features = ["tokio"], optional = true }
-reis = { git = "https://github.com/ids1024/reis", features = [ "tokio" ], optional = true }
+ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
+reis = { version = "0.2", features = [ "tokio" ], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
 core-graphics = { version = "0.23", features = ["highsierra"] }

 [target.'cfg(windows)'.dependencies]
-winapi = { version = "0.3.9", features = ["winuser"] }
+windows = {  version = "0.54.0", features = [ "Win32_UI_Input_KeyboardAndMouse" ] }

 [build-dependencies]
-glib-build-tools = "0.18.0"
+glib-build-tools = "0.19.0"

 [features]
 default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
--- a/README.md
+++ b/README.md
@@ -43,16 +43,25 @@ input capture (to send events *to* other clients) on different operating systems
 |---------------------------|--------------------------|--------------------------------------|
 | Wayland (wlroots)         | :heavy_check_mark:       | :heavy_check_mark:                   |
 | Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:                   |
-| Wayland (Gnome)           | :heavy_check_mark:       | WIP                                  |
+| Wayland (Gnome)           | :heavy_check_mark:       | :heavy_check_mark:                   |
 | X11                       | :heavy_check_mark:       | WIP                                  |
 | Windows                   | :heavy_check_mark:       | WIP                                  |
 | MacOS                     | :heavy_check_mark:       | WIP                                  |

 > [!Important]
+> Gnome -> Sway only partially works (modifier events are not handled correctly)
+
+> [!Important]
+> **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!**
 > Otherwise input capture will not work.

 ## Installation
+### Install with cargo
+```sh
+cargo install lan-mouse
+```

 ### Download from Releases
 The easiest way to install Lan Mouse is to download precompiled release binaries from the [releases section](https://github.com/feschber/lan-mouse/releases).
@@ -69,6 +78,10 @@ paru -S lan-mouse-git
 paru -S lan-mouse-bin
 ```

+### 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)
+

 ### Building from Source

@@ -96,7 +109,7 @@ gtk-update-icon-cache /usr/local/share/icons/hicolor/

 # install desktop entry
 sudo mkdir -p /usr/local/share/applications
-sudo cp de.feschber.LanMouse.dekstop /usr/local/share/applications
+sudo cp de.feschber.LanMouse.desktop /usr/local/share/applications

 # when using firewalld: install firewall rule
 sudo cp firewall/lan-mouse.xml /etc/firewalld/services
@@ -161,7 +174,7 @@ Build gtk from source
 # install chocolatey
 Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

-# install python 3.11 (Version is important, as 3.12 does not work currently)
+# install python 3.11 (Version is important, as 3.12 does not work currently) -> Has been fixed recently
 choco install python --version=3.11.0

 # install git
@@ -180,6 +193,10 @@ choco install visualstudio2022-workload-vctools
 # install gvsbuild with python
 python -m pip install --user pipx
 python -m pipx ensurepath
+```
+
+- Relaunch your powershell instance so the changes in the environment are reflected.
+```sh
 pipx install gvsbuild

 # build gtk + libadwaita
@@ -243,10 +260,17 @@ To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/c
 To create this file you can copy the following example config:

 ### Example config
+> [!TIP]
+> key symbols in the release bind are named according
+> to their names in [src/scancode.rs#L172](src/scancode.rs#L172).
+> This is bound to change

 ```toml
 # example configuration

+# configure release bind
+release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
+
 # optional port (defaults to 4242)
 port = 4242
 # # optional frontend -> defaults to gtk if available
@@ -281,11 +305,11 @@ Where `left` can be either `left`, `right`, `top` or `bottom`.
 - [x] IP Address switching
 - [x] Liveness tracking Automatically ungrab mouse when client unreachable
 - [x] Liveness tracking: Automatically release keys, when server offline
- [ ] Libei Input Capture
+- [x] MacOS KeyCode Translation
+- [x] Libei Input Capture
 - [ ] X11 Input Capture
 - [ ] Windows Input Capture
 - [ ] MacOS Input Capture
- [ ] MacOS KeyCode Translation
 - [ ] Latency measurement and visualization
 - [ ] Bandwidth usage measurement and visualization
 - [ ] Clipboard support
--- a/config.toml
+++ b/config.toml
@@ -1,5 +1,8 @@
 # example configuration

+# release bind
+release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
+
 # optional port (defaults to 4242)
 port = 4242
 # optional frontend -> defaults to gtk if available
--- a/flake.lock
+++ b/flake.lock
@@ -0,0 +1,82 @@
+{
+  "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": 1710806803,
+        "narHash": "sha256-qrxvLS888pNJFwJdK+hf1wpRCSQcqA6W5+Ox202NDa0=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "b06025f1533a1e07b6db3e75151caa155d1c7eb3",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1710987136,
+        "narHash": "sha256-Q8GRdlAIKZ8tJUXrbcRO1pA33AdoPfTUirsSnmGQnOU=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "97596b54ac34ad8184ca1eef44b1ec2e5c2b5f9e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "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",
+  "version": 7
+}
--- a/flake.nix
+++ b/flake.nix
@@ -0,0 +1,58 @@
+{
+  description = "Nix Flake for lan-mouse";
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+  outputs = {
+    self,
+    nixpkgs,
+    rust-overlay,
+    ...
+  }: let
+    inherit (nixpkgs) lib;
+    genSystems = lib.genAttrs [
+      "x86_64-linux"
+    ];
+    pkgsFor = system:
+      import nixpkgs {
+        inherit system;
+
+        overlays = [
+          rust-overlay.overlays.default
+        ];
+      };
+    mkRustToolchain = pkgs:
+      pkgs.rust-bin.stable.latest.default.override {
+        extensions = ["rust-src"];
+      };
+    pkgs = genSystems (system: import nixpkgs {inherit system;});
+  in {
+    packages = genSystems (system: rec {
+      default = pkgs.${system}.callPackage ./nix {};
+      lan-mouse = default;
+    });
+    homeManagerModules.default = import ./nix/hm-module.nix self;
+    devShells = genSystems (system: let
+      pkgs = pkgsFor system;
+      rust = mkRustToolchain pkgs;
+    in {
+      default = pkgs.mkShell {
+        packages = with pkgs; [
+          rust
+          rust-analyzer-unwrapped
+          pkg-config
+          xorg.libX11
+          gtk4
+          libadwaita
+          xorg.libXtst
+        ];
+
+        RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";
+      };
+    });
+  };
+}
--- a/nix/README.md
+++ b/nix/README.md
@@ -0,0 +1,40 @@
+# Nix Flake Usage
+
+## run
+
+```bash
+nix run github:feschber/lan-mouse
+
+# with params
+nix run github:feschber/lan-mouse -- --help
+
+```
+
+## home-manager module
+
+add input
+
+```nix
+inputs = {
+    lan-mouse.url = "github:feschber/lan-mouse";
+}
+```
+
+enable lan-mouse
+
+``` nix
+{
+  inputs,
+  ...
+}: {
+  # add the home manager module
+  imports = [inputs.lan-mouse.homeManagerModules.default];
+
+  programs.lan-mouse = {
+    enable = true;
+    # systemd = false;
+    # package = inputs.lan-mouse.packages.${pkgs.stdenv.hostPlatform.system}.default
+  };
+}
+
+```
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -0,0 +1,42 @@
+{
+  rustPlatform,
+  lib,
+  pkgs,
+}:
+rustPlatform.buildRustPackage {
+  pname = "lan-mouse";
+  version = "0.7.0";
+
+  nativeBuildInputs = with pkgs; [
+    pkg-config
+    cmake
+    buildPackages.gtk4
+  ];
+
+  buildInputs = with pkgs; [
+    xorg.libX11
+    gtk4
+    libadwaita
+    xorg.libXtst
+  ];
+
+  src = builtins.path {
+    name = "lan-mouse";
+    path = lib.cleanSource ../.;
+  };
+
+  cargoLock.lockFile = ../Cargo.lock;
+
+  # Set Environment Variables
+  RUST_BACKTRACE = "full";
+
+  meta = with lib; {
+    description = "Lan Mouse is a mouse and keyboard sharing software";
+    longDescription = ''
+      Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices. It allows for using multiple pcs with a single set of mouse and keyboard. This is also known as a Software KVM switch.
+      The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).
+    '';
+    mainProgram = "lan-mouse";
+    platforms = platforms.all;
+  };
+}
--- a/nix/hm-module.nix
+++ b/nix/hm-module.nix
@@ -0,0 +1,50 @@
+self: {
+  config,
+  pkgs,
+  lib,
+  ...
+}:
+with lib; let
+  cfg = config.programs.lan-mouse;
+  defaultPackage = self.packages.${pkgs.stdenv.hostPlatform.system}.default;
+in {
+  options.programs.lan-mouse = with types; {
+    enable = mkEnableOption "Whether or not to enable lan-mouse.";
+    package = mkOption {
+      type = with types; nullOr package;
+      default = defaultPackage;
+      defaultText = literalExpression "inputs.lan-mouse.packages.${pkgs.stdenv.hostPlatform.system}.default";
+      description = ''
+        The lan-mouse package to use.
+
+        By default, this option will use the `packages.default` as exposed by this flake.
+      '';
+    };
+    systemd = mkOption {
+      type = types.bool;
+      default = pkgs.stdenv.isLinux;
+      description = "Whether to enable to systemd service for lan-mouse.";
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.user.services.lan-mouse = lib.mkIf cfg.systemd {
+      Unit = {
+        Description = "Systemd service for Lan Mouse";
+        Requires = ["graphical-session.target"];
+      };
+      Service = {
+        Type = "simple";
+        ExecStart = "${cfg.package}/bin/lan-mouse --daemon";
+      };
+      Install.WantedBy = [
+        (lib.mkIf config.wayland.windowManager.hyprland.systemd.enable "hyprland-session.target")
+        (lib.mkIf config.wayland.windowManager.sway.systemd.enable "sway-session.target")
+      ];
+    };
+
+    home.packages = [
+      cfg.package
+    ];
+  };
+}
--- a/shell.nix
+++ b/shell.nix
@@ -0,0 +1 @@
+(builtins.getFlake ("git+file://" + toString ./.)).devShells.${builtins.currentSystem}.default
--- a/src/backend.rs
+++ b/src/backend.rs
@@ -1,2 +0,0 @@
-pub mod consumer;
-pub mod producer;
--- a/src/backend/consumer.rs
+++ b/src/backend/consumer.rs
@@ -1,20 +0,0 @@
-#[cfg(windows)]
-pub mod windows;
-
-#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-pub mod x11;
-
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-pub mod wlroots;
-
-#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-pub mod xdg_desktop_portal;
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-pub mod libei;
-
-#[cfg(target_os = "macos")]
-pub mod macos;
-
-/// fallback consumer
-pub mod dummy;
--- a/src/backend/producer.rs
+++ b/src/backend/producer.rs
@@ -1,17 +0,0 @@
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-pub mod libei;
-
-#[cfg(target_os = "macos")]
-pub mod macos;
-
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-pub mod wayland;
-
-#[cfg(windows)]
-pub mod windows;
-
-#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-pub mod x11;
-
-/// fallback event producer
-pub mod dummy;
--- a/src/backend/producer/libei.rs
+++ b/src/backend/producer/libei.rs
@@ -1,39 +0,0 @@
-use anyhow::{anyhow, Result};
-use std::{io, task::Poll};
-
-use futures_core::Stream;
-
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    event::Event,
-    producer::EventProducer,
-};
-
-pub struct LibeiProducer {}
-
-impl LibeiProducer {
-    pub fn new() -> Result<Self> {
-        Err(anyhow!("not implemented"))
-    }
-}
-
-impl EventProducer for LibeiProducer {
-    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl Stream for LibeiProducer {
-    type Item = io::Result<(ClientHandle, Event)>;
-
-    fn poll_next(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        Poll::Pending
-    }
-}
--- a/src/capture.rs
+++ b/src/capture.rs
@@ -0,0 +1,78 @@
+use std::io;
+
+use futures_core::Stream;
+
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    event::Event,
+};
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+pub mod libei;
+
+#[cfg(target_os = "macos")]
+pub mod macos;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+pub mod wayland;
+
+#[cfg(windows)]
+pub mod windows;
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+pub mod x11;
+
+/// fallback input capture (does not produce events)
+pub mod dummy;
+
+pub async fn create() -> Box<dyn InputCapture> {
+    #[cfg(target_os = "macos")]
+    match macos::MacOSInputCapture::new() {
+        Ok(p) => return Box::new(p),
+        Err(e) => log::info!("macos input capture not available: {e}"),
+    }
+
+    #[cfg(windows)]
+    match windows::WindowsInputCapture::new() {
+        Ok(p) => return Box::new(p),
+        Err(e) => log::info!("windows input capture not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    match libei::LibeiInputCapture::new().await {
+        Ok(p) => {
+            log::info!("using libei input capture");
+            return Box::new(p);
+        }
+        Err(e) => log::info!("libei input capture not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    match wayland::WaylandInputCapture::new() {
+        Ok(p) => {
+            log::info!("using layer-shell input capture");
+            return Box::new(p);
+        }
+        Err(e) => log::info!("layer_shell input capture not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    match x11::X11InputCapture::new() {
+        Ok(p) => {
+            log::info!("using x11 input capture");
+            return Box::new(p);
+        }
+        Err(e) => log::info!("x11 input capture not available: {e}"),
+    }
+
+    log::error!("falling back to dummy input capture");
+    Box::new(dummy::DummyInputCapture::new())
+}
+
+pub trait InputCapture: Stream<Item = io::Result<(ClientHandle, Event)>> + Unpin {
+    /// notify input capture of configuration changes
+    fn notify(&mut self, event: ClientEvent) -> io::Result<()>;
+
+    /// release mouse
+    fn release(&mut self) -> io::Result<()>;
+}
--- a/src/backend/producer/dummy.rs
+++ b/src/backend/producer/dummy.rs
@@ -4,26 +4,26 @@ use std::task::{Context, Poll};

 use futures_core::Stream;

+use crate::capture::InputCapture;
 use crate::event::Event;
-use crate::producer::EventProducer;

 use crate::client::{ClientEvent, ClientHandle};

-pub struct DummyProducer {}
+pub struct DummyInputCapture {}

-impl DummyProducer {
+impl DummyInputCapture {
    pub fn new() -> Self {
        Self {}
    }
 }

-impl Default for DummyProducer {
+impl Default for DummyInputCapture {
    fn default() -> Self {
        Self::new()
    }
 }

-impl EventProducer for DummyProducer {
+impl InputCapture for DummyInputCapture {
    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
        Ok(())
    }
@@ -33,7 +33,7 @@ impl EventProducer for DummyProducer {
    }
 }

-impl Stream for DummyProducer {
+impl Stream for DummyInputCapture {
    type Item = io::Result<(ClientHandle, Event)>;

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

-pub struct MacOSProducer;
+pub struct MacOSInputCapture;

-impl MacOSProducer {
+impl MacOSInputCapture {
    pub fn new() -> Result<Self> {
        Err(anyhow!("not yet implemented"))
    }
 }

-impl Stream for MacOSProducer {
+impl Stream for MacOSInputCapture {
    type Item = io::Result<(ClientHandle, Event)>;

    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
@@ -22,7 +22,7 @@ impl Stream for MacOSProducer {
    }
 }

-impl EventProducer for MacOSProducer {
+impl InputCapture for MacOSInputCapture {
    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
        Ok(())
    }
--- a/src/backend/producer/wayland.rs
+++ b/src/backend/producer/wayland.rs
@@ -1,6 +1,6 @@
 use crate::{
+    capture::InputCapture,
    client::{ClientEvent, ClientHandle, Position},
-    producer::EventProducer,
 };

 use anyhow::{anyhow, Result};
@@ -54,9 +54,12 @@ use wayland_client::{
    delegate_noop,
    globals::{registry_queue_init, GlobalListContents},
    protocol::{
-        wl_buffer, wl_compositor, wl_keyboard,
+        wl_buffer, wl_compositor,
+        wl_keyboard::{self, WlKeyboard},
        wl_output::{self, WlOutput},
-        wl_pointer, wl_region, wl_registry, wl_seat, wl_shm, wl_shm_pool, wl_surface,
+        wl_pointer::{self, WlPointer},
+        wl_region, wl_registry, wl_seat, wl_shm, wl_shm_pool,
+        wl_surface::WlSurface,
    },
    Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
 };
@@ -73,7 +76,7 @@ struct Globals {
    seat: wl_seat::WlSeat,
    shm: wl_shm::WlShm,
    layer_shell: ZwlrLayerShellV1,
-    outputs: Vec<wl_output::WlOutput>,
+    outputs: Vec<WlOutput>,
    xdg_output_manager: ZxdgOutputManagerV1,
 }

@@ -95,6 +98,8 @@ impl OutputInfo {
 }

 struct State {
+    pointer: Option<WlPointer>,
+    keyboard: Option<WlKeyboard>,
    pointer_lock: Option<ZwpLockedPointerV1>,
    rel_pointer: Option<ZwpRelativePointerV1>,
    shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
@@ -119,11 +124,11 @@ impl AsRawFd for Inner {
    }
 }

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

 struct Window {
    buffer: wl_buffer::WlBuffer,
-    surface: wl_surface::WlSurface,
+    surface: WlSurface,
    layer_surface: ZwlrLayerSurfaceV1,
    pos: Position,
 }
@@ -136,6 +141,7 @@ impl Window {
        pos: Position,
        size: (i32, i32),
    ) -> Window {
+        log::debug!("creating window output: {output:?}, size: {size:?}");
        let g = &state.g;

        let (width, height) = match pos {
@@ -217,6 +223,7 @@ fn get_edges(outputs: &[(WlOutput, OutputInfo)], pos: Position) -> Vec<(WlOutput
 fn get_output_configuration(state: &State, pos: Position) -> Vec<(WlOutput, OutputInfo)> {
    // get all output edges corresponding to the position
    let edges = get_edges(&state.output_info, pos);
+    log::debug!("edges: {edges:?}");
    let opposite_edges = get_edges(&state.output_info, pos.opposite());

    // remove those edges that are at the same position
@@ -249,7 +256,7 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
    }
 }

-impl WaylandEventProducer {
+impl WaylandInputCapture {
    pub fn new() -> Result<Self> {
        let conn = match Connection::connect_to_env() {
            Ok(c) => c,
@@ -331,6 +338,8 @@ impl WaylandEventProducer {
        std::mem::drop(read_guard);

        let mut state = State {
+            pointer: None,
+            keyboard: None,
            g,
            pointer_lock: None,
            rel_pointer: None,
@@ -381,7 +390,7 @@ impl WaylandEventProducer {

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

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

    fn add_client(&mut self, handle: ClientHandle, pos: Position) {
@@ -406,8 +415,8 @@ impl WaylandEventProducer {
 impl State {
    fn grab(
        &mut self,
-        surface: &wl_surface::WlSurface,
-        pointer: &wl_pointer::WlPointer,
+        surface: &WlSurface,
+        pointer: &WlPointer,
        serial: u32,
        qh: &QueueHandle<State>,
    ) {
@@ -489,6 +498,7 @@ impl State {
    fn add_client(&mut self, client: ClientHandle, pos: Position) {
        let outputs = get_output_configuration(self, pos);

+        log::debug!("outputs: {outputs:?}");
        outputs.iter().for_each(|(o, i)| {
            let window = Window::new(self, &self.qh, o, pos, i.size);
            let window = Rc::new(window);
@@ -577,7 +587,7 @@ impl Inner {
    }
 }

-impl EventProducer for WaylandEventProducer {
+impl InputCapture for WaylandInputCapture {
    fn notify(&mut self, client_event: ClientEvent) -> io::Result<()> {
        match client_event {
            ClientEvent::Create(handle, pos) => {
@@ -599,7 +609,7 @@ impl EventProducer for WaylandEventProducer {
    }
 }

-impl Stream for WaylandEventProducer {
+impl Stream for WaylandInputCapture {
    type Item = io::Result<(ClientHandle, Event)>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
@@ -654,7 +664,7 @@ impl Stream for WaylandEventProducer {

 impl Dispatch<wl_seat::WlSeat, ()> for State {
    fn event(
-        _: &mut Self,
+        state: &mut Self,
        seat: &wl_seat::WlSeat,
        event: <wl_seat::WlSeat as wayland_client::Proxy>::Event,
        _: &(),
@@ -665,21 +675,21 @@ impl Dispatch<wl_seat::WlSeat, ()> for State {
            capabilities: WEnum::Value(capabilities),
        } = event
        {
-            if capabilities.contains(wl_seat::Capability::Pointer) {
-                seat.get_pointer(qh, ());
+            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 capabilities.contains(wl_seat::Capability::Keyboard) && state.keyboard.is_none() {
                seat.get_keyboard(qh, ());
            }
        }
    }
 }

-impl Dispatch<wl_pointer::WlPointer, ()> for State {
+impl Dispatch<WlPointer, ()> for State {
    fn event(
        app: &mut Self,
-        pointer: &wl_pointer::WlPointer,
-        event: <wl_pointer::WlPointer as wayland_client::Proxy>::Event,
+        pointer: &WlPointer,
+        event: <WlPointer as wayland_client::Proxy>::Event,
        _: &(),
        _: &Connection,
        qh: &QueueHandle<Self>,
@@ -761,10 +771,10 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
    }
 }

-impl Dispatch<wl_keyboard::WlKeyboard, ()> for State {
+impl Dispatch<WlKeyboard, ()> for State {
    fn event(
        app: &mut Self,
-        _: &wl_keyboard::WlKeyboard,
+        _: &WlKeyboard,
        event: wl_keyboard::Event,
        _: &(),
        _: &Connection,
@@ -917,7 +927,7 @@ impl Dispatch<wl_registry::WlRegistry, ()> for State {
                    state
                        .g
                        .outputs
-                        .push(registry.bind::<wl_output::WlOutput, _, _>(name, 4, qh, ()))
+                        .push(registry.bind::<WlOutput, _, _>(name, 4, qh, ()))
                }
            }
            wl_registry::Event::GlobalRemove { .. } => {}
@@ -962,11 +972,11 @@ impl Dispatch<ZxdgOutputV1, WlOutput> for State {
    }
 }

-impl Dispatch<wl_output::WlOutput, ()> for State {
+impl Dispatch<WlOutput, ()> for State {
    fn event(
        state: &mut Self,
-        _proxy: &wl_output::WlOutput,
-        event: <wl_output::WlOutput as wayland_client::Proxy>::Event,
+        _proxy: &WlOutput,
+        event: <WlOutput as wayland_client::Proxy>::Event,
        _data: &(),
        _conn: &Connection,
        _qhandle: &QueueHandle<Self>,
@@ -990,6 +1000,6 @@ delegate_noop!(State: ZwpPointerConstraintsV1);
 delegate_noop!(State: ignore ZxdgOutputManagerV1);
 delegate_noop!(State: ignore wl_shm::WlShm);
 delegate_noop!(State: ignore wl_buffer::WlBuffer);
-delegate_noop!(State: ignore wl_surface::WlSurface);
+delegate_noop!(State: ignore WlSurface);
 delegate_noop!(State: ignore ZwpKeyboardShortcutsInhibitorV1);
 delegate_noop!(State: ignore ZwpLockedPointerV1);
--- a/src/backend/producer/windows.rs
+++ b/src/backend/producer/windows.rs
@@ -4,14 +4,14 @@ use futures::Stream;
 use std::{io, pin::Pin};

 use crate::{
+    capture::InputCapture,
    client::{ClientEvent, ClientHandle},
    event::Event,
-    producer::EventProducer,
 };

-pub struct WindowsProducer {}
+pub struct WindowsInputCapture {}

-impl EventProducer for WindowsProducer {
+impl InputCapture for WindowsInputCapture {
    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
        Ok(())
    }
@@ -21,13 +21,13 @@ impl EventProducer for WindowsProducer {
    }
 }

-impl WindowsProducer {
+impl WindowsInputCapture {
    pub(crate) fn new() -> Result<Self> {
        Err(anyhow!("not implemented"))
    }
 }

-impl Stream for WindowsProducer {
+impl Stream for WindowsInputCapture {
    type Item = io::Result<(ClientHandle, Event)>;
    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        Poll::Pending
--- a/src/backend/producer/x11.rs
+++ b/src/backend/producer/x11.rs
@@ -4,20 +4,20 @@ use std::task::Poll;

 use futures_core::Stream;

+use crate::capture::InputCapture;
 use crate::event::Event;
-use crate::producer::EventProducer;

 use crate::client::{ClientEvent, ClientHandle};

-pub struct X11Producer {}
+pub struct X11InputCapture {}

-impl X11Producer {
+impl X11InputCapture {
    pub fn new() -> Result<Self> {
        Err(anyhow!("not implemented"))
    }
 }

-impl EventProducer for X11Producer {
+impl InputCapture for X11InputCapture {
    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
        Ok(())
    }
@@ -27,7 +27,7 @@ impl EventProducer for X11Producer {
    }
 }

-impl Stream for X11Producer {
+impl Stream for X11InputCapture {
    type Item = io::Result<(ClientHandle, Event)>;

    fn poll_next(
--- a/src/client.rs
+++ b/src/client.rs
@@ -67,7 +67,7 @@ pub struct Client {
    /// fix ips, determined by the user
    pub fix_ips: Vec<IpAddr>,
    /// unique handle to refer to the client.
-    /// This way any event consumer / producer backend does not
+    /// This way any emulation / capture backend does not
    /// need to know anything about a client other than its handle.
    pub handle: ClientHandle,
    /// all ip addresses associated with a particular client
--- a/src/config.rs
+++ b/src/config.rs
@@ -8,6 +8,8 @@ use std::{error::Error, fs};
 use toml;

 use crate::client::Position;
+use crate::scancode;
+use crate::scancode::Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift};

 pub const DEFAULT_PORT: u16 = 4242;

@@ -15,6 +17,7 @@ pub const DEFAULT_PORT: u16 = 4242;
 pub struct ConfigToml {
    pub port: Option<u16>,
    pub frontend: Option<String>,
+    pub release_bind: Option<Vec<scancode::Linux>>,
    pub left: Option<TomlClient>,
    pub right: Option<TomlClient>,
    pub top: Option<TomlClient>,
@@ -70,6 +73,7 @@ pub struct Config {
    pub port: u16,
    pub clients: Vec<(TomlClient, Position)>,
    pub daemon: bool,
+    pub release_bind: Vec<scancode::Linux>,
 }

 pub struct ConfigClient {
@@ -80,6 +84,9 @@ pub struct ConfigClient {
    pub active: bool,
 }

+const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
+    [KeyLeftCtrl, KeyLeftShift, KeyLeftMeta, KeyLeftAlt];
+
 impl Config {
    pub fn new() -> Result<Self> {
        let args = CliArgs::parse();
@@ -138,6 +145,12 @@ impl Config {
            },
        };

+        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 mut clients: Vec<(TomlClient, Position)> = vec![];

        if let Some(config_toml) = config_toml {
@@ -162,6 +175,7 @@ impl Config {
            frontend,
            clients,
            port,
+            release_bind,
        })
    }

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

 #[derive(Default)]
-pub struct DummyConsumer;
+pub struct DummyEmulation;

-impl DummyConsumer {
+impl DummyEmulation {
    pub fn new() -> Self {
        Self {}
    }
 }

 #[async_trait]
-impl EventConsumer for DummyConsumer {
+impl InputEmulation for DummyEmulation {
    async fn consume(&mut self, event: Event, client_handle: ClientHandle) {
        log::info!("received event: ({client_handle}) {event}");
    }
--- a/src/backend/consumer/libei.rs
+++ b/src/backend/consumer/libei.rs
@@ -1,15 +1,17 @@
 use std::{
    collections::HashMap,
-    io,
-    os::{
-        fd::{FromRawFd, RawFd},
-        unix::net::UnixStream,
-    },
+    os::{fd::OwnedFd, unix::net::UnixStream},
    time::{SystemTime, UNIX_EPOCH},
 };

 use anyhow::{anyhow, Result};
-use ashpd::desktop::remote_desktop::{DeviceType, RemoteDesktop};
+use ashpd::{
+    desktop::{
+        remote_desktop::{DeviceType, RemoteDesktop},
+        ResponseError,
+    },
+    WindowIdentifier,
+};
 use async_trait::async_trait;
 use futures::StreamExt;

@@ -21,11 +23,11 @@ use reis::{

 use crate::{
    client::{ClientEvent, ClientHandle},
-    consumer::EventConsumer,
+    emulate::InputEmulation,
    event::Event,
 };

-pub struct LibeiConsumer {
+pub struct LibeiEmulation {
    handshake: bool,
    context: ei::Context,
    events: EiEventStream,
@@ -43,38 +45,42 @@ pub struct LibeiConsumer {
    serial: u32,
 }

-async fn get_ei_fd() -> Result<RawFd, ashpd::Error> {
+async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
    let proxy = RemoteDesktop::new().await?;
-    let session = proxy.create_session().await?;

-    // I HATE EVERYTHING, THIS TOOK 8 HOURS OF DEBUGGING
-    proxy
-        .select_devices(
-            &session,
-            DeviceType::Pointer | DeviceType::Keyboard | DeviceType::Touchscreen,
-        )
-        .await?;
+    // retry when user presses the cancel button
+    let (session, _) = loop {
+        log::debug!("creating session ...");
+        let session = proxy.create_session().await?;
+
+        log::debug!("selecting devices ...");
+        proxy
+            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+            .await?;
+
+        log::info!("requesting permission for input emulation");
+        match proxy
+            .start(&session, &WindowIdentifier::default())
+            .await?
+            .response()
+        {
+            Ok(d) => break (session, d),
+            Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
+                log::warn!("request cancelled!");
+                continue;
+            }
+            e => e?,
+        };
+    };

-    proxy
-        .start(&session, &ashpd::WindowIdentifier::default())
-        .await?
-        .response()?;
    proxy.connect_to_eis(&session).await
 }

-impl LibeiConsumer {
+impl LibeiEmulation {
    pub async fn new() -> Result<Self> {
        // fd is owned by the message, so we need to dup it
        let eifd = get_ei_fd().await?;
-        let eifd = unsafe {
-            let ret = libc::dup(eifd);
-            if ret < 0 {
-                Err(io::Error::last_os_error())
-            } else {
-                Ok(ret)
-            }
-        }?;
-        let stream = unsafe { UnixStream::from_raw_fd(eifd) };
+        let stream = UnixStream::from(eifd);
        // let stream = UnixStream::connect("/run/user/1000/eis-0")?;
        stream.set_nonblocking(true)?;
        let context = ei::Context::new(stream)?;
@@ -101,7 +107,7 @@ impl LibeiConsumer {
 }

 #[async_trait]
-impl EventConsumer for LibeiConsumer {
+impl InputEmulation for LibeiEmulation {
    async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
--- a/src/backend/consumer/macos.rs
+++ b/src/backend/consumer/macos.rs
@@ -1,5 +1,5 @@
 use crate::client::{ClientEvent, ClientHandle};
-use crate::consumer::EventConsumer;
+use crate::emulate::InputEmulation;
 use crate::event::{Event, KeyboardEvent, PointerEvent};
 use anyhow::{anyhow, Result};
 use async_trait::async_trait;
@@ -16,7 +16,7 @@ use tokio::task::AbortHandle;
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);

-pub struct MacOSConsumer {
+pub struct MacOSEmulation {
    pub event_source: CGEventSource,
    repeat_task: Option<AbortHandle>,
    button_state: ButtonState,
@@ -50,9 +50,9 @@ impl IndexMut<CGMouseButton> for ButtonState {
    }
 }

-unsafe impl Send for MacOSConsumer {}
+unsafe impl Send for MacOSEmulation {}

-impl MacOSConsumer {
+impl MacOSEmulation {
    pub fn new() -> Result<Self> {
        let event_source = match CGEventSource::new(CGEventSourceStateID::CombinedSessionState) {
            Ok(e) => e,
@@ -108,7 +108,7 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8) {
 }

 #[async_trait]
-impl EventConsumer for MacOSConsumer {
+impl InputEmulation for MacOSEmulation {
    async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
--- a/src/backend/consumer/windows.rs
+++ b/src/backend/consumer/windows.rs
@@ -1,21 +1,19 @@
 use crate::{
-    consumer::EventConsumer,
+    emulate::InputEmulation,
    event::{KeyboardEvent, PointerEvent},
    scancode,
 };
 use anyhow::Result;
 use async_trait::async_trait;
+use std::ops::BitOrAssign;
 use std::time::Duration;
 use tokio::task::AbortHandle;
-use winapi::um::winuser::{SendInput, KEYEVENTF_EXTENDEDKEY};
-use winapi::{
-    self,
-    um::winuser::{
-        INPUT, INPUT_KEYBOARD, INPUT_MOUSE, KEYBDINPUT, KEYEVENTF_KEYUP, KEYEVENTF_SCANCODE,
-        LPINPUT, MOUSEEVENTF_HWHEEL, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP,
-        MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN,
-        MOUSEEVENTF_RIGHTUP, MOUSEEVENTF_WHEEL, MOUSEINPUT,
-    },
+use windows::Win32::UI::Input::KeyboardAndMouse::{SendInput, INPUT_0, KEYEVENTF_EXTENDEDKEY};
+use windows::Win32::UI::Input::KeyboardAndMouse::{
+    INPUT, INPUT_KEYBOARD, INPUT_MOUSE, KEYBDINPUT, KEYEVENTF_KEYUP, KEYEVENTF_SCANCODE,
+    MOUSEEVENTF_HWHEEL, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP, MOUSEEVENTF_MIDDLEDOWN,
+    MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP,
+    MOUSEEVENTF_WHEEL, MOUSEINPUT,
 };

 use crate::{
@@ -26,18 +24,18 @@ use crate::{
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);

-pub struct WindowsConsumer {
+pub struct WindowsEmulation {
    repeat_task: Option<AbortHandle>,
 }

-impl WindowsConsumer {
+impl WindowsEmulation {
    pub fn new() -> Result<Self> {
        Ok(Self { repeat_task: None })
    }
 }

 #[async_trait]
-impl EventConsumer for WindowsConsumer {
+impl InputEmulation for WindowsEmulation {
    async fn consume(&mut self, event: Event, _: ClientHandle) {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
@@ -87,7 +85,7 @@ impl EventConsumer for WindowsConsumer {
    async fn destroy(&mut self) {}
 }

-impl WindowsConsumer {
+impl WindowsEmulation {
    async fn spawn_repeat_task(&mut self, key: u32) {
        // there can only be one repeating key and it's
        // always the last to be pressed
@@ -108,21 +106,30 @@ impl WindowsConsumer {
    }
 }

-fn send_mouse_input(mi: MOUSEINPUT) {
+fn send_input_safe(input: INPUT) {
    unsafe {
-        let mut input = INPUT {
-            type_: INPUT_MOUSE,
-            u: std::mem::transmute(mi),
-        };
-
-        SendInput(
-            1_u32,
-            &mut input as LPINPUT,
-            std::mem::size_of::<INPUT>() as i32,
-        );
+        loop {
+            /* retval = number of successfully submitted events */
+            if SendInput(&[input], std::mem::size_of::<INPUT>() as i32) > 0 {
+                break;
+            }
+        }
    }
 }

+fn send_mouse_input(mi: MOUSEINPUT) {
+    send_input_safe(INPUT {
+        r#type: INPUT_MOUSE,
+        Anonymous: INPUT_0 { mi },
+    });
+}
+
+fn send_keyboard_input(ki: KEYBDINPUT) {
+    send_input_safe(INPUT {
+        r#type: INPUT_KEYBOARD,
+        Anonymous: INPUT_0 { ki },
+    });
+}
 fn rel_mouse(dx: i32, dy: i32) {
    let mi = MOUSEINPUT {
        dx,
@@ -186,33 +193,23 @@ fn key_event(key: u32, state: u8) {
    };
    let extended = scancode > 0xff;
    let scancode = scancode & 0xff;
+    let mut flags = KEYEVENTF_SCANCODE;
+    if extended {
+        flags.bitor_assign(KEYEVENTF_EXTENDEDKEY);
+    }
+    if state == 0 {
+        flags.bitor_assign(KEYEVENTF_KEYUP);
+    }
    let ki = KEYBDINPUT {
-        wVk: 0,
+        wVk: Default::default(),
        wScan: scancode,
-        dwFlags: KEYEVENTF_SCANCODE
-            | if extended { KEYEVENTF_EXTENDEDKEY } else { 0 }
-            | match state {
-                0 => KEYEVENTF_KEYUP,
-                1 => 0u32,
-                _ => return,
-            },
+        dwFlags: flags,
        time: 0,
        dwExtraInfo: 0,
    };
    send_keyboard_input(ki);
 }

-fn send_keyboard_input(ki: KEYBDINPUT) {
-    unsafe {
-        let mut input = INPUT {
-            type_: INPUT_KEYBOARD,
-            u: std::mem::zeroed(),
-        };
-        *input.u.ki_mut() = ki;
-        SendInput(1_u32, &mut input, std::mem::size_of::<INPUT>() as i32);
-    }
-}
-
 fn linux_keycode_to_windows_scancode(linux_keycode: u32) -> Option<u16> {
    let linux_scancode = match scancode::Linux::try_from(linux_keycode) {
        Ok(s) => s,
--- a/src/backend/consumer/wlroots.rs
+++ b/src/backend/consumer/wlroots.rs
@@ -1,5 +1,5 @@
 use crate::client::{ClientEvent, ClientHandle};
-use crate::consumer::EventConsumer;
+use crate::emulate::InputEmulation;
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -40,13 +40,13 @@ struct State {
 }

 // App State, implements Dispatch event handlers
-pub(crate) struct WlrootsConsumer {
+pub(crate) struct WlrootsEmulation {
    last_flush_failed: bool,
    state: State,
    queue: EventQueue<State>,
 }

-impl WlrootsConsumer {
+impl WlrootsEmulation {
    pub fn new() -> Result<Self> {
        let conn = Connection::connect_to_env()?;
        let (globals, queue) = registry_queue_init::<State>(&conn)?;
@@ -62,7 +62,7 @@ impl WlrootsConsumer {

        let input_for_client: HashMap<ClientHandle, VirtualInput> = HashMap::new();

-        let mut consumer = WlrootsConsumer {
+        let mut emulate = WlrootsEmulation {
            last_flush_failed: false,
            state: State {
                keymap: None,
@@ -74,16 +74,13 @@ impl WlrootsConsumer {
            },
            queue,
        };
-        while consumer.state.keymap.is_none() {
-            consumer
-                .queue
-                .blocking_dispatch(&mut consumer.state)
-                .unwrap();
+        while emulate.state.keymap.is_none() {
+            emulate.queue.blocking_dispatch(&mut emulate.state).unwrap();
        }
-        // let fd = unsafe { &File::from_raw_fd(consumer.state.keymap.unwrap().1.as_raw_fd()) };
+        // let fd = unsafe { &File::from_raw_fd(emulate.state.keymap.unwrap().1.as_raw_fd()) };
        // let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
        // log::debug!("{:?}", &mmap[..100]);
-        Ok(consumer)
+        Ok(emulate)
    }
 }

@@ -106,7 +103,7 @@ impl State {
 }

 #[async_trait]
-impl EventConsumer for WlrootsConsumer {
+impl InputEmulation for WlrootsEmulation {
    async fn consume(&mut self, event: Event, client_handle: ClientHandle) {
        if let Some(virtual_input) = self.state.input_for_client.get(&client_handle) {
            if self.last_flush_failed {
--- a/src/backend/consumer/x11.rs
+++ b/src/backend/consumer/x11.rs
@@ -8,19 +8,19 @@ use x11::{

 use crate::{
    client::ClientHandle,
-    consumer::EventConsumer,
+    emulate::InputEmulation,
    event::{
        Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
    },
 };

-pub struct X11Consumer {
+pub struct X11Emulation {
    display: *mut xlib::Display,
 }

-unsafe impl Send for X11Consumer {}
+unsafe impl Send for X11Emulation {}

-impl X11Consumer {
+impl X11Emulation {
    pub fn new() -> Result<Self> {
        let display = unsafe {
            match xlib::XOpenDisplay(ptr::null()) {
@@ -91,7 +91,7 @@ impl X11Consumer {
    }
 }

-impl Drop for X11Consumer {
+impl Drop for X11Emulation {
    fn drop(&mut self) {
        unsafe {
            XCloseDisplay(self.display);
@@ -100,7 +100,7 @@ impl Drop for X11Consumer {
 }

 #[async_trait]
-impl EventConsumer for X11Consumer {
+impl InputEmulation for X11Emulation {
    async fn consume(&mut self, event: Event, _: ClientHandle) {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
--- a/src/backend/consumer/xdg_desktop_portal.rs
+++ b/src/backend/consumer/xdg_desktop_portal.rs
@@ -2,7 +2,7 @@ use anyhow::Result;
 use ashpd::{
    desktop::{
        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
-        Session,
+        ResponseError, Session,
    },
    WindowIdentifier,
 };
@@ -10,33 +10,48 @@ use async_trait::async_trait;

 use crate::{
    client::ClientEvent,
-    consumer::EventConsumer,
+    emulate::InputEmulation,
    event::{
        Event::{Keyboard, Pointer},
        KeyboardEvent, PointerEvent,
    },
 };

-pub struct DesktopPortalConsumer<'a> {
+pub struct DesktopPortalEmulation<'a> {
    proxy: RemoteDesktop<'a>,
    session: Session<'a>,
 }

-impl<'a> DesktopPortalConsumer<'a> {
-    pub async fn new() -> Result<DesktopPortalConsumer<'a>> {
+impl<'a> DesktopPortalEmulation<'a> {
+    pub async fn new() -> Result<DesktopPortalEmulation<'a>> {
        log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
        let proxy = RemoteDesktop::new().await?;
-        log::debug!("creating session ...");
-        let session = proxy.create_session().await?;
-        log::debug!("selecting devices ...");
-        proxy
-            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
-            .await?;

-        let _ = proxy
-            .start(&session, &WindowIdentifier::default())
-            .await?
-            .response()?;
+        // retry when user presses the cancel button
+        let (session, _) = loop {
+            log::debug!("creating session ...");
+            let session = proxy.create_session().await?;
+
+            log::debug!("selecting devices ...");
+            proxy
+                .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+                .await?;
+
+            log::info!("requesting permission for input emulation");
+            match proxy
+                .start(&session, &WindowIdentifier::default())
+                .await?
+                .response()
+            {
+                Ok(d) => break (session, d),
+                Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
+                    log::warn!("request cancelled!");
+                    continue;
+                }
+                e => e?,
+            };
+        };
+
        log::debug!("started session");

        Ok(Self { proxy, session })
@@ -44,7 +59,7 @@ impl<'a> DesktopPortalConsumer<'a> {
 }

 #[async_trait]
-impl<'a> EventConsumer for DesktopPortalConsumer<'a> {
+impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
    async fn consume(&mut self, event: crate::event::Event, _client: crate::client::ClientHandle) {
        match event {
            Pointer(p) => {
--- a/src/frontend/gtk.rs
+++ b/src/frontend/gtk.rs
@@ -129,7 +129,7 @@ fn build_ui(app: &Application) {
    window.imp().stream.borrow_mut().replace(tx);
    glib::spawn_future_local(clone!(@weak window => async move {
        loop {
-            let notify = receiver.recv().await.unwrap();
+            let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
            match notify {
                FrontendNotify::NotifyClientActivate(handle, active) => {
                    window.activate_client(handle, active);
--- a/src/frontend/gtk/client_row/imp.rs
+++ b/src/frontend/gtk/client_row/imp.rs
@@ -4,9 +4,9 @@ use adw::subclass::prelude::*;
 use adw::{prelude::*, ActionRow, ComboRow};
 use glib::{subclass::InitializingObject, Binding};
 use gtk::glib::clone;
-use gtk::glib::once_cell::sync::Lazy;
 use gtk::glib::subclass::Signal;
 use gtk::{glib, Button, CompositeTemplate, Switch};
+use std::sync::OnceLock;

 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/client_row.ui")]
@@ -55,15 +55,15 @@ impl ObjectImpl for ClientRow {
    }

    fn signals() -> &'static [glib::subclass::Signal] {
-        static SIGNALS: Lazy<Vec<Signal>> = Lazy::new(|| {
+        static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
+        SIGNALS.get_or_init(|| {
            vec![
                Signal::builder("request-update")
                    .param_types([bool::static_type()])
                    .build(),
                Signal::builder("request-delete").build(),
            ]
-        });
-        SIGNALS.as_ref()
+        })
    }
 }

--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,9 +4,8 @@ pub mod dns;
 pub mod event;
 pub mod server;

-pub mod consumer;
-pub mod producer;
+pub mod capture;
+pub mod emulate;

-pub mod backend;
 pub mod frontend;
 pub mod scancode;
--- a/src/main.rs
+++ b/src/main.rs
@@ -29,6 +29,7 @@ pub fn run() -> Result<()> {
    // parse config file + cli args
    let config = Config::new()?;
    log::debug!("{config:?}");
+    log::info!("release bind: {:?}", config.release_bind);

    if config.daemon {
        // if daemon is specified we run the service
--- a/src/producer.rs
+++ b/src/producer.rs
@@ -1,61 +0,0 @@
-use std::io;
-
-use futures_core::Stream;
-
-use crate::backend::producer;
-use crate::{
-    client::{ClientEvent, ClientHandle},
-    event::Event,
-};
-
-pub async fn create() -> Box<dyn EventProducer> {
-    #[cfg(target_os = "macos")]
-    match producer::macos::MacOSProducer::new() {
-        Ok(p) => return Box::new(p),
-        Err(e) => log::info!("macos event producer not available: {e}"),
-    }
-
-    #[cfg(windows)]
-    match producer::windows::WindowsProducer::new() {
-        Ok(p) => return Box::new(p),
-        Err(e) => log::info!("windows event producer not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    match producer::libei::LibeiProducer::new() {
-        Ok(p) => {
-            log::info!("using libei event producer");
-            return Box::new(p);
-        }
-        Err(e) => log::info!("libei event producer not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    match producer::wayland::WaylandEventProducer::new() {
-        Ok(p) => {
-            log::info!("using layer-shell event producer");
-            return Box::new(p);
-        }
-        Err(e) => log::info!("layer_shell event producer not available: {e}"),
-    }
-
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    match producer::x11::X11Producer::new() {
-        Ok(p) => {
-            log::info!("using x11 event producer");
-            return Box::new(p);
-        }
-        Err(e) => log::info!("x11 event producer not available: {e}"),
-    }
-
-    log::error!("falling back to dummy event producer");
-    Box::new(producer::dummy::DummyProducer::new())
-}
-
-pub trait EventProducer: Stream<Item = io::Result<(ClientHandle, Event)>> + Unpin {
-    /// notify event producer of configuration changes
-    fn notify(&mut self, event: ClientEvent) -> io::Result<()>;
-
-    /// release mouse
-    fn release(&mut self) -> io::Result<()>;
-}
--- a/src/scancode.rs
+++ b/src/scancode.rs
@@ -1,3 +1,5 @@
+use serde::{Deserialize, Serialize};
+
 /*
 * https://learn.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input
 */
@@ -165,7 +167,7 @@ pub enum Windows {
 * https://github.com/torvalds/linux/blob/master/include/uapi/linux/input-event-codes.h
 */
 #[repr(u32)]
-#[derive(Debug, Clone, Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq, Hash, PartialEq)]
 #[allow(dead_code)]
 pub enum Linux {
    KeyReserved = 0,
@@ -210,7 +212,7 @@ pub enum Linux {
    KeySemicolon = 39,
    KeyApostrophe = 40,
    KeyGrave = 41,
-    KeyLeftshift = 42,
+    KeyLeftShift = 42,
    KeyBackslash = 43,
    KeyZ = 44,
    KeyX = 45,
@@ -224,7 +226,7 @@ pub enum Linux {
    KeySlash = 53,
    KeyRightShift = 54,
    KeyKpAsterisk = 55,
-    KeyLeftalt = 56,
+    KeyLeftAlt = 56,
    KeySpace = 57,
    KeyCapsLock = 58,
    KeyF1 = 59,
@@ -294,7 +296,7 @@ pub enum Linux {
    // KEY_HANGUEL = KeyHangeul,
    KeyHanja = 123,
    KeyYen = 124,
-    KeyLeftmeta = 125,
+    KeyLeftMeta = 125,
    KeyRightmeta = 126,
    KeyCompose = 127,
    KeyStop = 128, /* AC Stop */
@@ -485,7 +487,7 @@ impl TryFrom<Linux> for Windows {
            Linux::KeySemicolon => Ok(Self::KeySemiColon),
            Linux::KeyApostrophe => Ok(Self::KeyApostrophe),
            Linux::KeyGrave => Ok(Self::KeyGrave),
-            Linux::KeyLeftshift => Ok(Self::KeyLeftShift),
+            Linux::KeyLeftShift => Ok(Self::KeyLeftShift),
            Linux::KeyBackslash => Ok(Self::KeyBackslash),
            Linux::KeyZ => Ok(Self::KeyZ),
            Linux::KeyX => Ok(Self::KeyX),
@@ -499,7 +501,7 @@ impl TryFrom<Linux> for Windows {
            Linux::KeySlash => Ok(Self::KeySlash),
            Linux::KeyRightShift => Ok(Self::KeyRightShift),
            Linux::KeyKpAsterisk => Ok(Self::KeypadStar),
-            Linux::KeyLeftalt => Ok(Self::KeyLeftAlt),
+            Linux::KeyLeftAlt => Ok(Self::KeyLeftAlt),
            Linux::KeySpace => Ok(Self::KeySpace),
            Linux::KeyCapsLock => Ok(Self::KeyCapsLock),
            Linux::KeyF1 => Ok(Self::KeyF1),
@@ -567,7 +569,7 @@ impl TryFrom<Linux> for Windows {
            Linux::KeyHangeul => Ok(Self::KeyInternational1), // TODO unsure
            Linux::KeyHanja => Ok(Self::KeyInternational2),   // TODO unsure
            Linux::KeyYen => Ok(Self::KeyInternational3),     // TODO unsure
-            Linux::KeyLeftmeta => Ok(Self::KeyLeftGUI),
+            Linux::KeyLeftMeta => Ok(Self::KeyLeftGUI),
            Linux::KeyRightmeta => Ok(Self::KeyRightGUI),
            Linux::KeyCompose => Ok(Self::KeyApplication),
            Linux::KeyStop => Ok(Self::ACStop),
--- a/src/server.rs
+++ b/src/server.rs
@@ -5,22 +5,22 @@ use std::{
 };
 use tokio::signal;

+use crate::{capture, emulate};
 use crate::{
    client::{ClientHandle, ClientManager},
    config::Config,
    dns,
    frontend::{FrontendEvent, FrontendListener},
-    server::producer_task::ProducerEvent,
+    server::capture_task::CaptureEvent,
 };
-use crate::{consumer, producer};

-use self::{consumer_task::ConsumerEvent, resolver_task::DnsRequest};
+use self::{emulation_task::EmulationEvent, resolver_task::DnsRequest};

-mod consumer_task;
+mod capture_task;
+mod emulation_task;
 mod frontend_task;
 mod network_task;
 mod ping_task;
-mod producer_task;
 mod resolver_task;

 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -40,6 +40,7 @@ pub struct Server {
    client_manager: Rc<RefCell<ClientManager>>,
    port: Rc<Cell<u16>>,
    state: Rc<Cell<State>>,
+    release_bind: Vec<crate::scancode::Linux>,
 }

 impl Server {
@@ -57,11 +58,13 @@ impl Server {
                config_client.active,
            );
        }
+        let release_bind = config.release_bind.clone();
        Self {
            active_client,
            client_manager,
            port,
            state,
+            release_bind,
        }
    }

@@ -75,7 +78,7 @@ impl Server {
                return anyhow::Ok(());
            }
        };
-        let (consumer, producer) = tokio::join!(consumer::create(), producer::create());
+        let (emulate, capture) = tokio::join!(emulate::create(), capture::create());

        let (timer_tx, timer_rx) = tokio::sync::mpsc::channel(1);
        let (frontend_notify_tx, frontend_notify_rx) = tokio::sync::mpsc::channel(1);
@@ -84,17 +87,22 @@ impl Server {
        let (mut udp_task, sender_tx, receiver_rx, port_tx) =
            network_task::new(self.clone(), frontend_notify_tx).await?;

-        // event producer
-        let (mut producer_task, producer_channel) =
-            producer_task::new(producer, self.clone(), sender_tx.clone(), timer_tx.clone());
+        // input capture
+        let (mut capture_task, capture_channel) = capture_task::new(
+            capture,
+            self.clone(),
+            sender_tx.clone(),
+            timer_tx.clone(),
+            self.release_bind.clone(),
+        );

-        // event consumer
-        let (mut consumer_task, consumer_channel) = consumer_task::new(
-            consumer,
+        // input emulation
+        let (mut emulation_task, emulate_channel) = emulation_task::new(
+            emulate,
            self.clone(),
            receiver_rx,
            sender_tx.clone(),
-            producer_channel.clone(),
+            capture_channel.clone(),
            timer_tx,
        );

@@ -107,8 +115,8 @@ impl Server {
            frontend,
            frontend_notify_rx,
            self.clone(),
-            producer_channel.clone(),
-            consumer_channel.clone(),
+            capture_channel.clone(),
+            emulate_channel.clone(),
            resolve_tx.clone(),
            port_tx,
        );
@@ -117,8 +125,8 @@ impl Server {
        let mut ping_task = ping_task::new(
            self.clone(),
            sender_tx.clone(),
-            consumer_channel.clone(),
-            producer_channel.clone(),
+            emulate_channel.clone(),
+            capture_channel.clone(),
            timer_rx,
        );

@@ -142,19 +150,20 @@ impl Server {
                let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
            }
        }
+        log::info!("running service");

        tokio::select! {
            _ = signal::ctrl_c() => {
                log::info!("terminating service");
            }
-            e = &mut producer_task => {
+            e = &mut capture_task => {
                if let Ok(Err(e)) = e {
-                    log::error!("error in event producer: {e}");
+                    log::error!("error in input capture task: {e}");
                }
            }
-            e = &mut consumer_task => {
+            e = &mut emulation_task => {
                if let Ok(Err(e)) = e {
-                    log::error!("error in event consumer: {e}");
+                    log::error!("error in input emulation task: {e}");
                }
            }
            e = &mut frontend_task => {
@@ -167,18 +176,18 @@ impl Server {
            _ = &mut ping_task => { }
        }

-        let _ = consumer_channel.send(ConsumerEvent::Terminate).await;
-        let _ = producer_channel.send(ProducerEvent::Terminate).await;
+        let _ = emulate_channel.send(EmulationEvent::Terminate).await;
+        let _ = capture_channel.send(CaptureEvent::Terminate).await;
        let _ = frontend_tx.send(FrontendEvent::Shutdown()).await;

-        if !producer_task.is_finished() {
-            if let Err(e) = producer_task.await {
-                log::error!("error in event producer: {e}");
+        if !capture_task.is_finished() {
+            if let Err(e) = capture_task.await {
+                log::error!("error in input capture task: {e}");
            }
        }
-        if !consumer_task.is_finished() {
-            if let Err(e) = consumer_task.await {
-                log::error!("error in event consumer: {e}");
+        if !emulation_task.is_finished() {
+            if let Err(e) = emulation_task.await {
+                log::error!("error in input emulation task: {e}");
            }
        }

--- a/src/server/producer_task.rs
+++ b/src/server/producer_task.rs
@@ -1,53 +1,59 @@
 use anyhow::{anyhow, Result};
 use futures::StreamExt;
-use std::net::SocketAddr;
+use std::{collections::HashSet, net::SocketAddr};

 use tokio::{sync::mpsc::Sender, task::JoinHandle};

 use crate::{
+    capture::InputCapture,
    client::{ClientEvent, ClientHandle},
    event::{Event, KeyboardEvent},
-    producer::EventProducer,
+    scancode,
    server::State,
 };

 use super::Server;

 #[derive(Clone, Copy, Debug)]
-pub enum ProducerEvent {
-    /// producer must release the mouse
+pub enum CaptureEvent {
+    /// capture must release the mouse
    Release,
-    /// producer is notified of a change in client states
+    /// capture is notified of a change in client states
    ClientEvent(ClientEvent),
    /// termination signal
    Terminate,
 }

 pub fn new(
-    mut producer: Box<dyn EventProducer>,
+    mut capture: Box<dyn InputCapture>,
    server: Server,
    sender_tx: Sender<(Event, SocketAddr)>,
    timer_tx: Sender<()>,
-) -> (JoinHandle<Result<()>>, Sender<ProducerEvent>) {
+    release_bind: Vec<scancode::Linux>,
+) -> (JoinHandle<Result<()>>, Sender<CaptureEvent>) {
    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
    let task = tokio::task::spawn_local(async move {
+        let mut pressed_keys = HashSet::new();
        loop {
            tokio::select! {
-                event = producer.next() => {
-                    let event = event.ok_or(anyhow!("event producer closed"))??;
-                    handle_producer_event(&server, &mut producer, &sender_tx, &timer_tx, event).await?;
+                event = capture.next() => {
+                    match event {
+                        Some(Ok(event)) => handle_capture_event(&server, &mut capture, &sender_tx, &timer_tx, event, &mut pressed_keys, &release_bind).await?,
+                        Some(Err(e)) => return Err(anyhow!("input capture: {e:?}")),
+                        None => return Err(anyhow!("input capture terminated")),
+                    }
                }
                e = rx.recv() => {
-                    log::debug!("producer notify rx: {e:?}");
+                    log::debug!("input capture notify rx: {e:?}");
                    match e {
                        Some(e) => match e {
-                            ProducerEvent::Release => {
-                                producer.release()?;
+                            CaptureEvent::Release => {
+                                capture.release()?;
                                server.state.replace(State::Receiving);

                            }
-                            ProducerEvent::ClientEvent(e) => producer.notify(e)?,
-                            ProducerEvent::Terminate => break,
+                            CaptureEvent::ClientEvent(e) => capture.notify(e)?,
+                            CaptureEvent::Terminate => break,
                        },
                        None => break,
                    }
@@ -59,21 +65,35 @@ pub fn new(
    (task, tx)
 }

-const RELEASE_MODIFIERDS: u32 = 77; // ctrl+shift+super+alt
+fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {
+    if let Ok(scancode) = scancode::Linux::try_from(key) {
+        log::debug!("key: {key}, state: {state}, scancode: {scancode:?}");
+        match state {
+            1 => pressed_keys.insert(scancode),
+            _ => pressed_keys.remove(&scancode),
+        };
+    }
+}

-async fn handle_producer_event(
+async fn handle_capture_event(
    server: &Server,
-    producer: &mut Box<dyn EventProducer>,
+    capture: &mut Box<dyn InputCapture>,
    sender_tx: &Sender<(Event, SocketAddr)>,
    timer_tx: &Sender<()>,
    event: (ClientHandle, Event),
+    pressed_keys: &mut HashSet<scancode::Linux>,
+    release_bind: &[scancode::Linux],
 ) -> Result<()> {
    let (c, mut e) = event;
    log::trace!("({c}) {e:?}");

-    if let Event::Keyboard(KeyboardEvent::Modifiers { mods_depressed, .. }) = e {
-        if mods_depressed == RELEASE_MODIFIERDS {
-            producer.release()?;
+    if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = e {
+        update_pressed_keys(pressed_keys, key, state);
+        log::debug!("{pressed_keys:?}");
+        if release_bind.iter().all(|k| pressed_keys.contains(k)) {
+            pressed_keys.clear();
+            log::info!("releasing pointer");
+            capture.release()?;
            server.state.replace(State::Receiving);
            log::trace!("STATE ===> Receiving");
            // send an event to release all the modifiers
@@ -92,7 +112,7 @@ async fn handle_producer_event(
            None => {
                // should not happen
                log::warn!("unknown client!");
-                producer.release()?;
+                capture.release()?;
                server.state.replace(State::Receiving);
                log::trace!("STATE ===> Receiving");
                return Ok(());
--- a/src/server/emulation_task.rs
+++ b/src/server/emulation_task.rs
@@ -8,53 +8,53 @@ use tokio::{

 use crate::{
    client::{ClientEvent, ClientHandle},
-    consumer::EventConsumer,
+    emulate::InputEmulation,
    event::{Event, KeyboardEvent},
    scancode,
    server::State,
 };

-use super::{ProducerEvent, Server};
+use super::{CaptureEvent, Server};

 #[derive(Clone, Debug)]
-pub enum ConsumerEvent {
-    /// consumer is notified of a change in client states
+pub enum EmulationEvent {
+    /// input emulation is notified of a change in client states
    ClientEvent(ClientEvent),
-    /// consumer must release keys for client
+    /// input emulation must release keys for client
    ReleaseKeys(ClientHandle),
    /// termination signal
    Terminate,
 }

 pub fn new(
-    mut consumer: Box<dyn EventConsumer>,
+    mut emulate: Box<dyn InputEmulation>,
    server: Server,
    mut udp_rx: Receiver<Result<(Event, SocketAddr)>>,
    sender_tx: Sender<(Event, SocketAddr)>,
-    producer_tx: Sender<ProducerEvent>,
+    capture_tx: Sender<CaptureEvent>,
    timer_tx: Sender<()>,
-) -> (JoinHandle<Result<()>>, Sender<ConsumerEvent>) {
+) -> (JoinHandle<Result<()>>, Sender<EmulationEvent>) {
    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-    let consumer_task = tokio::task::spawn_local(async move {
+    let emulate_task = tokio::task::spawn_local(async move {
        let mut last_ignored = None;

        loop {
            tokio::select! {
                udp_event = udp_rx.recv() => {
                    let udp_event = udp_event.ok_or(anyhow!("receiver closed"))??;
-                    handle_udp_rx(&server, &producer_tx, &mut consumer, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await;
+                    handle_udp_rx(&server, &capture_tx, &mut emulate, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await;
                }
-                consumer_event = rx.recv() => {
-                    match consumer_event {
+                emulate_event = rx.recv() => {
+                    match emulate_event {
                        Some(e) => match e {
-                            ConsumerEvent::ClientEvent(e) => consumer.notify(e).await,
-                            ConsumerEvent::ReleaseKeys(c) => release_keys(&server, &mut consumer, c).await,
-                            ConsumerEvent::Terminate => break,
+                            EmulationEvent::ClientEvent(e) => emulate.notify(e).await,
+                            EmulationEvent::ReleaseKeys(c) => release_keys(&server, &mut emulate, c).await,
+                            EmulationEvent::Terminate => break,
                        },
                        None => break,
                    }
                }
-                res = consumer.dispatch() => {
+                res = emulate.dispatch() => {
                    res?;
                }
            }
@@ -68,20 +68,20 @@ pub fn new(
            .map(|s| s.client.handle)
            .collect::<Vec<_>>();
        for client in clients {
-            release_keys(&server, &mut consumer, client).await;
+            release_keys(&server, &mut emulate, client).await;
        }

-        // destroy consumer
-        consumer.destroy().await;
+        // destroy emulator
+        emulate.destroy().await;
        anyhow::Ok(())
    });
-    (consumer_task, tx)
+    (emulate_task, tx)
 }

 async fn handle_udp_rx(
    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer: &mut Box<dyn EventConsumer>,
+    capture_tx: &Sender<CaptureEvent>,
+    emulate: &mut Box<dyn InputEmulation>,
    sender_tx: &Sender<(Event, SocketAddr)>,
    last_ignored: &mut Option<SocketAddr>,
    event: (Event, SocketAddr),
@@ -127,7 +127,7 @@ async fn handle_udp_rx(
            let _ = sender_tx.send((Event::Pong(), addr)).await;
        }
        (Event::Disconnect(), _) => {
-            release_keys(server, consumer, handle).await;
+            release_keys(server, emulate, handle).await;
        }
        (event, addr) => {
            // tell clients that we are ready to receive events
@@ -143,7 +143,7 @@ async fn handle_udp_rx(
                    } else {
                        // upon receiving any event, we go back to receiving mode
                        server.state.replace(State::Receiving);
-                        let _ = producer_notify_tx.send(ProducerEvent::Release).await;
+                        let _ = capture_tx.send(CaptureEvent::Release).await;
                        log::trace!("STATE ===> Receiving");
                    }
                }
@@ -176,8 +176,8 @@ async fn handle_udp_rx(
                    // workaround buggy rdp backend.
                    if !ignore_event {
                        // consume event
-                        consumer.consume(event, handle).await;
-                        log::trace!("{event:?} => consumer");
+                        emulate.consume(event, handle).await;
+                        log::trace!("{event:?} => emulate");
                    }
                }
                State::AwaitingLeave => {
@@ -194,7 +194,7 @@ async fn handle_udp_rx(
                    // event should still be possible
                    if let Event::Enter() = event {
                        server.state.replace(State::Receiving);
-                        let _ = producer_notify_tx.send(ProducerEvent::Release).await;
+                        let _ = capture_tx.send(CaptureEvent::Release).await;
                        log::trace!("STATE ===> Receiving");
                    }
                }
@@ -205,7 +205,7 @@ async fn handle_udp_rx(

 async fn release_keys(
    server: &Server,
-    consumer: &mut Box<dyn EventConsumer>,
+    emulate: &mut Box<dyn InputEmulation>,
    client: ClientHandle,
 ) {
    let keys = server
@@ -222,7 +222,7 @@ async fn release_keys(
            key,
            state: 0,
        });
-        consumer.consume(event, client).await;
+        emulate.consume(event, client).await;
        if let Ok(key) = scancode::Linux::try_from(key) {
            log::warn!("releasing stuck key: {key:?}");
        }
@@ -234,7 +234,7 @@ async fn release_keys(
        mods_locked: 0,
        group: 0,
    };
-    consumer
+    emulate
        .consume(Event::Keyboard(modifiers_event), client)
        .await;
 }
--- a/src/server/frontend_task.rs
+++ b/src/server/frontend_task.rs
@@ -22,15 +22,15 @@ use crate::{
 };

 use super::{
-    consumer_task::ConsumerEvent, producer_task::ProducerEvent, resolver_task::DnsRequest, Server,
+    capture_task::CaptureEvent, emulation_task::EmulationEvent, resolver_task::DnsRequest, Server,
 };

 pub(crate) fn new(
    mut frontend: FrontendListener,
    mut notify_rx: Receiver<FrontendNotify>,
    server: Server,
-    producer_notify: Sender<ProducerEvent>,
-    consumer_notify: Sender<ConsumerEvent>,
+    capture_notify: Sender<CaptureEvent>,
+    emulate_notify: Sender<EmulationEvent>,
    resolve_ch: Sender<DnsRequest>,
    port_tx: Sender<u16>,
 ) -> (JoinHandle<Result<()>>, Sender<FrontendEvent>) {
@@ -51,7 +51,7 @@ pub(crate) fn new(
                }
                event = event_rx.recv() => {
                    let frontend_event = event.ok_or(anyhow!("frontend channel closed"))?;
-                    if handle_frontend_event(&server, &producer_notify, &consumer_notify, &resolve_ch, &mut frontend, &port_tx, frontend_event).await {
+                    if handle_frontend_event(&server, &capture_notify, &emulate_notify, &resolve_ch, &mut frontend, &port_tx, frontend_event).await {
                        break;
                    }
                }
@@ -98,8 +98,8 @@ async fn handle_frontend_stream(

 async fn handle_frontend_event(
    server: &Server,
-    producer_tx: &Sender<ProducerEvent>,
-    consumer_tx: &Sender<ConsumerEvent>,
+    capture_tx: &Sender<CaptureEvent>,
+    emulate_tx: &Sender<EmulationEvent>,
    resolve_tx: &Sender<DnsRequest>,
    frontend: &mut FrontendListener,
    port_tx: &Sender<u16>,
@@ -120,7 +120,7 @@ async fn handle_frontend_event(
            Some(FrontendNotify::NotifyClientCreate(client))
        }
        FrontendEvent::ActivateClient(handle, active) => {
-            activate_client(server, producer_tx, consumer_tx, handle, active).await;
+            activate_client(server, capture_tx, emulate_tx, handle, active).await;
            Some(FrontendNotify::NotifyClientActivate(handle, active))
        }
        FrontendEvent::ChangePort(port) => {
@@ -128,7 +128,7 @@ async fn handle_frontend_event(
            None
        }
        FrontendEvent::DelClient(handle) => {
-            remove_client(server, producer_tx, consumer_tx, frontend, handle).await;
+            remove_client(server, capture_tx, emulate_tx, frontend, handle).await;
            Some(FrontendNotify::NotifyClientDelete(handle))
        }
        FrontendEvent::Enumerate() => {
@@ -147,8 +147,8 @@ async fn handle_frontend_event(
        FrontendEvent::UpdateClient(handle, hostname, port, pos) => {
            update_client(
                server,
-                producer_tx,
-                consumer_tx,
+                capture_tx,
+                emulate_tx,
                resolve_tx,
                (handle, hostname, port, pos),
            )
@@ -204,8 +204,8 @@ pub async fn add_client(

 pub async fn activate_client(
    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer_notify_tx: &Sender<ConsumerEvent>,
+    capture_notify_tx: &Sender<CaptureEvent>,
+    emulate_notify_tx: &Sender<EmulationEvent>,
    client: ClientHandle,
    active: bool,
 ) {
@@ -217,45 +217,49 @@ pub async fn activate_client(
        None => return,
    };
    if active {
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Create(client, pos)))
+        let _ = capture_notify_tx
+            .send(CaptureEvent::ClientEvent(ClientEvent::Create(client, pos)))
            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Create(client, pos)))
+        let _ = emulate_notify_tx
+            .send(EmulationEvent::ClientEvent(ClientEvent::Create(
+                client, pos,
+            )))
            .await;
    } else {
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Destroy(client)))
+        let _ = capture_notify_tx
+            .send(CaptureEvent::ClientEvent(ClientEvent::Destroy(client)))
            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Destroy(client)))
+        let _ = emulate_notify_tx
+            .send(EmulationEvent::ClientEvent(ClientEvent::Destroy(client)))
            .await;
    }
 }

 pub async fn remove_client(
    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer_notify_tx: &Sender<ConsumerEvent>,
+    capture_notify_tx: &Sender<CaptureEvent>,
+    emulate_notify_tx: &Sender<EmulationEvent>,
    frontend: &mut FrontendListener,
    client: ClientHandle,
 ) -> Option<ClientHandle> {
-    let _ = producer_notify_tx
-        .send(ProducerEvent::ClientEvent(ClientEvent::Destroy(client)))
-        .await;
-    let _ = consumer_notify_tx
-        .send(ConsumerEvent::ClientEvent(ClientEvent::Destroy(client)))
-        .await;
-
-    let Some(client) = server
+    let Some((client, active)) = server
        .client_manager
        .borrow_mut()
        .remove_client(client)
-        .map(|s| s.client.handle)
+        .map(|s| (s.client.handle, s.active))
    else {
        return None;
    };

+    if active {
+        let _ = capture_notify_tx
+            .send(CaptureEvent::ClientEvent(ClientEvent::Destroy(client)))
+            .await;
+        let _ = emulate_notify_tx
+            .send(EmulationEvent::ClientEvent(ClientEvent::Destroy(client)))
+            .await;
+    }
+
    let notify = FrontendNotify::NotifyClientDelete(client);
    log::debug!("{notify:?}");
    if let Err(e) = frontend.notify_all(notify).await {
@@ -266,12 +270,13 @@ pub async fn remove_client(

 async fn update_client(
    server: &Server,
-    producer_notify_tx: &Sender<ProducerEvent>,
-    consumer_notify_tx: &Sender<ConsumerEvent>,
+    capture_notify_tx: &Sender<CaptureEvent>,
+    emulate_notify_tx: &Sender<EmulationEvent>,
    resolve_tx: &Sender<DnsRequest>,
    client_update: (ClientHandle, Option<String>, u16, Position),
 ) {
    let (handle, hostname, port, pos) = client_update;
+    let mut changed = false;
    let (hostname, handle, active) = {
        // retrieve state
        let mut client_manager = server.client_manager.borrow_mut();
@@ -280,12 +285,16 @@ async fn update_client(
        };

        // update pos
-        state.client.pos = pos;
+        if state.client.pos != pos {
+            state.client.pos = pos;
+            changed = true;
+        }

        // update port
        if state.client.port != port {
            state.client.port = port;
            state.active_addr = state.active_addr.map(|a| SocketAddr::new(a.ip(), port));
+            changed = true;
        }

        // update hostname
@@ -293,6 +302,7 @@ async fn update_client(
            state.client.ips = HashSet::new();
            state.active_addr = None;
            state.client.hostname = hostname;
+            changed = true;
        }

        log::debug!("client updated: {:?}", state);
@@ -303,24 +313,30 @@ async fn update_client(
        )
    };

-    // resolve dns
-    if let Some(hostname) = hostname {
-        let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
+    // resolve dns if something changed
+    if changed {
+        // resolve dns
+        if let Some(hostname) = hostname {
+            let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
+        }
    }

-    // update state in event consumer & producer
-    if active {
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Destroy(handle)))
+    // update state in event input emulator & input capture
+    if changed && active {
+        // update state
+        let _ = capture_notify_tx
+            .send(CaptureEvent::ClientEvent(ClientEvent::Destroy(handle)))
            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Destroy(handle)))
+        let _ = emulate_notify_tx
+            .send(EmulationEvent::ClientEvent(ClientEvent::Destroy(handle)))
            .await;
-        let _ = producer_notify_tx
-            .send(ProducerEvent::ClientEvent(ClientEvent::Create(handle, pos)))
+        let _ = capture_notify_tx
+            .send(CaptureEvent::ClientEvent(ClientEvent::Create(handle, pos)))
            .await;
-        let _ = consumer_notify_tx
-            .send(ConsumerEvent::ClientEvent(ClientEvent::Create(handle, pos)))
+        let _ = emulate_notify_tx
+            .send(EmulationEvent::ClientEvent(ClientEvent::Create(
+                handle, pos,
+            )))
            .await;
    }
 }
--- a/src/server/network_task.rs
+++ b/src/server/network_task.rs
@@ -84,7 +84,6 @@ fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize> {
    log::trace!("{:20} ------>->->-> {addr}", e.to_string());
    let data: Vec<u8> = (&e).into();
    // When udp blocks, we dont want to block the event loop.
-    // Dropping events is better than potentially crashing the event
-    // producer.
+    // Dropping events is better than potentially crashing the input capture.
    Ok(sock.try_send_to(&data, addr)?)
 }
--- a/src/server/ping_task.rs
+++ b/src/server/ping_task.rs
@@ -7,15 +7,15 @@ use tokio::{

 use crate::{client::ClientHandle, event::Event};

-use super::{consumer_task::ConsumerEvent, producer_task::ProducerEvent, Server, State};
+use super::{capture_task::CaptureEvent, emulation_task::EmulationEvent, Server, State};

 const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);

 pub fn new(
    server: Server,
    sender_ch: Sender<(Event, SocketAddr)>,
-    consumer_notify: Sender<ConsumerEvent>,
-    producer_notify: Sender<ProducerEvent>,
+    emulate_notify: Sender<EmulationEvent>,
+    capture_notify: Sender<CaptureEvent>,
    mut timer_rx: Receiver<()>,
 ) -> JoinHandle<()> {
    // timer task
@@ -86,9 +86,9 @@ pub fn new(

                // give clients time to resond
                if receiving {
-                    log::debug!("waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ...");
+                    log::trace!("waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ...");
                } else {
-                    log::debug!(
+                    log::trace!(
                        "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
                        server.state.get()
                    );
@@ -114,14 +114,14 @@ pub fn new(
                if receiving {
                    for c in unresponsive_clients {
                        log::warn!("device not responding, releasing keys!");
-                        let _ = consumer_notify.send(ConsumerEvent::ReleaseKeys(c)).await;
+                        let _ = emulate_notify.send(EmulationEvent::ReleaseKeys(c)).await;
                    }
                } else {
                    // release pointer if the active client has not responded
                    if !unresponsive_clients.is_empty() {
                        log::warn!("client not responding, releasing pointer!");
                        server.state.replace(State::Receiving);
-                        let _ = producer_notify.send(ProducerEvent::Release).await;
+                        let _ = capture_notify.send(CaptureEvent::Release).await;
                    }
                }
            }
Author	SHA1	Message	Date
Ferdinand Schober	db96717044	chore: Release lan-mouse version 0.7.3	2024-03-22 12:46:57 +01:00
Ferdinand Schober	be8124a190	fix dns resolving	2024-03-22 12:40:05 +01:00
Ferdinand Schober	dcee2933a2	Create FUNDING.yml	2024-03-22 10:09:00 +01:00
Ferdinand Schober	8aaff9fb58	move to windows from win-api (#99 )	2024-03-21 23:04:20 +01:00
Ferdinand Schober	742b1585d7	rename producer, consumer to emulation and capture (#98 ) input emulation / input capture is clearer than event consumer and producer	2024-03-21 20:26:57 +01:00
Ferdinand Schober	78c9de45c7	add an arm64 build (#45 ) closes #45	2024-03-21 17:14:33 +01:00
Ferdinand Schober	a491c0e9e3	refactor producer and consumer (#97 )	2024-03-21 16:55:54 +01:00
Ferdinand Schober	af02cccc2a	exit instead of panicing when con to backend lost	2024-03-21 15:35:56 +01:00
Ferdinand Schober	4a6399f866	Update README.md - now available on crates.io	2024-03-21 13:37:01 +01:00
Ferdinand Schober	66bce9083e	chore: Release lan-mouse version 0.7.2	2024-03-21 13:06:28 +01:00
Ferdinand Schober	102b64f2b4	chore: Release lan-mouse version 0.7.1	2024-03-21 13:04:22 +01:00
Ferdinand Schober	4b499742ad	update dependencies	2024-03-21 13:02:21 +01:00
Ferdinand Schober	a86d74b52c	update to reis 0.2	2024-03-21 12:50:47 +01:00
Ferdinand Schober	c25a15e2d8	CI: fix download-artifact job	2024-03-20 15:28:05 +01:00
Ferdinand Schober	8b82325bdb	update flake.lock, Cargo.lock	2024-03-20 14:48:29 +01:00
Ferdinand Schober	5415205c83	chore: Release lan-mouse version 0.7.0	2024-03-20 14:31:25 +01:00
Ferdinand Schober	1666fb8b7b	Update README.md	2024-03-20 14:18:59 +01:00
Ferdinand Schober	9afe7da0dd	Libei Input Capture (#94 )	2024-03-20 14:03:52 +01:00
Ferdinand Schober	f7c59e40c9	Update config.toml	2024-03-19 13:14:53 +01:00
Ferdinand Schober	5be5b0ad7c	Update README.md	2024-03-19 13:14:36 +01:00
Ferdinand Schober	8ed4520172	Update README.md (#96 ) * Update README.md include release_bind in example config * update config.toml as well	2024-03-18 09:54:38 +01:00
Ferdinand Schober	9e56c546cd	make release bind configurable (#95 ) closes #85	2024-03-18 09:20:28 +01:00
Ferdinand Schober	daf8818a9f	Update README.md closes #80	2024-03-17 11:23:32 +01:00
Ferdinand Schober	6eaa199503	update actions (#93 )	2024-03-15 22:09:09 +01:00
虢豳	8ff991aefe	feat: add nix support(#80 ) (#82 ) * feat: add nix support(#80) * chore: nix flake update * update actions	2024-03-15 22:02:18 +01:00
Ferdinand Schober	abf95afb9f	Update README.md Remove Hyprland section - all issues are fixed	2024-03-15 17:27:24 +01:00
Ferdinand Schober	9a75a7622e	fix duplicate creating of wl_pointer / wl_keyboard (#92 ) closes #91	2024-03-15 17:00:59 +01:00
Ferdinand Schober	0196cfe56c	Update README.md sway 1.9 works	2024-03-03 12:02:38 +01:00
Ferdinand Schober	097468f708	Update README.md closes #90	2024-03-02 11:58:33 +01:00
Ferdinand Schober	3470abc03a	Update README.md update issues in Hyprland	2024-03-01 13:35:12 +01:00
Ferdinand Schober	a7397ad4f4	Update README.md fix typo	2024-02-05 16:08:25 +00:00
Ferdinand Schober	9889b49f10	Update README.md	2024-01-30 20:22:51 +01:00
				`@@ -0,0 +1 @@`
				`(builtins.getFlake ("git+file://" + toString ./.)).devShells.${builtins.currentSystem}.default`