Update README.md

.github/workflows/pre-release.yml

@@ -94,9 +94,7 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: |
+      run: cargo bundle --release
-        cargo bundle --release
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
@@ -122,9 +120,7 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: |
+      run: cargo bundle --release
-        cargo bundle --release
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx

.github/workflows/rust.yml

@@ -112,9 +112,7 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: |
+      run: cargo bundle
-        cargo bundle
-        scripts/copy-macos-dylib.sh
     - name: Zip bundle
       run: |
         cd target/debug/bundle/osx
@@ -144,9 +142,7 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: |
+      run: cargo bundle
-        cargo bundle
-        scripts/copy-macos-dylib.sh
     - name: Zip bundle
       run: |
         cd target/debug/bundle/osx

.github/workflows/tagged-release.yml

@@ -90,9 +90,7 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: |
+      run: cargo bundle --release
-        cargo bundle --release
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
@@ -118,9 +116,7 @@ jobs:
     - name: Install cargo bundle
       run: cargo install cargo-bundle
     - name: Bundle
-      run: |
+      run: cargo bundle --release
-        cargo bundle --release
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx

.gitignore

@@ -8,7 +8,3 @@ result
 *.pem
 *.csr
 extfile.conf
-
-# flatpak files
-.flatpak-builder
-repo

Cargo.toml

@@ -24,7 +24,7 @@ strip = true
 panic = "abort"
 
 [build-dependencies]
-shadow-rs = "1.2.0"
+shadow-rs = "0.38.0"
 
 [dependencies]
 input-event = { path = "input-event", version = "0.3.0" }
@@ -34,9 +34,9 @@ lan-mouse-cli = { path = "lan-mouse-cli", version = "0.2.0" }
 lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.2.0", optional = true }
 lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.2.0" }
 lan-mouse-proto = { path = "lan-mouse-proto", version = "0.2.0" }
-shadow-rs = { version = "1.2.0", features = ["metadata"] }
+shadow-rs = { version = "0.38.0", features = ["metadata"] }
 
-hickory-resolver = "0.25.2"
+hickory-resolver = "0.24.1"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4.20"
@@ -58,8 +58,8 @@ slab = "0.4.9"
 thiserror = "2.0.0"
 tokio-util = "0.7.11"
 local-channel = "0.1.5"
-webrtc-dtls = { version = "0.12.0", features = ["pem"] }
+webrtc-dtls = { version = "0.10.0", features = ["pem"] }
-webrtc-util = "0.11.0"
+webrtc-util = "0.9.0"
 rustls = { version = "0.23.12", default-features = false, features = [
     "std",
     "ring",

README.md

@@ -81,37 +81,15 @@ paru -S lan-mouse-git
 - flake: [README.md](./nix/README.md)
 </details>
 
-<details>
-    <summary>Fedora</summary>
-You can install Lan Mouse from the [Terra Repository](https://terra.fyralabs.com).
-
-
-After enabling Terra:
-
-```sh
-dnf install lan-mouse
-```
-</details>
-
-<details>
-    <summary>MacOS</summary>
-
-- Download the package for your Mac (Intel or ARM) from the releases page
-- Unzip it
-- Remove the quarantine with `xattr -rd com.apple.quarantine "Lan Mouse.app"`
-- Launch the app
-- Grant accessibility permissions in System Preferences
-
-</details>
 
 
 <details>
     <summary>Manual Installation</summary>
 
-First make sure to [install the necessary dependencies](#installing-dependencies-for-development--compiling-from-source).
+First make sure to [install the necessary dependencies](#installing-dependencies).
 
 Precompiled release binaries for Windows, MacOS and Linux are available in the [releases section](https://github.com/feschber/lan-mouse/releases).
-For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies-for-development--compiling-from-source).
+For Windows, the depenedencies are included in the .zip file, for other operating systems see [Installing Dependencies](#installing-dependencies).
 
 Alternatively, the `lan-mouse` binary can be compiled from source (see below).
 
@@ -183,15 +161,7 @@ For a detailed list of available features, checkout the [Cargo.toml](./Cargo.tom
     <summary>MacOS</summary>
 
 ```sh
-# Install dependencies
+brew install libadwaita pkg-config
-brew install libadwaita pkg-config imagemagick
-cargo install cargo-bundle
-# Create the macOS icon file
-scripts/makeicns.sh
-# Create the .app bundle
-cargo bundle
-# Copy all dynamic libraries into the bundle, and update the bundle to find them there
-scripts/copy-macos-dylib.sh
 ```
 </details>
 
@@ -298,17 +268,19 @@ If the device still can not be entered, make sure you have UDP port `4242` (or t
 <details>
     <summary>Command Line Interface</summary>
 
-The cli interface can be accessed by passing `cli` as a commandline argument.
+The cli interface can be enabled using `--frontend cli` as commandline arguments.
-Use
+Type `help` to list the available commands.
-```sh
-lan-mouse cli help
-```
- to list the available commands and
-```sh
-lan-mouse cli <cmd> help
-```
-for information on how to use a specific command.
 
+E.g.:
+```sh
+$ cargo run --release -- --frontend cli
+(...)
+> connect <host> left|right|top|bottom
+(...)
+> list
+(...)
+> activate 0
+```
 </details>
 
 <details>
@@ -316,10 +288,10 @@ for information on how to use a specific command.
 
 Lan Mouse can be launched in daemon mode to keep it running in the background (e.g. for use in a systemd-service).
 
-To do so, use the `daemon` subcommand:
+To do so, add `--daemon` to the commandline args:
 
 ```sh
-lan-mouse daemon
+lan-mouse --daemon
 ```
 
 In order to start lan-mouse with a graphical session automatically,
@@ -354,6 +326,9 @@ release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
 
 # optional port (defaults to 4242)
 port = 4242
+# # optional frontend -> defaults to gtk if available
+# # possible values are "cli" and "gtk"
+# frontend = "gtk"
 
 # list of authorized tls certificate fingerprints that
 # are accepted for incoming traffic
@@ -361,9 +336,7 @@ port = 4242
 "bc:05:ab:7a:a4:de:88:8c:2f:92:ac:bc:b8:49:b8:24:0d:44:b3:e6:a4:ef:d7:0b:6c:69:6d:77:53:0b:14:80" = "iridium"
 
 # define a client on the right side with host name "iridium"
-[[clients]]
+[right]
-# position (left | right | top | bottom)
-position = "right"
 # hostname
 hostname = "iridium"
 # activate this client immediately when lan-mouse is started
@@ -372,8 +345,7 @@ activate_on_startup = true
 ips = ["192.168.178.156"]
 
 # define a client on the left side with IP address 192.168.178.189
-[[clients]]
+[left]
-position = "left"
 # The hostname is optional: When no hostname is specified,
 # at least one ip address needs to be specified.
 hostname = "thorium"

build-aux/de.feschber.LanMouse.yml

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

config.toml

@@ -1,10 +1,14 @@
 # example configuration
 
-# configure release bind
+# capture_backend = "LayerShell"
-release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
+
+# release bind
+release_bind = ["KeyA", "KeyS", "KeyD", "KeyF"]
 
 # optional port (defaults to 4242)
 port = 4242
+# optional frontend -> defaults to gtk if available
+# frontend = "gtk"
 
 # list of authorized tls certificate fingerprints that
 # are accepted for incoming traffic
@@ -12,19 +16,14 @@ port = 4242
 "bc:05:ab:7a:a4:de:88:8c:2f:92:ac:bc:b8:49:b8:24:0d:44:b3:e6:a4:ef:d7:0b:6c:69:6d:77:53:0b:14:80" = "iridium"
 
 # define a client on the right side with host name "iridium"
-[[clients]]
+[right]
-# position (left | right | top | bottom)
-position = "right"
 # hostname
 hostname = "iridium"
-# activate this client immediately when lan-mouse is started
-activate_on_startup = true
 # optional list of (known) ip addresses
 ips = ["192.168.178.156"]
 
 # define a client on the left side with IP address 192.168.178.189
-[[clients]]
+[left]
-position = "left"
 # The hostname is optional: When no hostname is specified,
 # at least one ip address needs to be specified.
 hostname = "thorium"

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

dylibs/.gitignore

@@ -1 +0,0 @@
-*

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1752687322,
+        "lastModified": 1740560979,
-        "narHash": "sha256-RKwfXA4OZROjBTQAl9WOZQFm7L8Bo93FQwSJpAiSRvo=",
+        "narHash": "sha256-Vr3Qi346M+8CjedtbyUevIGDZW8LcA1fTG0ugPY/Hic=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "6e987485eb2c77e5dcc5af4e3c70843711ef9251",
+        "rev": "5135c59491985879812717f4c9fea69604e7f26f",
         "type": "github"
       },
       "original": {
@@ -29,11 +29,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1752806774,
+        "lastModified": 1740623427,
-        "narHash": "sha256-4cHeoR2roN7d/3J6gT+l6o7J2hTrBIUiCwVdDNMeXzE=",
+        "narHash": "sha256-3SdPQrZoa4odlScFDUHd4CUPQ/R1gtH4Mq9u8CBiK8M=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "3c90219b3ba1c9790c45a078eae121de48a39c55",
+        "rev": "d342e8b5fd88421ff982f383c853f0fc78a847ab",
         "type": "github"
       },
       "original": {

input-capture/Cargo.toml

@@ -40,21 +40,21 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.10", default-features = false, features = [
     "tokio",
 ], optional = true }
-reis = { version = "0.5.0", features = ["tokio"], optional = true }
+reis = { version = "0.4", features = ["tokio"], optional = true }
 
 [target.'cfg(target_os="macos")'.dependencies]
-core-graphics = { version = "0.25.0", features = ["highsierra"] }
+core-graphics = { version = "0.24.0", features = ["highsierra"] }
 core-foundation = "0.10.0"
 core-foundation-sys = "0.8.6"
 libc = "0.2.155"
-keycode = "1.0.0"
+keycode = "0.4.0"
 bitflags = "2.6.0"
 
 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.61.2", features = [
+windows = { version = "0.58.0", features = [
     "Win32_System_LibraryLoader",
     "Win32_System_Threading",
     "Win32_Foundation",

input-capture/src/layer_shell.rs

@@ -535,7 +535,7 @@ impl State {
     fn update_windows(&mut self) {
         log::info!("active outputs: ");
         for output in self.outputs.iter().filter(|o| o.info.is_some()) {
-            log::info!(" * {output}");
+            log::info!(" * {}", output);
         }
 
         self.active_windows.clear();
@@ -582,17 +582,17 @@ impl Inner {
         match self.queue.dispatch_pending(&mut self.state) {
             Ok(_) => {}
             Err(DispatchError::Backend(WaylandError::Io(e))) => {
-                log::error!("Wayland Error: {e}");
+                log::error!("Wayland Error: {}", e);
             }
             Err(DispatchError::Backend(e)) => {
-                panic!("backend error: {e}");
+                panic!("backend error: {}", e);
             }
             Err(DispatchError::BadMessage {
                 sender_id,
                 interface,
                 opcode,
             }) => {
-                panic!("bad message {sender_id}, {interface} , {opcode}");
+                panic!("bad message {}, {} , {}", sender_id, interface, opcode);
             }
         }
     }
@@ -813,7 +813,7 @@ impl Dispatch<WlPointer, ()> for State {
                     })),
                 ));
             }
-            wl_pointer::Event::Frame => {
+            wl_pointer::Event::Frame {} => {
                 // TODO properly handle frame events
                 // we simply insert a frame event on the client side
                 // after each event for now
@@ -974,7 +974,7 @@ impl Dispatch<ZxdgOutputV1, u32> for State {
             .find(|o| o.global.name == *name)
             .expect("output");
 
-        log::debug!("xdg_output {name} - {event:?}");
+        log::debug!("xdg_output {name} - {:?}", event);
         match event {
             zxdg_output_v1::Event::LogicalPosition { x, y } => {
                 output.pending_info.position = (x, y);
@@ -1010,7 +1010,7 @@ impl Dispatch<WlOutput, u32> for State {
         _conn: &Connection,
         _qhandle: &QueueHandle<Self>,
     ) {
-        log::debug!("wl_output {name} - {event:?}");
+        log::debug!("wl_output {name} - {:?}", event);
         if let wl_output::Event::Done = event {
             state.update_output_info(*name);
         }

input-capture/src/lib.rs

@@ -79,7 +79,7 @@ impl Display for Position {
             Position::Top => "top",
             Position::Bottom => "bottom",
         };
-        write!(f, "{pos}")
+        write!(f, "{}", pos)
     }
 }
 

input-capture/src/libei.rs

@@ -587,13 +587,9 @@ impl LanMouseInputCapture for LibeiInputCapture<'_> {
         self.cancellation_token.cancel();
         let task = &mut self.capture_task;
         log::debug!("waiting for capture to terminate...");
-        let res = if !task.is_finished() {
+        let res = task.await.expect("libei task panic");
-            task.await.expect("libei task panic")
-        } else {
-            Ok(())
-        };
-        self.terminated = true;
         log::debug!("done!");
+        self.terminated = true;
         res
     }
 }

input-capture/src/macos.rs

@@ -10,7 +10,7 @@ use core_graphics::base::{kCGErrorSuccess, CGError};
 use core_graphics::display::{CGDisplay, CGPoint};
 use core_graphics::event::{
     CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
-    CGEventTapProxy, CGEventType, CallbackResult, EventField,
+    CGEventTapProxy, CGEventType, EventField,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use futures_core::Stream;
@@ -390,15 +390,15 @@ fn create_event_tap<'a>(
 
             if let Some(pos) = pos {
                 res_events.iter().for_each(|e| {
-                    // error must be ignored, since the event channel
+                    event_tx
-                    // may already be closed when the InputCapture instance is dropped.
+                        .blocking_send((pos, *e))
-                    let _ = event_tx.blocking_send((pos, *e));
+                        .expect("Failed to send event");
                 });
-                // Returning Drop should stop the event from being processed
+                // Returning None should stop the event from being processed
                 // but core fundation still returns the event
                 cg_ev.set_type(CGEventType::Null);
             }
-            CallbackResult::Replace(cg_ev.to_owned())
+            Some(cg_ev.to_owned())
         };
 
     let tap = CGEventTap::new(
@@ -411,7 +411,7 @@ fn create_event_tap<'a>(
     .map_err(|_| MacosCaptureCreationError::EventTapCreation)?;
 
     let tap_source: CFRunLoopSource = tap
-        .mach_port()
+        .mach_port
         .create_runloop_source(0)
         .expect("Failed creating loop source");
 
@@ -426,8 +426,8 @@ fn event_tap_thread(
     client_state: Arc<Mutex<InputCaptureState>>,
     event_tx: Sender<(Position, CaptureEvent)>,
     notify_tx: Sender<ProducerEvent>,
-    ready: std::sync::mpsc::Sender<Result<CFRunLoop, MacosCaptureCreationError>>,
+    ready: std::sync::mpsc::Sender<Result<(), MacosCaptureCreationError>>,
-    exit: oneshot::Sender<()>,
+    exit: oneshot::Sender<Result<(), &'static str>>,
 ) {
     let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
         Err(e) => {
@@ -435,22 +435,18 @@ fn event_tap_thread(
             return;
         }
         Ok(tap) => {
-            let run_loop = CFRunLoop::get_current();
+            ready.send(Ok(())).expect("channel closed");
-            ready.send(Ok(run_loop)).expect("channel closed");
             tap
         }
     };
-    log::debug!("running CFRunLoop...");
     CFRunLoop::run_current();
-    log::debug!("event tap thread exiting!...");
 
-    let _ = exit.send(());
+    let _ = exit.send(Err("tap thread exited"));
 }
 
 pub struct MacOSInputCapture {
     event_rx: Receiver<(Position, CaptureEvent)>,
     notify_tx: Sender<ProducerEvent>,
-    run_loop: CFRunLoop,
 }
 
 impl MacOSInputCapture {
@@ -479,44 +475,36 @@ impl MacOSInputCapture {
         });
 
         // wait for event tap creation result
-        let run_loop = ready_rx.recv().expect("channel closed")?;
+        ready_rx.recv().expect("channel closed")?;
 
         let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
             loop {
                 tokio::select! {
                     producer_event = notify_rx.recv() => {
-                        let Some(producer_event) = producer_event else {
+                        let producer_event = producer_event.expect("channel closed");
-                            break;
-                        };
                         let mut state = state.lock().await;
                         state.handle_producer_event(producer_event).await.unwrap_or_else(|e| {
                             log::error!("Failed to handle producer event: {e}");
                         })
                     }
 
-                    _ = &mut tap_exit_rx => {
+                    res = &mut tap_exit_rx => {
-                        break;
+                        if let Err(e) = res.expect("channel closed") {
+                            log::error!("Tap thread failed: {:?}", e);
+                            break;
+                        }
                     }
                 }
             }
-            // show cursor
-            let _ = CGDisplay::show_cursor(&CGDisplay::main());
         });
 
         Ok(Self {
             event_rx,
             notify_tx,
-            run_loop,
         })
     }
 }
 
-impl Drop for MacOSInputCapture {
-    fn drop(&mut self) {
-        self.run_loop.stop();
-    }
-}
-
 #[async_trait]
 impl Capture for MacOSInputCapture {
     async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {

input-capture/src/windows/event_thread.rs

@@ -9,7 +9,7 @@ use std::thread;
 use tokio::sync::mpsc::error::TrySendError;
 use tokio::sync::mpsc::Sender;
 use windows::core::{w, PCWSTR};
-use windows::Win32::Foundation::{FALSE, HWND, LPARAM, LRESULT, RECT, WPARAM};
+use windows::Win32::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
 use windows::Win32::Graphics::Gdi::{
     EnumDisplayDevicesW, EnumDisplaySettingsW, DEVMODEW, DISPLAY_DEVICEW,
     DISPLAY_DEVICE_ATTACHED_TO_DESKTOP, ENUM_CURRENT_SETTINGS,
@@ -19,10 +19,10 @@ use windows::Win32::System::Threading::GetCurrentThreadId;
 
 use windows::Win32::UI::WindowsAndMessaging::{
     CallNextHookEx, CreateWindowExW, DispatchMessageW, GetMessageW, PostThreadMessageW,
-    RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HOOKPROC,
+    RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HHOOK,
-    KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL, WH_MOUSE_LL,
+    HMENU, HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL,
-    WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN, WM_LBUTTONUP,
+    WH_MOUSE_LL, WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN,
-    WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
+    WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_RBUTTONDOWN,
     WM_RBUTTONUP, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_USER, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSW,
     WNDPROC,
 };
@@ -128,7 +128,7 @@ thread_local! {
 fn get_msg() -> Option<MSG> {
     unsafe {
         let mut msg = std::mem::zeroed();
-        let ret = GetMessageW(addr_of_mut!(msg), None, 0, 0);
+        let ret = GetMessageW(addr_of_mut!(msg), HWND::default(), 0, 0);
         match ret.0 {
             0 => None,
             x if x > 0 => Some(msg),
@@ -176,15 +176,14 @@ fn start_routine(
 
     /* register hooks */
     unsafe {
-        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, None, 0).unwrap();
+        let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
-        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, None, 0).unwrap();
+        let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
     }
 
     let instance = unsafe { GetModuleHandleW(None).unwrap() };
-    let instance = instance.into();
     let window_class: WNDCLASSW = WNDCLASSW {
         lpfnWndProc: window_proc,
-        hInstance: instance,
+        hInstance: instance.into(),
         lpszClassName: w!("lan-mouse-message-window-class"),
         ..Default::default()
     };
@@ -214,9 +213,9 @@ fn start_routine(
             0,
             0,
             0,
-            None,
+            HWND::default(),
-            None,
+            HMENU::default(),
-            Some(instance),
+            instance,
             None,
         )
         .expect("CreateWindowExW");
@@ -313,7 +312,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
 
     /* no client was active */
     if !active {
-        return CallNextHookEx(None, ncode, wparam, lparam);
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
     }
 
     /* get active client if any */
@@ -338,7 +337,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
 unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
     /* get active client if any */
     let Some(client) = ACTIVE_CLIENT.get() else {
-        return CallNextHookEx(None, ncode, wparam, lparam);
+        return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
     };
 
     /* convert to key event */
@@ -389,10 +388,7 @@ fn enumerate_displays(display_rects: &mut Vec<RECT>) {
             if ret == FALSE {
                 break;
             }
-            if device
+            if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
-                .StateFlags
-                .contains(DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
-            {
                 devices.push(device.DeviceName);
             }
         }
@@ -541,10 +537,6 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
                 state: if p == WM_XBUTTONDOWN as usize { 1 } else { 0 },
             })
         }
-        WPARAM(p) if p == WM_MOUSEHWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
-            axis: 1, // Horizontal
-            value: mouse_low_level.mouseData as i32 >> 16,
-        }),
         w => {
             log::warn!("unknown mouse event: {w:?}");
             None

input-emulation/Cargo.toml

@@ -39,18 +39,18 @@ wayland-protocols-misc = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.10", default-features = false, features = [
     "tokio",
 ], optional = true }
-reis = { version = "0.5.0", features = ["tokio"], optional = true }
+reis = { version = "0.4", features = ["tokio"], optional = true }
 
 [target.'cfg(target_os="macos")'.dependencies]
 bitflags = "2.6.0"
-core-graphics = { version = "0.25.0", features = ["highsierra"] }
+core-graphics = { version = "0.24.0", features = ["highsierra"] }
-keycode = "1.0.0"
+keycode = "0.4.0"
 
 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.61.2", features = [
+windows = { version = "0.58.0", features = [
     "Win32_System_LibraryLoader",
     "Win32_System_Threading",
     "Win32_Foundation",

input-emulation/src/macos.rs

@@ -161,12 +161,12 @@ fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
     };
 
     if error != 0 {
-        log::warn!("error getting displays at point ({x}, {y}): {error}");
+        log::warn!("error getting displays at point ({}, {}): {}", x, y, error);
         return Option::None;
     }
 
     if display_count == 0 {
-        log::debug!("no displays found at point ({x}, {y})");
+        log::debug!("no displays found at point ({}, {})", x, y);
         return Option::None;
     }
 
@@ -343,10 +343,9 @@ impl Emulation for MacOSEmulation {
                     event.post(CGEventTapLocation::HID);
                 }
                 PointerEvent::AxisDiscrete120 { axis, value } => {
-                    const LINES_PER_STEP: i32 = 3;
                     let (count, wheel1, wheel2, wheel3) = match axis {
-                        0 => (1, value / (120 / LINES_PER_STEP), 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
+                        0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
-                        1 => (2, 0, value / (120 / LINES_PER_STEP), 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
+                        1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
                         _ => {
                             log::warn!("invalid scroll event: {axis}, {value}");
                             return Ok(());
@@ -354,7 +353,7 @@ impl Emulation for MacOSEmulation {
                     };
                     let event = match CGEvent::new_scroll_event(
                         self.event_source.clone(),
-                        ScrollEventUnit::LINE,
+                        ScrollEventUnit::PIXEL,
                         count,
                         wheel1,
                         wheel2,

input-emulation/src/wlroots.rs

@@ -12,7 +12,7 @@ use wayland_client::backend::WaylandError;
 use wayland_client::WEnum;
 
 use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
-use wayland_client::protocol::wl_pointer::{Axis, AxisSource, ButtonState};
+use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
 use wayland_protocols_wlr::virtual_pointer::v1::client::{
     zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
@@ -163,13 +163,13 @@ impl Emulation for WlrootsEmulation {
     async fn create(&mut self, handle: EmulationHandle) {
         self.state.add_client(handle);
         if let Err(e) = self.queue.flush() {
-            log::error!("{e}");
+            log::error!("{}", e);
         }
     }
     async fn destroy(&mut self, handle: EmulationHandle) {
         self.state.destroy_client(handle);
         if let Err(e) = self.queue.flush() {
-            log::error!("{e}");
+            log::error!("{}", e);
         }
     }
     async fn terminate(&mut self) {
@@ -210,8 +210,7 @@ impl VirtualInput {
                     PointerEvent::AxisDiscrete120 { axis, value } => {
                         let axis: Axis = (axis as u32).try_into()?;
                         self.pointer
-                            .axis_discrete(now, axis, value as f64 / 8., value / 120);
+                            .axis_discrete(now, axis, value as f64 / 6., value / 120);
-                        self.pointer.axis_source(AxisSource::Wheel);
                         self.pointer.frame();
                     }
                 }
@@ -222,7 +221,7 @@ impl VirtualInput {
                     self.keyboard.key(time, key, state as u32);
                     if let Ok(mut mods) = self.modifiers.lock() {
                         if mods.update_by_key_event(key, state) {
-                            log::trace!("Key triggers modifier change: {mods:?}");
+                            log::trace!("Key triggers modifier change: {:?}", mods);
                             self.keyboard.modifiers(
                                 mods.mask_pressed().bits(),
                                 0,
@@ -331,7 +330,7 @@ impl XMods {
 
     fn update_by_key_event(&mut self, key: u32, state: u8) -> bool {
         if let Ok(key) = scancode::Linux::try_from(key) {
-            log::trace!("Attempting to process modifier from: {key:#?}");
+            log::trace!("Attempting to process modifier from: {:#?}", key);
             let pressed_mask = match key {
                 scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
                 scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
@@ -349,7 +348,7 @@ impl XMods {
 
             // unchanged
             if pressed_mask.is_empty() && locked_mask.is_empty() {
-                log::trace!("{key:#?} is not a modifier key");
+                log::trace!("{:#?} is not a modifier key", key);
                 return false;
             }
             match state {

input-emulation/src/x11.rs

@@ -23,7 +23,7 @@ impl X11Emulation {
     pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
         let display = unsafe {
             match xlib::XOpenDisplay(ptr::null()) {
-                d if std::ptr::eq(d, ptr::null_mut::<xlib::Display>()) => {
+                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
                     Err(X11EmulationCreationError::OpenDisplay)
                 }
                 display => Ok(display),

input-emulation/src/xdg_desktop_portal.rs

@@ -143,6 +143,7 @@ impl Emulation for DesktopPortalEmulation<'_> {
 
 impl AsyncDrop for DesktopPortalEmulation<'_> {
     #[doc = r" Perform the async cleanup."]
+    #[must_use]
     #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
     fn async_drop<'async_trait>(
         self,

input-event/Cargo.toml

@@ -14,7 +14,7 @@ serde = { version = "1.0", features = ["derive"] }
 thiserror = "2.0.0"
 
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-reis = { version = "0.5.0", optional = true }
+reis = { version = "0.4", optional = true }
 
 [features]
 default = ["libei"]

input-event/src/lib.rs

@@ -112,8 +112,8 @@ impl Display for KeyboardEvent {
 impl Display for Event {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Event::Pointer(p) => write!(f, "{p}"),
+            Event::Pointer(p) => write!(f, "{}", p),
-            Event::Keyboard(k) => write!(f, "{k}"),
+            Event::Keyboard(k) => write!(f, "{}", k),
         }
     }
 }

lan-mouse-cli/Cargo.toml

@@ -9,8 +9,6 @@ repository = "https://github.com/feschber/lan-mouse"
 [dependencies]
 futures = "0.3.30"
 lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
-clap = { version = "4.4.11", features = ["derive"] }
-thiserror = "2.0.0"
 tokio = { version = "1.32.0", features = [
     "io-util",
     "io-std",

lan-mouse-cli/src/command.rs

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

lan-mouse-cli/src/lib.rs

@@ -1,167 +1,298 @@
-use clap::{Args, Parser, Subcommand};
 use futures::StreamExt;
-
+use tokio::{
-use std::{net::IpAddr, time::Duration};
+    io::{AsyncBufReadExt, BufReader},
-use thiserror::Error;
+    task::LocalSet,
-
-use lan_mouse_ipc::{
-    connect_async, ClientHandle, ConnectionError, FrontendEvent, FrontendRequest, IpcError,
-    Position,
 };
 
-#[derive(Debug, Error)]
+use std::io::{self, Write};
-pub enum CliError {
-    /// is the service running?
-    #[error("could not connect: `{0}` - is the service running?")]
-    ServiceNotRunning(#[from] ConnectionError),
-    #[error("error communicating with service: {0}")]
-    Ipc(#[from] IpcError),
-}
 
-#[derive(Parser, Clone, Debug, PartialEq, Eq)]
+use self::command::{Command, CommandType};
-#[command(name = "lan-mouse-cli", about = "LanMouse CLI interface")]
-pub struct CliArgs {
-    #[command(subcommand)]
-    command: CliSubcommand,
-}
 
-#[derive(Args, Clone, Debug, PartialEq, Eq)]
+use lan_mouse_ipc::{
-struct Client {
+    AsyncFrontendEventReader, AsyncFrontendRequestWriter, ClientConfig, ClientHandle, ClientState,
-    #[arg(long)]
+    FrontendEvent, FrontendRequest, IpcError, DEFAULT_PORT,
-    hostname: Option<String>,
+};
-    #[arg(long)]
-    port: Option<u16>,
-    #[arg(long)]
-    ips: Option<Vec<IpAddr>>,
-    #[arg(long)]
-    enter_hook: Option<String>,
-}
 
-#[derive(Clone, Subcommand, Debug, PartialEq, Eq)]
+mod command;
-enum CliSubcommand {
-    /// add a new client
-    AddClient(Client),
-    /// remove an existing client
-    RemoveClient { id: ClientHandle },
-    /// activate a client
-    Activate { id: ClientHandle },
-    /// deactivate a client
-    Deactivate { id: ClientHandle },
-    /// list configured clients
-    List,
-    /// change hostname
-    SetHost {
-        id: ClientHandle,
-        host: Option<String>,
-    },
-    /// change port
-    SetPort { id: ClientHandle, port: u16 },
-    /// set position
-    SetPosition { id: ClientHandle, pos: Position },
-    /// set ips
-    SetIps { id: ClientHandle, ips: Vec<IpAddr> },
-    /// re-enable capture
-    EnableCapture,
-    /// re-enable emulation
-    EnableEmulation,
-    /// authorize a public key
-    AuthorizeKey {
-        description: String,
-        sha256_fingerprint: String,
-    },
-    /// deauthorize a public key
-    RemoveAuthorizedKey { sha256_fingerprint: String },
-}
 
-pub async fn run(args: CliArgs) -> Result<(), CliError> {
+pub fn run() -> Result<(), IpcError> {
-    execute(args.command).await?;
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+    runtime.block_on(LocalSet::new().run_until(async move {
+        let (rx, tx) = lan_mouse_ipc::connect_async().await?;
+        let mut cli = Cli::new(rx, tx);
+        cli.run().await
+    }))?;
     Ok(())
 }
 
-async fn execute(cmd: CliSubcommand) -> Result<(), CliError> {
+struct Cli {
-    let (mut rx, mut tx) = connect_async(Some(Duration::from_millis(500))).await?;
+    clients: Vec<(ClientHandle, ClientConfig, ClientState)>,
-    match cmd {
+    rx: AsyncFrontendEventReader,
-        CliSubcommand::AddClient(Client {
+    tx: AsyncFrontendRequestWriter,
-            hostname,
+}
-            port,
+
-            ips,
+impl Cli {
-            enter_hook,
+    fn new(rx: AsyncFrontendEventReader, tx: AsyncFrontendRequestWriter) -> Cli {
-        }) => {
+        Self {
-            tx.request(FrontendRequest::Create).await?;
+            clients: vec![],
-            while let Some(e) = rx.next().await {
+            rx,
-                if let FrontendEvent::Created(handle, _, _) = e? {
+            tx,
-                    if let Some(hostname) = hostname {
-                        tx.request(FrontendRequest::UpdateHostname(handle, Some(hostname)))
-                            .await?;
-                    }
-                    if let Some(port) = port {
-                        tx.request(FrontendRequest::UpdatePort(handle, port))
-                            .await?;
-                    }
-                    if let Some(ips) = ips {
-                        tx.request(FrontendRequest::UpdateFixIps(handle, ips))
-                            .await?;
-                    }
-                    if let Some(enter_hook) = enter_hook {
-                        tx.request(FrontendRequest::UpdateEnterHook(handle, Some(enter_hook)))
-                            .await?;
-                    }
-                    break;
-                }
-            }
-        }
-        CliSubcommand::RemoveClient { id } => tx.request(FrontendRequest::Delete(id)).await?,
-        CliSubcommand::Activate { id } => tx.request(FrontendRequest::Activate(id, true)).await?,
-        CliSubcommand::Deactivate { id } => {
-            tx.request(FrontendRequest::Activate(id, false)).await?
-        }
-        CliSubcommand::List => {
-            tx.request(FrontendRequest::Enumerate()).await?;
-            while let Some(e) = rx.next().await {
-                if let FrontendEvent::Enumerate(clients) = e? {
-                    for (handle, config, state) in clients {
-                        let host = config.hostname.unwrap_or("unknown".to_owned());
-                        let port = config.port;
-                        let pos = config.pos;
-                        let active = state.active;
-                        let ips = state.ips;
-                        println!(
-                            "id {handle}: {host}:{port} ({pos}) active: {active}, ips: {ips:?}"
-                        );
-                    }
-                    break;
-                }
-            }
-        }
-        CliSubcommand::SetHost { id, host } => {
-            tx.request(FrontendRequest::UpdateHostname(id, host))
-                .await?
-        }
-        CliSubcommand::SetPort { id, port } => {
-            tx.request(FrontendRequest::UpdatePort(id, port)).await?
-        }
-        CliSubcommand::SetPosition { id, pos } => {
-            tx.request(FrontendRequest::UpdatePosition(id, pos)).await?
-        }
-        CliSubcommand::SetIps { id, ips } => {
-            tx.request(FrontendRequest::UpdateFixIps(id, ips)).await?
-        }
-        CliSubcommand::EnableCapture => tx.request(FrontendRequest::EnableCapture).await?,
-        CliSubcommand::EnableEmulation => tx.request(FrontendRequest::EnableEmulation).await?,
-        CliSubcommand::AuthorizeKey {
-            description,
-            sha256_fingerprint,
-        } => {
-            tx.request(FrontendRequest::AuthorizeKey(
-                description,
-                sha256_fingerprint,
-            ))
-            .await?
-        }
-        CliSubcommand::RemoveAuthorizedKey { sha256_fingerprint } => {
-            tx.request(FrontendRequest::RemoveAuthorizedKey(sha256_fingerprint))
-                .await?
         }
     }
+
+    async fn run(&mut self) -> Result<(), IpcError> {
+        let stdin = tokio::io::stdin();
+        let stdin = BufReader::new(stdin);
+        let mut stdin = stdin.lines();
+
+        /* initial state sync */
+        self.clients = loop {
+            match self.rx.next().await {
+                Some(Ok(e)) => {
+                    if let FrontendEvent::Enumerate(clients) = e {
+                        break clients;
+                    }
+                }
+                Some(Err(e)) => return Err(e),
+                None => return Ok(()),
+            }
+        };
+
+        loop {
+            prompt()?;
+            tokio::select! {
+                line = stdin.next_line() => {
+                    let Some(line) = line? else {
+                        break Ok(());
+                    };
+                    let cmd: Command = match line.parse() {
+                        Ok(cmd) => cmd,
+                        Err(e) => {
+                            eprintln!("{e}");
+                            continue;
+                        }
+                    };
+                    self.execute(cmd).await?;
+                }
+                event = self.rx.next() => {
+                    if let Some(event) = event {
+                        self.handle_event(event?);
+                    } else {
+                        break Ok(());
+                    }
+                }
+            }
+        }
+    }
+
+    async fn execute(&mut self, cmd: Command) -> Result<(), IpcError> {
+        match cmd {
+            Command::None => {}
+            Command::Connect(pos, host, port) => {
+                let request = FrontendRequest::Create;
+                self.tx.request(request).await?;
+                let handle = loop {
+                    if let Some(Ok(event)) = self.rx.next().await {
+                        match event {
+                            FrontendEvent::Created(h, c, s) => {
+                                self.clients.push((h, c, s));
+                                break h;
+                            }
+                            _ => {
+                                self.handle_event(event);
+                                continue;
+                            }
+                        }
+                    }
+                };
+                for request in [
+                    FrontendRequest::UpdateHostname(handle, Some(host.clone())),
+                    FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT)),
+                    FrontendRequest::UpdatePosition(handle, pos),
+                ] {
+                    self.tx.request(request).await?;
+                }
+            }
+            Command::Disconnect(id) => {
+                self.tx.request(FrontendRequest::Delete(id)).await?;
+                loop {
+                    if let Some(Ok(event)) = self.rx.next().await {
+                        self.handle_event(event.clone());
+                        if let FrontendEvent::Deleted(_) = event {
+                            self.handle_event(event);
+                            break;
+                        }
+                    }
+                }
+            }
+            Command::Activate(id) => {
+                self.tx.request(FrontendRequest::Activate(id, true)).await?;
+            }
+            Command::Deactivate(id) => {
+                self.tx
+                    .request(FrontendRequest::Activate(id, false))
+                    .await?;
+            }
+            Command::List => {
+                self.tx.request(FrontendRequest::Enumerate()).await?;
+                while let Some(e) = self.rx.next().await {
+                    let event = e?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Enumerate(_) = event {
+                        break;
+                    }
+                }
+            }
+            Command::SetHost(handle, host) => {
+                let request = FrontendRequest::UpdateHostname(handle, Some(host.clone()));
+                self.tx.request(request).await?;
+            }
+            Command::SetPort(handle, port) => {
+                let request = FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT));
+                self.tx.request(request).await?;
+            }
+            Command::Help => {
+                for cmd_type in [
+                    CommandType::List,
+                    CommandType::Connect,
+                    CommandType::Disconnect,
+                    CommandType::Activate,
+                    CommandType::Deactivate,
+                    CommandType::SetHost,
+                    CommandType::SetPort,
+                ] {
+                    eprintln!("{}", cmd_type.usage());
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn find_mut(
+        &mut self,
+        handle: ClientHandle,
+    ) -> Option<&mut (ClientHandle, ClientConfig, ClientState)> {
+        self.clients.iter_mut().find(|(h, _, _)| *h == handle)
+    }
+
+    fn remove(
+        &mut self,
+        handle: ClientHandle,
+    ) -> Option<(ClientHandle, ClientConfig, ClientState)> {
+        let idx = self.clients.iter().position(|(h, _, _)| *h == handle);
+        idx.map(|i| self.clients.swap_remove(i))
+    }
+
+    fn handle_event(&mut self, event: FrontendEvent) {
+        match event {
+            FrontendEvent::Created(h, c, s) => {
+                eprint!("client added ({h}): ");
+                print_config(&c);
+                eprint!(" ");
+                print_state(&s);
+                eprintln!();
+                self.clients.push((h, c, s));
+            }
+            FrontendEvent::NoSuchClient(h) => {
+                eprintln!("no such client: {h}");
+            }
+            FrontendEvent::State(h, c, s) => {
+                if let Some((_, config, state)) = self.find_mut(h) {
+                    let old_host = config.hostname.clone().unwrap_or("\"\"".into());
+                    let new_host = c.hostname.clone().unwrap_or("\"\"".into());
+                    if old_host != new_host {
+                        eprintln!(
+                            "client {h}: hostname updated ({} -> {})",
+                            old_host, new_host
+                        );
+                    }
+                    if config.port != c.port {
+                        eprintln!("client {h} changed port: {} -> {}", config.port, c.port);
+                    }
+                    if config.fix_ips != c.fix_ips {
+                        eprintln!("client {h} ips updated: {:?}", c.fix_ips)
+                    }
+                    *config = c;
+                    if state.active ^ s.active {
+                        eprintln!(
+                            "client {h} {}",
+                            if s.active { "activated" } else { "deactivated" }
+                        );
+                    }
+                    *state = s;
+                }
+            }
+            FrontendEvent::Deleted(h) => {
+                if let Some((h, c, _)) = self.remove(h) {
+                    eprint!("client {h} removed (");
+                    print_config(&c);
+                    eprintln!(")");
+                }
+            }
+            FrontendEvent::PortChanged(p, e) => {
+                if let Some(e) = e {
+                    eprintln!("failed to change port: {e}");
+                } else {
+                    eprintln!("changed port to {p}");
+                }
+            }
+            FrontendEvent::Enumerate(clients) => {
+                self.clients = clients;
+                self.print_clients();
+            }
+            FrontendEvent::Error(e) => {
+                eprintln!("ERROR: {e}");
+            }
+            FrontendEvent::CaptureStatus(s) => {
+                eprintln!("capture status: {s:?}")
+            }
+            FrontendEvent::EmulationStatus(s) => {
+                eprintln!("emulation status: {s:?}")
+            }
+            FrontendEvent::AuthorizedUpdated(fingerprints) => {
+                eprintln!("authorized keys changed:");
+                for (desc, fp) in fingerprints {
+                    eprintln!("{desc}: {fp}");
+                }
+            }
+            FrontendEvent::PublicKeyFingerprint(fp) => {
+                eprintln!("the public key fingerprint of this device is {fp}");
+            }
+            FrontendEvent::IncomingConnected(..) => {}
+            FrontendEvent::IncomingDisconnected(..) => {}
+        }
+    }
+
+    fn print_clients(&mut self) {
+        for (h, c, s) in self.clients.iter() {
+            eprint!("client {h}: ");
+            print_config(c);
+            eprint!(" ");
+            print_state(s);
+            eprintln!();
+        }
+    }
+}
+
+fn prompt() -> io::Result<()> {
+    eprint!("lan-mouse > ");
+    std::io::stderr().flush()?;
     Ok(())
 }
+
+fn print_config(c: &ClientConfig) {
+    eprint!(
+        "{}:{} ({}), ips: {:?}",
+        c.hostname.clone().unwrap_or("(no hostname)".into()),
+        c.port,
+        c.pos,
+        c.fix_ips
+    );
+}
+
+fn print_state(s: &ClientState) {
+    eprint!("active: {}, dns: {:?}", s.active, s.ips);
+}

lan-mouse-gtk/Cargo.toml

@@ -13,7 +13,6 @@ async-channel = { version = "2.1.1" }
 hostname = "0.4.0"
 log = "0.4.20"
 lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
-thiserror = "2.0.0"
 
 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }

lan-mouse-gtk/resources/authorization_window.ui

@@ -1,102 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<interface>
-  <requires lib="gtk" version="4.0"/>
-  <requires lib="libadwaita" version="1.0"/>
-  <template class="AuthorizationWindow" parent="AdwWindow">
-    <property name="modal">True</property>
-    <property name="width-request">180</property>
-    <property name="default-width">180</property>
-    <property name="height-request">180</property>
-    <property name="default-height">180</property>
-    <property name="title" translatable="yes">Unauthorized Device</property>
-    <property name="content">
-      <object class="GtkBox">
-        <property name="orientation">vertical</property>
-        <property name="vexpand">True</property>
-        <child type="top">
-          <object class="AdwHeaderBar">
-            <style>
-              <class name="flat"/>
-            </style>
-          </object>
-        </child>
-        <child>
-          <object class="GtkBox">
-            <property name="orientation">vertical</property>
-            <property name="spacing">30</property>
-            <property name="margin-start">30</property>
-            <property name="margin-end">30</property>
-            <property name="margin-top">30</property>
-            <property name="margin-bottom">30</property>
-            <child>
-              <object class="GtkLabel">
-                <property name="label">An unauthorized Device is trying to connect. Do you want to authorize this Device?</property>
-                <property name="width-request">100</property>
-                <property name="wrap">word-wrap</property>
-              </object>
-            </child>
-            <child>
-              <object class="AdwPreferencesGroup">
-                <property name="title">sha256 fingerprint</property>
-                <child>
-                  <object class="AdwActionRow">
-                    <property name="child">
-                      <object class="GtkLabel" id="fingerprint">
-                        <property name="ellipsize">PANGO_ELLIPSIZE_NONE</property>
-                        <property name="vexpand">True</property>
-                        <property name="hexpand">False</property>
-                        <property name="wrap">True</property>
-                        <property name="wrap-mode">word-char</property>
-                        <property name="justify">center</property>
-                        <property name="xalign">0.5</property>
-                        <property name="margin-top">10</property>
-                        <property name="margin-bottom">10</property>
-                        <property name="margin-start">10</property>
-                        <property name="margin-end">10</property>
-                        <property name="width-chars">64</property>
-                      </object>
-                    </property>
-                  </object>
-                </child>
-              </object>
-            </child>
-          </object>
-        </child>
-        <child>
-          <object class="GtkBox">
-            <property name="margin-start">30</property>
-            <property name="margin-end">30</property>
-            <property name="margin-top">30</property>
-            <property name="margin-bottom">30</property>
-            <property name="orientation">horizontal</property>
-            <property name="spacing">30</property>
-            <property name="hexpand">True</property>
-            <property name="vexpand">True</property>
-            <property name="valign">end</property>
-            <child>
-              <object class="GtkButton" id="cancel_button">
-                <signal name="clicked" handler="handle_cancel" swapped="true"/>
-                <property name="label" translatable="yes">Cancel</property>
-                <property name="can-shrink">True</property>
-                <property name="height-request">50</property>
-                <property name="hexpand">True</property>
-              </object>
-            </child>
-            <child>
-              <object class="GtkButton" id="confirm_button">
-                <signal name="clicked" handler="handle_confirm" swapped="true"/>
-                <property name="label" translatable="yes">Authorize</property>
-                <property name="can-shrink">True</property>
-                <property name="height-request">50</property>
-                <property name="hexpand">True</property>
-                <style>
-                  <class name="destructive-action"/>
-                </style>
-              </object>
-            </child>
-          </object>
-        </child>
-      </object>
-    </property>
-  </template>
-</interface>

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

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

lan-mouse-gtk/src/authorization_window.rs

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

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

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

lan-mouse-gtk/src/fingerprint_window.rs

@@ -1,7 +1,7 @@
 mod imp;
 
 use glib::Object;
-use gtk::{gio, glib, prelude::ObjectExt, subclass::prelude::ObjectSubclassIsExt};
+use gtk::{gio, glib};
 
 glib::wrapper! {
     pub struct FingerprintWindow(ObjectSubclass<imp::FingerprintWindow>)
@@ -11,12 +11,8 @@ glib::wrapper! {
 }
 
 impl FingerprintWindow {
-    pub(crate) fn new(fingerprint: Option<String>) -> Self {
+    pub(crate) fn new() -> Self {
         let window: Self = Object::builder().build();
-        if let Some(fp) = fingerprint {
-            window.imp().fingerprint.set_property("text", fp);
-            window.imp().fingerprint.set_property("editable", false);
-        }
         window
     }
 }

lan-mouse-gtk/src/key_row.rs

@@ -8,7 +8,7 @@ use super::KeyObject;
 
 glib::wrapper! {
     pub struct KeyRow(ObjectSubclass<imp::KeyRow>)
-    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ActionRow,
+    @extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
     @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
 }
 

lan-mouse-gtk/src/lib.rs

@@ -1,4 +1,3 @@
-mod authorization_window;
 mod client_object;
 mod client_row;
 mod fingerprint_window;
@@ -19,15 +18,7 @@ use gtk::{gio, glib, prelude::ApplicationExt};
 use self::client_object::ClientObject;
 use self::key_object::KeyObject;
 
-use thiserror::Error;
+pub fn run() -> glib::ExitCode {
-
-#[derive(Error, Debug)]
-pub enum GtkError {
-    #[error("gtk frontend exited with non zero exit code: {0}")]
-    NonZeroExitCode(i32),
-}
-
-pub fn run() -> Result<(), GtkError> {
     log::debug!("running gtk frontend");
     #[cfg(windows)]
     let ret = std::thread::Builder::new()
@@ -40,10 +31,13 @@ pub fn run() -> Result<(), GtkError> {
     #[cfg(not(windows))]
     let ret = gtk_main();
 
-    match ret {
+    if ret == glib::ExitCode::FAILURE {
-        glib::ExitCode::SUCCESS => Ok(()),
+        log::error!("frontend exited with failure");
-        e => Err(GtkError::NonZeroExitCode(e.value())),
+    } else {
+        log::info!("frontend exited successfully");
     }
+
+    ret
 }
 
 fn gtk_main() -> glib::ExitCode {
@@ -147,21 +141,8 @@ fn build_ui(app: &Application) {
                     FrontendEvent::EmulationStatus(s) => window.set_emulation(s.into()),
                     FrontendEvent::AuthorizedUpdated(keys) => window.set_authorized_keys(keys),
                     FrontendEvent::PublicKeyFingerprint(fp) => window.set_pk_fp(&fp),
-                    FrontendEvent::ConnectionAttempt { fingerprint } => {
+                    FrontendEvent::IncomingConnected(_fingerprint, addr, pos) => {
-                        window.request_authorization(&fingerprint);
+                        window.show_toast(format!("device connected: {addr} ({pos})").as_str());
-                    }
-                    FrontendEvent::DeviceConnected {
-                        fingerprint: _,
-                        addr,
-                    } => {
-                        window.show_toast(format!("device connected: {addr}").as_str());
-                    }
-                    FrontendEvent::DeviceEntered {
-                        fingerprint: _,
-                        addr,
-                        pos,
-                    } => {
-                        window.show_toast(format!("device entered: {addr} ({pos})").as_str());
                     }
                     FrontendEvent::IncomingDisconnected(addr) => {
                         window.show_toast(format!("{addr} disconnected").as_str());

lan-mouse-gtk/src/window.rs

@@ -16,10 +16,7 @@ use lan_mouse_ipc::{
     DEFAULT_PORT,
 };
 
-use crate::{
+use crate::{fingerprint_window::FingerprintWindow, key_object::KeyObject, key_row::KeyRow};
-    authorization_window::AuthorizationWindow, fingerprint_window::FingerprintWindow,
-    key_object::KeyObject, key_row::KeyRow,
-};
 
 use super::{client_object::ClientObject, client_row::ClientRow};
 
@@ -129,7 +126,7 @@ impl Window {
                             #[strong]
                             window,
                             move |row: ClientRow, hostname: String| {
-                                log::debug!("request-hostname-change");
+                                log::info!("request-hostname-change");
                                 if let Some(client) = window.client_by_idx(row.index() as u32) {
                                     let hostname = Some(hostname).filter(|s| !s.is_empty());
                                     /* changed in response to FrontendEvent
@@ -166,7 +163,7 @@ impl Window {
                             window,
                             move |row: ClientRow, active: bool| {
                                 if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    log::debug!(
+                                    log::info!(
                                         "request: {} client",
                                         if active { "activating" } else { "deactivating" }
                                     );
@@ -324,7 +321,7 @@ impl Window {
 
     pub(super) fn update_client_config(&self, handle: ClientHandle, client: ClientConfig) {
         let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+            log::warn!("could not find row for handle {}", handle);
             return;
         };
         row.set_hostname(client.hostname);
@@ -334,11 +331,11 @@ impl Window {
 
     pub(super) fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
         let Some(row) = self.row_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+            log::warn!("could not find row for handle {}", handle);
             return;
         };
         let Some(client_object) = self.client_object_for_handle(handle) else {
-            log::warn!("could not find row for handle {handle}");
+            log::warn!("could not find row for handle {}", handle);
             return;
         };
 
@@ -397,8 +394,8 @@ impl Window {
         self.request(FrontendRequest::Create);
     }
 
-    fn open_fingerprint_dialog(&self, fp: Option<String>) {
+    fn open_fingerprint_dialog(&self) {
-        let window = FingerprintWindow::new(fp);
+        let window = FingerprintWindow::new();
         window.set_transient_for(Some(self));
         window.connect_closure(
             "confirm-clicked",
@@ -472,33 +469,4 @@ impl Window {
     pub(super) fn set_pk_fp(&self, fingerprint: &str) {
         self.imp().fingerprint_row.set_subtitle(fingerprint);
     }
-
-    pub(super) fn request_authorization(&self, fingerprint: &str) {
-        if let Some(w) = self.imp().authorization_window.borrow_mut().take() {
-            w.close();
-        }
-        let window = AuthorizationWindow::new(fingerprint);
-        window.set_transient_for(Some(self));
-        window.connect_closure(
-            "confirm-clicked",
-            false,
-            closure_local!(
-                #[strong(rename_to = parent)]
-                self,
-                move |w: AuthorizationWindow, fp: String| {
-                    w.close();
-                    parent.open_fingerprint_dialog(Some(fp));
-                }
-            ),
-        );
-        window.connect_closure(
-            "cancel-clicked",
-            false,
-            closure_local!(move |w: AuthorizationWindow| {
-                w.close();
-            }),
-        );
-        window.present();
-        self.imp().authorization_window.replace(Some(window));
-    }
 }

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

@@ -8,8 +8,6 @@ use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Image, Label, ListBo
 
 use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};
 
-use crate::authorization_window::AuthorizationWindow;
-
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/window.ui")]
 pub struct Window {
@@ -51,7 +49,6 @@ pub struct Window {
     pub port: Cell<u16>,
     pub capture_active: Cell<bool>,
     pub emulation_active: Cell<bool>,
-    pub authorization_window: RefCell<Option<AuthorizationWindow>>,
 }
 
 #[glib::object_subclass]
@@ -152,7 +149,7 @@ impl Window {
 
     #[template_callback]
     fn handle_add_cert_fingerprint(&self, _button: &Button) {
-        self.obj().open_fingerprint_dialog(None);
+        self.obj().open_fingerprint_dialog();
     }
 
     pub fn set_port(&self, port: u16) {

lan-mouse-ipc/src/connect_async.rs

@@ -1,6 +1,7 @@
 use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
 use std::{
     cmp::min,
+    io,
     task::{ready, Poll},
     time::Duration,
 };
@@ -46,7 +47,7 @@ impl Stream for AsyncFrontendEventReader {
 }
 
 impl AsyncFrontendRequestWriter {
-    pub async fn request(&mut self, request: FrontendRequest) -> Result<(), IpcError> {
+    pub async fn request(&mut self, request: FrontendRequest) -> Result<(), io::Error> {
         let mut json = serde_json::to_string(&request).unwrap();
         log::debug!("requesting: {json}");
         json.push('\n');
@@ -56,16 +57,8 @@ impl AsyncFrontendRequestWriter {
 }
 
 pub async fn connect_async(
-    timeout: Option<Duration>,
 ) -> Result<(AsyncFrontendEventReader, AsyncFrontendRequestWriter), ConnectionError> {
-    let stream = if let Some(duration) = timeout {
+    let stream = wait_for_service().await?;
-        tokio::select! {
-            s = wait_for_service() => s?,
-            _ = tokio::time::sleep(duration) => return Err(ConnectionError::Timeout),
-        }
-    } else {
-        wait_for_service().await?
-    };
     #[cfg(unix)]
     let (rx, tx): (ReadHalf<UnixStream>, WriteHalf<UnixStream>) = tokio::io::split(stream);
     #[cfg(windows)]

lan-mouse-ipc/src/lib.rs

@@ -30,8 +30,6 @@ pub enum ConnectionError {
     SocketPath(#[from] SocketPathError),
     #[error(transparent)]
     Io(#[from] io::Error),
-    #[error("connection timed out")]
-    Timeout,
 }
 
 #[derive(Debug, Error)]
@@ -59,7 +57,6 @@ pub enum IpcError {
 pub const DEFAULT_PORT: u16 = 4242;
 
 #[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
 pub enum Position {
     #[default]
     Left,
@@ -202,21 +199,10 @@ pub enum FrontendEvent {
     AuthorizedUpdated(HashMap<String, String>),
     /// public key fingerprint of this device
     PublicKeyFingerprint(String),
-    /// new device connected
+    /// incoming connected
-    DeviceConnected {
+    IncomingConnected(String, SocketAddr, Position),
-        addr: SocketAddr,
-        fingerprint: String,
-    },
-    /// incoming device entered the screen
-    DeviceEntered {
-        fingerprint: String,
-        addr: SocketAddr,
-        pos: Position,
-    },
     /// incoming disconnected
     IncomingDisconnected(SocketAddr),
-    /// failed connection attempt (approval for fingerprint required)
-    ConnectionAttempt { fingerprint: String },
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
@@ -251,8 +237,6 @@ pub enum FrontendRequest {
     AuthorizeKey(String, String),
     /// remove fingerprint (fingerprint)
     RemoveAuthorizedKey(String),
-    /// change the hook command
-    UpdateEnterHook(u64, Option<String>),
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]

lan-mouse-ipc/src/listen.rs

@@ -45,7 +45,7 @@ impl AsyncFrontendListener {
         let (socket_path, listener) = {
             let socket_path = crate::default_socket_path()?;
 
-            log::debug!("remove socket: {socket_path:?}");
+            log::debug!("remove socket: {:?}", socket_path);
             if socket_path.exists() {
                 // try to connect to see if some other instance
                 // of lan-mouse is already running

nix/hm-module.nix

@@ -52,7 +52,7 @@ in {
       };
       Service = {
         Type = "simple";
-        ExecStart = "${cfg.package}/bin/lan-mouse daemon";
+        ExecStart = "${cfg.package}/bin/lan-mouse --daemon";
       };
       Install.WantedBy = [
         (lib.mkIf config.wayland.windowManager.hyprland.systemd.enable "hyprland-session.target")
@@ -65,7 +65,7 @@ in {
       config = {
         ProgramArguments = [
           "${cfg.package}/bin/lan-mouse"
-          "daemon"
+          "--daemon"
         ];
         KeepAlive = true;
       };

scripts/copy-macos-dylib.sh

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

service/lan-mouse.service

@@ -6,7 +6,7 @@ After=graphical-session.target
 BindsTo=graphical-session.target
 
 [Service]
-ExecStart=/usr/bin/lan-mouse daemon
+ExecStart=/usr/bin/lan-mouse --daemon
 Restart=on-failure
 
 [Install]

src/capture_test.rs

@@ -1,16 +1,12 @@
 use crate::config::Config;
-use clap::Args;
 use futures::StreamExt;
 use input_capture::{self, CaptureError, CaptureEvent, InputCapture, InputCaptureError, Position};
 use input_event::{Event, KeyboardEvent};
 
-#[derive(Args, Clone, Debug, Eq, PartialEq)]
+pub async fn run(config: Config) -> Result<(), InputCaptureError> {
-pub struct TestCaptureArgs {}
-
-pub async fn run(config: Config, _args: TestCaptureArgs) -> Result<(), InputCaptureError> {
     log::info!("running input capture test");
     log::info!("creating input capture");
-    let backend = config.capture_backend().map(|b| b.into());
+    let backend = config.capture_backend.map(|b| b.into());
     loop {
         let mut input_capture = InputCapture::new(backend).await?;
         log::info!("creating clients");

src/client.rs

@@ -199,13 +199,6 @@ impl ClientManager {
         }
     }
 
-    /// update the enter hook command of the client
-    pub(crate) fn set_enter_hook(&self, handle: ClientHandle, enter_hook: Option<String>) {
-        if let Some((c, _s)) = self.clients.borrow_mut().get_mut(handle as usize) {
-            c.cmd = enter_hook;
-        }
-    }
-
     /// set resolving status of the client
     pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
         if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {

src/config.rs

@@ -1,6 +1,4 @@
-use crate::capture_test::TestCaptureArgs;
+use clap::{Parser, ValueEnum};
-use crate::emulation_test::TestEmulationArgs;
-use clap::{Parser, Subcommand, ValueEnum};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::env::{self, VarError};
@@ -12,7 +10,6 @@ use std::{collections::HashSet, io};
 use thiserror::Error;
 use toml;
 
-use lan_mouse_cli::CliArgs;
 use lan_mouse_ipc::{Position, DEFAULT_PORT};
 
 use input_event::scancode::{
@@ -24,50 +21,33 @@ use shadow_rs::shadow;
 
 shadow!(build);
 
-const CONFIG_FILE_NAME: &str = "config.toml";
-const CERT_FILE_NAME: &str = "lan-mouse.pem";
-
-fn default_path() -> Result<PathBuf, VarError> {
-    #[cfg(unix)]
-    let default_path = {
-        let xdg_config_home =
-            env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
-        format!("{xdg_config_home}/lan-mouse/")
-    };
-
-    #[cfg(not(unix))]
-    let default_path = {
-        let app_data =
-            env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
-        format!("{app_data}\\lan-mouse\\")
-    };
-    Ok(PathBuf::from(default_path))
-}
-
 #[derive(Serialize, Deserialize, Debug)]
-struct ConfigToml {
+pub struct ConfigToml {
-    capture_backend: Option<CaptureBackend>,
+    pub capture_backend: Option<CaptureBackend>,
-    emulation_backend: Option<EmulationBackend>,
+    pub emulation_backend: Option<EmulationBackend>,
-    port: Option<u16>,
+    pub port: Option<u16>,
-    release_bind: Option<Vec<scancode::Linux>>,
+    pub frontend: Option<Frontend>,
-    cert_path: Option<PathBuf>,
+    pub release_bind: Option<Vec<scancode::Linux>>,
-    clients: Option<Vec<TomlClient>>,
+    pub cert_path: Option<PathBuf>,
-    authorized_fingerprints: Option<HashMap<String, String>>,
+    pub left: Option<TomlClient>,
+    pub right: Option<TomlClient>,
+    pub top: Option<TomlClient>,
+    pub bottom: Option<TomlClient>,
+    pub authorized_fingerprints: Option<HashMap<String, String>>,
 }
 
-#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct TomlClient {
+pub struct TomlClient {
-    hostname: Option<String>,
+    pub hostname: Option<String>,
-    host_name: Option<String>,
+    pub host_name: Option<String>,
-    ips: Option<Vec<IpAddr>>,
+    pub ips: Option<Vec<IpAddr>>,
-    port: Option<u16>,
+    pub port: Option<u16>,
-    position: Option<Position>,
+    pub activate_on_startup: Option<bool>,
-    activate_on_startup: Option<bool>,
+    pub enter_hook: Option<String>,
-    enter_hook: Option<String>,
 }
 
 impl ConfigToml {
-    fn new(path: &Path) -> Result<ConfigToml, ConfigError> {
+    pub fn new(path: &Path) -> Result<ConfigToml, ConfigError> {
         let config = fs::read_to_string(path)?;
         Ok(toml::from_str::<_>(&config)?)
     }
@@ -75,14 +55,30 @@ impl ConfigToml {
 
 #[derive(Parser, Debug)]
 #[command(author, version=build::CLAP_LONG_VERSION, about, long_about = None)]
-struct Args {
+struct CliArgs {
     /// the listen port for lan-mouse
     #[arg(short, long)]
     port: Option<u16>,
 
+    /// the frontend to use [cli | gtk]
+    #[arg(short, long)]
+    frontend: Option<Frontend>,
+
     /// non-default config file location
     #[arg(short, long)]
-    config: Option<PathBuf>,
+    config: Option<String>,
+
+    /// run only the service as a daemon without the frontend
+    #[arg(short, long)]
+    daemon: bool,
+
+    /// test input capture
+    #[arg(long)]
+    test_capture: bool,
+
+    /// test input emulation
+    #[arg(long)]
+    test_emulation: bool,
 
     /// capture backend override
     #[arg(long)]
@@ -95,22 +91,6 @@ struct Args {
     /// path to non-default certificate location
     #[arg(long)]
     cert_path: Option<PathBuf>,
-
-    /// subcommands
-    #[command(subcommand)]
-    command: Option<Command>,
-}
-
-#[derive(Subcommand, Clone, Debug, Eq, PartialEq)]
-pub enum Command {
-    /// test input emulation
-    TestEmulation(TestEmulationArgs),
-    /// test input capture
-    TestCapture(TestCaptureArgs),
-    /// Lan Mouse commandline interface
-    Cli(CliArgs),
-    /// run in daemon mode
-    Daemon,
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
@@ -234,16 +214,50 @@ impl Display for EmulationBackend {
     }
 }
 
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
+pub enum Frontend {
+    #[serde(rename = "gtk")]
+    Gtk,
+    #[serde(rename = "cli")]
+    Cli,
+}
+
+impl Default for Frontend {
+    fn default() -> Self {
+        if cfg!(feature = "gtk") {
+            Self::Gtk
+        } else {
+            Self::Cli
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Config {
-    /// command line arguments
+    /// the path to the configuration file used
-    args: Args,
+    pub path: PathBuf,
-    /// path to the certificate file used
+    /// public key fingerprints authorized for connection
-    cert_path: PathBuf,
+    pub authorized_fingerprints: HashMap<String, String>,
-    /// path to the config file used
+    /// optional input-capture backend override
-    config_path: PathBuf,
+    pub capture_backend: Option<CaptureBackend>,
-    /// the (optional) toml config and it's path
+    /// optional input-emulation backend override
-    config_toml: Option<ConfigToml>,
+    pub emulation_backend: Option<EmulationBackend>,
+    /// the frontend to use
+    pub frontend: Frontend,
+    /// the port to use (initially)
+    pub port: u16,
+    /// list of clients
+    pub clients: Vec<(TomlClient, Position)>,
+    /// whether or not to run as a daemon
+    pub daemon: bool,
+    /// configured release bind
+    pub release_bind: Vec<scancode::Linux>,
+    /// test capture instead of running the app
+    pub test_capture: bool,
+    /// test emulation instead of running the app
+    pub test_emulation: bool,
+    /// path to the tls certificate to use
+    pub cert_path: PathBuf,
 }
 
 pub struct ConfigClient {
@@ -255,25 +269,6 @@ pub struct ConfigClient {
     pub enter_hook: Option<String>,
 }
 
-impl From<TomlClient> for ConfigClient {
-    fn from(toml: TomlClient) -> Self {
-        let active = toml.activate_on_startup.unwrap_or(false);
-        let enter_hook = toml.enter_hook;
-        let hostname = toml.hostname;
-        let ips = HashSet::from_iter(toml.ips.into_iter().flatten());
-        let port = toml.port.unwrap_or(DEFAULT_PORT);
-        let pos = toml.position.unwrap_or_default();
-        Self {
-            ips,
-            hostname,
-            port,
-            pos,
-            active,
-            enter_hook,
-        }
-    }
-}
-
 #[derive(Debug, Error)]
 pub enum ConfigError {
     #[error(transparent)]
@@ -289,99 +284,134 @@ const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
 
 impl Config {
     pub fn new() -> Result<Self, ConfigError> {
-        let args = Args::parse();
+        let args = CliArgs::parse();
+        const CONFIG_FILE_NAME: &str = "config.toml";
+        const CERT_FILE_NAME: &str = "lan-mouse.pem";
+
+        #[cfg(unix)]
+        let config_path = {
+            let xdg_config_home =
+                env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
+            format!("{xdg_config_home}/lan-mouse/")
+        };
+
+        #[cfg(not(unix))]
+        let config_path = {
+            let app_data =
+                env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
+            format!("{app_data}\\lan-mouse\\")
+        };
+
+        let config_path = PathBuf::from(config_path);
+        let config_file = config_path.join(CONFIG_FILE_NAME);
 
         // --config <file> overrules default location
-        let config_path = args
+        let config_file = args.config.map(PathBuf::from).unwrap_or(config_file);
-            .config
-            .clone()
-            .unwrap_or(default_path()?.join(CONFIG_FILE_NAME));
 
-        let config_toml = match ConfigToml::new(&config_path) {
+        let mut config_toml = match ConfigToml::new(&config_file) {
             Err(e) => {
-                log::warn!("{config_path:?}: {e}");
+                log::warn!("{config_file:?}: {e}");
                 log::warn!("Continuing without config file ...");
                 None
             }
             Ok(c) => Some(c),
         };
 
-        // --cert-path <file> overrules default location
+        let frontend_arg = args.frontend;
+        let frontend_cfg = config_toml.as_ref().and_then(|c| c.frontend);
+        let frontend = frontend_arg.or(frontend_cfg).unwrap_or_default();
+
+        let port = args
+            .port
+            .or(config_toml.as_ref().and_then(|c| c.port))
+            .unwrap_or(DEFAULT_PORT);
+
+        log::debug!("{config_toml:?}");
+        let release_bind = config_toml
+            .as_ref()
+            .and_then(|c| c.release_bind.clone())
+            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()));
+
+        let capture_backend = args
+            .capture_backend
+            .or(config_toml.as_ref().and_then(|c| c.capture_backend));
+
+        let emulation_backend = args
+            .emulation_backend
+            .or(config_toml.as_ref().and_then(|c| c.emulation_backend));
+
         let cert_path = args
             .cert_path
-            .clone()
             .or(config_toml.as_ref().and_then(|c| c.cert_path.clone()))
-            .unwrap_or(default_path()?.join(CERT_FILE_NAME));
+            .unwrap_or(config_path.join(CERT_FILE_NAME));
+
+        let authorized_fingerprints = config_toml
+            .as_mut()
+            .and_then(|c| std::mem::take(&mut c.authorized_fingerprints))
+            .unwrap_or_default();
+
+        let mut clients: Vec<(TomlClient, Position)> = vec![];
+
+        if let Some(config_toml) = config_toml {
+            if let Some(c) = config_toml.right {
+                clients.push((c, Position::Right))
+            }
+            if let Some(c) = config_toml.left {
+                clients.push((c, Position::Left))
+            }
+            if let Some(c) = config_toml.top {
+                clients.push((c, Position::Top))
+            }
+            if let Some(c) = config_toml.bottom {
+                clients.push((c, Position::Bottom))
+            }
+        }
+
+        let daemon = args.daemon;
+        let test_capture = args.test_capture;
+        let test_emulation = args.test_emulation;
 
         Ok(Config {
-            args,
+            path: config_path,
+            authorized_fingerprints,
+            capture_backend,
+            emulation_backend,
+            daemon,
+            frontend,
+            clients,
+            port,
+            release_bind,
+            test_capture,
+            test_emulation,
             cert_path,
-            config_path,
-            config_toml,
         })
     }
 
-    /// the command to run
+    pub fn get_clients(&self) -> Vec<ConfigClient> {
-    pub fn command(&self) -> Option<Command> {
+        self.clients
-        self.args.command.clone()
+            .iter()
-    }
+            .map(|(c, pos)| {
-
+                let port = c.port.unwrap_or(DEFAULT_PORT);
-    pub fn config_path(&self) -> &Path {
+                let ips: HashSet<IpAddr> = if let Some(ips) = c.ips.as_ref() {
-        &self.config_path
+                    HashSet::from_iter(ips.iter().cloned())
-    }
+                } else {
-
+                    HashSet::new()
-    /// public key fingerprints authorized for connection
+                };
-    pub fn authorized_fingerprints(&self) -> HashMap<String, String> {
+                let hostname = match &c.hostname {
-        self.config_toml
+                    Some(h) => Some(h.clone()),
-            .as_ref()
+                    None => c.host_name.clone(),
-            .and_then(|c| c.authorized_fingerprints.clone())
+                };
-            .unwrap_or_default()
+                let active = c.activate_on_startup.unwrap_or(false);
-    }
+                let enter_hook = c.enter_hook.clone();
-
+                ConfigClient {
-    /// path to certificate
+                    ips,
-    pub fn cert_path(&self) -> &Path {
+                    hostname,
-        &self.cert_path
+                    port,
-    }
+                    pos: *pos,
-
+                    active,
-    /// optional input-capture backend override
+                    enter_hook,
-    pub fn capture_backend(&self) -> Option<CaptureBackend> {
+                }
-        self.args
+            })
-            .capture_backend
-            .or(self.config_toml.as_ref().and_then(|c| c.capture_backend))
-    }
-
-    /// optional input-emulation backend override
-    pub fn emulation_backend(&self) -> Option<EmulationBackend> {
-        self.args
-            .emulation_backend
-            .or(self.config_toml.as_ref().and_then(|c| c.emulation_backend))
-    }
-
-    /// the port to use (initially)
-    pub fn port(&self) -> u16 {
-        self.args
-            .port
-            .or(self.config_toml.as_ref().and_then(|c| c.port))
-            .unwrap_or(DEFAULT_PORT)
-    }
-
-    /// list of configured clients
-    pub fn clients(&self) -> Vec<ConfigClient> {
-        self.config_toml
-            .as_ref()
-            .map(|c| c.clients.clone())
-            .unwrap_or_default()
-            .into_iter()
-            .flatten()
-            .map(From::<TomlClient>::from)
             .collect()
     }
-
-    /// release bind for returning control to the host
-    pub fn release_bind(&self) -> Vec<scancode::Linux> {
-        self.config_toml
-            .as_ref()
-            .and_then(|c| c.release_bind.clone())
-            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()))
-    }
 }

src/dns.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, net::IpAddr};
 use local_channel::mpsc::{channel, Receiver, Sender};
 use tokio::task::{spawn_local, JoinHandle};
 
-use hickory_resolver::{ResolveError, TokioResolver};
+use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
 use tokio_util::sync::CancellationToken;
 
 use lan_mouse_ipc::ClientHandle;
@@ -26,7 +26,7 @@ pub(crate) enum DnsEvent {
 }
 
 struct DnsTask {
-    resolver: TokioResolver,
+    resolver: TokioAsyncResolver,
     request_rx: Receiver<DnsRequest>,
     event_tx: Sender<DnsEvent>,
     cancellation_token: CancellationToken,
@@ -35,7 +35,7 @@ struct DnsTask {
 
 impl DnsResolver {
     pub(crate) fn new() -> Result<Self, ResolveError> {
-        let resolver = TokioResolver::builder_tokio()?.build();
+        let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
         let (request_tx, request_rx) = channel();
         let (event_tx, event_rx) = channel();
         let cancellation_token = CancellationToken::new();

src/emulation.rs

@@ -1,4 +1,4 @@
-use crate::listen::{LanMouseListener, ListenEvent, ListenerCreationError};
+use crate::listen::{LanMouseListener, ListenerCreationError};
 use futures::StreamExt;
 use input_emulation::{EmulationHandle, InputEmulation, InputEmulationError};
 use input_event::Event;
@@ -24,15 +24,8 @@ pub(crate) struct Emulation {
 }
 
 pub(crate) enum EmulationEvent {
-    Connected {
-        addr: SocketAddr,
-        fingerprint: String,
-    },
-    ConnectionAttempt {
-        fingerprint: String,
-    },
     /// new connection
-    Entered {
+    Connected {
         /// address of the connection
         addr: SocketAddr,
         /// position of the connection
@@ -41,9 +34,7 @@ pub(crate) enum EmulationEvent {
         fingerprint: String,
     },
     /// connection closed
-    Disconnected {
+    Disconnected { addr: SocketAddr },
-        addr: SocketAddr,
-    },
     /// the port of the listener has changed
     PortChanged(Result<u16, ListenerCreationError>),
     /// emulation was disabled
@@ -128,42 +119,33 @@ impl ListenTask {
     async fn run(mut self) {
         let mut interval = tokio::time::interval(Duration::from_secs(5));
         let mut last_response = HashMap::new();
-        let mut rejected_connections = HashMap::new();
         loop {
             select! {
-                e = self.listener.next() => {match e {
+                e = self.listener.next() =>  {
-                    Some(ListenEvent::Msg { event, addr }) => {
+                    let (event, addr) = match e {
-                        log::trace!("{event} <-<-<-<-<- {addr}");
+                        Some(e) => e,
-                        last_response.insert(addr, Instant::now());
+                        None => break,
-                        match event {
+                    };
-                            ProtoEvent::Enter(pos) => {
+                    log::trace!("{event} <-<-<-<-<- {addr}");
-                                if let Some(fingerprint) = self.listener.get_certificate_fingerprint(addr).await {
+                    last_response.insert(addr, Instant::now());
-                                    log::info!("releasing capture: {addr} entered this device");
+                    match event {
-                                    self.event_tx.send(EmulationEvent::ReleaseNotify).expect("channel closed");
+                        ProtoEvent::Enter(pos) => {
-                                    self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                            if let Some(fingerprint) = self.listener.get_certificate_fingerprint(addr).await {
-                                    self.event_tx.send(EmulationEvent::Entered{addr, pos: to_ipc_pos(pos), fingerprint}).expect("channel closed");
+                                log::info!("releasing capture: {addr} entered this device");
-                                }
+                                self.event_tx.send(EmulationEvent::ReleaseNotify).expect("channel closed");
-                            }
-                            ProtoEvent::Leave(_) => {
-                                self.emulation_proxy.remove(addr);
                                 self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                                self.event_tx.send(EmulationEvent::Connected{addr, pos: to_ipc_pos(pos), fingerprint}).expect("channel closed");
                             }
-                            ProtoEvent::Input(event) => self.emulation_proxy.consume(event, addr),
-                            ProtoEvent::Ping => self.listener.reply(addr, ProtoEvent::Pong(self.emulation_proxy.emulation_active.get())).await,
-                            _ => {}
                         }
+                        ProtoEvent::Leave(_) => {
+                            self.emulation_proxy.remove(addr);
+                            self.listener.reply(addr, ProtoEvent::Ack(0)).await;
+                        }
+                        ProtoEvent::Input(event) => self.emulation_proxy.consume(event, addr),
+                        ProtoEvent::Ping => self.listener.reply(addr, ProtoEvent::Pong(self.emulation_proxy.emulation_active.get())).await,
+                        _ => {}
                     }
-                    Some(ListenEvent::Accept { addr, fingerprint }) => {
+                }
-                        self.event_tx.send(EmulationEvent::Connected { addr, fingerprint }).expect("channel closed");
-                    }
-                    Some(ListenEvent::Rejected { fingerprint }) => {
-                        if rejected_connections.insert(fingerprint.clone(), Instant::now())
-                            .is_none_or(|i| i.elapsed() >= Duration::from_secs(2)) {
-                                self.event_tx.send(EmulationEvent::ConnectionAttempt { fingerprint }).expect("channel closed");
-                            }
-                    }
-                    None => break
-                }}
                 event = self.emulation_proxy.event() => {
                     self.event_tx.send(event).expect("channel closed");
                 }

src/emulation_test.rs

@@ -1,5 +1,4 @@
 use crate::config::Config;
-use clap::Args;
 use input_emulation::{InputEmulation, InputEmulationError};
 use input_event::{Event, PointerEvent};
 use std::f64::consts::PI;
@@ -8,20 +7,10 @@ use std::time::{Duration, Instant};
 const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;
 
-#[derive(Args, Clone, Debug, Eq, PartialEq)]
+pub async fn run(config: Config) -> Result<(), InputEmulationError> {
-pub struct TestEmulationArgs {
-    #[arg(long)]
-    mouse: bool,
-    #[arg(long)]
-    keyboard: bool,
-    #[arg(long)]
-    scroll: bool,
-}
-
-pub async fn run(config: Config, _args: TestEmulationArgs) -> Result<(), InputEmulationError> {
     log::info!("running input emulation test");
 
-    let backend = config.emulation_backend().map(|b| b.into());
+    let backend = config.emulation_backend.map(|b| b.into());
     let mut emulation = InputEmulation::new(backend).await?;
     emulation.create(0).await;
 

src/listen.rs

@@ -3,15 +3,15 @@ use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
 use local_channel::mpsc::{channel, Receiver, Sender};
 use rustls::pki_types::CertificateDer;
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::HashMap,
     net::SocketAddr,
     rc::Rc,
-    sync::{Arc, Mutex, RwLock},
+    sync::{Arc, RwLock},
     time::Duration,
 };
 use thiserror::Error;
 use tokio::{
-    sync::Mutex as AsyncMutex,
+    sync::Mutex,
     task::{spawn_local, JoinHandle},
 };
 use webrtc_dtls::{
@@ -34,25 +34,11 @@ pub enum ListenerCreationError {
 
 type ArcConn = Arc<dyn Conn + Send + Sync>;
 
-pub(crate) enum ListenEvent {
-    Msg {
-        event: ProtoEvent,
-        addr: SocketAddr,
-    },
-    Accept {
-        addr: SocketAddr,
-        fingerprint: String,
-    },
-    Rejected {
-        fingerprint: String,
-    },
-}
-
 pub(crate) struct LanMouseListener {
-    listen_rx: Receiver<ListenEvent>,
+    listen_rx: Receiver<(ProtoEvent, SocketAddr)>,
-    listen_tx: Sender<ListenEvent>,
+    listen_tx: Sender<(ProtoEvent, SocketAddr)>,
     listen_task: JoinHandle<()>,
-    conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
+    conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
     request_port_change: Sender<u16>,
     port_changed: Receiver<Result<u16, ListenerCreationError>>,
 }
@@ -72,35 +58,26 @@ impl LanMouseListener {
         let (listen_tx, listen_rx) = channel();
         let (request_port_change, mut request_port_change_rx) = channel();
         let (port_changed_tx, port_changed) = channel();
-        let connection_attempts: Arc<Mutex<VecDeque<String>>> = Default::default();
 
         let authorized = authorized_keys.clone();
-        let verify_peer_certificate: Option<VerifyPeerCertificateFn> = {
+        let verify_peer_certificate: Option<VerifyPeerCertificateFn> = Some(Arc::new(
-            let connection_attempts = connection_attempts.clone();
+            move |certs: &[Vec<u8>], _chains: &[CertificateDer<'static>]| {
-            Some(Arc::new(
+                assert!(certs.len() == 1);
-                move |certs: &[Vec<u8>], _chains: &[CertificateDer<'static>]| {
+                let fingerprints = certs
-                    assert!(certs.len() == 1);
+                    .iter()
-                    let fingerprints = certs
+                    .map(|c| crypto::generate_fingerprint(c))
-                        .iter()
+                    .collect::<Vec<_>>();
-                        .map(|c| crypto::generate_fingerprint(c))
+                if authorized
-                        .collect::<Vec<_>>();
+                    .read()
-                    if authorized
+                    .expect("lock")
-                        .read()
+                    .contains_key(&fingerprints[0])
-                        .expect("lock")
+                {
-                        .contains_key(&fingerprints[0])
+                    Ok(())
-                    {
+                } else {
-                        Ok(())
+                    Err(webrtc_dtls::Error::ErrVerifyDataMismatch)
-                    } else {
+                }
-                        let fingerprint = fingerprints.into_iter().next().expect("fingerprint");
+            },
-                        connection_attempts
+        ));
-                            .lock()
-                            .expect("lock")
-                            .push_back(fingerprint);
-                        Err(webrtc_dtls::Error::ErrVerifyDataMismatch)
-                    }
-                },
-            ))
-        };
         let cfg = Config {
             certificates: vec![cert.clone()],
             extended_master_secret: ExtendedMasterSecretType::Require,
@@ -112,69 +89,43 @@ impl LanMouseListener {
         let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
         let mut listener = listen(listen_addr, cfg.clone()).await?;
 
-        let conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>> =
+        let conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>> = Rc::new(Mutex::new(Vec::new()));
-            Rc::new(AsyncMutex::new(Vec::new()));
 
         let conns_clone = conns.clone();
-        let listen_task: JoinHandle<()> = {
+        let tx = listen_tx.clone();
-            let listen_tx = listen_tx.clone();
+        let listen_task: JoinHandle<()> = spawn_local(async move {
-            let connection_attempts = connection_attempts.clone();
+            loop {
-            spawn_local(async move {
+                let sleep = tokio::time::sleep(Duration::from_secs(2));
-                loop {
+                tokio::select! {
-                    let sleep = tokio::time::sleep(Duration::from_secs(2));
+                    /* workaround for https://github.com/webrtc-rs/webrtc/issues/614 */
-                    tokio::select! {
+                    _ = sleep => continue,
-                        /* workaround for https://github.com/webrtc-rs/webrtc/issues/614 */
+                    c = listener.accept() => match c {
-                        _ = sleep => continue,
+                        Ok((conn, addr)) => {
-                        c = listener.accept() => match c {
+                            log::info!("dtls client connected, ip: {addr}");
-                            Ok((conn, addr)) => {
+                            let mut conns = conns_clone.lock().await;
-                                log::info!("dtls client connected, ip: {addr}");
+                            conns.push((addr, conn.clone()));
-                                let mut conns = conns_clone.lock().await;
+                            spawn_local(read_loop(conns_clone.clone(), addr, conn, tx.clone()));
-                                conns.push((addr, conn.clone()));
+                        },
-                                let dtls_conn: &DTLSConn = conn.as_any().downcast_ref().expect("dtls conn");
+                        Err(e) => log::warn!("accept: {e}"),
-                                let certs = dtls_conn.connection_state().await.peer_certificates;
+                    },
-                                let cert = certs.first().expect("cert");
+                    port = request_port_change_rx.recv() => {
-                                let fingerprint = crypto::generate_fingerprint(cert);
+                        let port = port.expect("channel closed");
-                                listen_tx.send(ListenEvent::Accept { addr, fingerprint }).expect("channel closed");
+                        let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
-                                spawn_local(read_loop(conns_clone.clone(), addr, conn, listen_tx.clone()));
+                        match listen(listen_addr, cfg.clone()).await {
-                            },
+                            Ok(new_listener) => {
-                            Err(e) => {
+                                let _ = listener.close().await;
-                                if let Error::Std(ref e) = e {
+                                listener = new_listener;
-                                    if let Some(e) = e.0.downcast_ref::<webrtc_dtls::Error>() {
+                                port_changed_tx.send(Ok(port)).expect("channel closed");
-                                        match e {
-                                            webrtc_dtls::Error::ErrVerifyDataMismatch => {
-                                                if let Some(fingerprint) = connection_attempts.lock().expect("lock").pop_front() {
-                                                    listen_tx.send(ListenEvent::Rejected { fingerprint }).expect("channel closed");
-                                                }
-                                            }
-                                            _ => log::warn!("accept: {e}"),
-                                        }
-                                    } else {
-                                        log::warn!("accept: {e:?}");
-                                    }
-                                } else {
-                                    log::warn!("accept: {e:?}");
-                                }
                             }
-                        },
+                            Err(e) => {
-                        port = request_port_change_rx.recv() => {
+                                log::warn!("unable to change port: {e}");
-                            let port = port.expect("channel closed");
+                                port_changed_tx.send(Err(e.into())).expect("channel closed");
-                            let listen_addr = SocketAddr::new("0.0.0.0".parse().expect("invalid ip"), port);
+                            }
-                            match listen(listen_addr, cfg.clone()).await {
+                        };
-                                Ok(new_listener) => {
+                    },
-                                    let _ = listener.close().await;
+                };
-                                    listener = new_listener;
+            }
-                                    port_changed_tx.send(Ok(port)).expect("channel closed");
+        });
-                                }
-                                Err(e) => {
-                                    log::warn!("unable to change port: {e}");
-                                    port_changed_tx.send(Err(e.into())).expect("channel closed");
-                                }
-                            };
-                        },
-                    };
-                }
-            })
-        };
 
         Ok(Self {
             conns,
@@ -235,7 +186,7 @@ impl LanMouseListener {
 }
 
 impl Stream for LanMouseListener {
-    type Item = ListenEvent;
+    type Item = (ProtoEvent, SocketAddr);
 
     fn poll_next(
         mut self: std::pin::Pin<&mut Self>,
@@ -246,25 +197,23 @@ impl Stream for LanMouseListener {
 }
 
 async fn read_loop(
-    conns: Rc<AsyncMutex<Vec<(SocketAddr, ArcConn)>>>,
+    conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
     addr: SocketAddr,
     conn: ArcConn,
-    dtls_tx: Sender<ListenEvent>,
+    dtls_tx: Sender<(ProtoEvent, SocketAddr)>,
 ) -> Result<(), Error> {
     let mut b = [0u8; MAX_EVENT_SIZE];
 
     while conn.recv(&mut b).await.is_ok() {
         match b.try_into() {
-            Ok(event) => dtls_tx
+            Ok(event) => dtls_tx.send((event, addr)).expect("channel closed"),
-                .send(ListenEvent::Msg { event, addr })
-                .expect("channel closed"),
             Err(e) => {
                 log::warn!("error receiving event: {e}");
                 break;
             }
         }
     }
-    log::info!("dtls client disconnected {addr:?}");
+    log::info!("dtls client disconnected {:?}", addr);
     let mut conns = conns.lock().await;
     let index = conns
         .iter()

src/main.rs

@@ -3,18 +3,15 @@ use input_capture::InputCaptureError;
 use input_emulation::InputEmulationError;
 use lan_mouse::{
     capture_test,
-    config::{self, Command, Config, ConfigError},
+    config::{Config, ConfigError, Frontend},
     emulation_test,
     service::{Service, ServiceError},
 };
-use lan_mouse_cli::CliError;
-#[cfg(feature = "gtk")]
-use lan_mouse_gtk::GtkError;
 use lan_mouse_ipc::{IpcError, IpcListenerCreationError};
 use std::{
     future::Future,
     io,
-    process::{self, Child},
+    process::{self, Child, Command},
 };
 use thiserror::Error;
 use tokio::task::LocalSet;
@@ -33,11 +30,6 @@ enum LanMouseError {
     Capture(#[from] InputCaptureError),
     #[error(transparent)]
     Emulation(#[from] InputEmulationError),
-    #[cfg(feature = "gtk")]
-    #[error(transparent)]
-    Gtk(#[from] GtkError),
-    #[error(transparent)]
-    Cli(#[from] CliError),
 }
 
 fn main() {
@@ -52,52 +44,35 @@ fn main() {
 }
 
 fn run() -> Result<(), LanMouseError> {
-    let config = config::Config::new()?;
+    // parse config file + cli args
-    match config.command() {
+    let config = Config::new()?;
-        Some(command) => match command {
+    if config.test_capture {
-            Command::TestEmulation(args) => run_async(emulation_test::run(config, args))?,
+        run_async(capture_test::run(config))?;
-            Command::TestCapture(args) => run_async(capture_test::run(config, args))?,
+    } else if config.test_emulation {
-            Command::Cli(cli_args) => run_async(lan_mouse_cli::run(cli_args))?,
+        run_async(emulation_test::run(config))?;
-            Command::Daemon => {
+    } else if config.daemon {
-                // if daemon is specified we run the service
+        // if daemon is specified we run the service
-                match run_async(run_service(config)) {
+        match run_async(run_service(config)) {
-                    Err(LanMouseError::Service(ServiceError::IpcListen(
+            Err(LanMouseError::Service(ServiceError::IpcListen(
-                        IpcListenerCreationError::AlreadyRunning,
+                IpcListenerCreationError::AlreadyRunning,
-                    ))) => log::info!("service already running!"),
+            ))) => log::info!("service already running!"),
-                    r => r?,
+            r => r?,
-                }
-            }
-        },
-        None => {
-            //  otherwise start the service as a child process and
-            //  run a frontend
-            #[cfg(feature = "gtk")]
-            {
-                let mut service = start_service()?;
-                let res = lan_mouse_gtk::run();
-                #[cfg(unix)]
-                {
-                    // on unix we give the service a chance to terminate gracefully
-                    let pid = service.id() as libc::pid_t;
-                    unsafe {
-                        libc::kill(pid, libc::SIGINT);
-                    }
-                    service.wait()?;
-                }
-                service.kill()?;
-                res?;
-            }
-            #[cfg(not(feature = "gtk"))]
-            {
-                // run daemon if gtk is diabled
-                match run_async(run_service(config)) {
-                    Err(LanMouseError::Service(ServiceError::IpcListen(
-                        IpcListenerCreationError::AlreadyRunning,
-                    ))) => log::info!("service already running!"),
-                    r => r?,
-                }
-            }
         }
+    } else {
+        //  otherwise start the service as a child process and
+        //  run a frontend
+        let mut service = start_service()?;
+        run_frontend(&config)?;
+        #[cfg(unix)]
+        {
+            // on unix we give the service a chance to terminate gracefully
+            let pid = service.id() as libc::pid_t;
+            unsafe {
+                libc::kill(pid, libc::SIGINT);
+            }
+            service.wait()?;
+        }
+        service.kill()?;
     }
 
     Ok(())
@@ -119,20 +94,33 @@ where
 }
 
 fn start_service() -> Result<Child, io::Error> {
-    let child = process::Command::new(std::env::current_exe()?)
+    let child = Command::new(std::env::current_exe()?)
         .args(std::env::args().skip(1))
-        .arg("daemon")
+        .arg("--daemon")
         .spawn()?;
     Ok(child)
 }
 
 async fn run_service(config: Config) -> Result<(), ServiceError> {
-    let release_bind = config.release_bind();
+    log::info!("using config: {:?}", config.path);
-    let config_path = config.config_path().to_owned();
+    log::info!("Press {:?} to release the mouse", config.release_bind);
     let mut service = Service::new(config).await?;
-    log::info!("using config: {config_path:?}");
-    log::info!("Press {release_bind:?} to release the mouse");
     service.run().await?;
     log::info!("service exited!");
     Ok(())
 }
+
+fn run_frontend(config: &Config) -> Result<(), IpcError> {
+    match config.frontend {
+        #[cfg(feature = "gtk")]
+        Frontend::Gtk => {
+            lan_mouse_gtk::run();
+        }
+        #[cfg(not(feature = "gtk"))]
+        Frontend::Gtk => panic!("gtk frontend requested but feature not enabled!"),
+        Frontend::Cli => {
+            lan_mouse_cli::run()?;
+        }
+    };
+    Ok(())
+}

src/service.rs

@@ -9,7 +9,7 @@ use crate::{
     listen::{LanMouseListener, ListenerCreationError},
 };
 use futures::StreamExt;
-use hickory_resolver::ResolveError;
+use hickory_resolver::error::ResolveError;
 use lan_mouse_ipc::{
     AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
     IpcError, IpcListenerCreationError, Position, Status,
@@ -80,7 +80,7 @@ struct Incoming {
 impl Service {
     pub async fn new(config: Config) -> Result<Self, ServiceError> {
         let client_manager = ClientManager::default();
-        for client in config.clients() {
+        for client in config.get_clients() {
             let config = ClientConfig {
                 hostname: client.hostname,
                 fix_ips: client.ips.into_iter().collect(),
@@ -99,28 +99,28 @@ impl Service {
         }
 
         // load certificate
-        let cert = crypto::load_or_generate_key_and_cert(config.cert_path())?;
+        let cert = crypto::load_or_generate_key_and_cert(&config.cert_path)?;
         let public_key_fingerprint = crypto::certificate_fingerprint(&cert);
 
         // create frontend communication adapter, exit if already running
         let frontend_listener = AsyncFrontendListener::new().await?;
 
-        let authorized_keys = Arc::new(RwLock::new(config.authorized_fingerprints()));
+        let authorized_keys = Arc::new(RwLock::new(config.authorized_fingerprints.clone()));
         // listener + connection
         let listener =
-            LanMouseListener::new(config.port(), cert.clone(), authorized_keys.clone()).await?;
+            LanMouseListener::new(config.port, cert.clone(), authorized_keys.clone()).await?;
         let conn = LanMouseConnection::new(cert.clone(), client_manager.clone());
 
         // input capture + emulation
-        let capture_backend = config.capture_backend().map(|b| b.into());
+        let capture_backend = config.capture_backend.map(|b| b.into());
-        let capture = Capture::new(capture_backend, conn, config.release_bind());
+        let capture = Capture::new(capture_backend, conn, config.release_bind.clone());
-        let emulation_backend = config.emulation_backend().map(|b| b.into());
+        let emulation_backend = config.emulation_backend.map(|b| b.into());
         let emulation = Emulation::new(emulation_backend, listener);
 
         // create dns resolver
         let resolver = DnsResolver::new()?;
 
-        let port = config.port();
+        let port = config.port;
         let service = Self {
             capture,
             emulation,
@@ -142,15 +142,11 @@ impl Service {
     }
 
     pub async fn run(&mut self) -> Result<(), ServiceError> {
-        let active = self.client_manager.active_clients();
+        for handle in self.client_manager.active_clients() {
-        for handle in active.iter() {
             // small hack: `activate_client()` checks, if the client
             // is already active in client_manager and does not create a
             // capture barrier in that case so we have to deactivate it first
-            self.client_manager.deactivate_client(*handle);
+            self.client_manager.deactivate_client(handle);
-        }
-
-        for handle in active {
             self.activate_client(handle);
         }
 
@@ -197,9 +193,6 @@ impl Service {
             FrontendRequest::ResolveDns(handle) => self.resolve(handle),
             FrontendRequest::Sync => self.sync_frontend(),
             FrontendRequest::RemoveAuthorizedKey(key) => self.remove_authorized_key(key),
-            FrontendRequest::UpdateEnterHook(handle, enter_hook) => {
-                self.update_enter_hook(handle, enter_hook)
-            }
         }
     }
 
@@ -211,10 +204,7 @@ impl Service {
 
     fn handle_emulation_event(&mut self, event: EmulationEvent) {
         match event {
-            EmulationEvent::ConnectionAttempt { fingerprint } => {
+            EmulationEvent::Connected {
-                self.notify_frontend(FrontendEvent::ConnectionAttempt { fingerprint });
-            }
-            EmulationEvent::Entered {
                 addr,
                 pos,
                 fingerprint,
@@ -222,11 +212,7 @@ impl Service {
                 // check if already registered
                 if !self.incoming_conns.contains(&addr) {
                     self.add_incoming(addr, pos, fingerprint.clone());
-                    self.notify_frontend(FrontendEvent::DeviceEntered {
+                    self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
-                        fingerprint,
-                        addr,
-                        pos,
-                    });
                 } else {
                     self.update_incoming(addr, pos, fingerprint);
                 }
@@ -253,9 +239,6 @@ impl Service {
                 self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
             }
             EmulationEvent::ReleaseNotify => self.capture.release(),
-            EmulationEvent::Connected { addr, fingerprint } => {
-                self.notify_frontend(FrontendEvent::DeviceConnected { addr, fingerprint });
-            }
         }
     }
 
@@ -357,11 +340,7 @@ impl Service {
             self.remove_incoming(addr);
             self.add_incoming(addr, pos, fingerprint.clone());
             self.notify_frontend(FrontendEvent::IncomingDisconnected(addr));
-            self.notify_frontend(FrontendEvent::DeviceEntered {
+            self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
-                fingerprint,
-                addr,
-                pos,
-            });
         }
     }
 
@@ -497,11 +476,6 @@ impl Service {
         self.broadcast_client(handle);
     }
 
-    fn update_enter_hook(&mut self, handle: ClientHandle, enter_hook: Option<String>) {
-        self.client_manager.set_enter_hook(handle, enter_hook);
-        self.broadcast_client(handle);
-    }
-
     fn broadcast_client(&mut self, handle: ClientHandle) {
         let event = self
             .client_manager