macos: fix scroll capture

2026-03-08 12:30:00 +03:00 · 2025-11-03 17:19:15 +01:00
20 changed files with 274 additions and 459 deletions
--- a/.github/workflows/cachix.yml
+++ b/.github/workflows/cachix.yml
@@ -1,46 +1,40 @@
-name: Nix Binary Cache
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-  workflow_dispatch:
+name: Binary Cache

+on: [push, pull_request, workflow_dispatch]
 jobs:
  nix:
    strategy:
      matrix:
-        os:
-          - ubuntu-latest
-          - macos-15-intel
-          - macos-latest
+       os: 
+        - ubuntu-latest
+        - macos-13
+        - macos-14
    name: "Build"
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{ matrix.os }} 
    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive

-      # - uses: DeterminateSystems/nix-installer-action@main
-      #   with:
-      #     logger: pretty
-      # - uses: DeterminateSystems/magic-nix-cache-action@main
-      - uses: cachix/install-nix-action@v31
-      - uses: cachix/cachix-action@v16
-        with:
-          name: lan-mouse
-          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
+    - uses: DeterminateSystems/nix-installer-action@main
+      with:
+        logger: pretty
+    - uses: DeterminateSystems/magic-nix-cache-action@main
+    - uses: cachix/cachix-action@v14
+      with:
+        name: lan-mouse
+        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'

-      - name: Build lan-mouse (x86_64-linux)
-        if: matrix.os == 'ubuntu-latest'
-        run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
+    - name: Build lan-mouse (x86_64-linux)
+      if: matrix.os == 'ubuntu-latest'
+      run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse

-      - name: Build lan-mouse (x86_64-darwin)
-        if: matrix.os == 'macos-15-intel'
-        run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
+    - name: Build lan-mouse (x86_64-darwin)
+      if: matrix.os == 'macos-13'
+      run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
+
+    - name: Build lan-mouse (aarch64-darwin)
+      if: matrix.os == 'macos-14'
+      run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse

-      - name: Build lan-mouse (aarch64-darwin)
-        if: matrix.os == 'macos-latest'
-        run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -11,7 +11,7 @@ env:

 jobs:
  linux-release-build:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
@@ -80,7 +80,7 @@ jobs:
        path: lan-mouse-windows.zip

  macos-release-build:
-    runs-on: macos-15-intel
+    runs-on: macos-13
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -10,87 +10,149 @@ env:
  CARGO_TERM_COLOR: always

 jobs:
-  fmt:
-    name: Formatting
+  build-linux:
+
    runs-on: ubuntu-latest
+
    steps:
-      - uses: actions/checkout@v4
-      - name: cargo fmt
-        run: cargo fmt --check
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxtst-dev
+        sudo apt-get install libadwaita-1-dev libgtk-4-dev
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse
+        path: target/debug/lan-mouse
+
+  build-windows:
+
+    runs-on: windows-latest

-  ci:
-    name: ${{ matrix.job }} ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os:
-          - ubuntu-latest
-          - windows-latest
-          - macos-latest
-          - macos-15-intel
-        job:
-          - build
-          - check
-          - clippy
-          - test
    steps:
-      - uses: actions/checkout@v4
-      - uses: Swatinem/rust-cache@v2
-      - name: Install Linux deps
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install libx11-dev libxtst-dev libadwaita-1-dev libgtk-4-dev
-      - name: Install macOS dependencies
-        if: runner.os == 'macOS'
-        run: brew install gtk4 libadwaita imagemagick
-      - name: Install Windows Dependencies - create gtk dir
-        if: runner.os == 'Windows'
-        run: mkdir C:\gtk-build\gtk\x64\release
-      - name: Install Windows Dependencies - install gtk from cache
-        uses: actions/cache@v3
-        if: runner.os == 'Windows'
-        id: cache
-        with:
-          path: c:/gtk-build/gtk/x64/release/**
-          key: gtk-windows-build
-          restore-keys: gtk-windows-build
-      - name: Install Windows Dependencies - update PATH
-        if: runner.os == 'Windows'
-        run: |
-          echo "PKG_CONFIG=C:\gtk-build\gtk\x64\release\bin\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-          echo "C:\pkg-config-lite-0.28-1\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          echo "C:\gtk-build\gtk\x64\release\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          echo $env:GITHUB_PATH
-          echo $env:PATH
-      - name: Install Windows dependencies - build gtk
-        if: runner.os == 'Windows' && steps.cache.outputs.cache-hit != 'true'
-        run: |
-          # choco install msys2
-          # choco install visualstudio2022-workload-vctools
-          # choco install pkgconfiglite
-          py -m venv .venv
-          .venv\Scripts\activate.ps1
-          py -m pip install gvsbuild
-          gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
-      - name: cargo build
-        if: matrix.job == 'build'
-        run: cargo build
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+    # needed for cache restore
+    - name: create gtk dir
+      run: mkdir C:\gtk-build\gtk\x64\release
+    - uses: actions/cache@v3
+      id: cache
+      with:
+        path: c:/gtk-build/gtk/x64/release/**
+        key: gtk-windows-build
+        restore-keys: gtk-windows-build
+    - name: Update path
+      run: |
+        echo "PKG_CONFIG=C:\gtk-build\gtk\x64\release\bin\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+        echo "C:\pkg-config-lite-0.28-1\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        echo "C:\gtk-build\gtk\x64\release\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        echo $env:GITHUB_PATH
+        echo $env:PATH
+    - name: Install dependencies
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        # choco install msys2
+        # choco install visualstudio2022-workload-vctools
+        # choco install pkgconfiglite
+        py -m venv .venv
+        .venv\Scripts\activate.ps1
+        py -m pip install gvsbuild
+        # see https://github.com/wingtk/gvsbuild/pull/1004
+        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
+        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
+        gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
+        Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
+        Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Copy Gtk Dlls
+      run: Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "target\\debug"
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: lan-mouse-windows
+        path: |
+          target/debug/lan-mouse.exe
+          target/debug/*.dll

-      - name: cargo check
-        if: matrix.job == 'check'
-        run: cargo check --workspace --all-targets --all-features
+  build-macos:
+    runs-on: macos-13
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita imagemagick
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: |
+        cargo bundle
+        scripts/copy-macos-dylib.sh
+    - name: Zip bundle
+      run: |
+        cd target/debug/bundle/osx
+        zip -r "Lan Mouse macOS (Intel).zip" "Lan Mouse.app"
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: Lan Mouse macOS (Intel)
+        path: target/debug/bundle/osx/Lan Mouse macOS (Intel).zip

-      - name: cargo test
-        if: matrix.job == 'test'
-        run: cargo test --workspace --all-features
-
-      - name: cargo clippy
-        if: matrix.job == 'clippy'
-        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
-
-      - uses: clechasseur/rs-clippy-check@v4
-        if: matrix.job == 'clippy'
-        with:
-          args: --workspace --all-targets --all-features
+  build-macos-aarch64:
+    runs-on: macos-14
+    steps:
+    - uses: actions/checkout@v4
+    - name: install dependencies
+      run: brew install gtk4 libadwaita imagemagick
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy --all-features --all-targets -- --deny warnings
+    - name: Make icns
+      run: scripts/makeicns.sh
+    - name: Install cargo bundle
+      run: cargo install cargo-bundle
+    - name: Bundle
+      run: |
+        cargo bundle
+        scripts/copy-macos-dylib.sh
+    - name: Zip bundle
+      run: |
+        cd target/debug/bundle/osx
+        zip -r "Lan Mouse macOS (ARM).zip" "Lan Mouse.app"
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: Lan Mouse macOS (ARM)
+        path: target/debug/bundle/osx/Lan Mouse macOS (ARM).zip
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -7,7 +7,7 @@ on:

 jobs:
  linux-release-build:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
@@ -76,7 +76,7 @@ jobs:
        path: lan-mouse-windows.zip

  macos-release-build:
-    runs-on: macos-15-intel
+    runs-on: macos-13
    steps:
    - uses: actions/checkout@v4
    - name: install dependencies
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1872,7 +1872,6 @@ dependencies = [
 "tokio",
 "tokio-util",
 "toml",
- "toml_edit",
 "webrtc-dtls",
 "webrtc-util",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,7 +38,6 @@ shadow-rs = { version = "1.2.0", features = ["metadata"] }

 hickory-resolver = "0.25.2"
 toml = "0.8"
-toml_edit = { version = "0.22", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4.20"
 env_logger = "0.11.3"
--- a/README.md
+++ b/README.md
@@ -321,9 +321,6 @@ To do so, use the `daemon` subcommand:
 ```sh
 lan-mouse daemon
 ```
-</details>
-
-## Systemd Service

 In order to start lan-mouse with a graphical session automatically,
 the [systemd-service](service/lan-mouse.service) can be used:
@@ -335,9 +332,7 @@ cp service/lan-mouse.service ~/.config/systemd/user
 systemctl --user daemon-reload
 systemctl --user enable --now lan-mouse.service
 ```
-> [!Important]
-> Make sure to point `ExecStart=/usr/bin/lan-mouse daemon` to the actual `lan-mouse` binary (in case it is not under `/usr/bin`, e.g. when installed manually.
-
+</details>

 ## Configuration
 To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -23,7 +23,6 @@ tokio = { version = "1.32.0", features = [
    "rt",
    "sync",
    "signal",
-    "time",
 ] }
 once_cell = "1.19.0"
 async-trait = "0.1.81"
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -18,9 +18,7 @@ use core_graphics::{
    event_source::{CGEventSource, CGEventSourceStateID},
 };
 use futures_core::Stream;
-use input_event::{
-    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
-};
+use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent};
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
@@ -306,28 +304,16 @@ fn get_events(
            })))
        }
        CGEventType::OtherMouseDown => {
-            let btn_num = ev.get_integer_value_field(EventField::MOUSE_EVENT_BUTTON_NUMBER);
-            let button = match btn_num {
-                3 => BTN_BACK,
-                4 => BTN_FORWARD,
-                _ => BTN_MIDDLE,
-            };
            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                time: 0,
-                button,
+                button: BTN_MIDDLE,
                state: 1,
            })))
        }
        CGEventType::OtherMouseUp => {
-            let btn_num = ev.get_integer_value_field(EventField::MOUSE_EVENT_BUTTON_NUMBER);
-            let button = match btn_num {
-                3 => BTN_BACK,
-                4 => BTN_FORWARD,
-                _ => BTN_MIDDLE,
-            };
            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                time: 0,
-                button,
+                button: BTN_MIDDLE,
                state: 0,
            })))
        }
@@ -467,10 +453,8 @@ fn create_event_tap<'a>(
                // Returning Drop should stop the event from being processed
                // but core fundation still returns the event
                cg_ev.set_type(CGEventType::Null);
-                CallbackResult::Drop
-            } else {
-                CallbackResult::Keep
            }
+            CallbackResult::Replace(cg_ev.to_owned())
        };

    let tap = CGEventTap::new(
@@ -660,7 +644,6 @@ unsafe fn configure_cf_settings() -> Result<(), MacosCaptureCreationError> {
    let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
        .map_err(|_| MacosCaptureCreationError::EventSourceCreation)?;
    CGEventSourceSetLocalEventsSuppressionInterval(event_source, 0.05);
-    // FIXME Memory Leak

    // This is a private settings that allows the cursor to be hidden while in the background.
    // It is used by Barrier and other apps.
--- a/input-emulation/src/libei.rs
+++ b/input-emulation/src/libei.rs
@@ -1,8 +1,7 @@
 use futures::{StreamExt, future};
 use std::{
-    env, fs, io,
+    io,
    os::{fd::OwnedFd, unix::net::UnixStream},
-    path::PathBuf,
    sync::{
        Arc, Mutex, RwLock,
        atomic::{AtomicBool, Ordering},
@@ -51,45 +50,10 @@ pub(crate) struct LibeiEmulation<'a> {
    session: Session<'a, RemoteDesktop<'a>>,
 }

-/// Get the path to the RemoteDesktop token file
-fn get_token_file_path() -> PathBuf {
-    let cache_dir = env::var("XDG_CACHE_HOME")
-        .ok()
-        .map(PathBuf::from)
-        .unwrap_or_else(|| {
-            let home = env::var("HOME").expect("HOME not set");
-            PathBuf::from(home).join(".cache")
-        });
-
-    cache_dir.join("lan-mouse").join("remote-desktop.token")
-}
-
-/// Read the RemoteDesktop token from file
-fn read_token() -> Option<String> {
-    let token_path = get_token_file_path();
-    match fs::read_to_string(&token_path) {
-        Ok(token) => Some(token.trim().to_string()),
-        Err(_) => None,
-    }
-}
-
-/// Write the RemoteDesktop token to file
-fn write_token(token: &str) -> io::Result<()> {
-    let token_path = get_token_file_path();
-    if let Some(parent) = token_path.parent() {
-        fs::create_dir_all(parent)?;
-    }
-
-    fs::write(&token_path, token)?;
-    Ok(())
-}
-
 async fn get_ei_fd<'a>()
 -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
    let remote_desktop = RemoteDesktop::new().await?;

-    let restore_token = read_token();
-
    log::debug!("creating session ...");
    let session = remote_desktop.create_session().await?;

@@ -98,20 +62,13 @@ async fn get_ei_fd<'a>()
        .select_devices(
            &session,
            DeviceType::Keyboard | DeviceType::Pointer,
-            restore_token.as_deref(),
+            None,
            PersistMode::ExplicitlyRevoked,
        )
        .await?;

    log::info!("requesting permission for input emulation");
-    let start_response = remote_desktop.start(&session, None).await?.response()?;
-
-    // The restore token is only valid once, we need to re-save it each time
-    if let Some(token_str) = start_response.restore_token() {
-        if let Err(e) = write_token(token_str) {
-            log::warn!("failed to save RemoteDesktop token: {}", e);
-        }
-    }
+    let _devices = remote_desktop.start(&session, None).await?.response()?;

    let fd = remote_desktop.connect_to_eis(&session).await?;
    Ok((remote_desktop, session, fd))
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -10,13 +10,10 @@ use core_graphics::event::{
    ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{
-    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
-    scancode,
-};
+use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent, scancode};
 use keycode::{KeyMap, KeyMapping};
 use std::cell::Cell;
-use std::collections::HashSet;
+use std::ops::{Index, IndexMut};
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -33,10 +30,10 @@ pub(crate) struct MacOSEmulation {
    event_source: CGEventSource,
    /// task handle for key repeats
    repeat_task: Option<JoinHandle<()>>,
-    /// current state of the mouse buttons (tracked by evdev button code)
-    pressed_buttons: HashSet<u32>,
-    /// button previously pressed (evdev button code)
-    previous_button: Option<u32>,
+    /// current state of the mouse buttons
+    button_state: ButtonState,
+    /// button previously pressed
+    previous_button: Option<CGMouseButton>,
    /// timestamp of previous click (button down)
    previous_button_click: Option<Instant>,
    /// click state, i.e. number of clicks in quick succession
@@ -47,13 +44,31 @@ pub(crate) struct MacOSEmulation {
    notify_repeat_task: Arc<Notify>,
 }

-/// Maps an evdev button code to the CGEventType used for drag events.
-fn drag_event_type(button: u32) -> CGEventType {
-    match button {
-        BTN_LEFT => CGEventType::LeftMouseDragged,
-        BTN_RIGHT => CGEventType::RightMouseDragged,
-        // middle, back, forward, and any other button all use OtherMouseDragged
-        _ => CGEventType::OtherMouseDragged,
+struct ButtonState {
+    left: bool,
+    right: bool,
+    center: bool,
+}
+
+impl Index<CGMouseButton> for ButtonState {
+    type Output = bool;
+
+    fn index(&self, index: CGMouseButton) -> &Self::Output {
+        match index {
+            CGMouseButton::Left => &self.left,
+            CGMouseButton::Right => &self.right,
+            CGMouseButton::Center => &self.center,
+        }
+    }
+}
+
+impl IndexMut<CGMouseButton> for ButtonState {
+    fn index_mut(&mut self, index: CGMouseButton) -> &mut Self::Output {
+        match index {
+            CGMouseButton::Left => &mut self.left,
+            CGMouseButton::Right => &mut self.right,
+            CGMouseButton::Center => &mut self.center,
+        }
    }
 }

@@ -63,9 +78,14 @@ impl MacOSEmulation {
    pub(crate) fn new() -> Result<Self, MacOSEmulationCreationError> {
        let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
            .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
+        let button_state = ButtonState {
+            left: false,
+            right: false,
+            center: false,
+        };
        Ok(Self {
            event_source,
-            pressed_buttons: HashSet::new(),
+            button_state,
            previous_button: None,
            previous_button_click: None,
            button_click_state: 0,
@@ -241,14 +261,14 @@ impl Emulation for MacOSEmulation {
                        mouse_location.x = new_mouse_x;
                        mouse_location.y = new_mouse_y;

-                        // If any button is held, emit a drag event for it;
-                        // otherwise emit a normal mouse-moved event.
-                        let event_type = self
-                            .pressed_buttons
-                            .iter()
-                            .next()
-                            .map(|&btn| drag_event_type(btn))
-                            .unwrap_or(CGEventType::MouseMoved);
+                        let mut event_type = CGEventType::MouseMoved;
+                        if self.button_state.left {
+                            event_type = CGEventType::LeftMouseDragged
+                        } else if self.button_state.right {
+                            event_type = CGEventType::RightMouseDragged
+                        } else if self.button_state.center {
+                            event_type = CGEventType::OtherMouseDragged
+                        };
                        let event = match CGEvent::new_mouse_event(
                            self.event_source.clone(),
                            event_type,
@@ -270,12 +290,6 @@ impl Emulation for MacOSEmulation {
                        button,
                        state,
                    } => {
-                        // button number for OtherMouse events (3 = back, 4 = forward, etc.)
-                        let cg_button_number: Option<i64> = match button {
-                            BTN_BACK => Some(3),
-                            BTN_FORWARD => Some(4),
-                            _ => None,
-                        };
                        let (event_type, mouse_button) = match (button, state) {
                            (BTN_LEFT, 1) => (CGEventType::LeftMouseDown, CGMouseButton::Left),
                            (BTN_LEFT, 0) => (CGEventType::LeftMouseUp, CGMouseButton::Left),
@@ -283,29 +297,17 @@ impl Emulation for MacOSEmulation {
                            (BTN_RIGHT, 0) => (CGEventType::RightMouseUp, CGMouseButton::Right),
                            (BTN_MIDDLE, 1) => (CGEventType::OtherMouseDown, CGMouseButton::Center),
                            (BTN_MIDDLE, 0) => (CGEventType::OtherMouseUp, CGMouseButton::Center),
-                            (BTN_BACK, 1) | (BTN_FORWARD, 1) => {
-                                (CGEventType::OtherMouseDown, CGMouseButton::Center)
-                            }
-                            (BTN_BACK, 0) | (BTN_FORWARD, 0) => {
-                                (CGEventType::OtherMouseUp, CGMouseButton::Center)
-                            }
                            _ => {
                                log::warn!("invalid button event: {button},{state}");
                                return Ok(());
                            }
                        };
-                        // store button state using the evdev button code so
-                        // back, forward, and middle are tracked independently
-                        if state == 1 {
-                            self.pressed_buttons.insert(button);
-                        } else {
-                            self.pressed_buttons.remove(&button);
-                        }
+                        // store button state
+                        self.button_state[mouse_button] = state == 1;

-                        // update double-click tracking using the evdev button
-                        // code so that back/forward don't alias with middle
+                        // update previous button state
                        if state == 1 {
-                            if self.previous_button == Some(button)
+                            if self.previous_button.is_some_and(|b| b.eq(&mouse_button))
                                && self
                                    .previous_button_click
                                    .is_some_and(|i| i.elapsed() < DOUBLE_CLICK_INTERVAL)
@@ -314,7 +316,7 @@ impl Emulation for MacOSEmulation {
                            } else {
                                self.button_click_state = 1;
                            }
-                            self.previous_button = Some(button);
+                            self.previous_button = Some(mouse_button);
                            self.previous_button_click = Some(Instant::now());
                        }

@@ -336,13 +338,6 @@ impl Emulation for MacOSEmulation {
                            EventField::MOUSE_EVENT_CLICK_STATE,
                            self.button_click_state,
                        );
-                        // Set the button number for extra buttons (back=3, forward=4)
-                        if let Some(btn_num) = cg_button_number {
-                            event.set_integer_value_field(
-                                EventField::MOUSE_EVENT_BUTTON_NUMBER,
-                                btn_num,
-                            );
-                        }
                        event.post(CGEventTapLocation::HID);
                    }
                    PointerEvent::Axis {
@@ -421,10 +416,7 @@ impl Emulation for MacOSEmulation {
                            return Ok(());
                        }
                    };
-                    let is_modifier = update_modifiers(&self.modifier_state, key, state);
-                    if is_modifier {
-                        modifier_event(self.event_source.clone(), self.modifier_state.get());
-                    }
+                    update_modifiers(&self.modifier_state, key, state);
                    match state {
                        // pressed
                        1 => self.spawn_repeat_task(code).await,
@@ -453,6 +445,21 @@ impl Emulation for MacOSEmulation {
    async fn terminate(&mut self) {}
 }

+trait ButtonEq {
+    fn eq(&self, other: &Self) -> bool;
+}
+
+impl ButtonEq for CGMouseButton {
+    fn eq(&self, other: &Self) -> bool {
+        matches!(
+            (self, other),
+            (CGMouseButton::Left, CGMouseButton::Left)
+                | (CGMouseButton::Right, CGMouseButton::Right)
+                | (CGMouseButton::Center, CGMouseButton::Center)
+        )
+    }
+}
+
 fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
    if let Ok(key) = scancode::Linux::try_from(key) {
        let mask = match key {
--- a/lan-mouse-cli/src/lib.rs
+++ b/lan-mouse-cli/src/lib.rs
@@ -71,8 +71,6 @@ enum CliSubcommand {
    },
    /// deauthorize a public key
    RemoveAuthorizedKey { sha256_fingerprint: String },
-    /// save configuration to file
-    SaveConfig,
 }

 pub async fn run(args: CliArgs) -> Result<(), CliError> {
@@ -164,7 +162,6 @@ async fn execute(cmd: CliSubcommand) -> Result<(), CliError> {
            tx.request(FrontendRequest::RemoveAuthorizedKey(sha256_fingerprint))
                .await?
        }
-        CliSubcommand::SaveConfig => tx.request(FrontendRequest::SaveConfiguration).await?,
    }
    Ok(())
 }
--- a/lan-mouse-ipc/Cargo.toml
+++ b/lan-mouse-ipc/Cargo.toml
@@ -12,5 +12,5 @@ log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.107"
 thiserror = "2.0.0"
-tokio = { version = "1.32.0", features = ["macros", "net", "io-util", "time"] }
+tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
 tokio-stream = { version = "0.1.15", features = ["io-util"] }
--- a/lan-mouse-ipc/src/lib.rs
+++ b/lan-mouse-ipc/src/lib.rs
@@ -253,8 +253,6 @@ pub enum FrontendRequest {
    RemoveAuthorizedKey(String),
    /// change the hook command
    UpdateEnterHook(u64, Option<String>),
-    /// save config file
-    SaveConfiguration,
 }

 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]
--- a/nix/README.md
+++ b/nix/README.md
@@ -1,18 +1,18 @@
 # Nix Flake Usage

-## Run
+## run

 ```bash
 nix run github:feschber/lan-mouse

-# With params
+# with params
 nix run github:feschber/lan-mouse -- --help

 ```

-## Home-manager module
+## home-manager module

-Add input:
+add input

 ```nix
 inputs = {
@@ -20,27 +20,14 @@ inputs = {
 }
 ```

-Optional: add [our binary cache](https://app.cachix.org/cache/lan-mouse) to allow a faster package install.
-
-```nix
-nixConfig = {
-    extra-substituters = [
-        "https://lan-mouse.cachix.org/"
-    ];
-    extra-trusted-public-keys = [
-      "lan-mouse.cachix.org-1:KlE2AEZUgkzNKM7BIzMQo8w9yJYqUpor1CAUNRY6OyM="
-    ];
-};
-```
-
-Enable lan-mouse:
+enable lan-mouse

 ``` nix
 {
  inputs,
  ...
 }: {
-  # Add the Home Manager module
+  # add the home manager module
  imports = [inputs.lan-mouse.homeManagerModules.default];

  programs.lan-mouse = {
--- a/src/capture.rs
+++ b/src/capture.rs
@@ -362,13 +362,7 @@ impl CaptureTask {
    }

    async fn release_capture(&mut self, capture: &mut InputCapture) -> Result<(), CaptureError> {
-        // If we have an active client, notify them we're leaving
-        if let Some(handle) = self.active_client.take() {
-            log::info!("sending Leave event to client {handle}");
-            if let Err(e) = self.conn.send(ProtoEvent::Leave(0), handle).await {
-                log::warn!("failed to send Leave to client {handle}: {e}");
-            }
-        }
+        self.active_client.take();
        capture.release().await
    }
 }
--- a/src/client.rs
+++ b/src/client.rs
@@ -15,15 +15,6 @@ pub struct ClientManager {
 }

 impl ClientManager {
-    /// get all clients
-    pub fn clients(&self) -> Vec<(ClientConfig, ClientState)> {
-        self.clients
-            .borrow()
-            .iter()
-            .map(|(_, c)| c.clone())
-            .collect::<Vec<_>>()
-    }
-
    /// add a new client to this manager
    pub fn add_client(&self) -> ClientHandle {
        self.clients.borrow_mut().insert(Default::default()) as ClientHandle
--- a/src/config.rs
+++ b/src/config.rs
@@ -5,14 +5,12 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::env::{self, VarError};
 use std::fmt::Display;
-use std::fs::{self, File};
-use std::io::Write;
+use std::fs;
 use std::net::IpAddr;
 use std::path::{Path, PathBuf};
 use std::{collections::HashSet, io};
 use thiserror::Error;
 use toml;
-use toml_edit::{self, DocumentMut};

 use lan_mouse_cli::CliArgs;
 use lan_mouse_ipc::{DEFAULT_PORT, Position};
@@ -46,7 +44,7 @@ fn default_path() -> Result<PathBuf, VarError> {
    Ok(PathBuf::from(default_path))
 }

-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+#[derive(Serialize, Deserialize, Debug)]
 struct ConfigToml {
    capture_backend: Option<CaptureBackend>,
    emulation_backend: Option<EmulationBackend>,
@@ -276,33 +274,6 @@ impl From<TomlClient> for ConfigClient {
    }
 }

-impl From<ConfigClient> for TomlClient {
-    fn from(client: ConfigClient) -> Self {
-        let hostname = client.hostname;
-        let host_name = None;
-        let mut ips = client.ips.into_iter().collect::<Vec<_>>();
-        ips.sort();
-        let ips = Some(ips);
-        let port = if client.port == DEFAULT_PORT {
-            None
-        } else {
-            Some(client.port)
-        };
-        let position = Some(client.pos);
-        let activate_on_startup = if client.active { Some(true) } else { None };
-        let enter_hook = client.enter_hook;
-        Self {
-            hostname,
-            host_name,
-            ips,
-            port,
-            position,
-            activate_on_startup,
-            enter_hook,
-        }
-    }
-}
-
 #[derive(Debug, Error)]
 pub enum ConfigError {
    #[error(transparent)]
@@ -413,66 +384,4 @@ impl Config {
            .and_then(|c| c.release_bind.clone())
            .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()))
    }
-
-    /// set configured clients
-    pub fn set_clients(&mut self, clients: Vec<ConfigClient>) {
-        if clients.is_empty() {
-            return;
-        }
-        if self.config_toml.is_none() {
-            self.config_toml = Some(Default::default());
-        }
-        self.config_toml.as_mut().expect("config").clients =
-            Some(clients.into_iter().map(|c| c.into()).collect::<Vec<_>>());
-    }
-
-    /// set authorized keys
-    pub fn set_authorized_keys(&mut self, fingerprints: HashMap<String, String>) {
-        if fingerprints.is_empty() {
-            return;
-        }
-        if self.config_toml.is_none() {
-            self.config_toml = Default::default();
-        }
-        self.config_toml
-            .as_mut()
-            .expect("config")
-            .authorized_fingerprints = Some(fingerprints);
-    }
-
-    pub fn write_back(&self) -> Result<(), io::Error> {
-        log::info!("writing config to {:?}", &self.config_path);
-        /* load the current configuration file */
-        let current_config = match fs::read_to_string(&self.config_path) {
-            Ok(c) => c.parse::<DocumentMut>().unwrap_or_default(),
-            Err(e) => {
-                log::info!("{:?} {e} => creating new config", self.config_path());
-                Default::default()
-            }
-        };
-        let _current_config =
-            toml_edit::de::from_document::<ConfigToml>(current_config).unwrap_or_default();
-
-        /* the new config */
-        let new_config = self.config_toml.clone().unwrap_or_default();
-        // let new_config = toml_edit::ser::to_document::<ConfigToml>(&new_config).expect("fixme");
-        let new_config = toml_edit::ser::to_string_pretty(&new_config).expect("config");
-
-        /*
-         * TODO merge documents => eventually we might want to split this up into clients configured
-         * via the config file and clients managed through the GUI / frontend.
-         * The latter should be saved to $XDG_DATA_HOME instead of $XDG_CONFIG_HOME,
-         * and clients configured through .config could be made permanent.
-         * For now we just override the config file.
-         */
-
-        /* write new config to file */
-        if let Some(p) = self.config_path().parent() {
-            fs::create_dir_all(p)?;
-        }
-        let mut f = File::create(self.config_path())?;
-        f.write_all(new_config.as_bytes())?;
-
-        Ok(())
-    }
 }
--- a/src/connect.rs
+++ b/src/connect.rs
@@ -223,18 +223,14 @@ async fn ping_pong(
 ) {
    loop {
        let (buf, len) = ProtoEvent::Ping.into();
-
-        // send 4 pings, at least one must be answered
-        for _ in 0..4 {
-            if let Err(e) = conn.send(&buf[..len]).await {
-                log::warn!("{addr}: send error `{e}`, closing connection");
-                let _ = conn.close().await;
-                break;
-            }
-            log::trace!("PING >->->->->- {addr}");
-
-            tokio::time::sleep(Duration::from_millis(500)).await;
+        if let Err(e) = conn.send(&buf[..len]).await {
+            log::warn!("{addr}: send error `{e}`, closing connection");
+            let _ = conn.close().await;
+            break;
        }
+        log::trace!("PING >->->->->- {addr}");
+
+        tokio::time::sleep(Duration::from_millis(500)).await;

        if !ping_response.borrow_mut().remove(&addr) {
            log::warn!("{addr} did not respond, closing connection");
--- a/src/service.rs
+++ b/src/service.rs
@@ -1,7 +1,7 @@
 use crate::{
    capture::{Capture, CaptureType, ICaptureEvent},
    client::ClientManager,
-    config::{Config, ConfigClient},
+    config::Config,
    connect::LanMouseConnection,
    crypto,
    dns::{DnsEvent, DnsResolver},
@@ -39,8 +39,6 @@ pub enum ServiceError {
 }

 pub struct Service {
-    /// configuration
-    config: Config,
    /// input capture
    capture: Capture,
    /// input emulation
@@ -124,7 +122,6 @@ impl Service {

        let port = config.port();
        let service = Self {
-            config,
            capture,
            emulation,
            frontend_listener,
@@ -185,73 +182,24 @@ impl Service {
            Err(e) => return log::error!("error receiving request: {e}"),
        };
        match request {
-            FrontendRequest::Activate(handle, active) => {
-                self.set_client_active(handle, active);
-                self.save_config();
-            }
-            FrontendRequest::AuthorizeKey(desc, fp) => {
-                self.add_authorized_key(desc, fp);
-                self.save_config();
-            }
+            FrontendRequest::Activate(handle, active) => self.set_client_active(handle, active),
+            FrontendRequest::AuthorizeKey(desc, fp) => self.add_authorized_key(desc, fp),
            FrontendRequest::ChangePort(port) => self.change_port(port),
-            FrontendRequest::Create => {
-                self.add_client();
-                self.save_config();
-            }
-            FrontendRequest::Delete(handle) => {
-                self.remove_client(handle);
-                self.save_config();
-            }
+            FrontendRequest::Create => self.add_client(),
+            FrontendRequest::Delete(handle) => self.remove_client(handle),
            FrontendRequest::EnableCapture => self.capture.reenable(),
            FrontendRequest::EnableEmulation => self.emulation.reenable(),
            FrontendRequest::Enumerate() => self.enumerate(),
-            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
-                self.update_fix_ips(handle, fix_ips);
-                self.save_config();
-            }
-            FrontendRequest::UpdateHostname(handle, host) => {
-                self.update_hostname(handle, host);
-                self.save_config();
-            }
-            FrontendRequest::UpdatePort(handle, port) => {
-                self.update_port(handle, port);
-                self.save_config();
-            }
-            FrontendRequest::UpdatePosition(handle, pos) => {
-                self.update_pos(handle, pos);
-                self.save_config();
-            }
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
+            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
+            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
+            FrontendRequest::UpdatePosition(handle, pos) => self.update_pos(handle, pos),
            FrontendRequest::ResolveDns(handle) => self.resolve(handle),
            FrontendRequest::Sync => self.sync_frontend(),
-            FrontendRequest::RemoveAuthorizedKey(key) => {
-                self.remove_authorized_key(key);
-                self.save_config();
-            }
+            FrontendRequest::RemoveAuthorizedKey(key) => self.remove_authorized_key(key),
            FrontendRequest::UpdateEnterHook(handle, enter_hook) => {
                self.update_enter_hook(handle, enter_hook)
            }
-            FrontendRequest::SaveConfiguration => self.save_config(),
-        }
-    }
-
-    fn save_config(&mut self) {
-        let clients = self.client_manager.clients();
-        let clients = clients
-            .into_iter()
-            .map(|(c, s)| ConfigClient {
-                ips: HashSet::from_iter(c.fix_ips),
-                hostname: c.hostname,
-                port: c.port,
-                pos: c.pos,
-                active: s.active,
-                enter_hook: c.cmd,
-            })
-            .collect();
-        self.config.set_clients(clients);
-        let authorized_keys = self.authorized_keys.read().expect("lock").clone();
-        self.config.set_authorized_keys(authorized_keys);
-        if let Err(e) = self.config.write_back() {
-            log::warn!("failed to write config: {e}");
        }
    }