macos: fix scroll capture

.github/workflows/cachix.yml

@@ -1,46 +1,40 @@
-name: Nix Binary Cache
+name: Binary Cache
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-  workflow_dispatch:
 
+on: [push, pull_request, workflow_dispatch]
 jobs:
   nix:
     strategy:
       matrix:
-        os:
+       os: 
-          - ubuntu-latest
+        - ubuntu-latest
-          - macos-15-intel
+        - macos-13
-          - macos-latest
+        - macos-14
     name: "Build"
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{ matrix.os }} 
     steps:
-      - name: Checkout
+    - name: Checkout
-        uses: actions/checkout@v4
+      uses: actions/checkout@v4
-        with:
+      with:
-          submodules: recursive
+        submodules: recursive
 
-      # - uses: DeterminateSystems/nix-installer-action@main
+    - uses: DeterminateSystems/nix-installer-action@main
-      #   with:
+      with:
-      #     logger: pretty
+        logger: pretty
-      # - uses: DeterminateSystems/magic-nix-cache-action@main
+    - uses: DeterminateSystems/magic-nix-cache-action@main
-      - uses: cachix/install-nix-action@v31
+    - uses: cachix/cachix-action@v14
-      - uses: cachix/cachix-action@v16
+      with:
-        with:
+        name: lan-mouse
-          name: lan-mouse
+        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
-          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
 
-      - name: Build lan-mouse (x86_64-linux)
+    - name: Build lan-mouse (x86_64-linux)
-        if: matrix.os == 'ubuntu-latest'
+      if: matrix.os == 'ubuntu-latest'
-        run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
+      run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
 
-      - name: Build lan-mouse (x86_64-darwin)
+    - name: Build lan-mouse (x86_64-darwin)
-        if: matrix.os == 'macos-15-intel'
+      if: matrix.os == 'macos-13'
-        run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
+      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

.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

.github/workflows/rust.yml

@@ -10,87 +10,149 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  fmt:
+  build-linux:
-    name: Formatting
+
     runs-on: ubuntu-latest
+
     steps:
-      - uses: actions/checkout@v4
+    - uses: actions/checkout@v4
-      - name: cargo fmt
+    - name: install dependencies
-        run: cargo fmt --check
+      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: actions/checkout@v4
-      - uses: Swatinem/rust-cache@v2
+    - uses: actions/setup-python@v5
-      - name: Install Linux deps
+      with:
-        if: runner.os == 'Linux'
+        python-version: '3.11'
-        run: |
+    # needed for cache restore
-          sudo apt-get update
+    - name: create gtk dir
-          sudo apt-get install libx11-dev libxtst-dev libadwaita-1-dev libgtk-4-dev
+      run: mkdir C:\gtk-build\gtk\x64\release
-      - name: Install macOS dependencies
+    - uses: actions/cache@v3
-        if: runner.os == 'macOS'
+      id: cache
-        run: brew install gtk4 libadwaita imagemagick
+      with:
-      - name: Install Windows Dependencies - create gtk dir
+        path: c:/gtk-build/gtk/x64/release/**
-        if: runner.os == 'Windows'
+        key: gtk-windows-build
-        run: mkdir C:\gtk-build\gtk\x64\release
+        restore-keys: gtk-windows-build
-      - name: Install Windows Dependencies - install gtk from cache
+    - name: Update path
-        uses: actions/cache@v3
+      run: |
-        if: runner.os == 'Windows'
+        echo "PKG_CONFIG=C:\gtk-build\gtk\x64\release\bin\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-        id: cache
+        echo "C:\pkg-config-lite-0.28-1\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-        with:
+        echo "C:\gtk-build\gtk\x64\release\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          path: c:/gtk-build/gtk/x64/release/**
+        echo $env:GITHUB_PATH
-          key: gtk-windows-build
+        echo $env:PATH
-          restore-keys: gtk-windows-build
+    - name: Install dependencies
-      - name: Install Windows Dependencies - update PATH
+      if: steps.cache.outputs.cache-hit != 'true'
-        if: runner.os == 'Windows'
+      run: |
-        run: |
+        # choco install msys2
-          echo "PKG_CONFIG=C:\gtk-build\gtk\x64\release\bin\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+        # choco install visualstudio2022-workload-vctools
-          echo "C:\pkg-config-lite-0.28-1\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        # choco install pkgconfiglite
-          echo "C:\gtk-build\gtk\x64\release\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        py -m venv .venv
-          echo $env:GITHUB_PATH
+        .venv\Scripts\activate.ps1
-          echo $env:PATH
+        py -m pip install gvsbuild
-      - name: Install Windows dependencies - build gtk
+        # see https://github.com/wingtk/gvsbuild/pull/1004
-        if: runner.os == 'Windows' && steps.cache.outputs.cache-hit != 'true'
+        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
-        run: |
+        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
-          # choco install msys2
+        gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
-          # choco install visualstudio2022-workload-vctools
+        Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
-          # choco install pkgconfiglite
+        Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
-          py -m venv .venv
+    - name: Build
-          .venv\Scripts\activate.ps1
+      run: cargo build --verbose
-          py -m pip install gvsbuild
+    - name: Run tests
-          gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
+      run: cargo test --verbose
-      - name: cargo build
+    - name: Check Formatting
-        if: matrix.job == 'build'
+      run: cargo fmt --check
-        run: cargo build
+    - 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
+  build-macos:
-        if: matrix.job == 'check'
+    runs-on: macos-13
-        run: cargo check --workspace --all-targets --all-features
+    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
+  build-macos-aarch64:
-        if: matrix.job == 'test'
+    runs-on: macos-14
-        run: cargo test --workspace --all-features
+    steps:
-
+    - uses: actions/checkout@v4
-      - name: cargo clippy
+    - name: install dependencies
-        if: matrix.job == 'clippy'
+      run: brew install gtk4 libadwaita imagemagick
-        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+    - name: Build
-
+      run: cargo build --verbose
-      - uses: clechasseur/rs-clippy-check@v4
+    - name: Run tests
-        if: matrix.job == 'clippy'
+      run: cargo test --verbose
-        with:
+    - name: Check Formatting
-          args: --workspace --all-targets --all-features
+      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

.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

Cargo.lock

@@ -1872,7 +1872,6 @@ dependencies = [
  "tokio",
  "tokio-util",
  "toml",
- "toml_edit",
  "webrtc-dtls",
  "webrtc-util",
 ]

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"

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]
+</details>
-> 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.
-
 
 ## Configuration
 To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.

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"

input-capture/src/macos.rs

@@ -18,9 +18,7 @@ use core_graphics::{
     event_source::{CGEventSource, CGEventSourceStateID},
 };
 use futures_core::Stream;
-use input_event::{
+use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent};
-    BTN_BACK, BTN_FORWARD, 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.

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()?;
+    let _devices = 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 fd = remote_desktop.connect_to_eis(&session).await?;
     Ok((remote_desktop, session, fd))

input-emulation/src/macos.rs

@@ -10,13 +10,10 @@ use core_graphics::event::{
     ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{
+use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent, scancode};
-    BTN_BACK, BTN_FORWARD, 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)
+    /// current state of the mouse buttons
-    pressed_buttons: HashSet<u32>,
+    button_state: ButtonState,
-    /// button previously pressed (evdev button code)
+    /// button previously pressed
-    previous_button: Option<u32>,
+    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.
+struct ButtonState {
-fn drag_event_type(button: u32) -> CGEventType {
+    left: bool,
-    match button {
+    right: bool,
-        BTN_LEFT => CGEventType::LeftMouseDragged,
+    center: bool,
-        BTN_RIGHT => CGEventType::RightMouseDragged,
+}
-        // middle, back, forward, and any other button all use OtherMouseDragged
+
-        _ => CGEventType::OtherMouseDragged,
+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;
+                        let mut event_type = CGEventType::MouseMoved;
-                        // otherwise emit a normal mouse-moved event.
+                        if self.button_state.left {
-                        let event_type = self
+                            event_type = CGEventType::LeftMouseDragged
-                            .pressed_buttons
+                        } else if self.button_state.right {
-                            .iter()
+                            event_type = CGEventType::RightMouseDragged
-                            .next()
+                        } else if self.button_state.center {
-                            .map(|&btn| drag_event_type(btn))
+                            event_type = CGEventType::OtherMouseDragged
-                            .unwrap_or(CGEventType::MouseMoved);
+                        };
                         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
+                        // store button state
-                        // back, forward, and middle are tracked independently
+                        self.button_state[mouse_button] = state == 1;
-                        if state == 1 {
-                            self.pressed_buttons.insert(button);
-                        } else {
-                            self.pressed_buttons.remove(&button);
-                        }
 
-                        // update double-click tracking using the evdev button
+                        // update previous button state
-                        // code so that back/forward don't alias with middle
                         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);
+                    update_modifiers(&self.modifier_state, key, state);
-                    if is_modifier {
-                        modifier_event(self.event_source.clone(), self.modifier_state.get());
-                    }
                     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 {

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(())
 }

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"] }

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)]

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.
+enable lan-mouse
-
-```nix
-nixConfig = {
-    extra-substituters = [
-        "https://lan-mouse.cachix.org/"
-    ];
-    extra-trusted-public-keys = [
-      "lan-mouse.cachix.org-1:KlE2AEZUgkzNKM7BIzMQo8w9yJYqUpor1CAUNRY6OyM="
-    ];
-};
-```
-
-Enable lan-mouse:
 
 ``` nix
 {
   inputs,
   ...
 }: {
-  # Add the Home Manager module
+  # add the home manager module
   imports = [inputs.lan-mouse.homeManagerModules.default];
 
   programs.lan-mouse = {

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
+        self.active_client.take();
-        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}");
-            }
-        }
         capture.release().await
     }
 }

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

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::fs;
-use std::io::Write;
 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(())
-    }
 }

src/connect.rs

@@ -223,18 +223,14 @@ async fn ping_pong(
 ) {
     loop {
         let (buf, len) = ProtoEvent::Ping.into();
-
+        if let Err(e) = conn.send(&buf[..len]).await {
-        // send 4 pings, at least one must be answered
+            log::warn!("{addr}: send error `{e}`, closing connection");
-        for _ in 0..4 {
+            let _ = conn.close().await;
-            if let Err(e) = conn.send(&buf[..len]).await {
+            break;
-                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;
         }
+        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");

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) => {
+            FrontendRequest::Activate(handle, active) => self.set_client_active(handle, active),
-                self.set_client_active(handle, active);
+            FrontendRequest::AuthorizeKey(desc, fp) => self.add_authorized_key(desc, fp),
-                self.save_config();
-            }
-            FrontendRequest::AuthorizeKey(desc, fp) => {
-                self.add_authorized_key(desc, fp);
-                self.save_config();
-            }
             FrontendRequest::ChangePort(port) => self.change_port(port),
-            FrontendRequest::Create => {
+            FrontendRequest::Create => self.add_client(),
-                self.add_client();
+            FrontendRequest::Delete(handle) => self.remove_client(handle),
-                self.save_config();
-            }
-            FrontendRequest::Delete(handle) => {
-                self.remove_client(handle);
-                self.save_config();
-            }
             FrontendRequest::EnableCapture => self.capture.reenable(),
             FrontendRequest::EnableEmulation => self.emulation.reenable(),
             FrontendRequest::Enumerate() => self.enumerate(),
-            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
-                self.update_fix_ips(handle, fix_ips);
+            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
-                self.save_config();
+            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
-            }
+            FrontendRequest::UpdatePosition(handle, pos) => self.update_pos(handle, pos),
-            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::ResolveDns(handle) => self.resolve(handle),
             FrontendRequest::Sync => self.sync_frontend(),
-            FrontendRequest::RemoveAuthorizedKey(key) => {
+            FrontendRequest::RemoveAuthorizedKey(key) => self.remove_authorized_key(key),
-                self.remove_authorized_key(key);
-                self.save_config();
-            }
             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}");
         }
     }