chore: Release lan-mouse version 0.4.0

* macos: initial support

- adapted conditional compilation
- moved lan-mouse socket to ~/Library/Caches/lan-mouse-socket.sock instead of XDG_RUNTIME_DIR
- support for mouse input emulation
TODO: Keycode translation, input capture

.github/workflows/pre-release.yml

@@ -18,6 +18,7 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install libx11-dev libxtst-dev
+        sudo apt-get install libadwaita-1-dev libgtk-4-dev
     - name: Release Build
       run: cargo build --release
     - name: Upload build artifact
@@ -38,9 +39,23 @@ jobs:
         name: lan-mouse-windows
         path: target/release/lan-mouse.exe
 
+  macos-release-build:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Release Build
+      run: cargo build --release
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v3
+      with:
+        name: lan-mouse-macos
+        path: target/release/lan-mouse
+
   pre-release:
     name: "Pre Release"
-    needs: [windows-release-build, linux-release-build]
+    needs: [windows-release-build, linux-release-build, macos-release-build]
     runs-on: "ubuntu-latest"
     steps:
     - name: Download build artifacts
@@ -55,3 +70,4 @@ jobs:
         files: |
           lan-mouse-linux/lan-mouse
           lan-mouse-windows/lan-mouse.exe
+          lan-mouse-macos/lan-mouse

.github/workflows/rust.yml

@@ -20,6 +20,7 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install libx11-dev libxtst-dev
+        sudo apt-get install libadwaita-1-dev libgtk-4-dev
     - name: Build
       run: cargo build --verbose
     - name: Run tests
@@ -45,3 +46,19 @@ jobs:
       with:
         name: lan-mouse-windows
         path: target/debug/lan-mouse.exe
+
+  build-macos:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v3
+      with:
+        name: lan-mouse-macos
+        path: target/debug/lan-mouse

.github/workflows/tagged-release.yml

@@ -14,6 +14,7 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install libx11-dev libxtst-dev
+        sudo apt-get install libadwaita-1-dev libgtk-4-dev
     - name: Release Build
       run: cargo build --release
     - name: Upload build artifact
@@ -34,9 +35,23 @@ jobs:
         name: lan-mouse-windows
         path: target/release/lan-mouse.exe
 
+  macos-release-build:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: install dependencies
+      run: brew install gtk4 libadwaita
+    - name: Release Build
+      run: cargo build --release
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v3
+      with:
+        name: lan-mouse-macos
+        path: target/release/lan-mouse
+
   tagged-release:
     name: "Tagged Release"
-    needs: [windows-release-build, linux-release-build]
+    needs: [windows-release-build, linux-release-build, macos-release-build]
     runs-on: "ubuntu-latest"
     steps:
     - name: Download build artifacts
@@ -49,3 +64,4 @@ jobs:
         files: |
           lan-mouse-linux/lan-mouse
           lan-mouse-windows/lan-mouse.exe
+          lan-mouse-macos/lan-mouse

.gitignore

@@ -1 +1,2 @@
 /target
+.gdbinit

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.1.1-alpha.1"
+version = "0.4.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/ferdinandschober/lan-mouse"
@@ -13,29 +13,49 @@ strip = true
 lto = "fat"
 
 [dependencies]
-tempfile = "3.6"
-trust-dns-resolver = "0.22"
+tempfile = "3.8"
+trust-dns-resolver = "0.23"
 memmap = "0.7"
 toml = "0.7"
-serde = "1.0"
-serde_derive = "1.0"
+serde = { version = "1.0", features = ["derive"] }
 anyhow = "1.0.71"
+log = "0.4.20"
+env_logger = "0.10.0"
+libc = "0.2.148"
+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"] }
 
-[target.'cfg(unix)'.dependencies]
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
 wayland-client = { version="0.30.2", optional = true }
 wayland-protocols = { version="0.30.0", features=["client", "staging", "unstable"], optional = true }
 wayland-protocols-wlr = { version="0.1.0", features=["client"], optional = true }
 wayland-protocols-misc = { version="0.1.0", features=["client"], optional = true }
 wayland-protocols-plasma = { version="0.1.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 }
+
+[target.'cfg(unix)'.dependencies]
+gtk = { package = "gtk4", version = "0.7.2", features = ["v4_6"], optional = true }
+adw = { package = "libadwaita", version = "0.5.2", features = ["v1_1"], 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"] }
 
+[target.'cfg(unix)'.build-dependencies]
+glib-build-tools = "0.18.0"
 
 [features]
-default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
+default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
 wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc", "dep:wayland-protocols-plasma"]
 x11 = ["dep:x11"]
-xdg_desktop_portal = []
-libei = []
+xdg_desktop_portal = ["dep:ashpd"]
+libei = ["dep:reis", "dep:ashpd"]
+gtk = ["dep:gtk", "dep:adw"]

README.md

@@ -1,47 +1,46 @@
-# Lan Mouse Share
+# Lan Mouse
+- _Now with a gtk frontend_
+
+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.
+
+The primary target is Wayland on Linux but Windows and MacOS have partial support as well (see below for more details).
+
+![Screenshot from 2023-12-09 01-48-12](https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df#gh-dark-mode-only)
+![Screenshot from 2023-12-09 01-48-19](https://github.com/feschber/lan-mouse/assets/40996949/d6318340-f811-4e16-9d6e-d1b79883c709#gh-light-mode-only)
+
+
 Goal of this project is to be an open-source replacement for proprietary tools like [Synergy](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/).
 
 Focus lies on performance and a clean, manageable implementation that can easily be expanded to support additional backends like e.g. Android, iOS, ... .
 
-Of course ***blazingly fast™*** and stable, because it's written in rust.
+***blazingly fast™*** because it's written in rust.
 
 For an alternative (with slightly different goals) you may check out [Input Leap](https://github.com/input-leap).
 
-## Configuration
-Configuration is done through the file `config.toml`,
-which must be located in the current working directory when
-executing lan-mouse.
+## OS Support
 
-### Example config
-A minimal config file could look like this:
+The following table shows support for input emulation (to emulate events received from other clients) and
+input capture (to send events *to* other clients) on different operating systems:
 
-```toml
-[left]
-host_name = "my-laptop"
-```
+| Backend                   | input emulation          | input capture                        |
+|---------------------------|--------------------------|--------------------------------------|
+| Wayland (wlroots)         | :heavy_check_mark:       | :heavy_check_mark:                   |
+| Wayland (KDE)             | :heavy_check_mark:       | :heavy_check_mark:                   |
+| Wayland (Gnome)           | :heavy_check_mark:       | WIP                                  |
+| X11                       | (WIP)                    | WIP                                  |
+| Windows                   | ( :heavy_check_mark: )   | WIP                                  |
+| MacOS                     | ( :heavy_check_mark: )   | WIP                                  |
 
-Where `left` can be either `left`, `right`, `top` or `bottom`.
-
-
-### Additional options
-Additionally
-- a preferred backend
-- a port override for the default port (4242)
-
-can be specified.
-
-Supported backends currently include "wlroots", "x11" and "windows".
-
-These two options can also be specified via the commandline
-options `--backend` and `--port` respectively.
+Keycode translation is not yet implemented so on MacOS only mouse emulation works as of right now.
 
 ## Build and Run
-Build only
+Build in release mode:
 ```sh
 cargo build --release
 ```
 
-Run
+Run directly:
 ```sh
 cargo run --release
 ```
@@ -65,83 +64,77 @@ an executable with just support for wayland:
 cargo build --no-default-features --features wayland
 ```
 
-## OS Support
+## Usage
+### Gtk Frontend
+By default the gtk frontend will open when running `lan-mouse`.
 
-The following table shows support for Event receiving and event Emitting
-on different operating systems:
+To add a new connection, simply click the `Add` button on *both* devices,
+enter the corresponding hostname and activate it.
 
-| Backend                   | Event Receiving          | Event Emitting                       |
-|---------------------------|--------------------------|--------------------------------------|
-| Wayland (wlroots)         | :heavy_check_mark:       | :heavy_check_mark:                   |
-| Wayland (KDE)             | WIP                      | :heavy_check_mark:                   |
-| Wayland (Gnome)           | TODO (libei support)     | TODO (wlr-layer-shell not supported) |
-| X11                       | WIP                      | TODO                                 |
-| Windows                   | needs improvements       | TODO                                 |
-| MacOS                     | TODO (I dont own a Mac)  | TODO (I dont own a Mac)              |
+If the mouse can not be moved onto a device, make sure you have port `4242` (or the one selected)
+opened up in your firewall.
 
-## Wayland compositor support
-### Input Emulation (for receiving events)
-On wayland input-emulation is in an early/unstable state as of writing this.
+### Command Line Interface
+The cli interface can be enabled using `--frontend cli` as commandline arguments.
+Type `help` to list the available commands.
 
-Different compositors have different ways of enabling input emulation:
+E.g.:
+```sh
+$ cargo run --release -- --frontend cli
+(...)
+> connect <host> left|right|top|bottom
+(...)
+> list
+(...)
+> activate 0
+```
 
-Most wlroots-based compositors like Hyprland and Sway support the following
-unstable wayland protocols for keyboard and mouse emulation:
-- [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1)
-- [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1) are used to emulate input on wlroots compositors
+### Daemon
+Lan Mouse can be launched in daemon mode to keep it running in the background.
+To do so, add `--daemon` to the commandline args:
 
-KDE also has a protocol for input emulation ([kde-fake-input](https://wayland.app/protocols/kde-fake-input)), it is however not exposed to
-third party apps, so the recommended way of enabling input emulation in KDE is the
-[freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop).
+```sh
+$ cargo run --release -- --daemon
+```
 
-Gnome uses [libei](https://gitlab.freedesktop.org/libinput/libei) for input emulation,
-which has the goal to become the general approach for emulating Input on wayland.
+## Configuration
+To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.
+`$XDG_CONFIG_HOME` defaults to `~/.config/`.
 
-|  Required Protocols  (Event Receiving) | Sway               | Kwin                 | Gnome                |
-|----------------------------------------|--------------------|----------------------|----------------------|
-| wlr-virtual-pointer-unstable-v1        | :heavy_check_mark: | :x:                  | :x:                  |
-| virtual-keyboard-unstable-v1           | :heavy_check_mark: | :x:                  | :x:                  |
-| ~fake-input~                           | :x:                | ~:heavy_check_mark:~ | :x:                  |
+To create this file you can copy the following example config:
 
-### Input capture
+### Example config
 
-To capture mouse and keyboard input, a few things are necessary:
-- Displaying an immovable surface at screen edges
-- Locking the mouse in place
-- (optionally but highly recommended) reading unaccelerated mouse input
+```toml
+# example configuration
 
-|  Required Protocols  (Event Emitting)  | Sway               | Kwin                 | Gnome                |
-|----------------------------------------|--------------------|----------------------|----------------------|
-| pointer-constraints-unstable-v1        | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
-| relative-pointer-unstable-v1           | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
-| keyboard-shortcuts-inhibit-unstable-v1 | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
-| wlr-layer-shell-unstable-v1            | :heavy_check_mark: | :heavy_check_mark:   | :x:                  |
+# optional port (defaults to 4242)
+port = 4242
+# # optional frontend -> defaults to gtk if available
+# # possible values are "cli" and "gtk" 
+# frontend = "gtk"
 
-The [zwlr\_virtual\_pointer\_manager\_v1](wlr-virtual-pointer-unstable-v1) is required
-to display surfaces on screen edges and used to display the immovable window on
-both wlroots based compositors and KDE.
+# define a client on the right side with host name "iridium"
+[right]
+# hostname
+host_name = "iridium"
+# optional list of (known) ip addresses
+ips = ["192.168.178.156"]
 
-Gnome unfortunately does not support this protocol
-and [likely won't ever support it](https://gitlab.gnome.org/GNOME/gnome-shell/-/issues/1141).
+# define a client on the left side with IP address 192.168.178.189
+[left]
+# The hostname is optional: When no hostname is specified,
+# at least one ip address needs to be specified.
+host_name = "thorium"
+# ips for ethernet and wifi
+ips = ["192.168.178.189", "192.168.178.172"]
+# optional port
+port = 4242
+```
 
-So there is currently no way of doing this in Wayland, aside from a custom Gnome-Shell
-extension, which is not a very elegant solution.
+Where `left` can be either `left`, `right`, `top` or `bottom`.
 
-This is to be looked into in the future.
-
-~In order for layershell surfaces to be able to lock the pointer using the pointer\_constraints protocol [this patch](https://github.com/swaywm/sway/pull/7178) needs to be applied to sway.~
-(this works natively on sway versions >= 1.8)
-
-## Windows support
-Currently windows can receive mouse and keyboard events, however unlike
-with the wlroots back-end,
-
-the scancodes are not translated between keyboard layouts.
-
-Event emitting is WIP.
-
-
-## TODOS
+## Roadmap
 - [x] Capture the actual mouse events on the server side via a wayland client and send them to the client
 - [x] Mouse grabbing
 - [x] Window with absolute position -> wlr\_layer\_shell
@@ -151,14 +144,13 @@ Event emitting is WIP.
 - [x] Button support
 - [ ] Latency measurement + logging
 - [ ] Bandwidth usage approximation + logging
-- [ ] Multiple IP addresses -> check which one is reachable
+- [x] Multiple IP addresses -> check which one is reachable
 - [x] Merge server and client -> Both client and server can send and receive events depending on what mouse is used where
-- [ ] Liveness tracking (automatically ungrab mouse when client unreachable)
+- [x] Liveness tracking (automatically ungrab mouse when client unreachable)
 - [ ] Clipboard support
-- [ ] Graphical frontend (gtk?)
-- [ ] *Encrytion*
-- [ ] Gnome Shell Extension (layer shell is not supported)
-- [ ] respect xdg-config-home for config file location.
+- [x] Graphical frontend (gtk?)
+- [ ] *Encryption*
+- [x] respect xdg-config-home for config file location.
 
 ## Protocol
 Currently *all* mouse and keyboard events are sent via **UDP** for performance reasons.
@@ -207,3 +199,55 @@ would be a better choice for the future and could also help for WIFI connections
 Sending key and mouse event data over the local network might not be the biggest security concern but in any public network or business environment it's *QUITE* a problem to basically broadcast your keystrokes.
 - There should be an encryption layer below the application to enable a secure link.
 - The encryption keys could be generated by the graphical frontend.
+
+
+## Wayland support
+### Input Emulation (for receiving events)
+On wayland input-emulation is in an early/unstable state as of writing this.
+
+For this reason a suitable backend is chosen based on the active desktop environment / compositor.
+
+Different compositors have different ways of enabling input emulation:
+
+#### Wlroots
+Most wlroots-based compositors like Hyprland and Sway support the following
+unstable wayland protocols for keyboard and mouse emulation:
+- [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1)
+- [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1)
+
+#### KDE
+KDE also has a protocol for input emulation ([kde-fake-input](https://wayland.app/protocols/kde-fake-input)),
+it is however not exposed to third party applications.
+
+The recommended way to emulate input on KDE is the
+[freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop).
+
+#### Gnome (TODO)
+Gnome uses [libei](https://gitlab.freedesktop.org/libinput/libei) for input emulation,
+which has the goal to become the general approach for emulating Input on wayland.
+
+
+### Input capture
+
+To capture mouse and keyboard input, a few things are necessary:
+- Displaying an immovable surface at screen edges
+- Locking the mouse in place
+- (optionally but highly recommended) reading unaccelerated mouse input
+
+|  Required Protocols  (Event Emitting)  | Sway               | Kwin                 | Gnome                |
+|----------------------------------------|--------------------|----------------------|----------------------|
+| pointer-constraints-unstable-v1        | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| relative-pointer-unstable-v1           | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| keyboard-shortcuts-inhibit-unstable-v1 | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:   |
+| wlr-layer-shell-unstable-v1            | :heavy_check_mark: | :heavy_check_mark:   | :x:                  |
+
+The [zwlr\_virtual\_pointer\_manager\_v1](wlr-virtual-pointer-unstable-v1) is required
+to display surfaces on screen edges and used to display the immovable window on
+both wlroots based compositors and KDE.
+
+Gnome unfortunately does not support this protocol
+and [likely won't ever support it](https://gitlab.gnome.org/GNOME/gnome-shell/-/issues/1141).
+
+~In order for layershell surfaces to be able to lock the pointer using the pointer\_constraints protocol [this patch](https://github.com/swaywm/sway/pull/7178) needs to be applied to sway.~
+(this works natively on sway versions >= 1.8)
+

build.rs

@@ -0,0 +1,9 @@
+fn main() {
+    // composite_templates
+    #[cfg(unix)]
+    glib_build_tools::compile_resources(
+        &["resources"],
+        "resources/resources.gresource.xml",
+        "lan-mouse.gresource",
+    );
+}

config.toml

@@ -1,22 +1,23 @@
 # example configuration
 
-# optional port
+# optional port (defaults to 4242)
 port = 4242
-# optional backend override
-backend = "wlroots"
+# optional frontend -> defaults to gtk if available
+# frontend = "gtk"
 
 # define a client on the right side with host name "iridium"
 [right]
 # hostname
 host_name = "iridium"
-# optional ip address
-ip = "192.168.178.141"
-# optional port (defaults to 4242)
-port = 4242
+# optional list of (known) ip addresses
+ips = ["192.168.178.156"]
 
 # define a client on the left side with IP address 192.168.178.189
-#
-# when an IP address is specified, it takes priority
-# and host_name can be omitted
 [left]
-ip = "192.168.178.189"
+# The hostname is optional: When no hostname is specified,
+# at least one ip address needs to be specified.
+host_name = "thorium"
+# ips for ethernet and wifi
+ips = ["192.168.178.189", "192.168.178.172"]
+# optional port
+port = 4242

de.feschber.LanMouse.yml

@@ -0,0 +1,14 @@
+app-id: de.feschber.LanMouse
+runtime: org.freedesktop.Platform
+runtime-version: '22.08'
+sdk: org.freedesktop.Sdk
+command: target/release/lan-mouse
+modules:
+  - name: hello
+    buildsystem: simple
+    build-commands:
+      - cargo build --release
+      - install -D lan-mouse /app/bin/lan-mouse
+    sources:
+      - type: file
+        path: target/release/lan-mouse

deny.toml

@@ -0,0 +1,272 @@
+# This template contains all of the possible sections and their default values
+
+# Note that all fields that take a lint level have these possible values:
+# * deny - An error will be produced and the check will fail
+# * warn - A warning will be produced, but the check will not fail
+# * allow - No warning or error will be produced, though in some cases a note
+# will be
+
+# The values provided in this template are the default values that will be used
+# when any section or field is not specified in your own configuration
+
+# Root options
+
+# If 1 or more target triples (and optionally, target_features) are specified,
+# only the specified targets will be checked when running `cargo deny check`.
+# This means, if a particular package is only ever used as a target specific
+# dependency, such as, for example, the `nix` crate only being used via the
+# `target_family = "unix"` configuration, that only having windows targets in
+# this list would mean the nix crate, as well as any of its exclusive
+# dependencies not shared by any other crates, would be ignored, as the target
+# list here is effectively saying which targets you are building for.
+targets = [
+    # The triple can be any string, but only the target triples built in to
+    # rustc (as of 1.40) can be checked against actual config expressions
+    #{ triple = "x86_64-unknown-linux-musl" },
+    # You can also specify which target_features you promise are enabled for a
+    # particular target. target_features are currently not validated against
+    # the actual valid features supported by the target architecture.
+    #{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
+]
+# When creating the dependency graph used as the source of truth when checks are
+# executed, this field can be used to prune crates from the graph, removing them
+# from the view of cargo-deny. This is an extremely heavy hammer, as if a crate
+# is pruned from the graph, all of its dependencies will also be pruned unless
+# they are connected to another crate in the graph that hasn't been pruned,
+# so it should be used with care. The identifiers are [Package ID Specifications]
+# (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html)
+#exclude = []
+# If true, metadata will be collected with `--all-features`. Note that this can't
+# be toggled off if true, if you want to conditionally enable `--all-features` it
+# is recommended to pass `--all-features` on the cmd line instead
+all-features = false
+# If true, metadata will be collected with `--no-default-features`. The same
+# caveat with `all-features` applies
+no-default-features = false
+# If set, these feature will be enabled when collecting metadata. If `--features`
+# is specified on the cmd line they will take precedence over this option.
+#features = []
+# When outputting inclusion graphs in diagnostics that include features, this
+# option can be used to specify the depth at which feature edges will be added.
+# This option is included since the graphs can be quite large and the addition
+# of features from the crate(s) to all of the graph roots can be far too verbose.
+# This option can be overridden via `--feature-depth` on the cmd line
+feature-depth = 1
+
+# This section is considered when running `cargo deny check advisories`
+# More documentation for the advisories section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
+[advisories]
+# The path where the advisory database is cloned/fetched into
+db-path = "~/.cargo/advisory-db"
+# The url(s) of the advisory databases to use
+db-urls = ["https://github.com/rustsec/advisory-db"]
+# The lint level for security vulnerabilities
+vulnerability = "deny"
+# The lint level for unmaintained crates
+unmaintained = "warn"
+# The lint level for crates that have been yanked from their source registry
+yanked = "warn"
+# The lint level for crates with security notices. Note that as of
+# 2019-12-17 there are no security notice advisories in
+# https://github.com/rustsec/advisory-db
+notice = "warn"
+# A list of advisory IDs to ignore. Note that ignored advisories will still
+# output a note when they are encountered.
+ignore = [
+    #"RUSTSEC-0000-0000",
+]
+# Threshold for security vulnerabilities, any vulnerability with a CVSS score
+# lower than the range specified will be ignored. Note that ignored advisories
+# will still output a note when they are encountered.
+# * None - CVSS Score 0.0
+# * Low - CVSS Score 0.1 - 3.9
+# * Medium - CVSS Score 4.0 - 6.9
+# * High - CVSS Score 7.0 - 8.9
+# * Critical - CVSS Score 9.0 - 10.0
+#severity-threshold =
+
+# If this is true, then cargo deny will use the git executable to fetch advisory database.
+# If this is false, then it uses a built-in git library.
+# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
+# See Git Authentication for more information about setting up git authentication.
+#git-fetch-with-cli = true
+
+# This section is considered when running `cargo deny check licenses`
+# More documentation for the licenses section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
+[licenses]
+# The lint level for crates which do not have a detectable license
+unlicensed = "deny"
+# List of explicitly allowed licenses
+# See https://spdx.org/licenses/ for list of possible licenses
+# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
+allow = [
+    "MIT",
+	"BSD-3-Clause",
+	"ISC",
+    "Apache-2.0",
+    "Apache-2.0 WITH LLVM-exception",
+	"Unicode-DFS-2016",
+]
+# List of explicitly disallowed licenses
+# See https://spdx.org/licenses/ for list of possible licenses
+# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
+deny = [
+    #"Nokia",
+]
+# Lint level for licenses considered copyleft
+copyleft = "warn"
+# Blanket approval or denial for OSI-approved or FSF Free/Libre licenses
+# * both - The license will be approved if it is both OSI-approved *AND* FSF
+# * either - The license will be approved if it is either OSI-approved *OR* FSF
+# * osi-only - The license will be approved if is OSI-approved *AND NOT* FSF
+# * fsf-only - The license will be approved if is FSF *AND NOT* OSI-approved
+# * neither - This predicate is ignored and the default lint level is used
+allow-osi-fsf-free = "neither"
+# Lint level used when no other predicates are matched
+# 1. License isn't in the allow or deny lists
+# 2. License isn't copyleft
+# 3. License isn't OSI/FSF, or allow-osi-fsf-free = "neither"
+default = "deny"
+# The confidence threshold for detecting a license from license text.
+# The higher the value, the more closely the license text must be to the
+# canonical license text of a valid SPDX license file.
+# [possible values: any between 0.0 and 1.0].
+confidence-threshold = 0.8
+# Allow 1 or more licenses on a per-crate basis, so that particular licenses
+# aren't accepted for every possible crate as with the normal allow list
+exceptions = [
+    # Each entry is the crate and version constraint, and its specific allow
+    # list
+    #{ allow = ["Zlib"], name = "adler32", version = "*" },
+]
+
+# Some crates don't have (easily) machine readable licensing information,
+# adding a clarification entry for it allows you to manually specify the
+# licensing information
+#[[licenses.clarify]]
+# The name of the crate the clarification applies to
+#name = "ring"
+# The optional version constraint for the crate
+#version = "*"
+# The SPDX expression for the license requirements of the crate
+#expression = "MIT AND ISC AND OpenSSL"
+# One or more files in the crate's source used as the "source of truth" for
+# the license expression. If the contents match, the clarification will be used
+# when running the license check, otherwise the clarification will be ignored
+# and the crate will be checked normally, which may produce warnings or errors
+# depending on the rest of your configuration
+#license-files = [
+    # Each entry is a crate relative path, and the (opaque) hash of its contents
+    #{ path = "LICENSE", hash = 0xbd0eed23 }
+#]
+
+[licenses.private]
+# If true, ignores workspace crates that aren't published, or are only
+# published to private registries.
+# To see how to mark a crate as unpublished (to the official registry),
+# visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field.
+ignore = false
+# One or more private registries that you might publish crates to, if a crate
+# is only published to private registries, and ignore is true, the crate will
+# not have its license(s) checked
+registries = [
+    #"https://sekretz.com/registry
+]
+
+# This section is considered when running `cargo deny check bans`.
+# More documentation about the 'bans' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
+[bans]
+# Lint level for when multiple versions of the same crate are detected
+multiple-versions = "warn"
+# Lint level for when a crate version requirement is `*`
+wildcards = "allow"
+# The graph highlighting used when creating dotgraphs for crates
+# with multiple versions
+# * lowest-version - The path to the lowest versioned duplicate is highlighted
+# * simplest-path - The path to the version with the fewest edges is highlighted
+# * all - Both lowest-version and simplest-path are used
+highlight = "all"
+# The default lint level for `default` features for crates that are members of
+# the workspace that is being checked. This can be overriden by allowing/denying
+# `default` on a crate-by-crate basis if desired.
+workspace-default-features = "allow"
+# The default lint level for `default` features for external crates that are not
+# members of the workspace. This can be overriden by allowing/denying `default`
+# on a crate-by-crate basis if desired.
+external-default-features = "allow"
+# List of crates that are allowed. Use with care!
+allow = [
+    #{ name = "ansi_term", version = "=0.11.0" },
+]
+# List of crates to deny
+deny = [
+    # Each entry the name of a crate and a version range. If version is
+    # not specified, all versions will be matched.
+    #{ name = "ansi_term", version = "=0.11.0" },
+    #
+    # Wrapper crates can optionally be specified to allow the crate when it
+    # is a direct dependency of the otherwise banned crate
+    #{ name = "ansi_term", version = "=0.11.0", wrappers = [] },
+]
+
+# List of features to allow/deny
+# Each entry the name of a crate and a version range. If version is
+# not specified, all versions will be matched.
+#[[bans.features]]
+#name = "reqwest"
+# Features to not allow
+#deny = ["json"]
+# Features to allow
+#allow = [
+#    "rustls",
+#    "__rustls",
+#    "__tls",
+#    "hyper-rustls",
+#    "rustls",
+#    "rustls-pemfile",
+#    "rustls-tls-webpki-roots",
+#    "tokio-rustls",
+#    "webpki-roots",
+#]
+# If true, the allowed features must exactly match the enabled feature set. If
+# this is set there is no point setting `deny`
+#exact = true
+
+# Certain crates/versions that will be skipped when doing duplicate detection.
+skip = [
+    #{ name = "ansi_term", version = "=0.11.0" },
+]
+# Similarly to `skip` allows you to skip certain crates during duplicate
+# detection. Unlike skip, it also includes the entire tree of transitive
+# dependencies starting at the specified crate, up to a certain depth, which is
+# by default infinite.
+skip-tree = [
+    #{ name = "ansi_term", version = "=0.11.0", depth = 20 },
+]
+
+# This section is considered when running `cargo deny check sources`.
+# More documentation about the 'sources' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
+[sources]
+# Lint level for what to happen when a crate from a crate registry that is not
+# in the allow list is encountered
+unknown-registry = "warn"
+# Lint level for what to happen when a crate from a git repository that is not
+# in the allow list is encountered
+unknown-git = "warn"
+# List of URLs for allowed crate registries. Defaults to the crates.io index
+# if not specified. If it is specified but empty, no registries are allowed.
+allow-registry = ["https://github.com/rust-lang/crates.io-index"]
+# List of URLs for allowed Git repositories
+allow-git = []
+
+[sources.allow-org]
+# 1 or more github.com organizations to allow git sources for
+github = [""]
+# 1 or more gitlab.com organizations to allow git sources for
+gitlab = [""]
+# 1 or more bitbucket.org organizations to allow git sources for
+bitbucket = [""]

resources/client_row.ui

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+	<template class="ClientRow" parent="AdwExpanderRow">
+		<property name="title">hostname</property>
+		<!-- enabled -->
+		<child type="prefix">
+			<object class="GtkSwitch" id="enable_switch">
+				<signal name="state_set" handler="handle_client_set_state" swapped="true"/>
+				<property name="valign">center</property>
+				<property name="halign">end</property>
+				<property name="tooltip-text" translatable="yes">enable</property>
+			</object>
+		</child>
+		<!-- host -->
+		<child>
+			<object class="AdwActionRow">
+				<property name="title">hostname</property>
+				<property name="subtitle">port</property>
+				<!-- hostname -->
+				<child>
+					<object class="GtkEntry" id="hostname">
+						<!-- <property name="title" translatable="yes">hostname</property> -->
+						<property name="xalign">0.5</property>
+						<property name="valign">center</property>
+						<property name="placeholder-text">hostname</property>
+						<property name="width-chars">-1</property>
+					</object>
+				</child>
+				<!-- port -->
+				<child>
+					<object class="GtkEntry" id="port">
+						<!-- <property name="title" translatable="yes">port</property> -->
+						<property name="input_purpose">GTK_INPUT_PURPOSE_NUMBER</property>
+						<property name="xalign">0.5</property>
+						<property name="valign">center</property>
+						<property name="placeholder-text">4242</property>
+						<property name="width-chars">5</property>
+					</object>
+				</child>
+			</object>
+		</child>
+		<!-- position -->
+		<child>
+			<object class="AdwComboRow" id="position">
+				<property name="title" translatable="yes">position</property>
+				<property name="model">
+					<object class="GtkStringList">
+						<items>
+							<item>Left</item>
+							<item>Right</item>
+							<item>Top</item>
+							<item>Bottom</item>
+						</items>
+					</object>
+				</property>
+			</object>
+		</child>
+		<!-- delete button -->
+		<child>
+			<object class="AdwActionRow" id="delete_row">
+				<property name="title">delete this client</property>
+				<child>
+					<object class="GtkButton" id="delete_button">
+						<signal name="activate" handler="handle_client_delete" object="delete_row" swapped="true"/>
+						<property name="icon-name">user-trash-symbolic</property>
+						<property name="valign">center</property>
+						<property name="halign">center</property>
+						<property name="name">delete-button</property>
+					</object>
+				</child>
+			</object>
+		</child>
+	</template>
+</interface>

resources/mouse-icon.svg

@@ -0,0 +1,171 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="48"
+   height="48"
+   viewBox="0 0 12.7 12.7"
+   version="1.1"
+   id="svg1"
+   inkscape:version="1.3 (0e150ed6c4, 2023-07-21)"
+   sodipodi:docname="mouse-icon.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     inkscape:zoom="22.737887"
+     inkscape:cx="19.54887"
+     inkscape:cy="26.167778"
+     inkscape:window-width="2560"
+     inkscape:window-height="1374"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" />
+  <defs
+     id="defs1" />
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <g
+       id="g20"
+       transform="translate(1.1586889,0.39019296)">
+      <g
+         id="g8"
+         transform="translate(-0.11519282,-3.9659242)">
+        <g
+           id="g6"
+           transform="translate(0.67275315,0.39959697)">
+          <g
+             id="g5">
+            <rect
+               style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+               id="rect4"
+               width="1.3032579"
+               height="1.3032579"
+               x="1.7199994"
+               y="7.5408325"
+               ry="0.3373504" />
+            <rect
+               style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+               id="rect4-2"
+               width="1.3032579"
+               height="1.3032579"
+               x="3.8428385"
+               y="7.5408325"
+               ry="0.3373504" />
+          </g>
+          <rect
+             style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+             id="rect4-3"
+             width="1.3032579"
+             height="1.3032579"
+             x="2.781419"
+             y="5.1382394"
+             ry="0.3373504" />
+        </g>
+        <path
+           style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+           d="M 1.1519282,7.3907619 H 7.059674"
+           id="path5" />
+        <path
+           style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+           d="M 4.1058009,6.8410941 V 7.3907617"
+           id="path6" />
+        <path
+           style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+           d="m 5.1672204,7.9404294 2e-7,-0.5496677"
+           id="path7" />
+        <path
+           style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+           d="M 3.0443815,7.9404294 V 7.3907617"
+           id="path8" />
+      </g>
+      <path
+         style="fill:none;stroke:#000000;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+         d="M 6.9444811,3.4248375 Z"
+         id="path9" />
+      <path
+         style="color:#000000;fill:#000000;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+         d="m 6.9840449,3.4464199 c -0.072714,-0.0035 -0.1209639,-0.2113583 -0.125,-0.1386718 -0.0035,0.072714 0.052314,0.1346357 0.125,0.1386718 0,0 0.6614057,0.034643 1.3535156,0.4765625 0.6921097,0.4419191 1.4111567,1.2803292 1.5136717,2.9433594 0.05132,0.832563 -0.07521,1.3855916 -0.279297,1.75 -0.20409,0.3644084 -0.482943,0.5482749 -0.777343,0.640625 -0.5888014,0.1847002 -1.2265629,-0.021484 -1.2265629,-0.021484 -0.069024,-0.023541 -0.144095,0.013122 -0.1679688,0.082031 -0.023366,0.069587 0.014295,0.1449093 0.083984,0.1679687 0,0 0.6961634,0.2406696 1.3886717,0.023437 C 9.2189712,9.4003039 9.5672292,9.1706004 9.8043572,8.7472012 10.041486,8.323802 10.170261,7.7150888 10.116858,6.8487637 10.009921,5.1140179 9.2320232,4.3532014 8.4801387,3.8731154 7.7282538,3.3930294 6.9840449,3.4464198 6.9840449,3.4464199 Z"
+         id="path18"
+         sodipodi:nodetypes="cccsssscccssssc" />
+      <g
+         id="g19"
+         transform="matrix(1.8148709,0,0,1.8148709,-4.1533763,-7.8818885)">
+        <g
+           id="g17"
+           transform="translate(0.01163623,0.23038484)">
+          <ellipse
+             style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+             id="path10"
+             cx="3.9823804"
+             cy="8.17869"
+             rx="0.49368349"
+             ry="0.62533247" />
+          <ellipse
+             style="fill:#3d3d3d;fill-opacity:1;stroke:none;stroke-width:0.168876;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+             id="ellipse17"
+             cx="3.9823804"
+             cy="8.17869"
+             rx="0.31096464"
+             ry="0.40317491" />
+        </g>
+        <path
+           id="path11"
+           style="stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round"
+           d="M 7.479305,9.4704944 C 7.4964603,9.9336885 6.9306558,9.9678313 5.3811502,10.087599 3.2109768,10.255341 2.4751992,9.6707727 2.4355055,9.5280908 2.3112754,9.0815374 3.8270232,8.4090748 5.3811502,8.4090748 c 1.5633309,0 2.0816988,0.6171052 2.0981548,1.0614196 z"
+           sodipodi:nodetypes="sssss" />
+        <circle
+           style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+           id="path12"
+           cx="3.5281858"
+           cy="9.0632057"
+           r="0.18513133" />
+        <g
+           id="g18"
+           transform="translate(0.01163623,0.23038484)">
+          <ellipse
+             style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+             id="path10-2"
+             cx="4.6085634"
+             cy="8.17869"
+             rx="0.49368349"
+             ry="0.62533247" />
+          <ellipse
+             style="fill:#3d3d3d;fill-opacity:1;stroke:none;stroke-width:0.168876;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+             id="ellipse16"
+             cx="4.6085634"
+             cy="8.17869"
+             rx="0.31096464"
+             ry="0.40317491" />
+        </g>
+        <ellipse
+           style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.112226;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;paint-order:normal"
+           id="circle18"
+           cx="3.5003331"
+           cy="9.0344076"
+           rx="0.078639306"
+           ry="0.07816644" />
+        <ellipse
+           style="fill:#4f4f4f;fill-opacity:1;stroke:none;stroke-width:0.264999;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;paint-order:normal"
+           id="path19"
+           cx="2.4818404"
+           cy="9.4499254"
+           rx="0.05348238"
+           ry="0.11930636" />
+      </g>
+    </g>
+  </g>
+</svg>

resources/resources.gresource.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/de/feschber/LanMouse">
+    <file compressed="true" preprocess="xml-stripblanks">window.ui</file>
+    <file compressed="true" preprocess="xml-stripblanks">client_row.ui</file>
+    <file compressed="true">style.css</file>
+    <file compressed="true">style-dark.css</file>
+  </gresource>
+  <gresource prefix="/de/feschber/LanMouse/icons">
+	<file compressed="true" preprocess="xml-stripblanks">mouse-icon.svg</file>
+  </gresource>
+</gresources>

resources/style-dark.css

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

resources/style.css

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

resources/window.ui

@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+	<requires lib="gtk" version="4.0"/>
+	<requires lib="libadwaita" version="1.0"/>
+	<menu id="main-menu">
+		<item>
+			<attribute name="label" translatable="yes">_Close window</attribute>
+			<attribute name="action">window.close</attribute>
+		</item>
+	</menu>
+	<template class="LanMouseWindow" parent="AdwApplicationWindow">
+		<property name="width-request">600</property>
+		<property name="height-request">700</property>
+		<property name="title" translatable="yes">Lan Mouse</property>
+		<property name="show-menubar">True</property>
+		<property name="content">
+			<object class="AdwToolbarView">
+				<child type="top">
+					<object class="AdwHeaderBar">
+						<child type ="end">
+							<object class="GtkMenuButton">
+								<property name="icon-name">open-menu-symbolic</property>
+								<property name="menu-model">main-menu</property>
+							</object>
+						</child>
+						<style>
+							<class name="flat"/>
+						</style>
+					</object>
+				</child>
+				<property name="content">
+					<object class="AdwToastOverlay" id="toast_overlay">
+						<child>
+							<object class="AdwStatusPage">
+								<property name="title" translatable="yes">Lan Mouse</property>
+								<property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
+								<property name="icon-name">mouse-icon</property>
+								<property name="child">
+								  <object class="AdwClamp">
+									<property name="maximum-size">600</property>
+									<property name="tightening-threshold">0</property>
+									<property name="child">
+									  <object class="GtkBox">
+										<property name="orientation">vertical</property>
+										<property name="spacing">12</property>
+										<child>
+											<object class="AdwPreferencesGroup">
+												<property name="title" translatable="yes">General</property>
+												<!--
+												<child>
+													<object class="AdwActionRow">
+														<property name="title" translatable="yes">enable</property>
+														<child type="suffix">
+															<object class="GtkSwitch">
+																<property name="valign">center</property>
+																<property name="tooltip-text" translatable="yes">enable</property>
+															</object>
+														</child>
+													</object>
+												</child>
+												-->
+												<child>
+													<object class="AdwActionRow">
+														<property name="title">port</property>
+														<child>
+															<object class="GtkEntry" id="port_entry">
+																<signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
+																<signal name="changed" handler="handle_port_changed" swapped="true"/>
+																<!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
+																<!-- <property name="title" translatable="yes">port</property> -->
+																<property name="placeholder-text">4242</property>
+																<property name="width-chars">5</property>
+																<property name="xalign">0.5</property>
+																<property name="valign">center</property>
+																<!-- <property name="show-apply-button">True</property> -->
+																<property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
+															</object>
+														</child>
+														<child>
+															<object class="GtkButton" id="port_edit_apply">
+																<signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
+																<property name="icon-name">object-select-symbolic</property>
+																<property name="valign">center</property>
+																<property name="visible">false</property>
+																<property name="name">port-edit-apply</property>
+															</object>
+														</child>
+														<child>
+															<object class="GtkButton" id="port_edit_cancel">
+																<signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
+																<property name="icon-name">process-stop-symbolic</property>
+																<property name="valign">center</property>
+																<property name="visible">false</property>
+																<property name="name">port-edit-cancel</property>
+															</object>
+														</child>
+													</object>
+												</child>
+											</object>
+										</child>
+										<child>
+											<object class="AdwPreferencesGroup">
+												<property name="title" translatable="yes">Connections</property>
+												<property name="header-suffix">
+													<object class="GtkButton">
+														<signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
+														<property name="child">
+															<object class="AdwButtonContent">
+																<property name="icon-name">list-add-symbolic</property>
+																<property name="label" translatable="yes">Add</property>
+															</object>
+														</property>
+													<style>
+														<class name="flat"/>
+													</style>
+													</object>
+												</property>
+												<child>
+												  <object class="GtkListBox" id="client_list">
+														<property name="selection-mode">none</property>
+														<child type="placeholder">
+															<object class="AdwActionRow" id="client_placeholder">
+																<property name="title">No connections!</property>
+																<property name="subtitle">add a new client via the + button</property>
+															</object>
+														</child>
+														<style>
+															<class name="boxed-list" />
+														</style>
+												  </object>
+												</child>
+											</object>
+										</child>
+									  </object>
+									</property>
+								  </object>
+							  </property>
+							</object>
+						</child>
+					</object>
+				</property>
+			</object>
+		</property>
+	</template>
+</interface>

src/backend/consumer.rs

@@ -1,14 +1,17 @@
 #[cfg(windows)]
 pub mod windows;
 
-#[cfg(all(unix, feature="x11"))]
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 pub mod x11;
 
-#[cfg(all(unix, feature = "wayland"))]
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 pub mod wlroots;
 
-#[cfg(all(unix, feature = "xdg_desktop_portal"))]
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 pub mod xdg_desktop_portal;
 
-#[cfg(all(unix, feature = "libei"))]
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 pub mod libei;
+
+#[cfg(target_os = "macos")]
+pub mod macos;

src/backend/consumer/libei.rs

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

src/backend/consumer/macos.rs

@@ -0,0 +1,221 @@
+use crate::client::{ClientEvent, ClientHandle};
+use crate::consumer::EventConsumer;
+use crate::event::{Event, KeyboardEvent, PointerEvent};
+use anyhow::{anyhow, Result};
+use async_trait::async_trait;
+use core_graphics::display::CGPoint;
+use core_graphics::event::{
+    CGEvent, CGEventTapLocation, CGEventType, CGMouseButton, ScrollEventUnit,
+};
+use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
+use std::ops::{Index, IndexMut};
+
+pub struct MacOSConsumer {
+    pub event_source: CGEventSource,
+    button_state: ButtonState,
+}
+
+struct ButtonState {
+    left: bool,
+    right: bool,
+    center: bool,
+}
+
+impl Index<CGMouseButton> for ButtonState {
+    type Output = bool;
+
+    fn index(&self, index: CGMouseButton) -> &Self::Output {
+        match index {
+            CGMouseButton::Left => &self.left,
+            CGMouseButton::Right => &self.right,
+            CGMouseButton::Center => &self.center,
+        }
+    }
+}
+
+impl IndexMut<CGMouseButton> for ButtonState {
+    fn index_mut(&mut self, index: CGMouseButton) -> &mut Self::Output {
+        match index {
+            CGMouseButton::Left => &mut self.left,
+            CGMouseButton::Right => &mut self.right,
+            CGMouseButton::Center => &mut self.center,
+        }
+    }
+}
+
+unsafe impl Send for MacOSConsumer {}
+
+impl MacOSConsumer {
+    pub fn new() -> Result<Self> {
+        let event_source = match CGEventSource::new(CGEventSourceStateID::CombinedSessionState) {
+            Ok(e) => e,
+            Err(_) => return Err(anyhow!("event source creation failed!")),
+        };
+        let button_state = ButtonState {
+            left: false,
+            right: false,
+            center: false,
+        };
+        Ok(Self {
+            event_source,
+            button_state,
+        })
+    }
+
+    fn get_mouse_location(&self) -> Option<CGPoint> {
+        let event: CGEvent = CGEvent::new(self.event_source.clone()).ok()?;
+        Some(event.location())
+    }
+}
+
+#[async_trait]
+impl EventConsumer for MacOSConsumer {
+    async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
+        match event {
+            Event::Pointer(pointer_event) => match pointer_event {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    let mut mouse_location = match self.get_mouse_location() {
+                        Some(l) => l,
+                        None => {
+                            log::warn!("could not get mouse location!");
+                            return;
+                        }
+                    };
+                    mouse_location.x += relative_x;
+                    mouse_location.y += relative_y;
+
+                    let mut event_type = CGEventType::MouseMoved;
+                    if self.button_state.left {
+                        event_type = CGEventType::LeftMouseDragged
+                    } else if self.button_state.right {
+                        event_type = CGEventType::RightMouseDragged
+                    } else if self.button_state.center {
+                        event_type = CGEventType::OtherMouseDragged
+                    };
+                    let event = match CGEvent::new_mouse_event(
+                        self.event_source.clone(),
+                        event_type,
+                        mouse_location,
+                        CGMouseButton::Left,
+                    ) {
+                        Ok(e) => e,
+                        Err(_) => {
+                            log::warn!("mouse event creation failed!");
+                            return;
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    let (event_type, mouse_button) = match (button, state) {
+                        (b, 1) if b == crate::event::BTN_LEFT => {
+                            (CGEventType::LeftMouseDown, CGMouseButton::Left)
+                        }
+                        (b, 0) if b == crate::event::BTN_LEFT => {
+                            (CGEventType::LeftMouseUp, CGMouseButton::Left)
+                        }
+                        (b, 1) if b == crate::event::BTN_RIGHT => {
+                            (CGEventType::RightMouseDown, CGMouseButton::Right)
+                        }
+                        (b, 0) if b == crate::event::BTN_RIGHT => {
+                            (CGEventType::RightMouseUp, CGMouseButton::Right)
+                        }
+                        (b, 1) if b == crate::event::BTN_MIDDLE => {
+                            (CGEventType::OtherMouseDown, CGMouseButton::Center)
+                        }
+                        (b, 0) if b == crate::event::BTN_MIDDLE => {
+                            (CGEventType::OtherMouseUp, CGMouseButton::Center)
+                        }
+                        _ => {
+                            log::warn!("invalid button event: {button},{state}");
+                            return;
+                        }
+                    };
+                    // store button state
+                    self.button_state[mouse_button] = if state == 1 { true } else { false };
+
+                    let location = self.get_mouse_location().unwrap();
+                    let event = match CGEvent::new_mouse_event(
+                        self.event_source.clone(),
+                        event_type,
+                        location,
+                        mouse_button,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("mouse event creation failed!");
+                            return;
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    let value = value as i32 / 10; // FIXME: high precision scroll events
+                    let (count, wheel1, wheel2, wheel3) = match axis {
+                        0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
+                        1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
+                        _ => {
+                            log::warn!("invalid scroll event: {axis}, {value}");
+                            return;
+                        }
+                    };
+                    let event = match CGEvent::new_scroll_event(
+                        self.event_source.clone(),
+                        ScrollEventUnit::LINE,
+                        count,
+                        wheel1,
+                        wheel2,
+                        wheel3,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("scroll event creation failed!");
+                            return;
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::Frame { .. } => {}
+            },
+            Event::Keyboard(keyboard_event) => match keyboard_event {
+                KeyboardEvent::Key { .. } => {
+                    /*
+                    let code = CGKeyCode::from_le(key as u16);
+                    let event = match CGEvent::new_keyboard_event(
+                        self.event_source.clone(),
+                        code,
+                        match state { 1 => true, _ => false }
+                    ) {
+                        Ok(e) => e,
+                        Err(_) => {
+                            log::warn!("unable to create key event");
+                            return
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                    */
+                }
+                KeyboardEvent::Modifiers { .. } => {}
+            },
+            Event::Release() => {}
+            Event::Ping() => {}
+            Event::Pong() => {}
+        }
+    }
+
+    async fn notify(&mut self, _client_event: ClientEvent) {}
+
+    async fn destroy(&mut self) {}
+}

src/backend/consumer/windows.rs

@@ -1,25 +1,74 @@
-use std::sync::mpsc::Receiver;
-
-use crate::event::{KeyboardEvent, PointerEvent};
+use crate::{
+    consumer::EventConsumer,
+    event::{KeyboardEvent, PointerEvent},
+};
+use async_trait::async_trait;
 use winapi::{
     self,
-    um::winuser::{INPUT, INPUT_MOUSE, LPINPUT, MOUSEEVENTF_MOVE, MOUSEINPUT,
-        MOUSEEVENTF_LEFTDOWN,
-        MOUSEEVENTF_RIGHTDOWN,
-        MOUSEEVENTF_MIDDLEDOWN,
-        MOUSEEVENTF_LEFTUP,
-        MOUSEEVENTF_RIGHTUP,
-        MOUSEEVENTF_MIDDLEUP,
-        MOUSEEVENTF_WHEEL,
-        MOUSEEVENTF_HWHEEL, INPUT_KEYBOARD, KEYBDINPUT, KEYEVENTF_SCANCODE, KEYEVENTF_KEYUP,
+    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 crate::{
-    client::{Client, ClientHandle},
+    client::{ClientEvent, ClientHandle},
     event::Event,
 };
 
+pub struct WindowsConsumer {}
+
+impl WindowsConsumer {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl EventConsumer for WindowsConsumer {
+    async fn consume(&mut self, event: Event, _: ClientHandle) {
+        match event {
+            Event::Pointer(pointer_event) => match pointer_event {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    rel_mouse(relative_x as i32, relative_y as i32);
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => mouse_button(button, state),
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => scroll(axis, value),
+                PointerEvent::Frame {} => {}
+            },
+            Event::Keyboard(keyboard_event) => match keyboard_event {
+                KeyboardEvent::Key {
+                    time: _,
+                    key,
+                    state,
+                } => key_event(key, state),
+                KeyboardEvent::Modifiers { .. } => {}
+            },
+            _ => {}
+        }
+    }
+
+    async fn notify(&mut self, _: ClientEvent) {
+        // nothing to do
+    }
+
+    async fn destroy(&mut self) {}
+}
+
 fn send_mouse_input(mi: MOUSEINPUT) {
     unsafe {
         let mut input = INPUT {
@@ -53,18 +102,19 @@ fn mouse_button(button: u32, state: u32) {
             0x110 => MOUSEEVENTF_LEFTUP,
             0x111 => MOUSEEVENTF_RIGHTUP,
             0x112 => MOUSEEVENTF_MIDDLEUP,
-            _ => return
-        }
+            _ => return,
+        },
         1 => match button {
             0x110 => MOUSEEVENTF_LEFTDOWN,
             0x111 => MOUSEEVENTF_RIGHTDOWN,
             0x112 => MOUSEEVENTF_MIDDLEDOWN,
-            _ => return
-        }
-        _ => return
+            _ => return,
+        },
+        _ => return,
     };
     let mi = MOUSEINPUT {
-        dx: 0, dy: 0, // no movement
+        dx: 0,
+        dy: 0, // no movement
         mouseData: 0,
         dwFlags: dw_flags,
         time: 0,
@@ -77,10 +127,11 @@ fn scroll(axis: u8, value: f64) {
     let event_type = match axis {
         0 => MOUSEEVENTF_WHEEL,
         1 => MOUSEEVENTF_HWHEEL,
-        _ => return
+        _ => return,
     };
     let mi = MOUSEINPUT {
-        dx: 0, dy: 0,
+        dx: 0,
+        dy: 0,
         mouseData: (-value * 15.0) as i32 as u32,
         dwFlags: event_type,
         time: 0,
@@ -93,11 +144,12 @@ fn key_event(key: u32, state: u8) {
     let ki = KEYBDINPUT {
         wVk: 0,
         wScan: key as u16,
-        dwFlags: KEYEVENTF_SCANCODE | match state {
-            0 => KEYEVENTF_KEYUP,
-            1 => 0u32,
-            _ => return
-        },
+        dwFlags: KEYEVENTF_SCANCODE
+            | match state {
+                0 => KEYEVENTF_KEYUP,
+                1 => 0u32,
+                _ => return,
+            },
         time: 0,
         dwExtraInfo: 0,
     };
@@ -114,27 +166,3 @@ fn send_keyboard_input(ki: KEYBDINPUT) {
         winapi::um::winuser::SendInput(1 as u32, &mut input, std::mem::size_of::<INPUT>() as i32);
     }
 }
-
-pub fn run(event_rx: Receiver<(Event, ClientHandle)>, _clients: Vec<Client>) {
-    loop {
-        match event_rx.recv().expect("event receiver unavailable").0 {
-            Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion {
-                    time: _,
-                    relative_x,
-                    relative_y,
-                } => {
-                    rel_mouse(relative_x as i32, relative_y as i32);
-                }
-                PointerEvent::Button { time:_, button, state } => { mouse_button(button, state)}
-                PointerEvent::Axis { time:_, axis, value } => { scroll(axis, value) }
-                PointerEvent::Frame {} => {}
-            },
-            Event::Keyboard(keyboard_event) => match keyboard_event {
-                KeyboardEvent::Key { time:_, key, state } => { key_event(key, state) }
-                KeyboardEvent::Modifiers { .. } => {}
-            },
-            Event::Release() => {}
-        }
-    }
-}

src/backend/consumer/wlroots.rs

@@ -1,16 +1,18 @@
-use crate::client::{Client, ClientHandle};
-use crate::request::{self, Request};
+use crate::client::{ClientEvent, ClientHandle};
+use crate::consumer::EventConsumer;
+use async_trait::async_trait;
 use std::collections::HashMap;
-use std::sync::mpsc::Receiver;
-use std::time::Duration;
-use std::{io, thread};
-use std::{
-    io::{BufWriter, Write},
-    os::unix::prelude::AsRawFd,
-};
+use std::io;
+use std::os::fd::OwnedFd;
+use std::os::unix::prelude::AsRawFd;
+use wayland_client::backend::WaylandError;
+use wayland_client::WEnum;
 
+use anyhow::{anyhow, Result};
 use wayland_client::globals::BindError;
+use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
 use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
+use wayland_client::protocol::wl_seat::WlSeat;
 use wayland_protocols_wlr::virtual_pointer::v1::client::{
     zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
     zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1 as Vp,
@@ -30,8 +32,6 @@ use wayland_client::{
     Connection, Dispatch, EventQueue, QueueHandle,
 };
 
-use tempfile;
-
 use crate::event::{Event, KeyboardEvent, PointerEvent};
 
 enum VirtualInputManager {
@@ -39,27 +39,32 @@ enum VirtualInputManager {
     Kde { fake_input: OrgKdeKwinFakeInput },
 }
 
-// App State, implements Dispatch event handlers
-struct App {
+struct State {
+    keymap: Option<(u32, OwnedFd, u32)>,
     input_for_client: HashMap<ClientHandle, VirtualInput>,
     seat: wl_seat::WlSeat,
-    event_rx: Receiver<(Event, ClientHandle)>,
     virtual_input_manager: VirtualInputManager,
-    queue: EventQueue<Self>,
     qh: QueueHandle<Self>,
 }
 
-pub fn run(event_rx: Receiver<(Event, ClientHandle)>, clients: Vec<Client>) {
-    let mut app = App::new(event_rx, clients);
-    app.run();
+// App State, implements Dispatch event handlers
+pub(crate) struct WlrootsConsumer {
+    last_flush_failed: bool,
+    state: State,
+    queue: EventQueue<State>,
 }
 
-impl App {
-    pub fn new(event_rx: Receiver<(Event, ClientHandle)>, clients: Vec<Client>) -> Self {
+impl WlrootsConsumer {
+    pub fn new() -> Result<Self> {
         let conn = Connection::connect_to_env().unwrap();
-        let (globals, queue) = registry_queue_init::<App>(&conn).unwrap();
+        let (globals, queue) = registry_queue_init::<State>(&conn).unwrap();
         let qh = queue.handle();
 
+        let seat: wl_seat::WlSeat = match globals.bind(&qh, 7..=8, ()) {
+            Ok(wl_seat) => wl_seat,
+            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
+        };
+
         let vpm: Result<VpManager, BindError> = globals.bind(&qh, 1..=1, ());
         let vkm: Result<VkManager, BindError> = globals.bind(&qh, 1..=1, ());
         let fake_input: Result<OrgKdeKwinFakeInput, BindError> = globals.bind(&qh, 4..=4, ());
@@ -74,10 +79,11 @@ impl App {
                 VirtualInputManager::Kde { fake_input }
             }
             (Err(e1), Err(e2), Err(e3)) => {
-                eprintln!("zwlr_virtual_pointer_v1: {e1}");
-                eprintln!("zwp_virtual_keyboard_v1: {e2}");
-                eprintln!("org_kde_kwin_fake_input: {e3}");
-                panic!("neither wlroots nor kde input emulation protocol supported!")
+                log::warn!("zwlr_virtual_pointer_v1: {e1}");
+                log::warn!("zwp_virtual_keyboard_v1: {e2}");
+                log::warn!("org_kde_kwin_fake_input: {e3}");
+                log::error!("neither wlroots nor kde input emulation protocol supported!");
+                return Err(anyhow!("could not create event consumer"));
             }
             _ => {
                 panic!()
@@ -85,155 +91,185 @@ impl App {
         };
 
         let input_for_client: HashMap<ClientHandle, VirtualInput> = HashMap::new();
-        let seat: wl_seat::WlSeat = globals.bind(&qh, 7..=8, ()).unwrap();
-        let mut app = App {
-            input_for_client,
-            seat,
-            event_rx,
-            virtual_input_manager,
+
+        let mut consumer = WlrootsConsumer {
+            last_flush_failed: false,
+            state: State {
+                keymap: None,
+                input_for_client,
+                seat,
+                virtual_input_manager,
+                qh,
+            },
             queue,
-            qh,
         };
-        for client in clients {
-            app.add_client(client);
+        while consumer.state.keymap.is_none() {
+            consumer
+                .queue
+                .blocking_dispatch(&mut consumer.state)
+                .unwrap();
         }
-        app
+        // let fd = unsafe { &File::from_raw_fd(consumer.state.keymap.unwrap().1.as_raw_fd()) };
+        // let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
+        // log::debug!("{:?}", &mmap[..100]);
+        Ok(consumer)
     }
+}
 
-    pub fn run(&mut self) {
-        loop {
-            let (event, client) = self.event_rx.recv().expect("event receiver unavailable");
-            if let Some(virtual_input) = self.input_for_client.get(&client) {
-                virtual_input.consume_event(event).unwrap();
-                if let Err(e) = self.queue.flush() {
-                    eprintln!("{}", e);
-                }
-            }
-        }
-    }
-
-    fn add_client(&mut self, client: Client) {
+impl State {
+    fn add_client(&mut self, client: ClientHandle) {
         // create virtual input devices
         match &self.virtual_input_manager {
             VirtualInputManager::Wlroots { vpm, vkm } => {
                 let pointer: Vp = vpm.create_virtual_pointer(None, &self.qh, ());
                 let keyboard: Vk = vkm.create_virtual_keyboard(&self.seat, &self.qh, ());
 
-                // receive keymap from device
-                eprint!("\rconnecting to {} ", client.addr);
-                let mut attempts = 0;
-                let data = loop {
-                    let result = request::request_data(client.addr, Request::KeyMap);
-                    eprint!("\rconnecting to {} ", client.addr);
-                    for _ in 0..attempts {
-                        eprint!(".");
-                    }
-                    match result {
-                        Ok(data) => break data,
-                        Err(e) => {
-                            eprint!(" - {}", e);
-                        }
-                    }
-                    io::stderr().flush().unwrap();
-                    thread::sleep(Duration::from_millis(500));
-                    attempts += 1;
-                };
-
-                eprint!("\rconnecting to {} ", client.addr);
-                for _ in 0..attempts {
-                    eprint!(".");
+                // TODO: use server side keymap
+                if let Some((format, fd, size)) = self.keymap.as_ref() {
+                    keyboard.keymap(*format, fd.as_raw_fd(), *size);
+                } else {
+                    panic!("no keymap");
                 }
-                eprintln!(" done!                          ");
-
-                // TODO use shm_open
-                let f = tempfile::tempfile().unwrap();
-                let mut buf = BufWriter::new(&f);
-                buf.write_all(&data[..]).unwrap();
-                buf.flush().unwrap();
-                keyboard.keymap(1, f.as_raw_fd(), data.len() as u32);
 
                 let vinput = VirtualInput::Wlroots { pointer, keyboard };
 
-                self.input_for_client.insert(client.handle, vinput);
+                self.input_for_client.insert(client, vinput);
             }
             VirtualInputManager::Kde { fake_input } => {
                 let fake_input = fake_input.clone();
                 let vinput = VirtualInput::Kde { fake_input };
-                self.input_for_client.insert(client.handle, vinput);
+                self.input_for_client.insert(client, vinput);
             }
         }
     }
 }
 
+#[async_trait]
+impl EventConsumer for WlrootsConsumer {
+    async fn consume(&mut self, event: Event, client_handle: ClientHandle) {
+        if let Some(virtual_input) = self.state.input_for_client.get(&client_handle) {
+            if self.last_flush_failed {
+                if let Err(WaylandError::Io(e)) = self.queue.flush() {
+                    if e.kind() == io::ErrorKind::WouldBlock {
+                        /*
+                         * outgoing buffer is full - sending more events
+                         * will overwhelm the output buffer and leave the
+                         * wayland connection in a broken state
+                         */
+                        log::warn!(
+                            "can't keep up, discarding event: ({client_handle}) - {event:?}"
+                        );
+                        return;
+                    }
+                }
+            }
+            virtual_input.consume_event(event).unwrap();
+            match self.queue.flush() {
+                Err(WaylandError::Io(e)) if e.kind() == io::ErrorKind::WouldBlock => {
+                    self.last_flush_failed = true;
+                    log::warn!("can't keep up, retrying ...");
+                }
+                Err(WaylandError::Io(e)) => {
+                    log::error!("{e}")
+                }
+                Err(WaylandError::Protocol(e)) => {
+                    panic!("wayland protocol violation: {e}")
+                }
+                Ok(()) => {
+                    self.last_flush_failed = false;
+                }
+            }
+        }
+    }
+
+    async fn notify(&mut self, client_event: ClientEvent) {
+        if let ClientEvent::Create(client, _) = client_event {
+            self.state.add_client(client);
+            if let Err(e) = self.queue.flush() {
+                log::error!("{}", e);
+            }
+        }
+    }
+
+    async fn destroy(&mut self) {}
+}
+
 enum VirtualInput {
     Wlroots { pointer: Vp, keyboard: Vk },
     Kde { fake_input: OrgKdeKwinFakeInput },
 }
 
 impl VirtualInput {
-    fn consume_event(&self, event: Event) -> Result<(),()> {
+    fn consume_event(&self, event: Event) -> Result<(), ()> {
         match event {
-            Event::Pointer(e) => match e {
-                PointerEvent::Motion {
-                    time,
-                    relative_x,
-                    relative_y,
-                } => match self {
-                    VirtualInput::Wlroots {
-                        pointer,
-                        keyboard: _,
-                    } => {
-                        pointer.motion(time, relative_x, relative_y);
-                        pointer.frame();
-                    }
-                    VirtualInput::Kde { fake_input } => {
-                        fake_input.pointer_motion(relative_y, relative_y);
-                    }
-                },
-                PointerEvent::Button {
-                    time,
-                    button,
-                    state,
-                } => {
-                    let state: ButtonState = state.try_into()?;
-                    match self {
+            Event::Pointer(e) => {
+                match e {
+                    PointerEvent::Motion {
+                        time,
+                        relative_x,
+                        relative_y,
+                    } => match self {
                         VirtualInput::Wlroots {
                             pointer,
                             keyboard: _,
                         } => {
-                            pointer.button(time, button, state);
-                            pointer.frame();
+                            pointer.motion(time, relative_x, relative_y);
                         }
                         VirtualInput::Kde { fake_input } => {
-                            fake_input.button(button, state as u32);
+                            fake_input.pointer_motion(relative_y, relative_y);
+                        }
+                    },
+                    PointerEvent::Button {
+                        time,
+                        button,
+                        state,
+                    } => {
+                        let state: ButtonState = state.try_into()?;
+                        match self {
+                            VirtualInput::Wlroots {
+                                pointer,
+                                keyboard: _,
+                            } => {
+                                pointer.button(time, button, state);
+                            }
+                            VirtualInput::Kde { fake_input } => {
+                                fake_input.button(button, state as u32);
+                            }
                         }
                     }
-                }
-                PointerEvent::Axis { time, axis, value } => {
-                    let axis: Axis = (axis as u32).try_into()?;
-                    match self {
+                    PointerEvent::Axis { time, axis, value } => {
+                        let axis: Axis = (axis as u32).try_into()?;
+                        match self {
+                            VirtualInput::Wlroots {
+                                pointer,
+                                keyboard: _,
+                            } => {
+                                pointer.axis(time, axis, value);
+                                pointer.frame();
+                            }
+                            VirtualInput::Kde { fake_input } => {
+                                fake_input.axis(axis as u32, value);
+                            }
+                        }
+                    }
+                    PointerEvent::Frame {} => match self {
                         VirtualInput::Wlroots {
                             pointer,
                             keyboard: _,
                         } => {
-                            pointer.axis(time, axis, value);
                             pointer.frame();
                         }
-                        VirtualInput::Kde { fake_input } => {
-                            fake_input.axis(axis as u32, value);
-                        }
-                    }
+                        VirtualInput::Kde { fake_input: _ } => {}
+                    },
                 }
-                PointerEvent::Frame {} => match self {
-                    VirtualInput::Wlroots {
-                        pointer,
-                        keyboard: _,
-                    } => {
+                match self {
+                    VirtualInput::Wlroots { pointer, .. } => {
+                        // insert a frame event after each mouse event
                         pointer.frame();
                     }
-                    VirtualInput::Kde { fake_input: _ } => {}
-                },
-            },
+                    _ => {}
+                }
+            }
             Event::Keyboard(e) => match e {
                 KeyboardEvent::Key { time, key, state } => match self {
                     VirtualInput::Wlroots {
@@ -261,36 +297,64 @@ impl VirtualInput {
                     VirtualInput::Kde { fake_input: _ } => {}
                 },
             },
-            Event::Release() => match self {
-                VirtualInput::Wlroots {
-                    pointer: _,
-                    keyboard,
-                } => {
-                    keyboard.modifiers(77, 0, 0, 0);
-                    keyboard.modifiers(0, 0, 0, 0);
-                }
-                VirtualInput::Kde { fake_input: _ } => {}
-            },
+            _ => {}
         }
         Ok(())
     }
 }
 
-delegate_noop!(App: Vp);
-delegate_noop!(App: Vk);
-delegate_noop!(App: VpManager);
-delegate_noop!(App: VkManager);
-delegate_noop!(App: wl_seat::WlSeat);
-delegate_noop!(App: OrgKdeKwinFakeInput);
+delegate_noop!(State: Vp);
+delegate_noop!(State: Vk);
+delegate_noop!(State: VpManager);
+delegate_noop!(State: VkManager);
+delegate_noop!(State: OrgKdeKwinFakeInput);
 
-impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for App {
+impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
     fn event(
-        _: &mut App,
+        _: &mut State,
         _: &wl_registry::WlRegistry,
         _: wl_registry::Event,
         _: &GlobalListContents,
         _: &Connection,
-        _: &QueueHandle<App>,
+        _: &QueueHandle<State>,
     ) {
     }
 }
+
+impl Dispatch<WlKeyboard, ()> for State {
+    fn event(
+        state: &mut Self,
+        _: &WlKeyboard,
+        event: <WlKeyboard as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_keyboard::Event::Keymap { format, fd, size } => {
+                state.keymap = Some((u32::from(format), fd, size));
+            }
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<WlSeat, ()> for State {
+    fn event(
+        _: &mut Self,
+        seat: &WlSeat,
+        event: <WlSeat as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        qhandle: &QueueHandle<Self>,
+    ) {
+        if let wl_seat::Event::Capabilities {
+            capabilities: WEnum::Value(capabilities),
+        } = event
+        {
+            if capabilities.contains(wl_seat::Capability::Keyboard) {
+                seat.get_keyboard(qhandle, ());
+            }
+        }
+    }
+}

src/backend/consumer/x11.rs

@@ -1,49 +1,59 @@
-use std::{ptr, sync::mpsc::Receiver};
+use async_trait::async_trait;
+use std::ptr;
 use x11::{xlib, xtest};
 
-use crate::{
-    client::{Client, ClientHandle},
-    event::Event,
-};
+use crate::{client::ClientHandle, consumer::EventConsumer, event::Event};
 
-fn open_display() -> Option<*mut xlib::Display> {
-    unsafe {
-        match xlib::XOpenDisplay(ptr::null()) {
-            d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => None,
-            display => Some(display),
+pub struct X11Consumer {
+    display: *mut xlib::Display,
+}
+
+unsafe impl Send for X11Consumer {}
+
+impl X11Consumer {
+    pub fn new() -> Self {
+        let display = unsafe {
+            match xlib::XOpenDisplay(ptr::null()) {
+                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => None,
+                display => Some(display),
+            }
+        };
+        let display = display.expect("could not open display");
+        Self { display }
+    }
+
+    fn relative_motion(&self, dx: i32, dy: i32) {
+        unsafe {
+            xtest::XTestFakeRelativeMotionEvent(self.display, dx, dy, 0, 0);
+            xlib::XFlush(self.display);
         }
     }
 }
 
-fn relative_motion(display: *mut xlib::Display, dx: i32, dy: i32) {
-    unsafe {
-        xtest::XTestFakeRelativeMotionEvent(display, dx, dy, 0, 0);
-        xlib::XFlush(display);
-    }
-}
-
-pub fn run(event_rx: Receiver<(Event, ClientHandle)>, _clients: Vec<Client>) {
-    let display = match open_display() {
-        None => panic!("could not open display!"),
-        Some(display) => display,
-    };
-
-    loop {
-        match event_rx.recv().expect("event receiver unavailable").0 {
+#[async_trait]
+impl EventConsumer for X11Consumer {
+    async fn consume(&mut self, event: Event, _: ClientHandle) {
+        match event {
             Event::Pointer(pointer_event) => match pointer_event {
                 crate::event::PointerEvent::Motion {
                     time: _,
                     relative_x,
                     relative_y,
                 } => {
-                    relative_motion(display, relative_x as i32, relative_y as i32);
+                    self.relative_motion(relative_x as i32, relative_y as i32);
                 }
                 crate::event::PointerEvent::Button { .. } => {}
                 crate::event::PointerEvent::Axis { .. } => {}
                 crate::event::PointerEvent::Frame {} => {}
             },
             Event::Keyboard(_) => {}
-            Event::Release() => {}
+            _ => {}
         }
     }
+
+    async fn notify(&mut self, _: crate::client::ClientEvent) {
+        // for our purposes it does not matter what client sent the event
+    }
+
+    async fn destroy(&mut self) {}
 }

src/backend/consumer/xdg_desktop_portal.rs

@@ -1,9 +1,128 @@
-use std::sync::mpsc::Receiver;
+use anyhow::Result;
+use ashpd::{
+    desktop::{
+        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
+        Session,
+    },
+    WindowIdentifier,
+};
+use async_trait::async_trait;
 
-use crate::{event::Event, client::{ClientHandle, Client}};
+use crate::consumer::EventConsumer;
 
-
-
-pub(crate) fn run(_consume_rx: Receiver<(Event, ClientHandle)>, _clients: Vec<Client>) {
-    todo!()
+pub struct DesktopPortalConsumer<'a> {
+    proxy: RemoteDesktop<'a>,
+    session: Session<'a>,
+}
+
+impl<'a> DesktopPortalConsumer<'a> {
+    pub async fn new() -> Result<DesktopPortalConsumer<'a>> {
+        let proxy = RemoteDesktop::new().await?;
+        let session = proxy.create_session().await?;
+        proxy
+            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+            .await?;
+
+        let _ = proxy
+            .start(&session, &WindowIdentifier::default())
+            .await?
+            .response()?;
+
+        Ok(Self { proxy, session })
+    }
+}
+
+#[async_trait]
+impl<'a> EventConsumer for DesktopPortalConsumer<'a> {
+    async fn consume(&mut self, event: crate::event::Event, _client: crate::client::ClientHandle) {
+        match event {
+            crate::event::Event::Pointer(p) => {
+                match p {
+                    crate::event::PointerEvent::Motion {
+                        time: _,
+                        relative_x,
+                        relative_y,
+                    } => {
+                        if let Err(e) = self
+                            .proxy
+                            .notify_pointer_motion(&self.session, relative_x, relative_y)
+                            .await
+                        {
+                            log::warn!("{e}");
+                        }
+                    }
+                    crate::event::PointerEvent::Button {
+                        time: _,
+                        button,
+                        state,
+                    } => {
+                        let state = match state {
+                            0 => KeyState::Released,
+                            _ => KeyState::Pressed,
+                        };
+                        if let Err(e) = self
+                            .proxy
+                            .notify_pointer_button(&self.session, button as i32, state)
+                            .await
+                        {
+                            log::warn!("{e}");
+                        }
+                    }
+                    crate::event::PointerEvent::Axis {
+                        time: _,
+                        axis,
+                        value,
+                    } => {
+                        let axis = match axis {
+                            0 => Axis::Vertical,
+                            _ => Axis::Horizontal,
+                        };
+                        // TODO smooth scrolling
+                        if let Err(e) = self
+                            .proxy
+                            .notify_pointer_axis_discrete(&self.session, axis, value as i32)
+                            .await
+                        {
+                            log::warn!("{e}");
+                        }
+                    }
+                    crate::event::PointerEvent::Frame {} => {}
+                }
+            }
+            crate::event::Event::Keyboard(k) => {
+                match k {
+                    crate::event::KeyboardEvent::Key {
+                        time: _,
+                        key,
+                        state,
+                    } => {
+                        let state = match state {
+                            0 => KeyState::Released,
+                            _ => KeyState::Pressed,
+                        };
+                        if let Err(e) = self
+                            .proxy
+                            .notify_keyboard_keycode(&self.session, key as i32, state)
+                            .await
+                        {
+                            log::warn!("{e}");
+                        }
+                    }
+                    crate::event::KeyboardEvent::Modifiers { .. } => {
+                        // ignore
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    async fn notify(&mut self, _client: crate::client::ClientEvent) {}
+
+    async fn destroy(&mut self) {
+        log::debug!("closing remote desktop session");
+        if let Err(e) = self.session.close().await {
+            log::error!("failed to close remote desktop session: {e}");
+        }
+    }
 }

src/backend/producer.rs

@@ -1,6 +1,10 @@
-#[cfg(all(unix, feature = "wayland"))]
+#[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"))]
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 pub mod x11;

src/backend/producer/libei.rs

@@ -0,0 +1,31 @@
+use anyhow::Result;
+use std::{io, task::Poll};
+
+use futures_core::Stream;
+
+use crate::{client::ClientHandle, event::Event, producer::EventProducer};
+
+pub struct LibeiProducer {}
+
+impl LibeiProducer {
+    pub fn new() -> Result<Self> {
+        Ok(Self {})
+    }
+}
+
+impl EventProducer for LibeiProducer {
+    fn notify(&mut self, _event: crate::client::ClientEvent) {}
+
+    fn release(&mut self) {}
+}
+
+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
+    }
+}

src/backend/producer/macos.rs

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

src/backend/producer/wayland.rs

@@ -1,32 +1,46 @@
 use crate::{
-    client::{Client, ClientHandle, Position},
-    request,
+    client::{ClientEvent, ClientHandle, Position},
+    producer::EventProducer,
 };
 
+use anyhow::{anyhow, Result};
+use futures_core::Stream;
 use memmap::MmapOptions;
+use std::{
+    collections::VecDeque,
+    env,
+    io::{self, ErrorKind},
+    os::fd::{OwnedFd, RawFd},
+    pin::Pin,
+    task::{ready, Context, Poll},
+};
+use tokio::io::unix::AsyncFd;
 
 use std::{
     fs::File,
     io::{BufWriter, Write},
     os::unix::prelude::{AsRawFd, FromRawFd},
     rc::Rc,
-    sync::mpsc::SyncSender,
-    thread,
-    time::Duration,
 };
 
-use wayland_protocols::wp::{
-    keyboard_shortcuts_inhibit::zv1::client::{
-        zwp_keyboard_shortcuts_inhibit_manager_v1::ZwpKeyboardShortcutsInhibitManagerV1,
-        zwp_keyboard_shortcuts_inhibitor_v1::ZwpKeyboardShortcutsInhibitorV1,
+use wayland_protocols::{
+    wp::{
+        keyboard_shortcuts_inhibit::zv1::client::{
+            zwp_keyboard_shortcuts_inhibit_manager_v1::ZwpKeyboardShortcutsInhibitManagerV1,
+            zwp_keyboard_shortcuts_inhibitor_v1::ZwpKeyboardShortcutsInhibitorV1,
+        },
+        pointer_constraints::zv1::client::{
+            zwp_locked_pointer_v1::ZwpLockedPointerV1,
+            zwp_pointer_constraints_v1::{Lifetime, ZwpPointerConstraintsV1},
+        },
+        relative_pointer::zv1::client::{
+            zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
+            zwp_relative_pointer_v1::{self, ZwpRelativePointerV1},
+        },
     },
-    pointer_constraints::zv1::client::{
-        zwp_locked_pointer_v1::ZwpLockedPointerV1,
-        zwp_pointer_constraints_v1::{Lifetime, ZwpPointerConstraintsV1},
-    },
-    relative_pointer::zv1::client::{
-        zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
-        zwp_relative_pointer_v1::{self, ZwpRelativePointerV1},
+    xdg::xdg_output::zv1::client::{
+        zxdg_output_manager_v1::ZxdgOutputManagerV1,
+        zxdg_output_v1::{self, ZxdgOutputV1},
     },
 };
 
@@ -36,14 +50,15 @@ use wayland_protocols_wlr::layer_shell::v1::client::{
 };
 
 use wayland_client::{
-    backend::WaylandError,
+    backend::{ReadEventsGuard, WaylandError},
     delegate_noop,
     globals::{registry_queue_init, GlobalListContents},
     protocol::{
-        wl_buffer, wl_compositor, wl_keyboard, wl_pointer, wl_region, wl_registry, wl_seat, wl_shm,
-        wl_shm_pool, wl_surface,
+        wl_buffer, wl_compositor, wl_keyboard,
+        wl_output::{self, WlOutput},
+        wl_pointer, wl_region, wl_registry, wl_seat, wl_shm, wl_shm_pool, wl_surface,
     },
-    Connection, Dispatch, DispatchError, QueueHandle, WEnum,
+    Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
 };
 
 use tempfile;
@@ -58,21 +73,54 @@ struct Globals {
     seat: wl_seat::WlSeat,
     shm: wl_shm::WlShm,
     layer_shell: ZwlrLayerShellV1,
+    outputs: Vec<wl_output::WlOutput>,
+    xdg_output_manager: ZxdgOutputManagerV1,
 }
 
-struct App {
-    running: bool,
+#[derive(Debug, Clone)]
+struct OutputInfo {
+    name: String,
+    position: (i32, i32),
+    size: (i32, i32),
+}
+
+impl OutputInfo {
+    fn new() -> Self {
+        Self {
+            name: "".to_string(),
+            position: (0, 0),
+            size: (0, 0),
+        }
+    }
+}
+
+struct State {
     pointer_lock: Option<ZwpLockedPointerV1>,
     rel_pointer: Option<ZwpRelativePointerV1>,
     shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
     client_for_window: Vec<(Rc<Window>, ClientHandle)>,
     focused: Option<(Rc<Window>, ClientHandle)>,
     g: Globals,
-    tx: SyncSender<(Event, ClientHandle)>,
-    server: request::Server,
+    wayland_fd: OwnedFd,
+    read_guard: Option<ReadEventsGuard>,
     qh: QueueHandle<Self>,
+    pending_events: VecDeque<(ClientHandle, Event)>,
+    output_info: Vec<(WlOutput, OutputInfo)>,
 }
 
+struct Inner {
+    state: State,
+    queue: EventQueue<State>,
+}
+
+impl AsRawFd for Inner {
+    fn as_raw_fd(&self) -> RawFd {
+        self.state.wayland_fd.as_raw_fd()
+    }
+}
+
+pub struct WaylandEventProducer(AsyncFd<Inner>);
+
 struct Window {
     buffer: wl_buffer::WlBuffer,
     surface: wl_surface::WlSurface,
@@ -80,8 +128,19 @@ struct Window {
 }
 
 impl Window {
-    fn new(g: &Globals, qh: &QueueHandle<App>, pos: Position) -> Window {
-        let (width, height) = (1, 1440);
+    fn new(
+        state: &State,
+        qh: &QueueHandle<State>,
+        output: &WlOutput,
+        pos: Position,
+        size: (i32, i32),
+    ) -> Window {
+        let g = &state.g;
+
+        let (width, height) = match pos {
+            Position::Left | Position::Right => (1, size.1 as u32),
+            Position::Top | Position::Bottom => (size.0 as u32, 1),
+        };
         let mut file = tempfile::tempfile().unwrap();
         draw(&mut file, (width, height));
         let pool = g
@@ -100,8 +159,8 @@ impl Window {
 
         let layer_surface = g.layer_shell.get_layer_surface(
             &surface,
-            None,
-            Layer::Top,
+            Some(&output),
+            Layer::Overlay,
             "LAN Mouse Sharing".into(),
             qh,
             (),
@@ -114,8 +173,8 @@ impl Window {
         };
 
         layer_surface.set_anchor(anchor);
-        layer_surface.set_size(1, 1440);
-        layer_surface.set_exclusive_zone(0);
+        layer_surface.set_size(width, height);
+        layer_surface.set_exclusive_zone(-1);
         layer_surface.set_margin(0, 0, 0, 0);
         surface.set_input_region(None);
         surface.commit();
@@ -127,96 +186,208 @@ impl Window {
     }
 }
 
-pub fn run(tx: SyncSender<(Event, ClientHandle)>, server: request::Server, clients: Vec<Client>) {
-    let conn = Connection::connect_to_env().expect("could not connect to wayland compositor");
-    let (g, mut queue) =
-        registry_queue_init::<App>(&conn).expect("failed to initialize wl_registry");
-    let qh = queue.handle();
-
-    let compositor: wl_compositor::WlCompositor = g
-        .bind(&qh, 4..=5, ())
-        .expect("wl_compositor >= v4 not supported");
-    let shm: wl_shm::WlShm = g.bind(&qh, 1..=1, ()).expect("wl_shm v1 not supported");
-    let layer_shell: ZwlrLayerShellV1 = g
-        .bind(&qh, 3..=4, ())
-        .expect("zwlr_layer_shell_v1 >= v3 not supported - required to display a surface at the edge of the screen");
-    let seat: wl_seat::WlSeat = g.bind(&qh, 7..=8, ()).expect("wl_seat >= v7 not supported");
-    let pointer_constraints: ZwpPointerConstraintsV1 = g
-        .bind(&qh, 1..=1, ())
-        .expect("zwp_pointer_constraints_v1 not supported");
-    let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
-        .bind(&qh, 1..=1, ())
-        .expect("zwp_relative_pointer_manager_v1 not supported");
-    let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 = g
-        .bind(&qh, 1..=1, ())
-        .expect("zwp_keyboard_shortcuts_inhibit_manager_v1 not supported");
-
-    let g = Globals {
-        compositor,
-        shm,
-        layer_shell,
-        seat,
-        pointer_constraints,
-        relative_pointer_manager,
-        shortcut_inhibit_manager,
-    };
-
-    let client_for_window = Vec::new();
-
-    let mut app = App {
-        running: true,
-        g,
-        pointer_lock: None,
-        rel_pointer: None,
-        shortcut_inhibitor: None,
-        client_for_window,
-        focused: None,
-        tx,
-        server,
-        qh,
-    };
-
-    for client in clients {
-        app.add_client(client.handle, client.pos);
+impl Drop for Window {
+    fn drop(&mut self) {
+        log::debug!("destroying window!");
+        self.layer_surface.destroy();
+        self.surface.destroy();
+        self.buffer.destroy();
     }
+}
 
-    while app.running {
-        match queue.blocking_dispatch(&mut app) {
-            Ok(_) => {}
-            Err(DispatchError::Backend(WaylandError::Io(e))) => {
-                eprintln!("Wayland Error: {}", e);
-                thread::sleep(Duration::from_millis(500));
-            }
-            Err(DispatchError::Backend(e)) => {
-                panic!("{}", e);
-            }
-            Err(DispatchError::BadMessage {
-                sender_id,
-                interface,
-                opcode,
-            }) => {
-                panic!("bad message {}, {} , {}", sender_id, interface, opcode);
-            }
-        }
-    }
+fn get_edges(outputs: &[(WlOutput, OutputInfo)], pos: Position) -> Vec<(WlOutput, i32)> {
+    outputs
+        .iter()
+        .map(|(o, i)| {
+            (
+                o.clone(),
+                match pos {
+                    Position::Left => i.position.0,
+                    Position::Right => i.position.0 + i.size.0,
+                    Position::Top => i.position.1,
+                    Position::Bottom => i.position.1 + i.size.1,
+                },
+            )
+        })
+        .collect()
+}
+
+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);
+    let opposite_edges = get_edges(&state.output_info, pos.opposite());
+
+    // remove those edges that are at the same position
+    // as an opposite edge of a different output
+    let outputs: Vec<WlOutput> = edges
+        .iter()
+        .filter(|(_, edge)| {
+            opposite_edges
+                .iter()
+                .map(|(_, e)| *e)
+                .find(|e| e == edge)
+                .is_none()
+        })
+        .map(|(o, _)| o.clone())
+        .collect();
+    state
+        .output_info
+        .iter()
+        .filter(|(o, _)| outputs.contains(o))
+        .map(|(o, i)| (o.clone(), i.clone()))
+        .collect()
 }
 
 fn draw(f: &mut File, (width, height): (u32, u32)) {
     let mut buf = BufWriter::new(f);
     for _ in 0..height {
         for _ in 0..width {
-            buf.write_all(&0x44FbF1C7u32.to_ne_bytes()).unwrap();
+            if env::var("LM_DEBUG_LAYER_SHELL").ok().is_some() {
+                // AARRGGBB
+                buf.write_all(&0xFF11d116u32.to_ne_bytes()).unwrap();
+            } else {
+                // AARRGGBB
+                buf.write_all(&0x00000000u32.to_ne_bytes()).unwrap();
+            }
         }
     }
 }
 
-impl App {
+impl WaylandEventProducer {
+    pub fn new() -> Result<Self> {
+        let conn = match Connection::connect_to_env() {
+            Ok(c) => c,
+            Err(e) => return Err(anyhow!("could not connect to wayland compositor: {e:?}")),
+        };
+
+        let (g, mut queue) = match registry_queue_init::<State>(&conn) {
+            Ok(q) => q,
+            Err(e) => return Err(anyhow!("failed to initialize wl_registry: {e:?}")),
+        };
+
+        let qh = queue.handle();
+
+        let compositor: wl_compositor::WlCompositor = match g.bind(&qh, 4..=5, ()) {
+            Ok(compositor) => compositor,
+            Err(_) => return Err(anyhow!("wl_compositor >= v4 not supported")),
+        };
+
+        let xdg_output_manager: ZxdgOutputManagerV1 = match g.bind(&qh, 1..=3, ()) {
+            Ok(xdg_output_manager) => xdg_output_manager,
+            Err(_) => return Err(anyhow!("xdg_output not supported!")),
+        };
+
+        let shm: wl_shm::WlShm = match g.bind(&qh, 1..=1, ()) {
+            Ok(wl_shm) => wl_shm,
+            Err(_) => return Err(anyhow!("wl_shm v1 not supported")),
+        };
+
+        let layer_shell: ZwlrLayerShellV1 = match g.bind(&qh, 3..=4, ()) {
+            Ok(layer_shell) => layer_shell,
+            Err(_) => return Err(anyhow!("zwlr_layer_shell_v1 >= v3 not supported - required to display a surface at the edge of the screen")),
+        };
+
+        let seat: wl_seat::WlSeat = match g.bind(&qh, 7..=8, ()) {
+            Ok(wl_seat) => wl_seat,
+            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
+        };
+
+        let pointer_constraints: ZwpPointerConstraintsV1 = match g.bind(&qh, 1..=1, ()) {
+            Ok(pointer_constraints) => pointer_constraints,
+            Err(_) => return Err(anyhow!("zwp_pointer_constraints_v1 not supported")),
+        };
+
+        let relative_pointer_manager: ZwpRelativePointerManagerV1 = match g.bind(&qh, 1..=1, ()) {
+            Ok(relative_pointer_manager) => relative_pointer_manager,
+            Err(_) => return Err(anyhow!("zwp_relative_pointer_manager_v1 not supported")),
+        };
+
+        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 =
+            match g.bind(&qh, 1..=1, ()) {
+                Ok(shortcut_inhibit_manager) => shortcut_inhibit_manager,
+                Err(_) => {
+                    return Err(anyhow!(
+                        "zwp_keyboard_shortcuts_inhibit_manager_v1 not supported"
+                    ))
+                }
+            };
+
+        let outputs = vec![];
+
+        let g = Globals {
+            compositor,
+            shm,
+            layer_shell,
+            seat,
+            pointer_constraints,
+            relative_pointer_manager,
+            shortcut_inhibit_manager,
+            outputs,
+            xdg_output_manager,
+        };
+
+        // flush outgoing events
+        queue.flush()?;
+
+        // prepare reading wayland events
+        let read_guard = queue.prepare_read()?;
+        let wayland_fd = read_guard.connection_fd().try_clone_to_owned().unwrap();
+        std::mem::drop(read_guard);
+
+        let mut state = State {
+            g,
+            pointer_lock: None,
+            rel_pointer: None,
+            shortcut_inhibitor: None,
+            client_for_window: Vec::new(),
+            focused: None,
+            qh,
+            wayland_fd,
+            read_guard: None,
+            pending_events: VecDeque::new(),
+            output_info: vec![],
+        };
+
+        // dispatch registry to () again, in order to read all wl_outputs
+        conn.display().get_registry(&state.qh, ());
+        log::debug!("==============> requested registry");
+
+        // roundtrip to read wl_output globals
+        queue.roundtrip(&mut state)?;
+        log::debug!("==============> roundtrip 1 done");
+
+        // read outputs
+        for output in state.g.outputs.iter() {
+            state
+                .g
+                .xdg_output_manager
+                .get_xdg_output(output, &state.qh, output.clone());
+        }
+
+        // roundtrip to read xdg_output events
+        queue.roundtrip(&mut state)?;
+
+        log::debug!("==============> roundtrip 2 done");
+        for i in &state.output_info {
+            log::debug!("{:#?}", i.1);
+        }
+
+        let read_guard = queue.prepare_read()?;
+        state.read_guard = Some(read_guard);
+
+        let inner = AsyncFd::new(Inner { queue, state })?;
+
+        Ok(WaylandEventProducer(inner))
+    }
+}
+
+impl State {
     fn grab(
         &mut self,
         surface: &wl_surface::WlSurface,
         pointer: &wl_pointer::WlPointer,
         serial: u32,
-        qh: &QueueHandle<App>,
+        qh: &QueueHandle<State>,
     ) {
         let (window, _) = self.focused.as_ref().unwrap();
 
@@ -235,7 +406,7 @@ impl App {
                 surface,
                 pointer,
                 None,
-                Lifetime::Oneshot,
+                Lifetime::Persistent,
                 qh,
                 (),
             ));
@@ -263,7 +434,10 @@ impl App {
 
     fn ungrab(&mut self) {
         // get focused client
-        let (window, _client) = self.focused.as_ref().unwrap();
+        let (window, _client) = match self.focused.as_ref() {
+            Some(focused) => focused,
+            None => return,
+        };
 
         // ungrab surface
         window
@@ -271,7 +445,7 @@ impl App {
             .set_keyboard_interactivity(KeyboardInteractivity::None);
         window.surface.commit();
 
-        // release pointer
+        // destroy pointer lock
         if let Some(pointer_lock) = &self.pointer_lock {
             pointer_lock.destroy();
             self.pointer_lock = None;
@@ -283,7 +457,7 @@ impl App {
             self.rel_pointer = None;
         }
 
-        // release shortcut inhibitor
+        // destroy shortcut inhibitor
         if let Some(shortcut_inhibitor) = &self.shortcut_inhibitor {
             shortcut_inhibitor.destroy();
             self.shortcut_inhibitor = None;
@@ -291,12 +465,158 @@ impl App {
     }
 
     fn add_client(&mut self, client: ClientHandle, pos: Position) {
-        let window = Rc::new(Window::new(&self.g, &self.qh, pos));
-        self.client_for_window.push((window, client));
+        let outputs = get_output_configuration(self, pos);
+
+        outputs.iter().for_each(|(o, i)| {
+            let window = Window::new(&self, &self.qh, &o, pos, i.size);
+            let window = Rc::new(window);
+            self.client_for_window.push((window, client));
+        });
     }
 }
 
-impl Dispatch<wl_seat::WlSeat, ()> for App {
+impl Inner {
+    fn read(&mut self) -> bool {
+        match self.state.read_guard.take().unwrap().read() {
+            Ok(_) => true,
+            Err(WaylandError::Io(e)) if e.kind() == ErrorKind::WouldBlock => false,
+            Err(WaylandError::Io(e)) => {
+                log::error!("error reading from wayland socket: {e}");
+                false
+            }
+            Err(WaylandError::Protocol(e)) => {
+                panic!("wayland protocol violation: {e}")
+            }
+        }
+    }
+
+    fn prepare_read(&mut self) {
+        match self.queue.prepare_read() {
+            Ok(r) => self.state.read_guard = Some(r),
+            Err(WaylandError::Io(e)) => {
+                log::error!("error preparing read from wayland socket: {e}")
+            }
+            Err(WaylandError::Protocol(e)) => {
+                panic!("wayland Protocol violation: {e}")
+            }
+        };
+    }
+
+    fn dispatch_events(&mut self) {
+        match self.queue.dispatch_pending(&mut self.state) {
+            Ok(_) => {}
+            Err(DispatchError::Backend(WaylandError::Io(e))) => {
+                log::error!("Wayland Error: {}", e);
+            }
+            Err(DispatchError::Backend(e)) => {
+                panic!("backend error: {}", e);
+            }
+            Err(DispatchError::BadMessage {
+                sender_id,
+                interface,
+                opcode,
+            }) => {
+                panic!("bad message {}, {} , {}", sender_id, interface, opcode);
+            }
+        }
+    }
+
+    fn flush_events(&mut self) {
+        // flush outgoing events
+        match self.queue.flush() {
+            Ok(_) => (),
+            Err(e) => match e {
+                WaylandError::Io(e) => {
+                    log::error!("error writing to wayland socket: {e}")
+                }
+                WaylandError::Protocol(e) => {
+                    panic!("wayland protocol violation: {e}")
+                }
+            },
+        }
+    }
+}
+
+impl EventProducer for WaylandEventProducer {
+    fn notify(&mut self, client_event: ClientEvent) {
+        match client_event {
+            ClientEvent::Create(handle, pos) => {
+                self.0.get_mut().state.add_client(handle, pos);
+            }
+            ClientEvent::Destroy(handle) => {
+                let inner = self.0.get_mut();
+                loop {
+                    // remove all windows corresponding to this client
+                    if let Some(i) = inner
+                        .state
+                        .client_for_window
+                        .iter()
+                        .position(|(_, c)| *c == handle)
+                    {
+                        inner.state.client_for_window.remove(i);
+                        inner.state.focused = None;
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+        let inner = self.0.get_mut();
+        inner.flush_events();
+    }
+
+    fn release(&mut self) {
+        let inner = self.0.get_mut();
+        inner.state.ungrab();
+        inner.flush_events();
+    }
+}
+
+impl Stream for WaylandEventProducer {
+    type Item = io::Result<(ClientHandle, Event)>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        log::trace!("producer.next()");
+        if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
+            return Poll::Ready(Some(Ok(event)));
+        }
+
+        loop {
+            let mut guard = ready!(self.0.poll_read_ready_mut(cx))?;
+
+            {
+                let inner = guard.get_inner_mut();
+
+                // read events
+                while inner.read() {
+                    // prepare next read
+                    inner.prepare_read();
+                }
+
+                // dispatch the events
+                inner.dispatch_events();
+
+                // flush outgoing events
+                inner.flush_events();
+
+                // prepare for the next read
+                inner.prepare_read();
+            }
+
+            // clear read readiness for tokio read guard
+            // guard.clear_ready_matching(Ready::READABLE);
+            guard.clear_ready();
+
+            // if an event has been queued during dispatch_events() we return it
+            match guard.get_inner_mut().state.pending_events.pop_front() {
+                Some(event) => return Poll::Ready(Some(Ok(event))),
+                None => continue,
+            }
+        }
+    }
+}
+
+impl Dispatch<wl_seat::WlSeat, ()> for State {
     fn event(
         _: &mut Self,
         seat: &wl_seat::WlSeat,
@@ -319,7 +639,7 @@ impl Dispatch<wl_seat::WlSeat, ()> for App {
     }
 }
 
-impl Dispatch<wl_pointer::WlPointer, ()> for App {
+impl Dispatch<wl_pointer::WlPointer, ()> for State {
     fn event(
         app: &mut Self,
         pointer: &wl_pointer::WlPointer,
@@ -336,22 +656,24 @@ impl Dispatch<wl_pointer::WlPointer, ()> for App {
                 surface_y: _,
             } => {
                 // get client corresponding to the focused surface
-
                 {
-                    let (window, client) = app
+                    if let Some((window, client)) = app
                         .client_for_window
                         .iter()
                         .find(|(w, _c)| w.surface == surface)
-                        .unwrap();
-                    app.focused = Some((window.clone(), *client));
-                    app.grab(&surface, pointer, serial.clone(), qh);
+                    {
+                        app.focused = Some((window.clone(), *client));
+                        app.grab(&surface, pointer, serial.clone(), qh);
+                    } else {
+                        return;
+                    }
                 }
                 let (_, client) = app
                     .client_for_window
                     .iter()
                     .find(|(w, _c)| w.surface == surface)
                     .unwrap();
-                app.tx.send((Event::Release(), *client)).unwrap();
+                app.pending_events.push_back((*client, Event::Release()));
             }
             wl_pointer::Event::Leave { .. } => {
                 app.ungrab();
@@ -363,42 +685,37 @@ impl Dispatch<wl_pointer::WlPointer, ()> for App {
                 state,
             } => {
                 let (_, client) = app.focused.as_ref().unwrap();
-                app.tx
-                    .send((
-                        Event::Pointer(PointerEvent::Button {
-                            time,
-                            button,
-                            state: u32::from(state),
-                        }),
-                        *client,
-                    ))
-                    .unwrap();
+                app.pending_events.push_back((
+                    *client,
+                    Event::Pointer(PointerEvent::Button {
+                        time,
+                        button,
+                        state: u32::from(state),
+                    }),
+                ));
             }
             wl_pointer::Event::Axis { time, axis, value } => {
                 let (_, client) = app.focused.as_ref().unwrap();
-                app.tx
-                    .send((
-                        Event::Pointer(PointerEvent::Axis {
-                            time,
-                            axis: u32::from(axis) as u8,
-                            value,
-                        }),
-                        *client,
-                    ))
-                    .unwrap();
+                app.pending_events.push_back((
+                    *client,
+                    Event::Pointer(PointerEvent::Axis {
+                        time,
+                        axis: u32::from(axis) as u8,
+                        value,
+                    }),
+                ));
             }
             wl_pointer::Event::Frame {} => {
-                let (_, client) = app.focused.as_ref().unwrap();
-                app.tx
-                    .send((Event::Pointer(PointerEvent::Frame {}), *client))
-                    .unwrap();
+                // TODO properly handle frame events
+                // we simply insert a frame event on the client side
+                // after each event for now
             }
             _ => {}
         }
     }
 }
 
-impl Dispatch<wl_keyboard::WlKeyboard, ()> for App {
+impl Dispatch<wl_keyboard::WlKeyboard, ()> for State {
     fn event(
         app: &mut Self,
         _: &wl_keyboard::WlKeyboard,
@@ -419,16 +736,14 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for App {
                 state,
             } => {
                 if let Some(client) = client {
-                    app.tx
-                        .send((
-                            Event::Keyboard(KeyboardEvent::Key {
-                                time,
-                                key,
-                                state: u32::from(state) as u8,
-                            }),
-                            *client,
-                        ))
-                        .unwrap();
+                    app.pending_events.push_back((
+                        *client,
+                        Event::Keyboard(KeyboardEvent::Key {
+                            time,
+                            key,
+                            state: u32::from(state) as u8,
+                        }),
+                    ));
                 }
             }
             wl_keyboard::Event::Modifiers {
@@ -439,17 +754,15 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for App {
                 group,
             } => {
                 if let Some(client) = client {
-                    app.tx
-                        .send((
-                            Event::Keyboard(KeyboardEvent::Modifiers {
-                                mods_depressed,
-                                mods_latched,
-                                mods_locked,
-                                group,
-                            }),
-                            *client,
-                        ))
-                        .unwrap();
+                    app.pending_events.push_back((
+                        *client,
+                        Event::Keyboard(KeyboardEvent::Modifiers {
+                            mods_depressed,
+                            mods_latched,
+                            mods_locked,
+                            group,
+                        }),
+                    ));
                 }
                 if mods_depressed == 77 {
                     // ctrl shift super alt
@@ -462,15 +775,15 @@ impl Dispatch<wl_keyboard::WlKeyboard, ()> for App {
                 size: _,
             } => {
                 let fd = unsafe { &File::from_raw_fd(fd.as_raw_fd()) };
-                let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
-                app.server.offer_data(request::Request::KeyMap, mmap);
+                let _mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
+                // TODO keymap
             }
             _ => (),
         }
     }
 }
 
-impl Dispatch<ZwpRelativePointerV1, ()> for App {
+impl Dispatch<ZwpRelativePointerV1, ()> for State {
     fn event(
         app: &mut Self,
         _: &ZwpRelativePointerV1,
@@ -490,22 +803,20 @@ impl Dispatch<ZwpRelativePointerV1, ()> for App {
         {
             if let Some((_window, client)) = &app.focused {
                 let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
-                app.tx
-                    .send((
-                        Event::Pointer(PointerEvent::Motion {
-                            time,
-                            relative_x: surface_x,
-                            relative_y: surface_y,
-                        }),
-                        *client,
-                    ))
-                    .unwrap();
+                app.pending_events.push_back((
+                    *client,
+                    Event::Pointer(PointerEvent::Motion {
+                        time,
+                        relative_x: surface_x,
+                        relative_y: surface_y,
+                    }),
+                ));
             }
         }
     }
 }
 
-impl Dispatch<ZwlrLayerSurfaceV1, ()> for App {
+impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
     fn event(
         app: &mut Self,
         layer_surface: &ZwlrLayerSurfaceV1,
@@ -515,25 +826,24 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for App {
         _: &QueueHandle<Self>,
     ) {
         if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
-            let (window, _client) = app
+            if let Some((window, _client)) = app
                 .client_for_window
                 .iter()
                 .find(|(w, _c)| &w.layer_surface == layer_surface)
-                .unwrap();
-            // client corresponding to the layer_surface
-            let surface = &window.surface;
-            let buffer = &window.buffer;
-            surface.commit();
-            layer_surface.ack_configure(serial);
-            surface.attach(Some(&buffer), 0, 0);
-            surface.commit();
+            {
+                // client corresponding to the layer_surface
+                let surface = &window.surface;
+                let buffer = &window.buffer;
+                surface.attach(Some(&buffer), 0, 0);
+                layer_surface.ack_configure(serial);
+                surface.commit();
+            }
         }
     }
 }
 
 // delegate wl_registry events to App itself
-// delegate_dispatch!(App: [wl_registry::WlRegistry: GlobalListContents] => App);
-impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for App {
+impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
     fn event(
         _state: &mut Self,
         _proxy: &wl_registry::WlRegistry,
@@ -545,18 +855,86 @@ impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for App {
     }
 }
 
+impl Dispatch<wl_registry::WlRegistry, ()> for State {
+    fn event(
+        state: &mut Self,
+        registry: &wl_registry::WlRegistry,
+        event: <wl_registry::WlRegistry as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        qh: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_registry::Event::Global {
+                name,
+                interface,
+                version: _,
+            } => match interface.as_str() {
+                "wl_output" => {
+                    log::debug!("wl_output global");
+                    state
+                        .g
+                        .outputs
+                        .push(registry.bind::<wl_output::WlOutput, _, _>(name, 4, qh, ()))
+                }
+                _ => {}
+            },
+            wl_registry::Event::GlobalRemove { .. } => {}
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<ZxdgOutputV1, WlOutput> for State {
+    fn event(
+        state: &mut Self,
+        _: &ZxdgOutputV1,
+        event: <ZxdgOutputV1 as wayland_client::Proxy>::Event,
+        wl_output: &WlOutput,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        log::debug!("xdg-output - {event:?}");
+        let output_info = match state.output_info.iter_mut().find(|(o, _)| o == wl_output) {
+            Some((_, c)) => c,
+            None => {
+                let output_info = OutputInfo::new();
+                state.output_info.push((wl_output.clone(), output_info));
+                &mut state.output_info.last_mut().unwrap().1
+            }
+        };
+
+        match event {
+            zxdg_output_v1::Event::LogicalPosition { x, y } => {
+                output_info.position = (x, y);
+            }
+            zxdg_output_v1::Event::LogicalSize { width, height } => {
+                output_info.size = (width, height);
+            }
+            zxdg_output_v1::Event::Done => {}
+            zxdg_output_v1::Event::Name { name } => {
+                output_info.name = name;
+            }
+            zxdg_output_v1::Event::Description { .. } => {}
+            _ => {}
+        }
+    }
+}
+
 // don't emit any events
-delegate_noop!(App: wl_region::WlRegion);
-delegate_noop!(App: wl_shm_pool::WlShmPool);
-delegate_noop!(App: wl_compositor::WlCompositor);
-delegate_noop!(App: ZwlrLayerShellV1);
-delegate_noop!(App: ZwpRelativePointerManagerV1);
-delegate_noop!(App: ZwpKeyboardShortcutsInhibitManagerV1);
-delegate_noop!(App: ZwpPointerConstraintsV1);
+delegate_noop!(State: wl_region::WlRegion);
+delegate_noop!(State: wl_shm_pool::WlShmPool);
+delegate_noop!(State: wl_compositor::WlCompositor);
+delegate_noop!(State: ZwlrLayerShellV1);
+delegate_noop!(State: ZwpRelativePointerManagerV1);
+delegate_noop!(State: ZwpKeyboardShortcutsInhibitManagerV1);
+delegate_noop!(State: ZwpPointerConstraintsV1);
 
 // ignore events
-delegate_noop!(App: ignore wl_shm::WlShm);
-delegate_noop!(App: ignore wl_buffer::WlBuffer);
-delegate_noop!(App: ignore wl_surface::WlSurface);
-delegate_noop!(App: ignore ZwpKeyboardShortcutsInhibitorV1);
-delegate_noop!(App: ignore ZwpLockedPointerV1);
+delegate_noop!(State: ignore wl_output::WlOutput);
+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 ZwpKeyboardShortcutsInhibitorV1);
+delegate_noop!(State: ignore ZwpLockedPointerV1);

src/backend/producer/windows.rs

@@ -1,11 +1,31 @@
-use std::sync::mpsc::SyncSender;
+use core::task::{Context, Poll};
+use futures::Stream;
+use std::io::Result;
+use std::pin::Pin;
 
 use crate::{
-    client::{Client, ClientHandle},
+    client::{ClientEvent, ClientHandle},
     event::Event,
-    request::Server,
+    producer::EventProducer,
 };
 
-pub fn run(_produce_tx: SyncSender<(Event, ClientHandle)>, _server: Server, _clients: Vec<Client>) {
-    todo!();
+pub struct WindowsProducer {}
+
+impl EventProducer for WindowsProducer {
+    fn notify(&mut self, _: ClientEvent) {}
+
+    fn release(&mut self) {}
+}
+
+impl WindowsProducer {
+    pub(crate) fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Stream for WindowsProducer {
+    type Item = Result<(ClientHandle, Event)>;
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
 }

src/backend/producer/x11.rs

@@ -1,9 +1,34 @@
-use std::sync::mpsc::SyncSender;
+use std::io;
+use std::task::Poll;
+
+use futures_core::Stream;
 
-use crate::client::Client;
 use crate::event::Event;
-use crate::request::Server;
+use crate::producer::EventProducer;
 
-pub fn run(_produce_tx: SyncSender<(Event, u32)>, _request_server: Server, _clients: Vec<Client>) {
-    todo!()
+use crate::client::{ClientEvent, ClientHandle};
+
+pub struct X11Producer {}
+
+impl X11Producer {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl EventProducer for X11Producer {
+    fn notify(&mut self, _: ClientEvent) {}
+
+    fn release(&mut self) {}
+}
+
+impl Stream for X11Producer {
+    type Item = io::Result<(ClientHandle, Event)>;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
 }

src/client.rs

@@ -1,8 +1,13 @@
-use std::{net::SocketAddr, error::Error, fmt::Display, sync::{Arc, atomic::{AtomicBool, Ordering, AtomicU32}, RwLock}};
+use std::{
+    collections::HashSet,
+    fmt::Display,
+    net::{IpAddr, SocketAddr},
+    time::Instant,
+};
 
-use crate::{config::{self, DEFAULT_PORT}, dns};
+use serde::{Deserialize, Serialize};
 
-#[derive(Eq, Hash, PartialEq, Clone, Copy)]
+#[derive(Debug, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
 pub enum Position {
     Left,
     Right,
@@ -10,97 +15,179 @@ pub enum Position {
     Bottom,
 }
 
-#[derive(Clone, Copy)]
-pub struct Client {
-    pub addr: SocketAddr,
-    pub pos: Position,
-    pub handle: ClientHandle,
-}
-
-impl Client {
-    pub fn handle(&self) -> ClientHandle {
-        return self.handle;
+impl Default for Position {
+    fn default() -> Self {
+        Self::Left
     }
 }
 
-pub enum ClientEvent {
-    Create(Client),
-    Destroy(Client),
+impl Position {
+    pub fn opposite(&self) -> Self {
+        match self {
+            Position::Left => Self::Right,
+            Position::Right => Self::Left,
+            Position::Top => Self::Bottom,
+            Position::Bottom => Self::Top,
+        }
+    }
 }
 
-pub struct ClientManager {
-    next_id: AtomicU32,
-    clients: RwLock<Vec<Client>>,
-    subscribers: RwLock<Vec<Arc<AtomicBool>>>,
+impl Display for Position {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Position::Left => "left",
+                Position::Right => "right",
+                Position::Top => "top",
+                Position::Bottom => "bottom",
+            }
+        )
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
+pub struct Client {
+    /// hostname of this client
+    pub hostname: Option<String>,
+    /// unique handle to refer to the client.
+    /// This way any event consumer / producer backend does not
+    /// need to know anything about a client other than its handle.
+    pub handle: ClientHandle,
+    /// `active` address of the client, used to send data to.
+    /// This should generally be the socket address where data
+    /// was last received from.
+    pub active_addr: Option<SocketAddr>,
+    /// all socket addresses associated with a particular client
+    /// e.g. Laptops usually have at least an ethernet and a wifi port
+    /// which have different ip addresses
+    pub addrs: HashSet<SocketAddr>,
+    /// both active_addr and addrs can be None / empty so port needs to be stored seperately
+    pub port: u16,
+    /// position of a client on screen
+    pub pos: Position,
+}
+
+pub enum ClientEvent {
+    Create(ClientHandle, Position),
+    Destroy(ClientHandle),
 }
 
 pub type ClientHandle = u32;
 
-#[derive(Debug)]
-struct ClientConfigError;
-
-impl Display for ClientConfigError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "neither ip nor hostname specified")
-    }
+#[derive(Debug, Clone)]
+pub struct ClientState {
+    pub client: Client,
+    pub active: bool,
+    pub last_ping: Option<Instant>,
+    pub last_seen: Option<Instant>,
+    pub last_replied: Option<Instant>,
 }
 
-impl Error for ClientConfigError {}
+pub struct ClientManager {
+    clients: Vec<Option<ClientState>>, // HashMap likely not beneficial
+}
 
 impl ClientManager {
-    fn add_client(&self, client: &config::Client, pos: Position) -> Result<(), Box<dyn Error>> {
-        let ip = match client.ip {
-            Some(ip) => ip,
-            None => match &client.host_name {
-                Some(host_name) => dns::resolve(host_name)?,
-                None => return Err(Box::new(ClientConfigError{})),
-            },
-        };
-        let addr = SocketAddr::new(ip, client.port.unwrap_or(DEFAULT_PORT));
-        self.register_client(addr, pos);
-        Ok(())
+    pub fn new() -> Self {
+        Self { clients: vec![] }
     }
 
-    fn notify(&self) {
-        for subscriber in self.subscribers.read().unwrap().iter() {
-            subscriber.store(true, Ordering::SeqCst);
-        }
-    }
+    /// add a new client to this manager
+    pub fn add_client(
+        &mut self,
+        hostname: Option<String>,
+        addrs: HashSet<IpAddr>,
+        port: u16,
+        pos: Position,
+    ) -> ClientHandle {
+        // get a new client_handle
+        let handle = self.free_id();
 
-    fn new_id(&self) -> ClientHandle {
-        let id = self.next_id.load(Ordering::Acquire);
-        self.next_id.store(id + 1, Ordering::Release);
-        id as ClientHandle
-    }
+        // we dont know, which IP is initially active
+        let active_addr = None;
 
-    pub fn new(config: &config::Config) -> Result<Self, Box<dyn Error>> {
+        // map ip addresses to socket addresses
+        let addrs = HashSet::from_iter(addrs.into_iter().map(|ip| SocketAddr::new(ip, port)));
 
-        let client_manager = ClientManager {
-            next_id: AtomicU32::new(0),
-            clients: RwLock::new(Vec::new()),
-            subscribers: RwLock::new(vec![]),
+        // store the client
+        let client = Client {
+            hostname,
+            handle,
+            active_addr,
+            addrs,
+            port,
+            pos,
         };
 
-        // add clients from config
-        for (client, pos) in config.clients.iter() {
-            client_manager.add_client(&client, *pos)?;
+        // client was never seen, nor pinged
+        let client_state = ClientState {
+            client,
+            last_ping: None,
+            last_seen: None,
+            last_replied: None,
+            active: false,
+        };
+
+        if handle as usize >= self.clients.len() {
+            assert_eq!(handle as usize, self.clients.len());
+            self.clients.push(Some(client_state));
+        } else {
+            self.clients[handle as usize] = Some(client_state);
         }
-
-        Ok(client_manager)
+        handle
     }
 
-    pub fn register_client(&self, addr: SocketAddr, pos: Position) {
-        let handle = self.new_id();
-        let client = Client { addr, pos, handle };
-        self.clients.write().unwrap().push(client);
-        self.notify();
+    /// find a client by its address
+    pub fn get_client(&self, addr: SocketAddr) -> Option<ClientHandle> {
+        // since there shouldn't be more than a handful of clients at any given
+        // time this is likely faster than using a HashMap
+        self.clients
+            .iter()
+            .position(|c| {
+                if let Some(c) = c {
+                    c.active && c.client.addrs.contains(&addr)
+                } else {
+                    false
+                }
+            })
+            .map(|p| p as ClientHandle)
     }
 
-    pub fn get_clients(&self) -> Vec<Client> {
-        self.clients.read().unwrap().clone()
+    /// remove a client from the list
+    pub fn remove_client(&mut self, client: ClientHandle) -> Option<ClientState> {
+        // remove id from occupied ids
+        self.clients.get_mut(client as usize)?.take()
     }
 
-    pub fn subscribe(&self, subscriber: Arc<AtomicBool>) {
-        self.subscribers.write().unwrap().push(subscriber);
+    /// get a free slot in the client list
+    fn free_id(&mut self) -> ClientHandle {
+        for i in 0..u32::MAX {
+            if self.clients.get(i as usize).is_none()
+                || self.clients.get(i as usize).unwrap().is_none()
+            {
+                return i;
+            }
+        }
+        panic!("Out of client ids");
+    }
+
+    // returns an immutable reference to the client state corresponding to `client`
+    pub fn get<'a>(&'a self, client: ClientHandle) -> Option<&'a ClientState> {
+        self.clients.get(client as usize)?.as_ref()
+    }
+
+    /// returns a mutable reference to the client state corresponding to `client`
+    pub fn get_mut<'a>(&'a mut self, client: ClientHandle) -> Option<&'a mut ClientState> {
+        self.clients.get_mut(client as usize)?.as_mut()
+    }
+
+    pub fn enumerate(&self) -> Vec<(Client, bool)> {
+        self.clients
+            .iter()
+            .filter_map(|s| s.as_ref())
+            .map(|s| (s.client.clone(), s.active))
+            .collect()
     }
 }

src/config.rs

@@ -1,9 +1,10 @@
-use serde_derive::{Deserialize, Serialize};
-use core::fmt;
+use anyhow::Result;
+use clap::Parser;
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::env;
 use std::net::IpAddr;
 use std::{error::Error, fs};
-
-use std::env;
 use toml;
 
 use crate::client::Position;
@@ -13,7 +14,7 @@ pub const DEFAULT_PORT: u16 = 4242;
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ConfigToml {
     pub port: Option<u16>,
-    pub backend: Option<String>,
+    pub frontend: Option<String>,
     pub left: Option<Client>,
     pub right: Option<Client>,
     pub top: Option<Client>,
@@ -23,77 +24,108 @@ pub struct ConfigToml {
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct Client {
     pub host_name: Option<String>,
-    pub ip: Option<IpAddr>,
+    pub ips: Option<Vec<IpAddr>>,
     pub port: Option<u16>,
 }
 
-#[derive(Debug, Clone)]
-struct MissingParameter {
-    arg: &'static str,
-}
-
-impl fmt::Display for MissingParameter {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Missing a parameter for argument: {}", self.arg)
-    }
-}
-
-impl Error for MissingParameter {}
-
 impl ConfigToml {
     pub fn new(path: &str) -> Result<ConfigToml, Box<dyn Error>> {
         let config = fs::read_to_string(path)?;
+        log::info!("using config: \"{path}\"");
         Ok(toml::from_str::<_>(&config)?)
     }
 }
 
-fn find_arg(key: &'static str) -> Result<Option<String>, MissingParameter> {
-    let args: Vec<String> = env::args().collect();
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct CliArgs {
+    /// the listen port for lan-mouse
+    #[arg(short, long)]
+    port: Option<u16>,
 
-    for (i, arg) in args.iter().enumerate() {
-        if arg != key {
-            continue;
-        }
-        match args.get(i+1) {
-            None => return Err(MissingParameter { arg: key }),
-            Some(arg) => return Ok(Some(arg.clone())),
-        };
-    }
-    Ok(None)
+    /// the frontend to use [cli | gtk]
+    #[arg(short, long)]
+    frontend: Option<String>,
+
+    /// non-default config file location
+    #[arg(short, long)]
+    config: Option<String>,
+
+    /// run only the service as a daemon without the frontend
+    #[arg(short, long)]
+    daemon: bool,
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum Frontend {
+    Gtk,
+    Cli,
+}
+
+#[derive(Debug)]
 pub struct Config {
-    pub backend: Option<String>,
+    pub frontend: Frontend,
     pub port: u16,
     pub clients: Vec<(Client, Position)>,
+    pub daemon: bool,
 }
 
 impl Config {
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let config_path = "config.toml";
-        let config_toml = match ConfigToml::new(config_path) {
+    pub fn new() -> Result<Self> {
+        let args = CliArgs::parse();
+        let config_file = "config.toml";
+        #[cfg(unix)]
+        let config_path = {
+            let xdg_config_home =
+                env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
+            format!("{xdg_config_home}/lan-mouse/{config_file}")
+        };
+
+        #[cfg(not(unix))]
+        let config_path = {
+            let app_data =
+                env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
+            format!("{app_data}\\lan-mouse\\{config_file}")
+        };
+
+        // --config <file> overrules default location
+        let config_path = args.config.unwrap_or(config_path);
+
+        let config_toml = match ConfigToml::new(config_path.as_str()) {
             Err(e) => {
-                eprintln!("config.toml: {e}");
-                eprintln!("Continuing without config file ...");
+                log::error!("{config_path}: {e}");
+                log::warn!("Continuing without config file ...");
                 None
-            },
+            }
             Ok(c) => Some(c),
         };
 
-        let backend = match find_arg("--backend")? {
+        let frontend = match args.frontend {
             None => match &config_toml {
-                Some(c) => c.backend.clone(),
+                Some(c) => c.frontend.clone(),
                 None => None,
             },
-            backend => backend,
+            frontend => frontend,
         };
 
-        let port = match find_arg("--port")? {
-            Some(port) => port.parse::<u16>()?,
+        let frontend = match frontend {
+            #[cfg(all(unix, feature = "gtk"))]
+            None => Frontend::Gtk,
+            #[cfg(any(not(feature = "gtk"), not(unix)))]
+            None => Frontend::Cli,
+            Some(s) => match s.as_str() {
+                "cli" => Frontend::Cli,
+                "gtk" => Frontend::Gtk,
+                _ => Frontend::Cli,
+            },
+        };
+
+        let port = match args.port {
+            Some(port) => port,
             None => match &config_toml {
                 Some(c) => c.port.unwrap_or(DEFAULT_PORT),
                 None => DEFAULT_PORT,
-            }
+            },
         };
 
         let mut clients: Vec<(Client, Position)> = vec![];
@@ -113,6 +145,29 @@ impl Config {
             }
         }
 
-        Ok(Config { backend, clients, port })
+        let daemon = args.daemon;
+
+        Ok(Config {
+            daemon,
+            frontend,
+            clients,
+            port,
+        })
+    }
+
+    pub fn get_clients(&self) -> Vec<(HashSet<IpAddr>, Option<String>, u16, Position)> {
+        self.clients
+            .iter()
+            .map(|(c, p)| {
+                let port = c.port.unwrap_or(DEFAULT_PORT);
+                let ips: HashSet<IpAddr> = if let Some(ips) = c.ips.as_ref() {
+                    HashSet::from_iter(ips.iter().cloned())
+                } else {
+                    HashSet::new()
+                };
+                let host_name = c.host_name.clone();
+                (ips, host_name, port, *p)
+            })
+            .collect()
     }
 }

src/consumer.rs

@@ -1,11 +1,17 @@
-use std::{thread::{JoinHandle, self}, sync::mpsc::Receiver, error::Error};
+use async_trait::async_trait;
+use std::future;
 
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "macos")))]
 use std::env;
 
-use crate::{backend::consumer, client::{Client, ClientHandle}, event::Event};
+use crate::{
+    backend::consumer,
+    client::{ClientEvent, ClientHandle},
+    event::Event,
+};
+use anyhow::Result;
 
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "macos")))]
 #[derive(Debug)]
 enum Backend {
     Wlroots,
@@ -14,63 +20,103 @@ enum Backend {
     Libei,
 }
 
-pub fn start(consume_rx: Receiver<(Event, ClientHandle)>, clients: Vec<Client>, backend: Option<String>) -> Result<JoinHandle<()>, Box<dyn Error>> {
-    #[cfg(windows)]
-    let _backend = backend;
+#[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(())
+    }
 
-    Ok(thread::Builder::new()
-        .name("event consumer".into())
-        .spawn(move || {
-            #[cfg(windows)]
-            consumer::windows::run(consume_rx, clients);
-
-            #[cfg(unix)]
-            let backend = match env::var("XDG_SESSION_TYPE") {
-                Ok(session_type) => match session_type.as_str() {
-                    "x11" => Backend::X11,
-                    "wayland" => {
-                        match backend {
-                            Some(backend) => match backend.as_str() {
-                                "wlroots" => Backend::Wlroots,
-                                "libei" => Backend::Libei,
-                                "xdg_desktop_portal" => Backend::RemoteDesktopPortal,
-                                backend => panic!("invalid backend: {}", backend)
-                            }
-                            // default to wlroots backend for now
-                            _ => Backend::Wlroots,
-                        }
-                    }
-                    _ => panic!("unknown XDG_SESSION_TYPE"),
-                },
-                Err(_) => panic!("could not detect session type: XDG_SESSION_TYPE environment variable not set!"),
-            };
-
-            #[cfg(unix)]
-            match backend {
-                Backend::Libei => {
-                    #[cfg(not(feature = "libei"))]
-                    panic!("feature libei not enabled");
-                    #[cfg(feature = "libei")]
-                    consumer::libei::run(consume_rx, clients);
-                },
-                Backend::RemoteDesktopPortal => {
-                    #[cfg(not(feature = "xdg_desktop_portal"))]
-                    panic!("feature xdg_desktop_portal not enabled");
-                    #[cfg(feature = "xdg_desktop_portal")]
-                    consumer::xdg_desktop_portal::run(consume_rx, clients);
-                },
-                Backend::Wlroots => {
-                    #[cfg(not(feature = "wayland"))]
-                    panic!("feature wayland not enabled");
-                    #[cfg(feature = "wayland")]
-                    consumer::wlroots::run(consume_rx, clients);
-                },
-                Backend::X11 => {
-                    #[cfg(not(feature = "x11"))]
-                    panic!("feature x11 not enabled");
-                    #[cfg(feature = "x11")]
-                    consumer::x11::run(consume_rx, clients);
-                },
-            }
-        })?)
+    async fn destroy(&mut self);
+}
+
+pub async fn create() -> Result<Box<dyn EventConsumer>> {
+    #[cfg(windows)]
+    return Ok(Box::new(consumer::windows::WindowsConsumer::new()));
+
+    #[cfg(target_os = "macos")]
+    return Ok(Box::new(consumer::macos::MacOSConsumer::new()?));
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let backend = match env::var("XDG_SESSION_TYPE") {
+        Ok(session_type) => match session_type.as_str() {
+            "x11" => {
+                log::info!("XDG_SESSION_TYPE = x11 -> using x11 event consumer");
+                Backend::X11
+            }
+            "wayland" => {
+                log::info!("XDG_SESSION_TYPE = wayland -> using wayland event consumer");
+                match env::var("XDG_CURRENT_DESKTOP") {
+                    Ok(current_desktop) => match current_desktop.as_str() {
+                        "GNOME" => {
+                            log::info!("XDG_CURRENT_DESKTOP = GNOME -> using libei backend");
+                            Backend::Libei
+                        }
+                        "KDE" => {
+                            log::info!(
+                                "XDG_CURRENT_DESKTOP = KDE -> using xdg_desktop_portal backend"
+                            );
+                            Backend::RemoteDesktopPortal
+                        }
+                        "sway" => {
+                            log::info!("XDG_CURRENT_DESKTOP = sway -> using wlroots backend");
+                            Backend::Wlroots
+                        }
+                        "Hyprland" => {
+                            log::info!("XDG_CURRENT_DESKTOP = Hyprland -> using wlroots backend");
+                            Backend::Wlroots
+                        }
+                        _ => {
+                            log::warn!(
+                                "unknown XDG_CURRENT_DESKTOP -> defaulting to wlroots backend"
+                            );
+                            Backend::Wlroots
+                        }
+                    },
+                    // default to wlroots backend for now
+                    _ => {
+                        log::warn!("unknown XDG_CURRENT_DESKTOP -> defaulting to wlroots backend");
+                        Backend::Wlroots
+                    }
+                }
+            }
+            _ => panic!("unknown XDG_SESSION_TYPE"),
+        },
+        Err(_) => {
+            panic!("could not detect session type: XDG_SESSION_TYPE environment variable not set!")
+        }
+    };
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    match backend {
+        Backend::Libei => {
+            #[cfg(not(feature = "libei"))]
+            panic!("feature libei not enabled");
+            #[cfg(feature = "libei")]
+            Ok(Box::new(consumer::libei::LibeiConsumer::new().await?))
+        }
+        Backend::RemoteDesktopPortal => {
+            #[cfg(not(feature = "xdg_desktop_portal"))]
+            panic!("feature xdg_desktop_portal not enabled");
+            #[cfg(feature = "xdg_desktop_portal")]
+            Ok(Box::new(
+                consumer::xdg_desktop_portal::DesktopPortalConsumer::new().await?,
+            ))
+        }
+        Backend::Wlroots => {
+            #[cfg(not(feature = "wayland"))]
+            panic!("feature wayland not enabled");
+            #[cfg(feature = "wayland")]
+            Ok(Box::new(consumer::wlroots::WlrootsConsumer::new()?))
+        }
+        Backend::X11 => {
+            #[cfg(not(feature = "x11"))]
+            panic!("feature x11 not enabled");
+            #[cfg(feature = "x11")]
+            Ok(Box::new(consumer::x11::X11Consumer::new()))
+        }
+    }
 }

src/dns.rs

@@ -1,27 +1,23 @@
-use std::{error::Error, fmt::Display, net::IpAddr};
+use anyhow::Result;
+use std::{error::Error, net::IpAddr};
 
-use trust_dns_resolver::Resolver;
+use trust_dns_resolver::TokioAsyncResolver;
 
-#[derive(Debug, Clone)]
-struct InvalidConfigError;
-
-#[derive(Debug, Clone)]
-struct DnsError {
-    host: String,
+pub(crate) struct DnsResolver {
+    resolver: TokioAsyncResolver,
 }
+impl DnsResolver {
+    pub(crate) async fn new() -> Result<Self> {
+        let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
+        Ok(Self { resolver })
+    }
 
-impl Error for DnsError {}
-
-impl Display for DnsError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "couldn't resolve host \"{}\"", self.host)
-    }
-}
-
-pub fn resolve(host: &String) -> Result<IpAddr, Box<dyn Error>> {
-    let response = Resolver::from_system_conf()?.lookup_ip(host)?;
-    match response.iter().next() {
-        Some(ip) => Ok(ip),
-        None => Err(DnsError { host: host.clone() }.into()),
+    pub(crate) async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
+        log::info!("resolving {host} ...");
+        let response = self.resolver.lookup_ip(host).await?;
+        for ip in response.iter() {
+            log::info!("{host}: adding ip {ip}");
+        }
+        Ok(response.iter().collect())
     }
 }

src/event.rs

@@ -1,7 +1,14 @@
-use std::{error::Error, fmt};
+use std::{
+    error::Error,
+    fmt::{self, Display},
+};
 
-pub mod server;
+// FIXME
+pub(crate) const BTN_LEFT: u32 = 0x110;
+pub(crate) const BTN_RIGHT: u32 = 0x111;
+pub(crate) const BTN_MIDDLE: u32 = 0x112;
 
+#[derive(Debug, Clone, Copy)]
 pub enum PointerEvent {
     Motion {
         time: u32,
@@ -21,6 +28,7 @@ pub enum PointerEvent {
     Frame {},
 }
 
+#[derive(Debug, Clone, Copy)]
 pub enum KeyboardEvent {
     Key {
         time: u32,
@@ -35,14 +43,70 @@ pub enum KeyboardEvent {
     },
 }
 
+#[derive(Debug, Clone, Copy)]
 pub enum Event {
     Pointer(PointerEvent),
     Keyboard(KeyboardEvent),
     Release(),
+    Ping(),
+    Pong(),
 }
 
-unsafe impl Send for Event {}
-unsafe impl Sync for Event {}
+impl Display for PointerEvent {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            PointerEvent::Motion {
+                time: _,
+                relative_x,
+                relative_y,
+            } => write!(f, "motion({relative_x},{relative_y})"),
+            PointerEvent::Button {
+                time: _,
+                button,
+                state,
+            } => write!(f, "button({button}, {state})"),
+            PointerEvent::Axis {
+                time: _,
+                axis,
+                value,
+            } => write!(f, "scroll({axis}, {value})"),
+            PointerEvent::Frame {} => write!(f, "frame()"),
+        }
+    }
+}
+
+impl Display for KeyboardEvent {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            KeyboardEvent::Key {
+                time: _,
+                key,
+                state,
+            } => write!(f, "key({key}, {state})"),
+            KeyboardEvent::Modifiers {
+                mods_depressed,
+                mods_latched,
+                mods_locked,
+                group,
+            } => write!(
+                f,
+                "modifiers({mods_depressed},{mods_latched},{mods_locked},{group})"
+            ),
+        }
+    }
+}
+
+impl Display for Event {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Event::Pointer(p) => write!(f, "{}", p),
+            Event::Keyboard(k) => write!(f, "{}", k),
+            Event::Release() => write!(f, "release"),
+            Event::Ping() => write!(f, "ping"),
+            Event::Pong() => write!(f, "pong"),
+        }
+    }
+}
 
 impl Event {
     fn event_type(&self) -> EventType {
@@ -50,6 +114,8 @@ impl Event {
             Self::Pointer(_) => EventType::POINTER,
             Self::Keyboard(_) => EventType::KEYBOARD,
             Self::Release() => EventType::RELEASE,
+            Self::Ping() => EventType::PING,
+            Self::Pong() => EventType::PONG,
         }
     }
 }
@@ -88,6 +154,8 @@ enum EventType {
     POINTER,
     KEYBOARD,
     RELEASE,
+    PING,
+    PONG,
 }
 
 impl TryFrom<u8> for PointerEventType {
@@ -127,6 +195,8 @@ impl Into<Vec<u8>> for &Event {
             Event::Pointer(p) => p.into(),
             Event::Keyboard(k) => k.into(),
             Event::Release() => vec![],
+            Event::Ping() => vec![],
+            Event::Pong() => vec![],
         };
         vec![event_id, event_data].concat()
     }
@@ -153,6 +223,8 @@ impl TryFrom<Vec<u8>> for Event {
             i if i == (EventType::POINTER as u8) => Ok(Event::Pointer(value.try_into()?)),
             i if i == (EventType::KEYBOARD as u8) => Ok(Event::Keyboard(value.try_into()?)),
             i if i == (EventType::RELEASE as u8) => Ok(Event::Release()),
+            i if i == (EventType::PING as u8) => Ok(Event::Ping()),
+            i if i == (EventType::PONG as u8) => Ok(Event::Pong()),
             _ => Err(Box::new(ProtocolError {
                 msg: format!("invalid event_id {}", event_id),
             })),

src/event/server.rs

@@ -1,166 +0,0 @@
-use anyhow::Result;
-
-use std::{
-    collections::HashMap,
-    error::Error,
-    net::{SocketAddr, UdpSocket},
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc::{Receiver, SyncSender},
-        Arc,
-    },
-    thread::{self, JoinHandle},
-};
-
-use crate::{client::{ClientHandle, ClientManager}, ioutils::{ask_confirmation, ask_position}};
-
-use super::Event;
-
-pub struct Server {
-    listen_addr: SocketAddr,
-    sending: Arc<AtomicBool>,
-}
-
-impl Server {
-    pub fn new(port: u16) -> Result<Self, Box<dyn Error>> {
-        let listen_addr = SocketAddr::new("0.0.0.0".parse()?, port);
-        let sending = Arc::new(AtomicBool::new(false));
-        Ok(Server {
-            listen_addr,
-            sending,
-        })
-    }
-
-    pub fn run(
-        &self,
-        client_manager: Arc<ClientManager>,
-        produce_rx: Receiver<(Event, ClientHandle)>,
-        consume_tx: SyncSender<(Event, ClientHandle)>,
-    ) -> Result<(JoinHandle<Result<()>>, JoinHandle<Result<()>>), Box<dyn Error>> {
-        let udp_socket = UdpSocket::bind(self.listen_addr)?;
-        let rx = udp_socket.try_clone()?;
-        let tx = udp_socket;
-
-        let sending = self.sending.clone();
-        let clients_updated = Arc::new(AtomicBool::new(true));
-        client_manager.subscribe(clients_updated.clone());
-        let client_manager_clone = client_manager.clone();
-
-        let receiver = thread::Builder::new()
-            .name("event receiver".into())
-            .spawn(move || {
-                let mut client_for_socket = HashMap::new();
-
-                loop {
-                    let (event, addr) = match Server::receive_event(&rx) {
-                        Ok(e) => e,
-                        Err(e) => {
-                            eprintln!("{}", e);
-                            continue;
-                        }
-                    };
-
-                    if let Ok(_) = clients_updated.compare_exchange(
-                        true,
-                        false,
-                        Ordering::SeqCst,
-                        Ordering::SeqCst,
-                    ) {
-                        clients_updated.store(false, Ordering::SeqCst);
-                        client_for_socket.clear();
-                        println!("updating clients: ");
-                        for client in client_manager_clone.get_clients() {
-                            println!("{}: {}", client.handle, client.addr);
-                            client_for_socket.insert(client.addr, client.handle);
-                        }
-                    }
-
-                    let client_handle = match client_for_socket.get(&addr) {
-                        Some(c) => *c,
-                        None => {
-                            eprint!("Allow connection from {:?}? ", addr);
-                            if ask_confirmation(false)? {
-                                client_manager_clone.register_client(addr, ask_position()?);
-                            } else {
-                                eprintln!("rejecting client: {:?}?", addr);
-                            }
-                            continue;
-                        }
-                    };
-
-                    // There is a race condition between loading this
-                    // value and handling the event:
-                    // In the meantime a event could be produced, which
-                    // should theoretically disable receiving of events.
-                    //
-                    // This is however not a huge problem, as some
-                    // events that make it through are not a large problem
-                    if sending.load(Ordering::Acquire) {
-                        // ignore received events when in sending state
-                        // if release event is received, switch state to receiving
-                        if let Event::Release() = event {
-                            sending.store(false, Ordering::Release);
-                            consume_tx
-                                .send((event, client_handle))
-                                .expect("event consumer unavailable");
-                        }
-                    } else {
-                        if let Event::Release() = event {
-                            sending.store(false, Ordering::Release);
-                        }
-                        // we retrieve all events
-                        consume_tx
-                            .send((event, client_handle))
-                            .expect("event consumer unavailable");
-                    }
-                }
-            })?;
-
-        let sending = self.sending.clone();
-
-        let mut socket_for_client = HashMap::new();
-        for client in client_manager.get_clients() {
-            socket_for_client.insert(client.handle, client.addr);
-        }
-        let sender = thread::Builder::new()
-            .name("event sender".into())
-            .spawn(move || {
-                loop {
-                    let (event, client_handle) =
-                        produce_rx.recv().expect("event producer unavailable");
-                    let addr = match socket_for_client.get(&client_handle) {
-                        Some(addr) => addr,
-                        None => continue,
-                    };
-
-                    if sending.load(Ordering::Acquire) {
-                        Server::send_event(&tx, event, *addr);
-                    } else {
-                        // only accept enter event
-                        if let Event::Release() = event {
-                            // set state to sending, to ignore incoming events
-                            // and enable sending of events
-                            sending.store(true, Ordering::Release);
-                            Server::send_event(&tx, event, *addr);
-                        }
-                    }
-                }
-            })?;
-        Ok((receiver, sender))
-    }
-
-    fn send_event(tx: &UdpSocket, e: Event, addr: SocketAddr) {
-        let data: Vec<u8> = (&e).into();
-        if let Err(e) = tx.send_to(&data[..], addr) {
-            eprintln!("{}", e);
-        }
-    }
-
-    fn receive_event(rx: &UdpSocket) -> Result<(Event, SocketAddr), Box<dyn Error>> {
-        let mut buf = vec![0u8; 22];
-        match rx.recv_from(&mut buf) {
-            Ok((_amt, src)) => Ok((Event::try_from(buf)?, src)),
-            Err(e) => Err(Box::new(e)),
-        }
-    }
-}

src/frontend.rs

@@ -0,0 +1,273 @@
+use anyhow::{anyhow, Result};
+use std::{cmp::min, io::ErrorKind, str, time::Duration};
+
+#[cfg(unix)]
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+use tokio::io::ReadHalf;
+use tokio::io::{AsyncReadExt, AsyncWriteExt, WriteHalf};
+
+#[cfg(unix)]
+use tokio::net::UnixListener;
+#[cfg(unix)]
+use tokio::net::UnixStream;
+
+#[cfg(windows)]
+use tokio::net::TcpListener;
+#[cfg(windows)]
+use tokio::net::TcpStream;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    client::{Client, ClientHandle, Position},
+    config::{Config, Frontend},
+};
+
+/// cli frontend
+pub mod cli;
+
+/// gtk frontend
+#[cfg(all(unix, feature = "gtk"))]
+pub mod gtk;
+
+pub fn run_frontend(config: &Config) -> Result<()> {
+    match config.frontend {
+        #[cfg(all(unix, feature = "gtk"))]
+        Frontend::Gtk => {
+            gtk::run();
+        }
+        #[cfg(any(not(feature = "gtk"), not(unix)))]
+        Frontend::Gtk => panic!("gtk frontend requested but feature not enabled!"),
+        Frontend::Cli => {
+            cli::run()?;
+        }
+    };
+    Ok(())
+}
+
+fn exponential_back_off(duration: &mut Duration) -> &Duration {
+    let new = duration.saturating_mul(2);
+    *duration = min(new, Duration::from_secs(1));
+    duration
+}
+
+/// wait for the lan-mouse socket to come online
+#[cfg(unix)]
+pub fn wait_for_service() -> Result<std::os::unix::net::UnixStream> {
+    let socket_path = FrontendListener::socket_path()?;
+    let mut duration = Duration::from_millis(1);
+    loop {
+        use std::os::unix::net::UnixStream;
+        if let Ok(stream) = UnixStream::connect(&socket_path) {
+            break Ok(stream);
+        }
+        // a signaling mechanism or inotify could be used to
+        // improve this
+        std::thread::sleep(*exponential_back_off(&mut duration));
+    }
+}
+
+#[cfg(windows)]
+pub fn wait_for_service() -> Result<std::net::TcpStream> {
+    let mut duration = Duration::from_millis(1);
+    loop {
+        use std::net::TcpStream;
+        if let Ok(stream) = TcpStream::connect("127.0.0.1:5252") {
+            break Ok(stream);
+        }
+        std::thread::sleep(*exponential_back_off(&mut duration));
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
+pub enum FrontendEvent {
+    /// add a new client
+    AddClient(Option<String>, u16, Position),
+    /// activate/deactivate client
+    ActivateClient(ClientHandle, bool),
+    /// change the listen port (recreate udp listener)
+    ChangePort(u16),
+    /// remove a client
+    DelClient(ClientHandle),
+    /// request an enumertaion of all clients
+    Enumerate(),
+    /// service shutdown
+    Shutdown(),
+    /// update a client (hostname, port, position)
+    UpdateClient(ClientHandle, Option<String>, u16, Position),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum FrontendNotify {
+    NotifyClientCreate(ClientHandle, Option<String>, u16, Position),
+    NotifyClientUpdate(ClientHandle, Option<String>, u16, Position),
+    NotifyClientDelete(ClientHandle),
+    /// new port, reason of failure (if failed)
+    NotifyPortChange(u16, Option<String>),
+    Enumerate(Vec<(Client, bool)>),
+    NotifyError(String),
+}
+
+pub struct FrontendListener {
+    #[cfg(windows)]
+    listener: TcpListener,
+    #[cfg(unix)]
+    listener: UnixListener,
+    #[cfg(unix)]
+    socket_path: PathBuf,
+    #[cfg(unix)]
+    tx_streams: Vec<WriteHalf<UnixStream>>,
+    #[cfg(windows)]
+    tx_streams: Vec<WriteHalf<TcpStream>>,
+}
+
+impl FrontendListener {
+    #[cfg(all(unix, not(target_os = "macos")))]
+    pub fn socket_path() -> Result<PathBuf> {
+        let xdg_runtime_dir = match env::var("XDG_RUNTIME_DIR") {
+            Ok(d) => d,
+            Err(e) => return Err(anyhow!("could not find XDG_RUNTIME_DIR: {e}")),
+        };
+        let xdg_runtime_dir = Path::new(xdg_runtime_dir.as_str());
+        Ok(xdg_runtime_dir.join("lan-mouse-socket.sock"))
+    }
+
+    #[cfg(all(unix, target_os = "macos"))]
+    pub fn socket_path() -> Result<PathBuf> {
+        let home = match env::var("HOME") {
+            Ok(d) => d,
+            Err(e) => return Err(anyhow!("could not find HOME: {e}")),
+        };
+        let home = Path::new(home.as_str());
+        let path = home
+            .join("Library")
+            .join("Caches")
+            .join("lan-mouse-socket.sock");
+        Ok(path)
+    }
+
+    pub async fn new() -> Option<Result<Self>> {
+        #[cfg(unix)]
+        let (socket_path, listener) = {
+            let socket_path = match Self::socket_path() {
+                Ok(path) => path,
+                Err(e) => return Some(Err(e)),
+            };
+
+            log::debug!("remove socket: {:?}", socket_path);
+            if socket_path.exists() {
+                // try to connect to see if some other instance
+                // of lan-mouse is already running
+                match UnixStream::connect(&socket_path).await {
+                    // connected -> lan-mouse is already running
+                    Ok(_) => return None,
+                    // lan-mouse is not running but a socket was left behind
+                    Err(e) => {
+                        log::debug!("{socket_path:?}: {e} - removing left behind socket");
+                        let _ = std::fs::remove_file(&socket_path);
+                    }
+                }
+            }
+            let listener = match UnixListener::bind(&socket_path) {
+                Ok(ls) => ls,
+                // some other lan-mouse instance has bound the socket in the meantime
+                Err(e) if e.kind() == ErrorKind::AddrInUse => return None,
+                Err(e) => return Some(Err(anyhow!("failed to bind lan-mouse-socket: {e}"))),
+            };
+            (socket_path, listener)
+        };
+
+        #[cfg(windows)]
+        let listener = match TcpListener::bind("127.0.0.1:5252").await {
+            Ok(ls) => ls,
+            // some other lan-mouse instance has bound the socket in the meantime
+            Err(e) if e.kind() == ErrorKind::AddrInUse => return None,
+            Err(e) => return Some(Err(anyhow!("failed to bind lan-mouse-socket: {e}"))),
+        };
+
+        let adapter = Self {
+            listener,
+            #[cfg(unix)]
+            socket_path,
+            tx_streams: vec![],
+        };
+
+        Some(Ok(adapter))
+    }
+
+    #[cfg(unix)]
+    pub async fn accept(&mut self) -> Result<ReadHalf<UnixStream>> {
+        log::trace!("frontend.accept()");
+
+        let stream = self.listener.accept().await?.0;
+        let (rx, tx) = tokio::io::split(stream);
+        self.tx_streams.push(tx);
+        Ok(rx)
+    }
+
+    #[cfg(windows)]
+    pub async fn accept(&mut self) -> Result<ReadHalf<TcpStream>> {
+        let stream = self.listener.accept().await?.0;
+        let (rx, tx) = tokio::io::split(stream);
+        self.tx_streams.push(tx);
+        Ok(rx)
+    }
+
+    pub(crate) async fn notify_all(&mut self, notify: FrontendNotify) -> Result<()> {
+        // encode event
+        let json = serde_json::to_string(&notify).unwrap();
+        let payload = json.as_bytes();
+        let len = payload.len().to_be_bytes();
+        log::debug!("json: {json}, len: {}", payload.len());
+
+        let mut keep = vec![];
+
+        // TODO do simultaneously
+        for tx in self.tx_streams.iter_mut() {
+            // write len + payload
+            if let Err(_) = tx.write(&len).await {
+                keep.push(false);
+                continue;
+            }
+            if let Err(_) = tx.write(payload).await {
+                keep.push(false);
+                continue;
+            }
+            keep.push(true);
+        }
+
+        // could not find a better solution because async
+        let mut keep = keep.into_iter();
+        self.tx_streams.retain(|_| keep.next().unwrap());
+        Ok(())
+    }
+}
+
+#[cfg(unix)]
+impl Drop for FrontendListener {
+    fn drop(&mut self) {
+        log::debug!("remove socket: {:?}", self.socket_path);
+        let _ = std::fs::remove_file(&self.socket_path);
+    }
+}
+
+#[cfg(unix)]
+pub async fn read_event(stream: &mut ReadHalf<UnixStream>) -> Result<FrontendEvent> {
+    let len = stream.read_u64().await?;
+    assert!(len <= 256);
+    let mut buf = [0u8; 256];
+    stream.read_exact(&mut buf[..len as usize]).await?;
+    Ok(serde_json::from_slice(&buf[..len as usize])?)
+}
+
+#[cfg(windows)]
+pub async fn read_event(stream: &mut ReadHalf<TcpStream>) -> Result<FrontendEvent> {
+    let len = stream.read_u64().await?;
+    let mut buf = [0u8; 256];
+    stream.read_exact(&mut buf[..len as usize]).await?;
+    Ok(serde_json::from_slice(&buf[..len as usize])?)
+}

src/frontend/cli.rs

@@ -0,0 +1,257 @@
+use anyhow::{anyhow, Context, Result};
+#[cfg(windows)]
+use std::net::SocketAddrV4;
+use std::{
+    io::{ErrorKind, Read, Write},
+    str::SplitWhitespace,
+    thread,
+};
+
+#[cfg(windows)]
+use std::net::TcpStream;
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
+use crate::{client::Position, config::DEFAULT_PORT};
+
+use super::{FrontendEvent, FrontendNotify};
+
+pub fn run() -> Result<()> {
+    #[cfg(unix)]
+    let socket_path = super::FrontendListener::socket_path()?;
+
+    #[cfg(unix)]
+    let Ok(mut tx) = UnixStream::connect(&socket_path) else {
+        return Err(anyhow!("Could not connect to lan-mouse-socket"));
+    };
+
+    #[cfg(windows)]
+    let Ok(mut tx) = TcpStream::connect("127.0.0.1:5252".parse::<SocketAddrV4>().unwrap()) else {
+        return Err(anyhow!("Could not connect to lan-mouse-socket"));
+    };
+
+    let mut rx = tx.try_clone()?;
+
+    let reader = thread::Builder::new()
+        .name("cli-frontend".to_string())
+        .spawn(move || {
+            // all further prompts
+            prompt();
+            loop {
+                let mut buf = String::new();
+                match std::io::stdin().read_line(&mut buf) {
+                    Ok(0) => break,
+                    Ok(len) => {
+                        if let Some(events) = parse_cmd(buf, len) {
+                            for event in events.iter() {
+                                let json = serde_json::to_string(&event).unwrap();
+                                let bytes = json.as_bytes();
+                                let len = bytes.len().to_be_bytes();
+                                if let Err(e) = tx.write(&len) {
+                                    log::error!("error sending message: {e}");
+                                };
+                                if let Err(e) = tx.write(bytes) {
+                                    log::error!("error sending message: {e}");
+                                };
+                                if *event == FrontendEvent::Shutdown() {
+                                    return;
+                                }
+                            }
+                            // prompt is printed after the server response is received
+                        } else {
+                            prompt();
+                        }
+                    }
+                    Err(e) => {
+                        log::error!("error reading from stdin: {e}");
+                        break;
+                    }
+                }
+            }
+        })?;
+
+    let writer = thread::Builder::new()
+        .name("cli-frontend-notify".to_string())
+        .spawn(move || {
+            loop {
+                // read len
+                let mut len = [0u8; 8];
+                match rx.read_exact(&mut len) {
+                    Ok(()) => (),
+                    Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
+                    Err(e) => break log::error!("{e}"),
+                };
+                let len = usize::from_be_bytes(len);
+
+                // read payload
+                let mut buf: Vec<u8> = vec![0u8; len];
+                match rx.read_exact(&mut buf[..len]) {
+                    Ok(()) => (),
+                    Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
+                    Err(e) => break log::error!("{e}"),
+                };
+
+                let notify: FrontendNotify = match serde_json::from_slice(&buf) {
+                    Ok(n) => n,
+                    Err(e) => break log::error!("{e}"),
+                };
+                match notify {
+                    FrontendNotify::NotifyClientCreate(client, host, port, pos) => {
+                        log::info!(
+                            "new client ({client}): {}:{port} - {pos}",
+                            host.as_deref().unwrap_or("")
+                        );
+                    }
+                    FrontendNotify::NotifyClientUpdate(client, host, port, pos) => {
+                        log::info!(
+                            "client ({client}) updated: {}:{port} - {pos}",
+                            host.as_deref().unwrap_or("")
+                        );
+                    }
+                    FrontendNotify::NotifyClientDelete(client) => {
+                        log::info!("client ({client}) deleted.");
+                    }
+                    FrontendNotify::NotifyError(e) => {
+                        log::warn!("{e}");
+                    }
+                    FrontendNotify::Enumerate(clients) => {
+                        for (client, active) in clients.into_iter() {
+                            log::info!(
+                                "client ({}) [{}]: active: {}, associated addresses: [{}]",
+                                client.handle,
+                                client.hostname.as_deref().unwrap_or(""),
+                                if active { "yes" } else { "no" },
+                                client
+                                    .addrs
+                                    .into_iter()
+                                    .map(|a| a.to_string())
+                                    .collect::<Vec<String>>()
+                                    .join(", ")
+                            );
+                        }
+                    }
+                    FrontendNotify::NotifyPortChange(port, msg) => match msg {
+                        Some(msg) => log::info!("could not change port: {msg}"),
+                        None => log::info!("port changed: {port}"),
+                    },
+                }
+                prompt();
+            }
+        })?;
+    match reader.join() {
+        Ok(_) => (),
+        Err(e) => {
+            let msg = match (e.downcast_ref::<&str>(), e.downcast_ref::<String>()) {
+                (Some(&s), _) => s,
+                (_, Some(s)) => s,
+                _ => "no panic info",
+            };
+            log::error!("reader thread paniced: {msg}");
+        }
+    }
+    match writer.join() {
+        Ok(_) => (),
+        Err(e) => {
+            let msg = match (e.downcast_ref::<&str>(), e.downcast_ref::<String>()) {
+                (Some(&s), _) => s,
+                (_, Some(s)) => s,
+                _ => "no panic info",
+            };
+            log::error!("writer thread paniced: {msg}");
+        }
+    }
+    Ok(())
+}
+
+fn prompt() {
+    eprint!("lan-mouse > ");
+    std::io::stderr().flush().unwrap();
+}
+
+fn parse_cmd(s: String, len: usize) -> Option<Vec<FrontendEvent>> {
+    if len == 0 {
+        return Some(vec![FrontendEvent::Shutdown()]);
+    }
+    let mut l = s.split_whitespace();
+    let cmd = l.next()?;
+    let res = match cmd {
+        "help" => {
+            log::info!("list                                                 list clients");
+            log::info!("connect <host> left|right|top|bottom [port]          add a new client");
+            log::info!("disconnect <client>                                  remove a client");
+            log::info!("activate <client>                                    activate a client");
+            log::info!("deactivate <client>                                  deactivate a client");
+            log::info!("exit                                                 exit lan-mouse");
+            log::info!("setport <port>                                       change port");
+            None
+        }
+        "exit" => return Some(vec![FrontendEvent::Shutdown()]),
+        "list" => return Some(vec![FrontendEvent::Enumerate()]),
+        "connect" => Some(parse_connect(l)),
+        "disconnect" => Some(parse_disconnect(l)),
+        "activate" => Some(parse_activate(l)),
+        "deactivate" => Some(parse_deactivate(l)),
+        "setport" => Some(parse_port(l)),
+        _ => {
+            log::error!("unknown command: {s}");
+            None
+        }
+    };
+    match res {
+        Some(Ok(e)) => Some(e),
+        Some(Err(e)) => {
+            log::warn!("{e}");
+            None
+        }
+        _ => None,
+    }
+}
+
+fn parse_connect(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
+    let usage = "usage: connect <host> left|right|top|bottom [port]";
+    let host = l.next().context(usage)?.to_owned();
+    let pos = match l.next().context(usage)? {
+        "right" => Position::Right,
+        "top" => Position::Top,
+        "bottom" => Position::Bottom,
+        _ => Position::Left,
+    };
+    let port = if let Some(p) = l.next() {
+        p.parse()?
+    } else {
+        DEFAULT_PORT
+    };
+    Ok(vec![
+        FrontendEvent::AddClient(Some(host), port, pos),
+        FrontendEvent::Enumerate(),
+    ])
+}
+
+fn parse_disconnect(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
+    let client = l.next().context("usage: disconnect <client_id>")?.parse()?;
+    Ok(vec![
+        FrontendEvent::DelClient(client),
+        FrontendEvent::Enumerate(),
+    ])
+}
+
+fn parse_activate(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
+    let client = l.next().context("usage: activate <client_id>")?.parse()?;
+    Ok(vec![
+        FrontendEvent::ActivateClient(client, true),
+        FrontendEvent::Enumerate(),
+    ])
+}
+
+fn parse_deactivate(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
+    let client = l.next().context("usage: deactivate <client_id>")?.parse()?;
+    Ok(vec![
+        FrontendEvent::ActivateClient(client, false),
+        FrontendEvent::Enumerate(),
+    ])
+}
+
+fn parse_port(mut l: SplitWhitespace) -> Result<Vec<FrontendEvent>> {
+    let port = l.next().context("usage: setport <port>")?.parse()?;
+    Ok(vec![FrontendEvent::ChangePort(port)])
+}

src/frontend/gtk.rs

@@ -0,0 +1,198 @@
+mod client_object;
+mod client_row;
+mod window;
+
+use std::{
+    env,
+    io::{ErrorKind, Read},
+    process, str,
+};
+
+use crate::{config::DEFAULT_PORT, frontend::gtk::window::Window};
+
+use adw::Application;
+use gtk::{
+    gdk::Display,
+    gio::{SimpleAction, SimpleActionGroup},
+    glib::{clone, MainContext, Priority},
+    prelude::*,
+    subclass::prelude::ObjectSubclassIsExt,
+    CssProvider, IconTheme,
+};
+use gtk::{gio, glib, prelude::ApplicationExt};
+
+use self::client_object::ClientObject;
+
+use super::FrontendNotify;
+
+pub fn run() -> glib::ExitCode {
+    log::debug!("running gtk frontend");
+    let ret = gtk_main();
+    log::debug!("frontend exited");
+    ret
+}
+
+fn gtk_main() -> glib::ExitCode {
+    gio::resources_register_include!("lan-mouse.gresource").expect("Failed to register resources.");
+
+    let app = Application::builder()
+        .application_id("de.feschber.lan-mouse")
+        .build();
+
+    app.connect_startup(|_| load_icons());
+    app.connect_startup(|_| load_css());
+    app.connect_activate(build_ui);
+
+    let args: Vec<&'static str> = vec![];
+    app.run_with_args(&args)
+}
+
+fn load_css() {
+    let provider = CssProvider::new();
+    provider.load_from_resource("de/feschber/LanMouse/style.css");
+    gtk::style_context_add_provider_for_display(
+        &Display::default().expect("Could not connect to a display."),
+        &provider,
+        gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+    );
+}
+
+fn load_icons() {
+    let icon_theme =
+        IconTheme::for_display(&Display::default().expect("Could not connect to a display."));
+    icon_theme.add_resource_path("/de/feschber/LanMouse/icons");
+}
+
+fn build_ui(app: &Application) {
+    log::debug!("connecting to lan-mouse-socket");
+    let mut rx = match super::wait_for_service() {
+        Ok(stream) => stream,
+        Err(e) => {
+            log::error!("could not connect to lan-mouse-socket: {e}");
+            process::exit(1);
+        }
+    };
+    let tx = match rx.try_clone() {
+        Ok(sock) => sock,
+        Err(e) => {
+            log::error!("{e}");
+            process::exit(1);
+        }
+    };
+    log::debug!("connected to lan-mouse-socket");
+
+    let (sender, receiver) = MainContext::channel::<FrontendNotify>(Priority::default());
+
+    gio::spawn_blocking(move || {
+        match loop {
+            // read length
+            let mut len = [0u8; 8];
+            match rx.read_exact(&mut len) {
+                Ok(_) => (),
+                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
+                Err(e) => break Err(e),
+            };
+            let len = usize::from_be_bytes(len);
+
+            // read payload
+            let mut buf = vec![0u8; len];
+            match rx.read_exact(&mut buf) {
+                Ok(_) => (),
+                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
+                Err(e) => break Err(e),
+            };
+
+            // parse json
+            let json = str::from_utf8(&buf).unwrap();
+            match serde_json::from_str(json) {
+                Ok(notify) => sender.send(notify).unwrap(),
+                Err(e) => log::error!("{e}"),
+            }
+        } {
+            Ok(()) => {}
+            Err(e) => log::error!("{e}"),
+        }
+    });
+
+    let window = Window::new(app);
+    window.imp().stream.borrow_mut().replace(tx);
+    receiver.attach(None, clone!(@weak window => @default-return glib::ControlFlow::Break,
+        move |notify| {
+            match notify {
+                FrontendNotify::NotifyClientCreate(client, hostname, port, position) => {
+                    window.new_client(client, hostname, port, position, false);
+                },
+                FrontendNotify::NotifyClientUpdate(client, hostname, port, position) => {
+                    log::info!("client updated: {client}, {}:{port}, {position}", hostname.unwrap_or("".to_string()));
+                }
+                FrontendNotify::NotifyError(e) => {
+                    // TODO
+                    log::error!("{e}");
+                },
+                FrontendNotify::NotifyClientDelete(client) => {
+                    window.delete_client(client);
+                }
+                FrontendNotify::Enumerate(clients) => {
+                    for (client, active) in clients {
+                        if window.client_idx(client.handle).is_some() {
+                            continue
+                        }
+                        window.new_client(
+                            client.handle,
+                            client.hostname,
+                            client.addrs
+                                .iter()
+                                .next()
+                                .map(|s| s.port())
+                                .unwrap_or(DEFAULT_PORT),
+                            client.pos,
+                            active,
+                        );
+                    }
+                },
+                FrontendNotify::NotifyPortChange(port, msg) => {
+                    match msg {
+                        None => window.show_toast(format!("port changed: {port}").as_str()),
+                        Some(msg) => window.show_toast(msg.as_str()),
+                    }
+                    window.imp().set_port(port);
+                }
+            }
+            glib::ControlFlow::Continue
+        }
+    ));
+
+    let action_request_client_update =
+        SimpleAction::new("request-client-update", Some(&u32::static_variant_type()));
+
+    // remove client
+    let action_client_delete =
+        SimpleAction::new("request-client-delete", Some(&u32::static_variant_type()));
+
+    // update client state
+    action_request_client_update.connect_activate(clone!(@weak window => move |_action, param| {
+        log::debug!("request-client-update");
+        let index = param.unwrap()
+            .get::<u32>()
+            .unwrap();
+        let Some(client) = window.clients().item(index as u32) else {
+            return;
+        };
+        let client = client.downcast_ref::<ClientObject>().unwrap();
+        window.request_client_update(client);
+    }));
+
+    action_client_delete.connect_activate(clone!(@weak window => move |_action, param| {
+        log::debug!("delete-client");
+        let idx = param.unwrap()
+            .get::<u32>()
+            .unwrap();
+        window.request_client_delete(idx);
+    }));
+
+    let actions = SimpleActionGroup::new();
+    window.insert_action_group("win", Some(&actions));
+    actions.add_action(&action_request_client_update);
+    actions.add_action(&action_client_delete);
+    window.present();
+}

src/frontend/gtk/client_object.rs

@@ -0,0 +1,41 @@
+mod imp;
+
+use adw::subclass::prelude::*;
+use gtk::glib::{self, Object};
+
+use crate::client::ClientHandle;
+
+glib::wrapper! {
+    pub struct ClientObject(ObjectSubclass<imp::ClientObject>);
+}
+
+impl ClientObject {
+    pub fn new(
+        handle: ClientHandle,
+        hostname: Option<String>,
+        port: u32,
+        position: String,
+        active: bool,
+    ) -> Self {
+        Object::builder()
+            .property("handle", handle)
+            .property("hostname", hostname)
+            .property("port", port)
+            .property("active", active)
+            .property("position", position)
+            .build()
+    }
+
+    pub fn get_data(&self) -> ClientData {
+        self.imp().data.borrow().clone()
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct ClientData {
+    pub handle: ClientHandle,
+    pub hostname: Option<String>,
+    pub port: u32,
+    pub active: bool,
+    pub position: String,
+}

src/frontend/gtk/client_object/imp.rs

@@ -0,0 +1,30 @@
+use std::cell::RefCell;
+
+use glib::Properties;
+use gtk::glib;
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+
+use crate::client::ClientHandle;
+
+use super::ClientData;
+
+#[derive(Properties, Default)]
+#[properties(wrapper_type = super::ClientObject)]
+pub struct ClientObject {
+    #[property(name = "handle", get, set, type = ClientHandle, member = handle)]
+    #[property(name = "hostname", get, set, type = String, member = hostname)]
+    #[property(name = "port", get, set, type = u32, member = port, maximum = u16::MAX as u32)]
+    #[property(name = "active", get, set, type = bool, member = active)]
+    #[property(name = "position", get, set, type = String, member = position)]
+    pub data: RefCell<ClientData>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for ClientObject {
+    const NAME: &'static str = "ClientObject";
+    type Type = super::ClientObject;
+}
+
+#[glib::derived_properties]
+impl ObjectImpl for ClientObject {}

src/frontend/gtk/client_row.rs

@@ -0,0 +1,119 @@
+mod imp;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use gtk::glib::{self, Object};
+
+use crate::config::DEFAULT_PORT;
+
+use super::ClientObject;
+
+glib::wrapper! {
+    pub struct ClientRow(ObjectSubclass<imp::ClientRow>)
+    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
+    @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
+}
+
+impl ClientRow {
+    pub fn new(_client_object: &ClientObject) -> Self {
+        Object::builder().build()
+    }
+
+    pub fn bind(&self, client_object: &ClientObject) {
+        let mut bindings = self.imp().bindings.borrow_mut();
+
+        let active_binding = client_object
+            .bind_property("active", &self.imp().enable_switch.get(), "state")
+            .bidirectional()
+            .sync_create()
+            .build();
+
+        let hostname_binding = client_object
+            .bind_property("hostname", &self.imp().hostname.get(), "text")
+            .transform_to(|_, v: Option<String>| {
+                if let Some(hostname) = v {
+                    Some(hostname)
+                } else {
+                    Some("".to_string())
+                }
+            })
+            .transform_from(|_, v: String| {
+                if v.as_str().trim() == "" {
+                    Some(None)
+                } else {
+                    Some(Some(v))
+                }
+            })
+            .bidirectional()
+            .sync_create()
+            .build();
+
+        let title_binding = client_object
+            .bind_property("hostname", self, "title")
+            .transform_to(|_, v: Option<String>| {
+                if let Some(hostname) = v {
+                    Some(hostname)
+                } else {
+                    Some("<span font_style=\"italic\" font_weight=\"light\" foreground=\"darkgrey\">no hostname!</span>".to_string())
+                }
+            })
+            .sync_create()
+            .build();
+
+        let port_binding = client_object
+            .bind_property("port", &self.imp().port.get(), "text")
+            .transform_from(|_, v: String| {
+                if v == "" {
+                    Some(DEFAULT_PORT as u32)
+                } else {
+                    Some(v.parse::<u16>().unwrap_or(DEFAULT_PORT) as u32)
+                }
+            })
+            .transform_to(|_, v: u32| {
+                if v == 4242 {
+                    Some("".to_string())
+                } else {
+                    Some(v.to_string())
+                }
+            })
+            .bidirectional()
+            .sync_create()
+            .build();
+
+        let subtitle_binding = client_object
+            .bind_property("port", self, "subtitle")
+            .sync_create()
+            .build();
+
+        let position_binding = client_object
+            .bind_property("position", &self.imp().position.get(), "selected")
+            .transform_from(|_, v: u32| match v {
+                1 => Some("right"),
+                2 => Some("top"),
+                3 => Some("bottom"),
+                _ => Some("left"),
+            })
+            .transform_to(|_, v: String| match v.as_str() {
+                "right" => Some(1),
+                "top" => Some(2u32),
+                "bottom" => Some(3u32),
+                _ => Some(0u32),
+            })
+            .bidirectional()
+            .sync_create()
+            .build();
+
+        bindings.push(active_binding);
+        bindings.push(hostname_binding);
+        bindings.push(title_binding);
+        bindings.push(port_binding);
+        bindings.push(subtitle_binding);
+        bindings.push(position_binding);
+    }
+
+    pub fn unbind(&self) {
+        for binding in self.imp().bindings.borrow_mut().drain(..) {
+            binding.unbind();
+        }
+    }
+}

src/frontend/gtk/client_row/imp.rs

@@ -0,0 +1,81 @@
+use std::cell::RefCell;
+
+use adw::subclass::prelude::*;
+use adw::{prelude::*, ActionRow, ComboRow};
+use glib::{subclass::InitializingObject, Binding};
+use gtk::glib::clone;
+use gtk::{glib, Button, CompositeTemplate, Switch};
+
+#[derive(CompositeTemplate, Default)]
+#[template(resource = "/de/feschber/LanMouse/client_row.ui")]
+pub struct ClientRow {
+    #[template_child]
+    pub enable_switch: TemplateChild<gtk::Switch>,
+    #[template_child]
+    pub hostname: TemplateChild<gtk::Entry>,
+    #[template_child]
+    pub port: TemplateChild<gtk::Entry>,
+    #[template_child]
+    pub position: TemplateChild<ComboRow>,
+    #[template_child]
+    pub delete_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub delete_button: TemplateChild<gtk::Button>,
+    pub bindings: RefCell<Vec<Binding>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for ClientRow {
+    // `NAME` needs to match `class` attribute of template
+    const NAME: &'static str = "ClientRow";
+    type Type = super::ClientRow;
+    type ParentType = adw::ExpanderRow;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+        klass.bind_template_callbacks();
+    }
+
+    fn instance_init(obj: &InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+impl ObjectImpl for ClientRow {
+    fn constructed(&self) {
+        self.parent_constructed();
+        self.delete_button
+            .connect_clicked(clone!(@weak self as row => move |button| {
+                row.handle_client_delete(button);
+            }));
+    }
+}
+
+#[gtk::template_callbacks]
+impl ClientRow {
+    #[template_callback]
+    fn handle_client_set_state(&self, state: bool, switch: &Switch) -> bool {
+        let idx = self.obj().index() as u32;
+        switch
+            .activate_action("win.request-client-update", Some(&idx.to_variant()))
+            .unwrap();
+        switch.set_state(state);
+
+        true // dont run default handler
+    }
+
+    #[template_callback]
+    fn handle_client_delete(&self, button: &Button) {
+        log::debug!("delete button pressed");
+        let idx = self.obj().index() as u32;
+        button
+            .activate_action("win.request-client-delete", Some(&idx.to_variant()))
+            .unwrap();
+    }
+}
+
+impl WidgetImpl for ClientRow {}
+impl BoxImpl for ClientRow {}
+impl ListBoxRowImpl for ClientRow {}
+impl PreferencesRowImpl for ClientRow {}
+impl ExpanderRowImpl for ClientRow {}

src/frontend/gtk/window.rs

@@ -0,0 +1,179 @@
+mod imp;
+
+use std::io::Write;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use glib::{clone, Object};
+use gtk::{gio, glib, NoSelection};
+
+use crate::{
+    client::{ClientHandle, Position},
+    config::DEFAULT_PORT,
+    frontend::{gtk::client_object::ClientObject, FrontendEvent},
+};
+
+use super::client_row::ClientRow;
+
+glib::wrapper! {
+    pub struct Window(ObjectSubclass<imp::Window>)
+        @extends adw::ApplicationWindow, gtk::Window, gtk::Widget,
+        @implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable,
+                    gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
+}
+
+impl Window {
+    pub(crate) fn new(app: &adw::Application) -> Self {
+        Object::builder().property("application", app).build()
+    }
+
+    pub fn clients(&self) -> gio::ListStore {
+        self.imp()
+            .clients
+            .borrow()
+            .clone()
+            .expect("Could not get clients")
+    }
+
+    fn setup_clients(&self) {
+        let model = gio::ListStore::new::<ClientObject>();
+        self.imp().clients.replace(Some(model));
+
+        let selection_model = NoSelection::new(Some(self.clients()));
+        self.imp().client_list.bind_model(
+            Some(&selection_model),
+            clone!(@weak self as window => @default-panic, move |obj| {
+                let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
+                let row = window.create_client_row(client_object);
+                row.upcast()
+            })
+        );
+    }
+
+    /// workaround for a bug in libadwaita that shows an ugly line beneath
+    /// the last element if a placeholder is set.
+    /// https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/6308
+    pub fn set_placeholder_visible(&self, visible: bool) {
+        let placeholder = self.imp().client_placeholder.get();
+        self.imp().client_list.set_placeholder(match visible {
+            true => Some(&placeholder),
+            false => None,
+        });
+    }
+
+    fn setup_icon(&self) {
+        self.set_icon_name(Some("mouse-icon"));
+    }
+
+    fn create_client_row(&self, client_object: &ClientObject) -> ClientRow {
+        let row = ClientRow::new(client_object);
+        row.bind(client_object);
+        row
+    }
+
+    pub fn new_client(
+        &self,
+        handle: ClientHandle,
+        hostname: Option<String>,
+        port: u16,
+        position: Position,
+        active: bool,
+    ) {
+        let client = ClientObject::new(handle, hostname, port as u32, position.to_string(), active);
+        self.clients().append(&client);
+        self.set_placeholder_visible(false);
+    }
+
+    pub fn client_idx(&self, handle: ClientHandle) -> Option<usize> {
+        self.clients()
+            .iter::<ClientObject>()
+            .position(|c| {
+                if let Ok(c) = c {
+                    c.handle() == handle
+                } else {
+                    false
+                }
+            })
+            .map(|p| p as usize)
+    }
+
+    pub fn delete_client(&self, handle: ClientHandle) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {handle}");
+            return;
+        };
+
+        self.clients().remove(idx as u32);
+        if self.clients().n_items() == 0 {
+            self.set_placeholder_visible(true);
+        }
+    }
+
+    pub fn request_client_create(&self) {
+        let event = FrontendEvent::AddClient(None, DEFAULT_PORT, Position::default());
+        self.imp().set_port(DEFAULT_PORT);
+        self.request(event);
+    }
+
+    pub fn request_port_change(&self) {
+        let port = self.imp().port_entry.get().text().to_string();
+        if let Ok(port) = u16::from_str_radix(port.as_str(), 10) {
+            self.request(FrontendEvent::ChangePort(port));
+        } else {
+            self.request(FrontendEvent::ChangePort(DEFAULT_PORT));
+        }
+    }
+
+    pub fn request_client_update(&self, client: &ClientObject) {
+        let data = client.get_data();
+        let position = match data.position.as_str() {
+            "left" => Position::Left,
+            "right" => Position::Right,
+            "top" => Position::Top,
+            "bottom" => Position::Bottom,
+            _ => {
+                log::error!("invalid position: {}", data.position);
+                return;
+            }
+        };
+        let hostname = data.hostname;
+        let port = data.port as u16;
+        let event = FrontendEvent::UpdateClient(client.handle(), hostname, port, position);
+        self.request(event);
+
+        let event = FrontendEvent::ActivateClient(client.handle(), !client.active());
+        self.request(event);
+    }
+
+    pub fn request_client_delete(&self, idx: u32) {
+        if let Some(obj) = self.clients().item(idx) {
+            let client_object: &ClientObject = obj
+                .downcast_ref()
+                .expect("Expected object of type `ClientObject`.");
+            let handle = client_object.handle();
+            let event = FrontendEvent::DelClient(handle);
+            self.request(event);
+        }
+    }
+
+    fn request(&self, event: FrontendEvent) {
+        let json = serde_json::to_string(&event).unwrap();
+        log::debug!("requesting {json}");
+        let mut stream = self.imp().stream.borrow_mut();
+        let stream = stream.as_mut().unwrap();
+        let bytes = json.as_bytes();
+        let len = bytes.len().to_be_bytes();
+        if let Err(e) = stream.write(&len) {
+            log::error!("error sending message: {e}");
+        };
+        if let Err(e) = stream.write(bytes) {
+            log::error!("error sending message: {e}");
+        };
+    }
+
+    pub fn show_toast(&self, msg: &str) {
+        let toast = adw::Toast::new(msg);
+        let toast_overlay = &self.imp().toast_overlay;
+        toast_overlay.add_toast(toast);
+    }
+}

src/frontend/gtk/window/imp.rs

@@ -0,0 +1,105 @@
+use std::{
+    cell::{Cell, RefCell},
+    os::unix::net::UnixStream,
+};
+
+use adw::subclass::prelude::*;
+use adw::{
+    prelude::{EditableExt, WidgetExt},
+    ActionRow, ToastOverlay,
+};
+use glib::subclass::InitializingObject;
+use gtk::{gio, glib, Button, CompositeTemplate, Entry, ListBox};
+
+use crate::config::DEFAULT_PORT;
+
+#[derive(CompositeTemplate, Default)]
+#[template(resource = "/de/feschber/LanMouse/window.ui")]
+pub struct Window {
+    #[template_child]
+    pub port_edit_apply: TemplateChild<Button>,
+    #[template_child]
+    pub port_edit_cancel: TemplateChild<Button>,
+    #[template_child]
+    pub client_list: TemplateChild<ListBox>,
+    #[template_child]
+    pub client_placeholder: TemplateChild<ActionRow>,
+    #[template_child]
+    pub port_entry: TemplateChild<Entry>,
+    #[template_child]
+    pub toast_overlay: TemplateChild<ToastOverlay>,
+    pub clients: RefCell<Option<gio::ListStore>>,
+    pub stream: RefCell<Option<UnixStream>>,
+    pub port: Cell<u16>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for Window {
+    // `NAME` needs to match `class` attribute of template
+    const NAME: &'static str = "LanMouseWindow";
+    type Type = super::Window;
+    type ParentType = adw::ApplicationWindow;
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.bind_template();
+        klass.bind_template_callbacks();
+    }
+
+    fn instance_init(obj: &InitializingObject<Self>) {
+        obj.init_template();
+    }
+}
+
+#[gtk::template_callbacks]
+impl Window {
+    #[template_callback]
+    fn handle_add_client_pressed(&self, _button: &Button) {
+        self.obj().request_client_create();
+    }
+
+    #[template_callback]
+    fn handle_port_changed(&self, _entry: &Entry) {
+        self.port_edit_apply.set_visible(true);
+        self.port_edit_cancel.set_visible(true);
+    }
+
+    #[template_callback]
+    fn handle_port_edit_apply(&self) {
+        self.obj().request_port_change();
+    }
+
+    #[template_callback]
+    fn handle_port_edit_cancel(&self) {
+        log::debug!("cancel port edit");
+        self.port_entry
+            .set_text(self.port.get().to_string().as_str());
+        self.port_edit_apply.set_visible(false);
+        self.port_edit_cancel.set_visible(false);
+    }
+
+    pub fn set_port(&self, port: u16) {
+        self.port.set(port);
+        if port == DEFAULT_PORT {
+            self.port_entry.set_text("");
+        } else {
+            self.port_entry.set_text(format!("{port}").as_str());
+        }
+        self.port_edit_apply.set_visible(false);
+        self.port_edit_cancel.set_visible(false);
+    }
+}
+
+impl ObjectImpl for Window {
+    fn constructed(&self) {
+        self.parent_constructed();
+        self.set_port(DEFAULT_PORT);
+        let obj = self.obj();
+        obj.setup_icon();
+        obj.setup_clients();
+    }
+}
+
+impl WidgetImpl for Window {}
+impl WindowImpl for Window {}
+impl ApplicationWindowImpl for Window {}
+impl AdwApplicationWindowImpl for Window {}

src/ioutils.rs

@@ -2,9 +2,8 @@ use std::io::{self, Write};
 
 use crate::client::Position;
 
-
 pub fn ask_confirmation(default: bool) -> Result<bool, io::Error> {
-    eprint!("{}", if default {" [Y,n] "} else { " [y,N] "});
+    eprint!("{}", if default { " [Y,n] " } else { " [y,N] " });
     io::stderr().flush()?;
     let answer = loop {
         let mut buffer = String::new();
@@ -18,7 +17,7 @@ pub fn ask_confirmation(default: bool) -> Result<bool, io::Error> {
             _ => {
                 eprint!("Enter y for Yes or n for No: ");
                 io::stderr().flush()?;
-                continue
+                continue;
             }
         }
     };
@@ -41,7 +40,7 @@ pub fn ask_position() -> Result<Position, io::Error> {
             _ => {
                 eprint!("Invalid position: {answer} - enter top (t) | bottom (b) | left(l) | right(r): ");
                 io::stderr().flush()?;
-                continue
+                continue;
             }
         };
     };

src/lib.rs

@@ -2,10 +2,11 @@ pub mod client;
 pub mod config;
 pub mod dns;
 pub mod event;
-pub mod request;
+pub mod server;
 
 pub mod consumer;
 pub mod producer;
 
 pub mod backend;
+pub mod frontend;
 pub mod ioutils;

src/main.rs

@@ -1,111 +1,86 @@
-use std::{sync::{mpsc, Arc}, process, env};
+use anyhow::Result;
+use std::process::{self, Child, Command};
 
+use env_logger::Env;
 use lan_mouse::{
-    client::ClientManager,
-    consumer, producer,
-    config, event, request,
+    config::Config,
+    consumer,
+    frontend::{self, FrontendListener},
+    producer,
+    server::Server,
 };
 
-fn usage() {
-    eprintln!("usage: {} [--backend <backend>] [--port <port>]",
-        env::args().next().unwrap_or("lan-mouse".into()));
-}
+use tokio::{join, task::LocalSet};
 
 pub fn main() {
-    // parse config file
-    let config = match config::Config::new() {
-        Err(e) => {
-            eprintln!("{e}");
-            usage();
-            process::exit(1);
-        }
-        Ok(config) => config,
-    };
+    // init logging
+    let env = Env::default().filter_or("LAN_MOUSE_LOG_LEVEL", "info");
+    env_logger::init_from_env(env);
 
-    // port or default
-    let port = config.port;
-
-    // event channel for producing events
-    let (produce_tx, produce_rx) = mpsc::sync_channel(128);
-
-    // event channel for consuming events
-    let (consume_tx, consume_rx) = mpsc::sync_channel(128);
-
-    // create client manager
-    let client_manager = match ClientManager::new(&config) {
-        Err(e) => {
-            eprintln!("{e}");
-            process::exit(1);
-        }
-        Ok(m) => m,
-    };
-
-    // start receiving client connection requests
-    let (request_server, request_thread) = match request::Server::listen(port) {
-        Err(e) => {
-            eprintln!("Could not bind to port {port}: {e}");
-            process::exit(1);
-        }
-        Ok(r) => r,
-    };
-
-    println!("Press Ctrl+Alt+Shift+Super to release the mouse");
-
-    // start producing and consuming events
-    let event_producer = match producer::start(produce_tx, client_manager.get_clients(), request_server) {
-        Err(e) => {
-            eprintln!("Could not start event producer: {e}");
-            None
-        },
-        Ok(p) => Some(p),
-    };
-    let event_consumer = match consumer::start(consume_rx, client_manager.get_clients(), config.backend) {
-        Err(e) => {
-            eprintln!("Could not start event consumer: {e}");
-            None
-        },
-        Ok(p) => Some(p),
-    };
-
-    if event_consumer.is_none() && event_producer.is_none() {
-        process::exit(1);
-    }
-
-    // start sending and receiving events
-    let event_server = match event::server::Server::new(port) {
-        Ok(s) => s,
-        Err(e) => {
-            eprintln!("{e}");
-            process::exit(1);
-        }
-    };
-    let (receiver, sender) = match event_server.run(Arc::new(client_manager), produce_rx, consume_tx) {
-        Ok((r,s)) => (r,s),
-        Err(e) => {
-            eprintln!("{e}");
-            process::exit(1);
-        }
-    };
-
-    request_thread.join().unwrap();
-
-    // stop receiving events and terminate event-consumer
-    if let Err(e) = receiver.join().unwrap() {
-        eprint!("{e}");
-        process::exit(1);
-    }
-
-    if let Some(thread) = event_consumer {
-        thread.join().unwrap();
-    }
-
-    // stop producing events and terminate event-sender
-    if let Some(thread) = event_producer {
-        thread.join().unwrap();
-    }
-
-    if let Err(e) = sender.join().unwrap() {
-        eprint!("{e}");
+    if let Err(e) = run() {
+        log::error!("{e}");
         process::exit(1);
     }
 }
+
+pub fn start_service() -> Result<Child> {
+    let child = Command::new(std::env::current_exe()?)
+        .args(std::env::args().skip(1))
+        .arg("--daemon")
+        .spawn()?;
+    Ok(child)
+}
+
+pub fn run() -> Result<()> {
+    // parse config file + cli args
+    let config = Config::new()?;
+    log::debug!("{config:?}");
+
+    if config.daemon {
+        // if daemon is specified we run the service
+        run_service(&config)?;
+    } else {
+        //  otherwise start the service as a child process and
+        //  run a frontend
+        start_service()?;
+        frontend::run_frontend(&config)?;
+    }
+
+    anyhow::Ok(())
+}
+
+fn run_service(config: &Config) -> Result<()> {
+    // create single threaded tokio runtime
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+
+    // run async event loop
+    runtime.block_on(LocalSet::new().run_until(async {
+        // create frontend communication adapter
+        let frontend_adapter = match FrontendListener::new().await {
+            Some(Err(e)) => return Err(e),
+            Some(Ok(f)) => f,
+            None => {
+                // none means some other instance is already running
+                log::info!("service already running, exiting");
+                return anyhow::Ok(());
+            }
+        };
+
+        // create event producer and consumer
+        let (producer, consumer) = join!(producer::create(), consumer::create(),);
+        let (producer, consumer) = (producer?, consumer?);
+
+        // create server
+        let mut event_server = Server::new(config, frontend_adapter, consumer, producer).await?;
+        log::info!("Press Ctrl+Alt+Shift+Super to release the mouse");
+
+        // run event loop
+        event_server.run().await?;
+        log::debug!("service exiting");
+        anyhow::Ok(())
+    }))?;
+    Ok(())
+}

src/producer.rs

@@ -1,52 +1,91 @@
-#[cfg(unix)]
-use std::env;
-use std::{thread::{JoinHandle, self}, sync::mpsc::SyncSender, error::Error};
+use anyhow::Result;
+use std::io;
 
-use crate::{client::{Client, ClientHandle}, event::Event, request::Server};
+use futures_core::Stream;
 
 use crate::backend::producer;
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    event::Event,
+};
 
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "macos")))]
+use std::env;
+
+#[cfg(all(unix, not(target_os = "macos")))]
 enum Backend {
-    Wayland,
+    LayerShell,
+    Libei,
     X11,
 }
 
-pub fn start(
-    produce_tx: SyncSender<(Event, ClientHandle)>,
-    clients: Vec<Client>,
-    request_server: Server,
-) -> Result<JoinHandle<()>, Box<dyn Error>> {
-    Ok(thread::Builder::new()
-        .name("event producer".into())
-        .spawn(move || {
-            #[cfg(windows)]
-            producer::windows::run(produce_tx, request_server, clients);
+pub async fn create() -> Result<Box<dyn EventProducer>> {
+    #[cfg(target_os = "macos")]
+    return Ok(Box::new(producer::macos::MacOSProducer::new()));
 
-            #[cfg(unix)]
-            let backend = match env::var("XDG_SESSION_TYPE") {
-                Ok(session_type) => match session_type.as_str() {
-                    "x11" => Backend::X11,
-                    "wayland" => Backend::Wayland,
-                    _ => panic!("unknown XDG_SESSION_TYPE"),
-                },
-                Err(_) => panic!("could not detect session type: XDG_SESSION_TYPE environment variable not set!"),
-            };
+    #[cfg(windows)]
+    return Ok(Box::new(producer::windows::WindowsProducer::new()));
 
-            #[cfg(unix)]
-            match backend {
-                Backend::X11 => {
-                    #[cfg(not(feature = "x11"))]
-                    panic!("feature x11 not enabled");
-                    #[cfg(feature = "x11")]
-                    producer::x11::run(produce_tx, request_server, clients);
-                }
-                Backend::Wayland => {
-                    #[cfg(not(feature = "wayland"))]
-                    panic!("feature wayland not enabled");
-                    #[cfg(feature = "wayland")]
-                    producer::wayland::run(produce_tx, request_server, clients);
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let backend = match env::var("XDG_SESSION_TYPE") {
+        Ok(session_type) => match session_type.as_str() {
+            "x11" => {
+                log::info!("XDG_SESSION_TYPE = x11 -> using X11 event producer");
+                Backend::X11
+            }
+            "wayland" => {
+                log::info!("XDG_SESSION_TYPE = wayland -> using wayland event producer");
+                match env::var("XDG_CURRENT_DESKTOP") {
+                    Ok(desktop) => match desktop.as_str() {
+                        "GNOME" => {
+                            log::info!("XDG_CURRENT_DESKTOP = GNOME -> using libei backend");
+                            Backend::Libei
+                        }
+                        d => {
+                            log::info!("XDG_CURRENT_DESKTOP = {d} -> using layer_shell backend");
+                            Backend::LayerShell
+                        }
+                    },
+                    Err(_) => {
+                        log::warn!("XDG_CURRENT_DESKTOP not set! Assuming layer_shell support -> using layer_shell backend");
+                        Backend::LayerShell
+                    }
                 }
             }
-        })?)
+            _ => panic!("unknown XDG_SESSION_TYPE"),
+        },
+        Err(_) => {
+            panic!("could not detect session type: XDG_SESSION_TYPE environment variable not set!")
+        }
+    };
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    match backend {
+        Backend::X11 => {
+            #[cfg(not(feature = "x11"))]
+            panic!("feature x11 not enabled");
+            #[cfg(feature = "x11")]
+            Ok(Box::new(producer::x11::X11Producer::new()))
+        }
+        Backend::LayerShell => {
+            #[cfg(not(feature = "wayland"))]
+            panic!("feature wayland not enabled");
+            #[cfg(feature = "wayland")]
+            Ok(Box::new(producer::wayland::WaylandEventProducer::new()?))
+        }
+        Backend::Libei => {
+            #[cfg(not(feature = "libei"))]
+            panic!("feature libei not enabled");
+            #[cfg(feature = "libei")]
+            Ok(Box::new(producer::libei::LibeiProducer::new()?))
+        }
+    }
+}
+
+pub trait EventProducer: Stream<Item = io::Result<(ClientHandle, Event)>> + Unpin {
+    /// notify event producer of configuration changes
+    fn notify(&mut self, event: ClientEvent);
+
+    /// release mouse
+    fn release(&mut self);
 }

src/request.rs

@@ -1,139 +0,0 @@
-use std::{
-    collections::HashMap,
-    error::Error,
-    fmt::Display,
-    io::prelude::*,
-    net::{SocketAddr, TcpListener, TcpStream},
-    sync::{Arc, RwLock},
-    thread::{self, JoinHandle},
-};
-
-use memmap::MmapMut;
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub enum Request {
-    KeyMap,
-    Connect,
-}
-
-impl TryFrom<[u8; 4]> for Request {
-    fn try_from(buf: [u8; 4]) -> Result<Self, Self::Error> {
-        let val = u32::from_ne_bytes(buf);
-        match val {
-            x if x == Request::KeyMap as u32 => Ok(Self::KeyMap),
-            x if x == Request::Connect as u32 => Ok(Self::Connect),
-            _ => Err("Bad Request"),
-        }
-    }
-
-    type Error = &'static str;
-}
-
-#[derive(Clone)]
-pub struct Server {
-    data: Arc<RwLock<HashMap<Request, MmapMut>>>,
-}
-
-impl Server {
-    fn handle_request(&self, mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
-        let mut buf = [0u8; 4];
-        stream.read_exact(&mut buf)?;
-        match Request::try_from(buf) {
-            Ok(Request::KeyMap) => {
-                let data = self.data.read().unwrap();
-                let buf = data.get(&Request::KeyMap);
-                match buf {
-                    None => {
-                        stream.write(&0u32.to_ne_bytes())?;
-                    }
-                    Some(buf) => {
-                        stream.write(&buf[..].len().to_ne_bytes())?;
-                        stream.write(&buf[..])?;
-                    }
-                }
-                stream.flush()?;
-            }
-            Ok(Request::Connect) => todo!(),
-            Err(msg) => eprintln!("{}", msg),
-        }
-        Ok(())
-    }
-
-    pub fn listen(port: u16) -> Result<(Server, JoinHandle<()>), Box<dyn Error>> {
-        let data: Arc<RwLock<HashMap<Request, MmapMut>>> = Arc::new(RwLock::new(HashMap::new()));
-        let listen_addr = SocketAddr::new("0.0.0.0".parse()?, port);
-        let server = Server { data };
-        let server_copy = server.clone();
-        let listen_socket = TcpListener::bind(listen_addr)?;
-        let thread = thread::Builder::new()
-            .name("tcp server".into())
-            .spawn(move || {
-            for stream in listen_socket.incoming() {
-                match stream {
-                    Ok(stream) => {
-                        if let Err(e) = server.handle_request(stream) {
-                            eprintln!("{}", e);
-                        }
-                    }
-                    Err(e) => {
-                        eprintln!("{}", e);
-                    }
-                }
-            }
-        })?;
-        Ok((server_copy, thread))
-    }
-
-    pub fn offer_data(&self, req: Request, d: MmapMut) {
-        self.data.write().unwrap().insert(req, d);
-    }
-}
-
-#[derive(Debug)]
-pub struct BadRequest;
-
-impl Display for BadRequest {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "BadRequest")
-    }
-}
-
-impl Error for BadRequest {}
-
-pub fn request_data(addr: SocketAddr, req: Request) -> Result<Vec<u8>, Box<dyn Error>> {
-    // connect to server
-    let mut sock = match TcpStream::connect(addr) {
-        Ok(sock) => sock,
-        Err(e) => return Err(Box::new(e)),
-    };
-
-    // write the request to the socket
-    // convert to u32
-    let req: u32 = req as u32;
-    if let Err(e) = sock.write(&req.to_ne_bytes()) {
-        return Err(Box::new(e));
-    }
-    if let Err(e) = sock.flush() {
-        return Err(Box::new(e));
-    }
-
-    // read the response = (len, data) - len 0 means no data / bad request
-    // read len
-    let mut buf = [0u8; 8];
-    if let Err(e) = sock.read_exact(&mut buf[..]) {
-        return Err(Box::new(e));
-    }
-    let len = usize::from_ne_bytes(buf);
-
-    // check for bad request
-    if len == 0 {
-        return Err(Box::new(BadRequest {}));
-    }
-
-    // read the data
-    let mut data: Vec<u8> = vec![0u8; len];
-    if let Err(e) = sock.read_exact(&mut data[..]) {
-        return Err(Box::new(e));
-    }
-    Ok(data)
-}

src/server.rs

@@ -0,0 +1,553 @@
+use futures::stream::StreamExt;
+use log;
+use std::{
+    collections::HashSet,
+    error::Error,
+    io::Result,
+    net::IpAddr,
+    time::{Duration, Instant},
+};
+use tokio::{
+    io::ReadHalf,
+    net::UdpSocket,
+    signal,
+    sync::mpsc::{Receiver, Sender},
+};
+
+#[cfg(unix)]
+use tokio::net::UnixStream;
+
+#[cfg(windows)]
+use tokio::net::TcpStream;
+
+use std::{io::ErrorKind, net::SocketAddr};
+
+use crate::event::Event;
+use crate::{
+    client::{ClientEvent, ClientHandle, ClientManager, Position},
+    config::Config,
+    consumer::EventConsumer,
+    dns::{self, DnsResolver},
+    frontend::{self, FrontendEvent, FrontendListener, FrontendNotify},
+    producer::EventProducer,
+};
+
+/// keeps track of state to prevent a feedback loop
+/// of continuously sending and receiving the same event.
+#[derive(Eq, PartialEq)]
+enum State {
+    Sending,
+    Receiving,
+}
+
+pub struct Server {
+    resolver: DnsResolver,
+    client_manager: ClientManager,
+    state: State,
+    frontend: FrontendListener,
+    consumer: Box<dyn EventConsumer>,
+    producer: Box<dyn EventProducer>,
+    socket: UdpSocket,
+    frontend_rx: Receiver<FrontendEvent>,
+    frontend_tx: Sender<FrontendEvent>,
+}
+
+impl Server {
+    pub async fn new(
+        config: &Config,
+        frontend: FrontendListener,
+        consumer: Box<dyn EventConsumer>,
+        producer: Box<dyn EventProducer>,
+    ) -> anyhow::Result<Self> {
+        // create dns resolver
+        let resolver = dns::DnsResolver::new().await?;
+
+        // bind the udp socket
+        let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), config.port);
+        let socket = UdpSocket::bind(listen_addr).await?;
+        let (frontend_tx, frontend_rx) = tokio::sync::mpsc::channel(1);
+
+        // create client manager
+        let client_manager = ClientManager::new();
+        let mut server = Server {
+            frontend,
+            consumer,
+            producer,
+            resolver,
+            socket,
+            client_manager,
+            state: State::Receiving,
+            frontend_rx,
+            frontend_tx,
+        };
+
+        // add clients from config
+        for (c, h, port, p) in config.get_clients().into_iter() {
+            server.add_client(h, c, port, p).await;
+        }
+
+        Ok(server)
+    }
+
+    pub async fn run(&mut self) -> anyhow::Result<()> {
+        loop {
+            log::trace!("polling ...");
+            tokio::select! {
+                // safety: cancellation safe
+                udp_event = receive_event(&self.socket) => {
+                    log::trace!("-> receive_event");
+                    match udp_event {
+                        Ok(e) => self.handle_udp_rx(e).await,
+                        Err(e) => log::error!("error reading event: {e}"),
+                    }
+                }
+                // safety: cancellation safe
+                res = self.producer.next() => {
+                    log::trace!("-> producer.next()");
+                    match res {
+                        Some(Ok((client, event))) => {
+                            self.handle_producer_event(client,event).await;
+                        },
+                        Some(Err(e)) => log::error!("error reading from event producer: {e}"),
+                        _ => break,
+                    }
+                }
+                // safety: cancellation safe
+                stream = self.frontend.accept() => {
+                    log::trace!("-> frontend.accept()");
+                    match stream {
+                        Ok(s) => self.handle_frontend_stream(s).await,
+                        Err(e) => log::error!("error connecting to frontend: {e}"),
+                    }
+                }
+                // safety: cancellation safe
+                frontend_event = self.frontend_rx.recv() => {
+                    log::trace!("-> frontend.recv()");
+                    if let Some(event) = frontend_event {
+                        if self.handle_frontend_event(event).await {
+                            break;
+                        }
+                    }
+                }
+                // safety: cancellation safe
+                e = self.consumer.dispatch() => {
+                    log::trace!("-> consumer.dispatch()");
+                    if let Err(e) = e {
+                        return Err(e);
+                    }
+                }
+                // safety: cancellation safe
+                _ = signal::ctrl_c() => {
+                    log::info!("terminating gracefully ...");
+                    break;
+                }
+            }
+        }
+
+        // destroy consumer
+        self.consumer.destroy().await;
+
+        Ok(())
+    }
+
+    pub async fn add_client(
+        &mut self,
+        hostname: Option<String>,
+        mut addr: HashSet<IpAddr>,
+        port: u16,
+        pos: Position,
+    ) -> ClientHandle {
+        let ips = if let Some(hostname) = hostname.as_ref() {
+            match self.resolver.resolve(hostname.as_str()).await {
+                Ok(ips) => HashSet::from_iter(ips.iter().cloned()),
+                Err(e) => {
+                    log::warn!("could not resolve host: {e}");
+                    HashSet::new()
+                }
+            }
+        } else {
+            HashSet::new()
+        };
+        addr.extend(ips.iter());
+        log::info!(
+            "adding client [{}]{} @ {:?}",
+            pos,
+            hostname.as_deref().unwrap_or(""),
+            &ips
+        );
+        let client = self
+            .client_manager
+            .add_client(hostname.clone(), addr, port, pos);
+        log::debug!("add_client {client}");
+        let notify = FrontendNotify::NotifyClientCreate(client, hostname, port, pos);
+        if let Err(e) = self.frontend.notify_all(notify).await {
+            log::error!("error notifying frontend: {e}");
+        };
+        client
+    }
+
+    pub async fn activate_client(&mut self, client: ClientHandle, active: bool) {
+        if let Some(state) = self.client_manager.get_mut(client) {
+            state.active = active;
+            if state.active {
+                self.producer
+                    .notify(ClientEvent::Create(client, state.client.pos));
+                self.consumer
+                    .notify(ClientEvent::Create(client, state.client.pos))
+                    .await;
+            } else {
+                self.producer.notify(ClientEvent::Destroy(client));
+                self.consumer.notify(ClientEvent::Destroy(client)).await;
+            }
+        }
+    }
+
+    pub async fn remove_client(&mut self, client: ClientHandle) -> Option<ClientHandle> {
+        self.producer.notify(ClientEvent::Destroy(client));
+        self.consumer.notify(ClientEvent::Destroy(client)).await;
+        if let Some(client) = self
+            .client_manager
+            .remove_client(client)
+            .map(|s| s.client.handle)
+        {
+            let notify = FrontendNotify::NotifyClientDelete(client);
+            log::debug!("{notify:?}");
+            if let Err(e) = self.frontend.notify_all(notify).await {
+                log::error!("error notifying frontend: {e}");
+            }
+            Some(client)
+        } else {
+            None
+        }
+    }
+
+    pub async fn update_client(
+        &mut self,
+        client: ClientHandle,
+        hostname: Option<String>,
+        port: u16,
+        pos: Position,
+    ) {
+        // retrieve state
+        let Some(state) = self.client_manager.get_mut(client) else {
+            return;
+        };
+
+        // update pos
+        state.client.pos = pos;
+        if state.active {
+            self.producer.notify(ClientEvent::Destroy(client));
+            self.consumer.notify(ClientEvent::Destroy(client)).await;
+            self.producer.notify(ClientEvent::Create(client, pos));
+            self.consumer.notify(ClientEvent::Create(client, pos)).await;
+        }
+
+        // update port
+        if state.client.port != port {
+            state.client.port = port;
+            state.client.addrs = state
+                .client
+                .addrs
+                .iter()
+                .cloned()
+                .map(|mut a| {
+                    a.set_port(port);
+                    a
+                })
+                .collect();
+            state
+                .client
+                .active_addr
+                .map(|a| SocketAddr::new(a.ip(), port));
+        }
+
+        // update hostname
+        if state.client.hostname != hostname {
+            state.client.addrs = HashSet::new();
+            state.client.active_addr = None;
+            state.client.hostname = hostname;
+            if let Some(hostname) = state.client.hostname.as_ref() {
+                match self.resolver.resolve(hostname.as_str()).await {
+                    Ok(ips) => {
+                        let addrs = ips.iter().map(|i| SocketAddr::new(*i, port));
+                        state.client.addrs = HashSet::from_iter(addrs);
+                    }
+                    Err(e) => {
+                        log::warn!("could not resolve host: {e}");
+                    }
+                }
+            }
+        }
+        log::debug!("client updated: {:?}", state);
+    }
+
+    async fn handle_udp_rx(&mut self, event: (Event, SocketAddr)) {
+        let (event, addr) = event;
+
+        // get handle for addr
+        let handle = match self.client_manager.get_client(addr) {
+            Some(a) => a,
+            None => {
+                log::warn!("ignoring event from client {addr:?}");
+                return;
+            }
+        };
+
+        log::trace!("{:20} <-<-<-<------ {addr} ({handle})", event.to_string());
+        let state = match self.client_manager.get_mut(handle) {
+            Some(s) => s,
+            None => {
+                log::error!("unknown handle");
+                return;
+            }
+        };
+
+        // reset ttl for client and
+        state.last_seen = Some(Instant::now());
+        // set addr as new default for this client
+        state.client.active_addr = Some(addr);
+        match (event, addr) {
+            (Event::Pong(), _) => {}
+            (Event::Ping(), addr) => {
+                if let Err(e) = send_event(&self.socket, Event::Pong(), addr).await {
+                    log::error!("udp send: {}", e);
+                }
+                // we release the mouse here,
+                // since its very likely, that we wont get a release event
+                self.producer.release();
+            }
+            (event, addr) => match self.state {
+                State::Sending => {
+                    // in sending state, we dont want to process
+                    // any events to avoid feedback loops,
+                    // therefore we tell the event producer
+                    // to release the pointer and move on
+                    // first event -> release pointer
+                    if let Event::Release() = event {
+                        log::debug!("releasing pointer ...");
+                        self.producer.release();
+                        self.state = State::Receiving;
+                    }
+                }
+                State::Receiving => {
+                    // consume event
+                    self.consumer.consume(event, handle).await;
+
+                    // let the server know we are still alive once every second
+                    let last_replied = state.last_replied;
+                    if last_replied.is_none()
+                        || last_replied.is_some()
+                            && last_replied.unwrap().elapsed() > Duration::from_secs(1)
+                    {
+                        state.last_replied = Some(Instant::now());
+                        if let Err(e) = send_event(&self.socket, Event::Pong(), addr).await {
+                            log::error!("udp send: {}", e);
+                        }
+                    }
+                }
+            },
+        }
+    }
+
+    async fn handle_producer_event(&mut self, c: ClientHandle, e: Event) {
+        let mut should_release = false;
+        // in receiving state, only release events
+        // must be transmitted
+        if let Event::Release() = e {
+            self.state = State::Sending;
+        }
+
+        log::trace!("producer: ({c}) {e:?}");
+        let state = match self.client_manager.get_mut(c) {
+            Some(state) => state,
+            None => {
+                log::warn!("unknown client!");
+                return;
+            }
+        };
+        // otherwise we should have an address to send to
+        // transmit events to the corrensponding client
+        if let Some(addr) = state.client.active_addr {
+            if let Err(e) = send_event(&self.socket, e, addr).await {
+                log::error!("udp send: {}", e);
+            }
+        }
+
+        // if client last responded > 2 seconds ago
+        // and we have not sent a ping since 500 milliseconds,
+        // send a ping
+        if state.last_seen.is_some() && state.last_seen.unwrap().elapsed() < Duration::from_secs(2)
+        {
+            return;
+        }
+
+        // client last seen > 500ms ago
+        if state.last_ping.is_some()
+            && state.last_ping.unwrap().elapsed() < Duration::from_millis(500)
+        {
+            return;
+        }
+
+        // release mouse if client didnt respond to the first ping
+        if state.last_ping.is_some() && state.last_ping.unwrap().elapsed() < Duration::from_secs(1)
+        {
+            should_release = true;
+        }
+
+        // last ping > 500ms ago -> ping all interfaces
+        state.last_ping = Some(Instant::now());
+        for addr in state.client.addrs.iter() {
+            log::debug!("pinging {addr}");
+            if let Err(e) = send_event(&self.socket, Event::Ping(), *addr).await {
+                if e.kind() != ErrorKind::WouldBlock {
+                    log::error!("udp send: {}", e);
+                }
+            }
+            // send additional release event, in case client is still in sending mode
+            if let Err(e) = send_event(&self.socket, Event::Release(), *addr).await {
+                if e.kind() != ErrorKind::WouldBlock {
+                    log::error!("udp send: {}", e);
+                }
+            }
+        }
+
+        if should_release && self.state != State::Receiving {
+            log::info!("client not responding - releasing pointer");
+            self.producer.release();
+            self.state = State::Receiving;
+        }
+    }
+
+    #[cfg(unix)]
+    async fn handle_frontend_stream(&mut self, mut stream: ReadHalf<UnixStream>) {
+        use std::io;
+
+        let tx = self.frontend_tx.clone();
+        tokio::task::spawn_local(async move {
+            loop {
+                let event = frontend::read_event(&mut stream).await;
+                match event {
+                    Ok(event) => tx.send(event).await.unwrap(),
+                    Err(e) => {
+                        if let Some(e) = e.downcast_ref::<io::Error>() {
+                            if e.kind() == ErrorKind::UnexpectedEof {
+                                return;
+                            }
+                        }
+                        log::error!("error reading frontend event: {e}");
+                    }
+                }
+            }
+        });
+        self.enumerate().await;
+    }
+
+    #[cfg(windows)]
+    async fn handle_frontend_stream(&mut self, mut stream: ReadHalf<TcpStream>) {
+        let tx = self.frontend_tx.clone();
+        tokio::task::spawn_local(async move {
+            loop {
+                let event = frontend::read_event(&mut stream).await;
+                match event {
+                    Ok(event) => tx.send(event).await.unwrap(),
+                    Err(e) => log::error!("error reading frontend event: {e}"),
+                }
+            }
+        });
+        self.enumerate().await;
+    }
+
+    async fn handle_frontend_event(&mut self, event: FrontendEvent) -> bool {
+        log::debug!("frontend: {event:?}");
+        match event {
+            FrontendEvent::AddClient(hostname, port, pos) => {
+                self.add_client(hostname, HashSet::new(), port, pos).await;
+            }
+            FrontendEvent::ActivateClient(client, active) => {
+                self.activate_client(client, active).await
+            }
+            FrontendEvent::ChangePort(port) => {
+                let current_port = self.socket.local_addr().unwrap().port();
+                if current_port == port {
+                    if let Err(e) = self
+                        .frontend
+                        .notify_all(FrontendNotify::NotifyPortChange(port, None))
+                        .await
+                    {
+                        log::warn!("error notifying frontend: {e}");
+                    }
+                    return false;
+                }
+                let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), port);
+                match UdpSocket::bind(listen_addr).await {
+                    Ok(socket) => {
+                        self.socket = socket;
+                        if let Err(e) = self
+                            .frontend
+                            .notify_all(FrontendNotify::NotifyPortChange(port, None))
+                            .await
+                        {
+                            log::warn!("error notifying frontend: {e}");
+                        }
+                    }
+                    Err(e) => {
+                        log::warn!("could not change port: {e}");
+                        let port = self.socket.local_addr().unwrap().port();
+                        if let Err(e) = self
+                            .frontend
+                            .notify_all(FrontendNotify::NotifyPortChange(
+                                port,
+                                Some(format!("could not change port: {e}")),
+                            ))
+                            .await
+                        {
+                            log::error!("error notifying frontend: {e}");
+                        }
+                    }
+                }
+            }
+            FrontendEvent::DelClient(client) => {
+                self.remove_client(client).await;
+            }
+            FrontendEvent::Enumerate() => self.enumerate().await,
+            FrontendEvent::Shutdown() => {
+                log::info!("terminating gracefully...");
+                return true;
+            }
+            FrontendEvent::UpdateClient(client, hostname, port, pos) => {
+                self.update_client(client, hostname, port, pos).await
+            }
+        }
+        false
+    }
+
+    async fn enumerate(&mut self) {
+        let clients = self.client_manager.enumerate();
+        if let Err(e) = self
+            .frontend
+            .notify_all(FrontendNotify::Enumerate(clients))
+            .await
+        {
+            log::error!("error notifying frontend: {e}");
+        }
+    }
+}
+
+async fn receive_event(
+    socket: &UdpSocket,
+) -> std::result::Result<(Event, SocketAddr), Box<dyn Error>> {
+    log::trace!("receive_event");
+    let mut buf = vec![0u8; 22];
+    match socket.recv_from(&mut buf).await {
+        Ok((_amt, src)) => Ok((Event::try_from(buf)?, src)),
+        Err(e) => Err(Box::new(e)),
+    }
+}
+
+async fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize> {
+    log::trace!("{:20} ------>->->-> {addr}", e.to_string());
+    let data: Vec<u8> = (&e).into();
+    // We are currently abusing a blocking send to get the lowest possible latency.
+    // It may be better to set the socket to non-blocking and only send when ready.
+    sock.send_to(&data[..], addr).await
+}