mirror of
https://github.com/feschber/lan-mouse.git
synced 2026-03-08 04:20:01 +03:00
Compare commits
1 Commits
remove-git
...
log-keypre
| Author | SHA1 | Date | |
|---|---|---|---|
|
f0f73ea7ba |
4
.github/workflows/pre-release.yml
vendored
4
.github/workflows/pre-release.yml
vendored
@@ -55,9 +55,7 @@ jobs:
|
||||
# choco install msys2
|
||||
# choco install visualstudio2022-workload-vctools
|
||||
# choco install pkgconfiglite
|
||||
py -m venv .venv
|
||||
.venv\Scripts\activate.ps1
|
||||
py -m pip install gvsbuild
|
||||
pipx 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"
|
||||
|
||||
4
.github/workflows/rust.yml
vendored
4
.github/workflows/rust.yml
vendored
@@ -66,9 +66,7 @@ jobs:
|
||||
# choco install msys2
|
||||
# choco install visualstudio2022-workload-vctools
|
||||
# choco install pkgconfiglite
|
||||
py -m venv .venv
|
||||
.venv\Scripts\activate.ps1
|
||||
py -m pip install gvsbuild
|
||||
pipx 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"
|
||||
|
||||
8
.github/workflows/tagged-release.yml
vendored
8
.github/workflows/tagged-release.yml
vendored
@@ -3,7 +3,7 @@ name: "Tagged Release"
|
||||
on:
|
||||
push:
|
||||
tags:
|
||||
- v**
|
||||
- "v*"
|
||||
|
||||
jobs:
|
||||
linux-release-build:
|
||||
@@ -51,9 +51,7 @@ jobs:
|
||||
# choco install msys2
|
||||
# choco install visualstudio2022-workload-vctools
|
||||
# choco install pkgconfiglite
|
||||
py -m venv .venv
|
||||
.venv\Scripts\activate.ps1
|
||||
py -m pip install gvsbuild
|
||||
pipx 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"
|
||||
@@ -114,7 +112,7 @@ jobs:
|
||||
steps:
|
||||
- name: Download build artifacts
|
||||
uses: actions/download-artifact@v4
|
||||
- name: Create Release
|
||||
- name: "Create Release"
|
||||
uses: "marvinpinto/action-automatic-releases@latest"
|
||||
with:
|
||||
repo_token: "${{ secrets.GITHUB_TOKEN }}"
|
||||
|
||||
5
.gitignore
vendored
5
.gitignore
vendored
@@ -4,7 +4,4 @@
|
||||
.vs/
|
||||
.vscode/
|
||||
.direnv/
|
||||
result
|
||||
*.pem
|
||||
*.csr
|
||||
extfile.conf
|
||||
result
|
||||
2222
Cargo.lock
generated
2222
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
56
Cargo.toml
56
Cargo.toml
@@ -12,29 +12,23 @@ members = [
|
||||
[package]
|
||||
name = "lan-mouse"
|
||||
description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
|
||||
version = "0.10.0"
|
||||
version = "0.9.1"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
|
||||
[profile.release]
|
||||
codegen-units = 1
|
||||
lto = "fat"
|
||||
strip = true
|
||||
panic = "abort"
|
||||
|
||||
[build-dependencies]
|
||||
shadow-rs = "0.38.0"
|
||||
lto = "fat"
|
||||
|
||||
[dependencies]
|
||||
input-event = { path = "input-event", version = "0.3.0" }
|
||||
input-emulation = { path = "input-emulation", version = "0.3.0", default-features = false }
|
||||
input-capture = { path = "input-capture", version = "0.3.0", default-features = false }
|
||||
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 = "0.38.0", features = ["metadata"] }
|
||||
input-event = { path = "input-event", version = "0.2.1" }
|
||||
input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
|
||||
input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
|
||||
lan-mouse-cli = { path = "lan-mouse-cli", version = "0.1.0" }
|
||||
lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.1.0", optional = true }
|
||||
lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.1.0" }
|
||||
lan-mouse-proto = { path = "lan-mouse-proto", version = "0.1.0" }
|
||||
|
||||
hickory-resolver = "0.24.1"
|
||||
toml = "0.8"
|
||||
@@ -55,37 +49,17 @@ tokio = { version = "1.32.0", features = [
|
||||
futures = "0.3.28"
|
||||
clap = { version = "4.4.11", features = ["derive"] }
|
||||
slab = "0.4.9"
|
||||
thiserror = "2.0.0"
|
||||
thiserror = "1.0.61"
|
||||
tokio-util = "0.7.11"
|
||||
local-channel = "0.1.5"
|
||||
webrtc-dtls = { version = "0.10.0", features = ["pem"] }
|
||||
webrtc-util = "0.9.0"
|
||||
rustls = { version = "0.23.12", default-features = false, features = [
|
||||
"std",
|
||||
"ring",
|
||||
] }
|
||||
rcgen = "0.13.1"
|
||||
sha2 = "0.10.8"
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
libc = "0.2.148"
|
||||
|
||||
[features]
|
||||
default = [
|
||||
"gtk",
|
||||
"layer_shell_capture",
|
||||
"x11_capture",
|
||||
"libei_capture",
|
||||
"wlroots_emulation",
|
||||
"libei_emulation",
|
||||
"rdp_emulation",
|
||||
"x11_emulation",
|
||||
]
|
||||
default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
|
||||
wayland = ["input-capture/wayland", "input-emulation/wayland"]
|
||||
x11 = ["input-capture/x11", "input-emulation/x11"]
|
||||
xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
|
||||
libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
|
||||
gtk = ["dep:lan-mouse-gtk"]
|
||||
layer_shell_capture = ["input-capture/layer_shell"]
|
||||
x11_capture = ["input-capture/x11"]
|
||||
libei_capture = ["input-event/libei", "input-capture/libei"]
|
||||
libei_emulation = ["input-event/libei", "input-emulation/libei"]
|
||||
wlroots_emulation = ["input-emulation/wlroots"]
|
||||
x11_emulation = ["input-emulation/x11"]
|
||||
rdp_emulation = ["input-emulation/remote_desktop_portal"]
|
||||
|
||||
359
README.md
359
README.md
@@ -1,64 +1,78 @@
|
||||
# Lan Mouse
|
||||
Lan Mouse is a *cross-platform* mouse and keyboard sharing software similar to universal-control on Apple devices.
|
||||
It allows for using multiple PCs via a single set of mouse and keyboard.
|
||||
Lan Mouse is a mouse and keyboard sharing software similar to universal-control on Apple devices.
|
||||
It allows for using multiple pcs with a single set of mouse and keyboard.
|
||||
This is also known as a Software KVM switch.
|
||||
|
||||
Goal of this project is to be an open-source alternative to proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/)
|
||||
and other open source tools like [Deskflow](https://github.com/deskflow/deskflow) or [Input Leap](https://github.com/input-leap) (Synergy fork).
|
||||
|
||||
Focus lies on performance, ease of use and a maintainable implementation that can be expanded to support additional backends for e.g. Android, iOS, ... in the future.
|
||||
|
||||
***blazingly fast™*** because it's written in rust.
|
||||
The primary target is Wayland on Linux but Windows and MacOS and Linux on Xorg have partial support as well (see below for more details).
|
||||
|
||||
- _Now with a gtk frontend_
|
||||
|
||||
<picture>
|
||||
<source media="(prefers-color-scheme: dark)" srcset="/screenshots/dark.png?raw=true">
|
||||
<source media="(prefers-color-scheme: light)" srcset="/screenshots/light.png?raw=true">
|
||||
<img alt="Screenshot of Lan-Mouse" srcset="/screenshots/dark.png">
|
||||
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
|
||||
<source media="(prefers-color-scheme: light)" srcset="https://github.com/feschber/lan-mouse/assets/40996949/d6318340-f811-4e16-9d6e-d1b79883c709">
|
||||
<img alt="Screenshot of Lan-Mouse" srcset="https://github.com/feschber/lan-mouse/assets/40996949/016a06a9-76db-4951-9dcc-127d012c59df">
|
||||
</picture>
|
||||
|
||||
|
||||
## Encryption
|
||||
Goal of this project is to be an open-source replacement for proprietary tools like [Synergy 2/3](https://symless.com/synergy), [Share Mouse](https://www.sharemouse.com/de/).
|
||||
|
||||
Focus lies on performance and a clean, manageable implementation that can easily be expanded to support additional backends like e.g. Android, iOS, ... .
|
||||
|
||||
***blazingly fast™*** because it's written in rust.
|
||||
|
||||
For an alternative (with slightly different goals) you may check out [Synergy 1 Community Edition](https://github.com/symless/synergy) or [Input Leap](https://github.com/input-leap) (Synergy fork).
|
||||
|
||||
|
||||
> [!WARNING]
|
||||
> Since this tool has gained a bit of popularity over the past couple of days:
|
||||
>
|
||||
> All network traffic is currently **unencrypted** and sent in **plaintext**.
|
||||
>
|
||||
> A malicious actor with access to the network could read input data or send input events with spoofed IPs to take control over a device.
|
||||
>
|
||||
> Therefore you should only use this tool in your local network with trusted devices for now
|
||||
> and I take no responsibility for any leakage of data!
|
||||
|
||||
Lan Mouse encrypts all network traffic using the DTLS implementation provided by [WebRTC.rs](https://github.com/webrtc-rs/webrtc).
|
||||
There are currently no mitigations in place for timing side-channel attacks.
|
||||
|
||||
## OS Support
|
||||
|
||||
Most current desktop environments and operating systems are fully supported, this includes
|
||||
- GNOME >= 45
|
||||
- KDE Plasma >= 6.1
|
||||
- Most wlroots based compositors, including Sway (>= 1.8), Hyprland and Wayfire
|
||||
- Windows
|
||||
- MacOS
|
||||
The following table shows support for input emulation (to emulate events received from other clients) and
|
||||
input capture (to send events *to* other clients) on different operating systems:
|
||||
|
||||
|
||||
### Caveats / Known Issues
|
||||
| OS / Desktop Environment | input emulation | input capture |
|
||||
|---------------------------|--------------------------|--------------------------------------|
|
||||
| Wayland (wlroots) | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| Wayland (KDE) | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| Wayland (Gnome) | :heavy_check_mark: | :heavy_check_mark: (starting at GNOME 45) |
|
||||
| Windows | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| X11 | :heavy_check_mark: | WIP |
|
||||
| MacOS | :heavy_check_mark: | WIP |
|
||||
|
||||
> [!Important]
|
||||
> - **X11** currently only has support for input emulation, i.e. can only be used on the receiving end.
|
||||
> Gnome -> Sway only partially works (modifier events are not handled correctly)
|
||||
|
||||
> [!Important]
|
||||
> **Wayfire**
|
||||
>
|
||||
> - **Sway / wlroots**: Wlroots based compositors without libei support on the receiving end currently do not handle modifier events on the client side.
|
||||
> This results in CTRL / SHIFT / ALT / SUPER keys not working with a sending device that is NOT using the `layer-shell` backend
|
||||
>
|
||||
> - **Wayfire**: If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
|
||||
> If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
|
||||
> Otherwise input capture will not work.
|
||||
>
|
||||
> - **Windows**: The mouse cursor will be invisible when sending input to a Windows system if
|
||||
|
||||
> [!Important]
|
||||
> The mouse cursor will be invisible when sending input to a Windows system if
|
||||
> there is no real mouse connected to the machine.
|
||||
|
||||
For more detailed information about os support see [Detailed OS Support](#detailed-os-support)
|
||||
|
||||
### Android & IOS
|
||||
|
||||
A proof of concept for an Android / IOS Application by [rohitsangwan01](https://github.com/rohitsangwan01) can be found [here](https://github.com/rohitsangwan01/lan-mouse-mobile).
|
||||
It can be used as a remote control for any device supported by Lan Mouse.
|
||||
|
||||
## Installation
|
||||
### Install via cargo
|
||||
```sh
|
||||
cargo install lan-mouse
|
||||
```
|
||||
|
||||
<details>
|
||||
<summary>Arch Linux</summary>
|
||||
### Download from Releases
|
||||
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).
|
||||
|
||||
### Arch Linux
|
||||
|
||||
Lan Mouse can be installed from the [official repositories](https://archlinux.org/packages/extra/x86_64/lan-mouse/):
|
||||
|
||||
@@ -66,37 +80,39 @@ Lan Mouse can be installed from the [official repositories](https://archlinux.or
|
||||
pacman -S lan-mouse
|
||||
```
|
||||
|
||||
The prerelease version (following `main`) is available on the AUR:
|
||||
It is also available on the AUR:
|
||||
|
||||
```sh
|
||||
# git version (includes latest changes)
|
||||
paru -S lan-mouse-git
|
||||
|
||||
# alternatively
|
||||
paru -S lan-mouse-bin
|
||||
```
|
||||
</details>
|
||||
|
||||
|
||||
<details>
|
||||
<summary>Nix (OS)</summary>
|
||||
|
||||
### Nix
|
||||
- nixpkgs: [search.nixos.org](https://search.nixos.org/packages?channel=unstable&show=lan-mouse&from=0&size=50&sort=relevance&type=packages&query=lan-mouse)
|
||||
- flake: [README.md](./nix/README.md)
|
||||
</details>
|
||||
|
||||
|
||||
|
||||
<details>
|
||||
<summary>Manual Installation</summary>
|
||||
### Manual Installation
|
||||
|
||||
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).
|
||||
|
||||
Alternatively, the `lan-mouse` binary can be compiled from source (see below).
|
||||
|
||||
### Installing desktop file, app icon and firewall rules (optional)
|
||||
Build in release mode:
|
||||
```sh
|
||||
# install lan-mouse (replace path/to/ with the correct path)
|
||||
sudo cp path/to/lan-mouse /usr/local/bin/
|
||||
cargo build --release
|
||||
```
|
||||
|
||||
Run directly:
|
||||
```sh
|
||||
cargo run --release
|
||||
```
|
||||
|
||||
Install the files:
|
||||
```sh
|
||||
# install lan-mouse
|
||||
sudo cp target/release/lan-mouse /usr/local/bin/
|
||||
|
||||
# install app icon
|
||||
sudo mkdir -p /usr/local/share/icons/hicolor/scalable/apps
|
||||
@@ -114,34 +130,17 @@ sudo cp firewall/lan-mouse.xml /etc/firewalld/services
|
||||
# -> enable the service in firewalld settings
|
||||
```
|
||||
|
||||
Instead of downloading from the releases, the `lan-mouse` binary
|
||||
can be easily compiled via cargo or nix:
|
||||
### Conditional Compilation
|
||||
|
||||
### Compiling and installing manually:
|
||||
```sh
|
||||
# compile in release mode
|
||||
cargo build --release
|
||||
Currently only x11, wayland, windows and MacOS are supported backends.
|
||||
Depending on the toolchain used, support for other platforms is omitted
|
||||
automatically (it does not make sense to build a Windows `.exe` with
|
||||
support for x11 and wayland backends).
|
||||
|
||||
# install lan-mouse
|
||||
sudo cp target/release/lan-mouse /usr/local/bin/
|
||||
```
|
||||
However one might still want to omit support for e.g. wayland, x11 or libei on
|
||||
a Linux system.
|
||||
|
||||
### Compiling and installing via cargo:
|
||||
```sh
|
||||
# will end up in ~/.cargo/bin
|
||||
cargo install lan-mouse
|
||||
```
|
||||
|
||||
### Compiling and installing via nix:
|
||||
```sh
|
||||
# you can find the executable in result/bin/lan-mouse
|
||||
nix-build
|
||||
```
|
||||
### Conditional compilation
|
||||
Support for other platforms is omitted automatically based on the active
|
||||
rust toolchain.
|
||||
|
||||
Additionally, available backends and frontends can be configured manually via
|
||||
This is possible through
|
||||
[cargo features](https://doc.rust-lang.org/cargo/reference/features.html).
|
||||
|
||||
E.g. if only wayland support is needed, the following command produces
|
||||
@@ -150,17 +149,14 @@ an executable with just support for wayland:
|
||||
cargo build --no-default-features --features wayland
|
||||
```
|
||||
For a detailed list of available features, checkout the [Cargo.toml](./Cargo.toml)
|
||||
</details>
|
||||
|
||||
|
||||
|
||||
|
||||
## Installing Dependencies for Development / Compiling from Source
|
||||
## Installing Dependencies
|
||||
<details>
|
||||
<summary>MacOS</summary>
|
||||
|
||||
```sh
|
||||
brew install libadwaita pkg-config
|
||||
brew install libadwaita
|
||||
```
|
||||
</details>
|
||||
|
||||
@@ -187,24 +183,12 @@ sudo pacman -S libadwaita gtk libx11 libxtst
|
||||
sudo dnf install libadwaita-devel libXtst-devel libX11-devel
|
||||
```
|
||||
</details>
|
||||
<details>
|
||||
<summary>Nix</summary>
|
||||
|
||||
```sh
|
||||
nix-shell .
|
||||
```
|
||||
</details>
|
||||
<details>
|
||||
<summary>Nix (flake)</summary>
|
||||
|
||||
```sh
|
||||
nix develop
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary>Windows</summary>
|
||||
|
||||
> [!NOTE]
|
||||
> This is only necessary when building lan-mouse from source. The windows release comes with precompiled gtk dlls.
|
||||
|
||||
- First install [Rust](https://www.rust-lang.org/tools/install).
|
||||
|
||||
- Then follow the instructions at [gtk-rs.org](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation_windows.html)
|
||||
@@ -235,38 +219,27 @@ python -m pipx ensurepath
|
||||
pipx install gvsbuild
|
||||
|
||||
# build gtk + libadwaita
|
||||
gvsbuild build gtk4 libadwaita librsvg adwaita-icon-theme
|
||||
gvsbuild build gtk4 libadwaita librsvg
|
||||
```
|
||||
|
||||
- **Make sure to add the directory** `C:\gtk-build\gtk\x64\release\bin`
|
||||
[**to the `PATH` environment variable**]((https://learn.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14))). Otherwise the project will fail to build.
|
||||
|
||||
To avoid building GTK from source, it is possible to disable
|
||||
the gtk frontend (see conditional compilation).
|
||||
the gtk frontend (see conditional compilation below).
|
||||
</details>
|
||||
|
||||
## Usage
|
||||
<details>
|
||||
<summary>Gtk Frontend</summary>
|
||||
|
||||
### Gtk Frontend
|
||||
By default the gtk frontend will open when running `lan-mouse`.
|
||||
|
||||
To connect a device you want to control, simply click the `Add` button and enter the hostname
|
||||
of the device.
|
||||
To add a new connection, simply click the `Add` button on *both* devices,
|
||||
enter the corresponding hostname and activate it.
|
||||
|
||||
On the *remote* device, authorize your *local* device for incoming traffic using the `Authorize` button
|
||||
under the "Incoming Connections" section.
|
||||
The fingerprint for authorization can be found under the general section of your *local* device.
|
||||
It is of the form "aa:bb:cc:..."
|
||||
|
||||
Authorized devices can be persisted using the configuration file (see [Configuration](#configuration)).
|
||||
|
||||
If the device still can not be entered, make sure you have UDP port `4242` (or the one selected) opened up in your firewall.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary>Command Line Interface</summary>
|
||||
If the mouse can not be moved onto a device, make sure you have port `4242` (or the one selected)
|
||||
opened up in your firewall.
|
||||
|
||||
### Command Line Interface
|
||||
The cli interface can be enabled using `--frontend cli` as commandline arguments.
|
||||
Type `help` to list the available commands.
|
||||
|
||||
@@ -280,17 +253,13 @@ $ cargo run --release -- --frontend cli
|
||||
(...)
|
||||
> activate 0
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary>Daemon Mode</summary>
|
||||
|
||||
Lan Mouse can be launched in daemon mode to keep it running in the background (e.g. for use in a systemd-service).
|
||||
|
||||
### Daemon
|
||||
Lan Mouse can be launched in daemon mode to keep it running in the background.
|
||||
To do so, add `--daemon` to the commandline args:
|
||||
|
||||
```sh
|
||||
lan-mouse --daemon
|
||||
$ cargo run --release -- --daemon
|
||||
```
|
||||
|
||||
In order to start lan-mouse with a graphical session automatically,
|
||||
@@ -303,7 +272,6 @@ cp service/lan-mouse.service ~/.config/systemd/user
|
||||
systemctl --user daemon-reload
|
||||
systemctl --user enable --now lan-mouse.service
|
||||
```
|
||||
</details>
|
||||
|
||||
## Configuration
|
||||
To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.
|
||||
@@ -314,7 +282,7 @@ To create this file you can copy the following example config:
|
||||
### Example config
|
||||
> [!TIP]
|
||||
> key symbols in the release bind are named according
|
||||
> to their names in [input-event/src/scancode.rs#L172](input-event/src/scancode.rs#L176).
|
||||
> to their names in [src/scancode.rs#L172](src/scancode.rs#L172).
|
||||
> This is bound to change
|
||||
|
||||
```toml
|
||||
@@ -326,14 +294,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"
|
||||
# # possible values are "cli" and "gtk"
|
||||
# frontend = "gtk"
|
||||
|
||||
# list of authorized tls certificate fingerprints that
|
||||
# are accepted for incoming traffic
|
||||
[authorized_fingerprints]
|
||||
"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"
|
||||
[right]
|
||||
# hostname
|
||||
@@ -364,57 +327,109 @@ Where `left` can be either `left`, `right`, `top` or `bottom`.
|
||||
- [x] Liveness tracking: Automatically release keys, when server offline
|
||||
- [x] MacOS KeyCode Translation
|
||||
- [x] Libei Input Capture
|
||||
- [x] MacOS Input Capture
|
||||
- [x] Windows Input Capture
|
||||
- [x] Encryption
|
||||
- [ ] X11 Input Capture
|
||||
- [ ] Windows Input Capture
|
||||
- [ ] MacOS Input Capture
|
||||
- [ ] Latency measurement and visualization
|
||||
- [ ] Bandwidth usage measurement and visualization
|
||||
- [ ] Clipboard support
|
||||
- [ ] *Encryption*
|
||||
|
||||
## Protocol
|
||||
Currently *all* mouse and keyboard events are sent via **UDP** for performance reasons.
|
||||
Each event is sent as one single datagram, currently without any acknowledgement to guarantee 0% packet loss.
|
||||
This means, any packet that is lost results in a discarded mouse / key event, which is ignored for now.
|
||||
|
||||
**UDP** also has the additional benefit that no reconnection logic is required.
|
||||
Any client can just go offline and it will simply start working again as soon as it comes back online.
|
||||
|
||||
Additionally a tcp server is hosted for data that needs to be sent reliably (e.g. the keymap from the server or clipboard contents in the future) can be requested via a tcp connection.
|
||||
|
||||
## Bandwidth considerations
|
||||
The most bandwidth is taken up by mouse events. A typical office mouse has a polling rate of 125Hz
|
||||
while gaming mice typically have a much higher polling rate of 1000Hz.
|
||||
A mouse Event consists of 21 Bytes:
|
||||
- 1 Byte for the event type enum,
|
||||
- 4 Bytes (u32) for the timestamp,
|
||||
- 8 Bytes (f64) for dx,
|
||||
- 8 Bytes (f64) for dy.
|
||||
|
||||
Additionally the IP header with 20 Bytes and the udp header with 8 Bytes take up another 28 Byte.
|
||||
So in total there is 49 * 1000 Bytes/s for a 1000Hz gaming mouse.
|
||||
This makes for a bandwidth requirement of 392 kbit/s in total _even_ for a high end gaming mouse.
|
||||
So bandwidth is a non-issue.
|
||||
|
||||
Larger data chunks, like the keymap are offered by the server via tcp listening on the same port.
|
||||
This way we dont need to implement any congestion control and leave this up to tcp.
|
||||
In the future this can be used for e.g. clipboard contents as well.
|
||||
|
||||
## Packets per Second
|
||||
While on LAN the performance is great,
|
||||
some WIFI cards seem to struggle with the amount of packets per second,
|
||||
particularly on high-end gaming mice with 1000Hz+ polling rates.
|
||||
|
||||
The plan is to implement a way of accumulating packets and sending them as
|
||||
one single key event to reduce the packet rate (basically reducing the polling
|
||||
rate artificially).
|
||||
|
||||
The way movement data is currently sent is also quite wasteful since even a 16bit integer
|
||||
is likely enough to represent even the fastest possible mouse movement.
|
||||
A different encoding that is more efficient for smaller values like
|
||||
[Protocol Buffers](https://protobuf.dev/programming-guides/encoding/)
|
||||
would be a better choice for the future and could also help for WIFI connections.
|
||||
|
||||
## Security
|
||||
Sending key and mouse event data over the local network might not be the biggest security concern but in any public network or business environment it's *QUITE* a problem to basically broadcast your keystrokes.
|
||||
- There should be an encryption layer below the application to enable a secure link.
|
||||
- The encryption keys could be generated by the graphical frontend.
|
||||
|
||||
|
||||
## Detailed OS Support
|
||||
## Wayland support
|
||||
### Input Emulation (for receiving events)
|
||||
On wayland input-emulation is in an early/unstable state as of writing this.
|
||||
|
||||
In order to use a device for sending events, an **input-capture** backend is required, while receiving events requires
|
||||
a supported **input-emulation** *and* **input-capture** backend.
|
||||
For this reason a suitable backend is chosen based on the active desktop environment / compositor.
|
||||
|
||||
A suitable backend is chosen automatically based on the active desktop environment / compositor.
|
||||
Different compositors have different ways of enabling input emulation:
|
||||
|
||||
The following sections detail the emulation and capture backends provided by lan-mouse and their support in desktop environments / operating systems.
|
||||
#### Wlroots
|
||||
Most wlroots-based compositors like Hyprland and Sway support the following
|
||||
unstable wayland protocols for keyboard and mouse emulation:
|
||||
- [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1)
|
||||
- [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1)
|
||||
|
||||
### Input Emulation Support
|
||||
#### KDE
|
||||
KDE also has a protocol for input emulation ([kde-fake-input](https://wayland.app/protocols/kde-fake-input)),
|
||||
it is however not exposed to third party applications.
|
||||
|
||||
| Desktop / Backend | wlroots | libei | remote-desktop portal | windows | macos | x11 |
|
||||
|---------------------------|--------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|--------------------|
|
||||
| Wayland (wlroots) | :heavy_check_mark: | | | | | |
|
||||
| Wayland (KDE) | | :heavy_check_mark: | :heavy_check_mark: | | | |
|
||||
| Wayland (Gnome) | | :heavy_check_mark: | :heavy_check_mark: | | | |
|
||||
| Windows | | | | :heavy_check_mark: | | |
|
||||
| MacOS | | | | | :heavy_check_mark: | |
|
||||
| X11 | | | | | | :heavy_check_mark: |
|
||||
The recommended way to emulate input on KDE is the
|
||||
[freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop).
|
||||
|
||||
- `wlroots`: This backend makes use of the [wlr-virtual-pointer-unstable-v1](https://wayland.app/protocols/wlr-virtual-pointer-unstable-v1) and [virtual-keyboard-unstable-v1](https://wayland.app/protocols/virtual-keyboard-unstable-v1) protocols and is supported by most wlroots based compositors.
|
||||
- `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
|
||||
- `xdp`: This backend uses the [freedesktop remote-desktop-portal](https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.freedesktop.portal.RemoteDesktop) and is supported on GNOME and Plasma.
|
||||
- `x11`: Backend for X11 sessions.
|
||||
- `windows`: Backend for Windows.
|
||||
- `macos`: Backend for MacOS.
|
||||
#### Gnome
|
||||
Gnome uses [libei](https://gitlab.freedesktop.org/libinput/libei) for input emulation and capture,
|
||||
which has the goal to become the general approach for emulating and capturing Input on Wayland.
|
||||
|
||||
### Input capture
|
||||
|
||||
To capture mouse and keyboard input, a few things are necessary:
|
||||
- Displaying an immovable surface at screen edges
|
||||
- Locking the mouse in place
|
||||
- (optionally but highly recommended) reading unaccelerated mouse input
|
||||
|
||||
### Input Capture Support
|
||||
| Required Protocols (Event Emitting) | Sway | Kwin | Gnome |
|
||||
|----------------------------------------|--------------------|----------------------|----------------------|
|
||||
| pointer-constraints-unstable-v1 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| relative-pointer-unstable-v1 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| keyboard-shortcuts-inhibit-unstable-v1 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| wlr-layer-shell-unstable-v1 | :heavy_check_mark: | :heavy_check_mark: | :x: |
|
||||
|
||||
| Desktop / Backend | layer-shell | libei | windows | macos | x11 |
|
||||
|---------------------------|--------------------------|--------------------------|--------------------------|----------------------------------------|-----|
|
||||
| Wayland (wlroots) | :heavy_check_mark: | | | | |
|
||||
| Wayland (KDE) | :heavy_check_mark: | :heavy_check_mark: | | | |
|
||||
| Wayland (Gnome) | | :heavy_check_mark: | | | |
|
||||
| Windows | | | :heavy_check_mark: | | |
|
||||
| MacOS | | | | :heavy_check_mark: | |
|
||||
| X11 | | | | | WIP |
|
||||
The [zwlr\_virtual\_pointer\_manager\_v1](wlr-virtual-pointer-unstable-v1) is required
|
||||
to display surfaces on screen edges and used to display the immovable window on
|
||||
both wlroots based compositors and KDE.
|
||||
|
||||
Gnome unfortunately does not support this protocol
|
||||
and [likely won't ever support it](https://gitlab.gnome.org/GNOME/gnome-shell/-/issues/1141).
|
||||
|
||||
~In order for layershell surfaces to be able to lock the pointer using the pointer\_constraints protocol [this patch](https://github.com/swaywm/sway/pull/7178) needs to be applied to sway.~
|
||||
(this works natively on sway versions >= 1.8)
|
||||
|
||||
- `layer-shell`: This backend creates a single pixel wide window on the edges of Displays to capture the cursor using the [layer-shell protocol](https://wayland.app/protocols/wlr-layer-shell-unstable-v1).
|
||||
- `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
|
||||
- `windows`: Backend for input capture on Windows.
|
||||
- `macos`: Backend for input capture on MacOS.
|
||||
- `x11`: TODO (not yet supported)
|
||||
|
||||
17
build.rs
17
build.rs
@@ -1,8 +1,15 @@
|
||||
use shadow_rs::ShadowBuilder;
|
||||
use std::process::Command;
|
||||
|
||||
fn main() {
|
||||
ShadowBuilder::builder()
|
||||
.deny_const(Default::default())
|
||||
.build()
|
||||
.expect("shadow build");
|
||||
// commit hash
|
||||
let git_describe = Command::new("git")
|
||||
.arg("describe")
|
||||
.arg("--always")
|
||||
.arg("--dirty")
|
||||
.arg("--tags")
|
||||
.output()
|
||||
.unwrap();
|
||||
|
||||
let git_describe = String::from_utf8(git_describe.stdout).unwrap();
|
||||
println!("cargo::rustc-env=GIT_DESCRIBE={git_describe}");
|
||||
}
|
||||
|
||||
@@ -3,18 +3,13 @@
|
||||
# capture_backend = "LayerShell"
|
||||
|
||||
# release bind
|
||||
release_bind = ["KeyA", "KeyS", "KeyD", "KeyF"]
|
||||
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
|
||||
[authorized_fingerprints]
|
||||
"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"
|
||||
[right]
|
||||
# hostname
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
{ pkgs ? import <nixpkgs> { }
|
||||
}:
|
||||
pkgs.callPackage nix/default.nix { }
|
||||
46
flake.lock
generated
46
flake.lock
generated
@@ -1,12 +1,30 @@
|
||||
{
|
||||
"nodes": {
|
||||
"flake-utils": {
|
||||
"inputs": {
|
||||
"systems": "systems"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1705309234,
|
||||
"narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1728018373,
|
||||
"narHash": "sha256-NOiTvBbRLIOe5F6RbHaAh6++BNjsb149fGZd1T4+KBg=",
|
||||
"lastModified": 1716293225,
|
||||
"narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
|
||||
"owner": "nixos",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "bc947f541ae55e999ffdb4013441347d83b00feb",
|
||||
"rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
@@ -24,16 +42,17 @@
|
||||
},
|
||||
"rust-overlay": {
|
||||
"inputs": {
|
||||
"flake-utils": "flake-utils",
|
||||
"nixpkgs": [
|
||||
"nixpkgs"
|
||||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1728181869,
|
||||
"narHash": "sha256-sQXHXsjIcGEoIHkB+RO6BZdrPfB+43V1TEpyoWRI3ww=",
|
||||
"lastModified": 1716257780,
|
||||
"narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
|
||||
"owner": "oxalica",
|
||||
"repo": "rust-overlay",
|
||||
"rev": "cd46aa3906c14790ef5cbe278d9e54f2c38f95c0",
|
||||
"rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
@@ -41,6 +60,21 @@
|
||||
"repo": "rust-overlay",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"systems": {
|
||||
"locked": {
|
||||
"lastModified": 1681028828,
|
||||
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
|
||||
"owner": "nix-systems",
|
||||
"repo": "default",
|
||||
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nix-systems",
|
||||
"repo": "default",
|
||||
"type": "github"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[package]
|
||||
name = "input-capture"
|
||||
description = "cross-platform input-capture library used by lan-mouse"
|
||||
version = "0.3.0"
|
||||
version = "0.2.0"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
@@ -10,10 +10,10 @@ repository = "https://github.com/feschber/lan-mouse"
|
||||
futures = "0.3.28"
|
||||
futures-core = "0.3.30"
|
||||
log = "0.4.22"
|
||||
input-event = { path = "../input-event", version = "0.3.0" }
|
||||
input-event = { path = "../input-event", version = "0.2.1" }
|
||||
memmap = "0.7"
|
||||
tempfile = "3.8"
|
||||
thiserror = "2.0.0"
|
||||
thiserror = "1.0.61"
|
||||
tokio = { version = "1.32.0", features = [
|
||||
"io-util",
|
||||
"io-std",
|
||||
@@ -40,18 +40,18 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
|
||||
"client",
|
||||
], optional = true }
|
||||
x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
|
||||
ashpd = { version = "0.10", default-features = false, features = [
|
||||
ashpd = { version = "0.9", default-features = false, features = [
|
||||
"tokio",
|
||||
], optional = true }
|
||||
reis = { version = "0.4", features = ["tokio"], optional = true }
|
||||
reis = { version = "0.2", features = ["tokio"], optional = true }
|
||||
|
||||
[target.'cfg(target_os="macos")'.dependencies]
|
||||
core-graphics = { version = "0.24.0", features = ["highsierra"] }
|
||||
core-foundation = "0.10.0"
|
||||
core-graphics = { version = "0.23", features = ["highsierra"] }
|
||||
core-foundation = "0.9.4"
|
||||
core-foundation-sys = "0.8.6"
|
||||
libc = "0.2.155"
|
||||
keycode = "0.4.0"
|
||||
bitflags = "2.6.0"
|
||||
bitflags = "2.5.0"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.58.0", features = [
|
||||
@@ -65,8 +65,8 @@ windows = { version = "0.58.0", features = [
|
||||
] }
|
||||
|
||||
[features]
|
||||
default = ["layer_shell", "x11", "libei"]
|
||||
layer_shell = [
|
||||
default = ["wayland", "x11", "libei"]
|
||||
wayland = [
|
||||
"dep:wayland-client",
|
||||
"dep:wayland-protocols",
|
||||
"dep:wayland-protocols-wlr",
|
||||
|
||||
@@ -8,7 +8,7 @@ use futures_core::Stream;
|
||||
use input_event::PointerEvent;
|
||||
use tokio::time::{self, Instant, Interval};
|
||||
|
||||
use super::{Capture, CaptureError, CaptureEvent, Position};
|
||||
use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
|
||||
|
||||
pub struct DummyInputCapture {
|
||||
start: Option<Instant>,
|
||||
@@ -34,11 +34,11 @@ impl Default for DummyInputCapture {
|
||||
|
||||
#[async_trait]
|
||||
impl Capture for DummyInputCapture {
|
||||
async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
|
||||
async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
|
||||
async fn destroy(&mut self, _handle: CaptureHandle) -> Result<(), CaptureError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -55,7 +55,7 @@ const FREQUENCY_HZ: f64 = 1.0;
|
||||
const RADIUS: f64 = 100.0;
|
||||
|
||||
impl Stream for DummyInputCapture {
|
||||
type Item = Result<(Position, CaptureEvent), CaptureError>;
|
||||
type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
|
||||
|
||||
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||
let current = ready!(self.interval.poll_tick(cx));
|
||||
@@ -81,6 +81,6 @@ impl Stream for DummyInputCapture {
|
||||
}))
|
||||
}
|
||||
};
|
||||
Poll::Ready(Some(Ok((Position::Left, event))))
|
||||
Poll::Ready(Some(Ok((0, event))))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,9 +8,9 @@ pub enum InputCaptureError {
|
||||
Capture(#[from] CaptureError),
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
use std::io;
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
use wayland_client::{
|
||||
backend::WaylandError,
|
||||
globals::{BindError, GlobalError},
|
||||
@@ -19,10 +19,26 @@ use wayland_client::{
|
||||
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
use ashpd::desktop::ResponseError;
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
use reis::tokio::{EiConvertEventStreamError, HandshakeError};
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
use core_graphics::base::CGError;
|
||||
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[derive(Debug, Error)]
|
||||
#[error("error in libei stream: {inner:?}")]
|
||||
pub struct ReisConvertEventStreamError {
|
||||
inner: EiConvertEventStreamError,
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
impl From<EiConvertEventStreamError> for ReisConvertEventStreamError {
|
||||
fn from(e: EiConvertEventStreamError) -> Self {
|
||||
Self { inner: e }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum CaptureError {
|
||||
#[error("activation stream closed unexpectedly")]
|
||||
@@ -32,8 +48,11 @@ pub enum CaptureError {
|
||||
#[error("io error: `{0}`")]
|
||||
Io(#[from] std::io::Error),
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[error("libei error: `{0}`")]
|
||||
Reis(#[from] reis::Error),
|
||||
#[error("error in libei stream: `{0}`")]
|
||||
Reis(#[from] ReisConvertEventStreamError),
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[error("libei handshake failed: `{0}`")]
|
||||
Handshake(#[from] HandshakeError),
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[error(transparent)]
|
||||
Portal(#[from] ashpd::Error),
|
||||
@@ -64,7 +83,7 @@ pub enum CaptureCreationError {
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[error("error creating input-capture-portal backend: `{0}`")]
|
||||
Libei(#[from] LibeiCaptureCreationError),
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
#[error("error creating layer-shell capture backend: `{0}`")]
|
||||
LayerShell(#[from] LayerShellCaptureCreationError),
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
@@ -74,7 +93,7 @@ pub enum CaptureCreationError {
|
||||
#[error("error creating windows capture backend")]
|
||||
Windows,
|
||||
#[cfg(target_os = "macos")]
|
||||
#[error("error creating macos capture backend: `{0}`")]
|
||||
#[error("error creating macos capture backend")]
|
||||
MacOS(#[from] MacosCaptureCreationError),
|
||||
}
|
||||
|
||||
@@ -102,7 +121,7 @@ pub enum LibeiCaptureCreationError {
|
||||
Ashpd(#[from] ashpd::Error),
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
#[derive(Debug, Error)]
|
||||
#[error("{protocol} protocol not supported: {inner}")]
|
||||
pub struct WaylandBindError {
|
||||
@@ -110,14 +129,14 @@ pub struct WaylandBindError {
|
||||
protocol: &'static str,
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
impl WaylandBindError {
|
||||
pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
|
||||
Self { inner, protocol }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
#[derive(Debug, Error)]
|
||||
pub enum LayerShellCaptureCreationError {
|
||||
#[error(transparent)]
|
||||
@@ -146,9 +165,6 @@ pub enum X11InputCaptureCreationError {
|
||||
pub enum MacosCaptureCreationError {
|
||||
#[error("event source creation failed!")]
|
||||
EventSourceCreation,
|
||||
#[cfg(target_os = "macos")]
|
||||
#[error("event tap creation failed")]
|
||||
EventTapCreation,
|
||||
#[error("failed to set CG Cursor property")]
|
||||
CGCursorProperty,
|
||||
#[cfg(target_os = "macos")]
|
||||
|
||||
@@ -1,9 +1,4 @@
|
||||
use std::{
|
||||
collections::{HashMap, HashSet, VecDeque},
|
||||
fmt::Display,
|
||||
mem::swap,
|
||||
task::{ready, Poll},
|
||||
};
|
||||
use std::{collections::HashSet, fmt::Display, task::Poll};
|
||||
|
||||
use async_trait::async_trait;
|
||||
use futures::StreamExt;
|
||||
@@ -21,8 +16,8 @@ mod libei;
|
||||
#[cfg(target_os = "macos")]
|
||||
mod macos;
|
||||
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
mod layer_shell;
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
mod wayland;
|
||||
|
||||
#[cfg(windows)]
|
||||
mod windows;
|
||||
@@ -87,7 +82,7 @@ impl Display for Position {
|
||||
pub enum Backend {
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
InputCapturePortal,
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
LayerShell,
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
X11,
|
||||
@@ -103,7 +98,7 @@ impl Display for Backend {
|
||||
match self {
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Backend::InputCapturePortal => write!(f, "input-capture-portal"),
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Backend::LayerShell => write!(f, "layer-shell"),
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
Backend::X11 => write!(f, "X11"),
|
||||
@@ -117,52 +112,19 @@ impl Display for Backend {
|
||||
}
|
||||
|
||||
pub struct InputCapture {
|
||||
/// capture backend
|
||||
capture: Box<dyn Capture>,
|
||||
/// keys pressed by active capture
|
||||
pressed_keys: HashSet<scancode::Linux>,
|
||||
/// map from position to ids
|
||||
position_map: HashMap<Position, Vec<CaptureHandle>>,
|
||||
/// map from id to position
|
||||
id_map: HashMap<CaptureHandle, Position>,
|
||||
/// pending events
|
||||
pending: VecDeque<(CaptureHandle, CaptureEvent)>,
|
||||
}
|
||||
|
||||
impl InputCapture {
|
||||
/// create a new client with the given id
|
||||
pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
|
||||
assert!(!self.id_map.contains_key(&id));
|
||||
|
||||
self.id_map.insert(id, pos);
|
||||
|
||||
if let Some(v) = self.position_map.get_mut(&pos) {
|
||||
v.push(id);
|
||||
Ok(())
|
||||
} else {
|
||||
self.position_map.insert(pos, vec![id]);
|
||||
self.capture.create(pos).await
|
||||
}
|
||||
self.capture.create(id, pos).await
|
||||
}
|
||||
|
||||
/// destroy the client with the given id, if it exists
|
||||
pub async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
|
||||
let pos = self
|
||||
.id_map
|
||||
.remove(&id)
|
||||
.expect("no position for this handle");
|
||||
|
||||
log::debug!("destroying capture {id} @ {pos}");
|
||||
let remaining = self.position_map.get_mut(&pos).expect("id vector");
|
||||
remaining.retain(|&i| i != id);
|
||||
|
||||
log::debug!("remaining ids @ {pos}: {remaining:?}");
|
||||
if remaining.is_empty() {
|
||||
log::debug!("destroying capture @ {pos} - no remaining ids");
|
||||
self.position_map.remove(&pos);
|
||||
self.capture.destroy(pos).await?;
|
||||
}
|
||||
Ok(())
|
||||
self.capture.destroy(id).await
|
||||
}
|
||||
|
||||
/// release mouse
|
||||
@@ -181,9 +143,6 @@ impl InputCapture {
|
||||
let capture = create(backend).await?;
|
||||
Ok(Self {
|
||||
capture,
|
||||
id_map: Default::default(),
|
||||
pending: Default::default(),
|
||||
position_map: Default::default(),
|
||||
pressed_keys: HashSet::new(),
|
||||
})
|
||||
}
|
||||
@@ -201,6 +160,7 @@ impl InputCapture {
|
||||
_ => self.pressed_keys.remove(&scancode),
|
||||
};
|
||||
}
|
||||
log::info!("pressed keys: {:?}", self.pressed_keys);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -211,65 +171,29 @@ impl Stream for InputCapture {
|
||||
mut self: std::pin::Pin<&mut Self>,
|
||||
cx: &mut std::task::Context<'_>,
|
||||
) -> Poll<Option<Self::Item>> {
|
||||
if let Some(e) = self.pending.pop_front() {
|
||||
return Poll::Ready(Some(Ok(e)));
|
||||
}
|
||||
|
||||
// ready
|
||||
let event = ready!(self.capture.poll_next_unpin(cx));
|
||||
|
||||
// stream closed
|
||||
let event = match event {
|
||||
Some(e) => e,
|
||||
None => return Poll::Ready(None),
|
||||
};
|
||||
|
||||
// error occurred
|
||||
let (pos, event) = match event {
|
||||
Ok(e) => e,
|
||||
Err(e) => return Poll::Ready(Some(Err(e))),
|
||||
};
|
||||
|
||||
// handle key presses
|
||||
if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })) = event {
|
||||
self.update_pressed_keys(key, state);
|
||||
}
|
||||
|
||||
let len = self
|
||||
.position_map
|
||||
.get(&pos)
|
||||
.map(|ids| ids.len())
|
||||
.unwrap_or(0);
|
||||
|
||||
match len {
|
||||
0 => Poll::Pending,
|
||||
1 => Poll::Ready(Some(Ok((
|
||||
self.position_map.get(&pos).expect("no id")[0],
|
||||
event,
|
||||
)))),
|
||||
_ => {
|
||||
let mut position_map = HashMap::new();
|
||||
swap(&mut self.position_map, &mut position_map);
|
||||
match self.capture.poll_next_unpin(cx) {
|
||||
Poll::Ready(e) => {
|
||||
if let Some(Ok((
|
||||
_,
|
||||
CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })),
|
||||
))) = e
|
||||
{
|
||||
for &id in position_map.get(&pos).expect("position") {
|
||||
self.pending.push_back((id, event));
|
||||
}
|
||||
self.update_pressed_keys(key, state);
|
||||
}
|
||||
swap(&mut self.position_map, &mut position_map);
|
||||
|
||||
Poll::Ready(Some(Ok(self.pending.pop_front().expect("event"))))
|
||||
Poll::Ready(e)
|
||||
}
|
||||
Poll::Pending => Poll::Pending,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + Unpin {
|
||||
trait Capture: Stream<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>> + Unpin {
|
||||
/// create a new client with the given id
|
||||
async fn create(&mut self, pos: Position) -> Result<(), CaptureError>;
|
||||
async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;
|
||||
|
||||
/// destroy the client with the given id, if it exists
|
||||
async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError>;
|
||||
async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError>;
|
||||
|
||||
/// release mouse
|
||||
async fn release(&mut self) -> Result<(), CaptureError>;
|
||||
@@ -281,14 +205,14 @@ trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + U
|
||||
async fn create_backend(
|
||||
backend: Backend,
|
||||
) -> Result<
|
||||
Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
|
||||
Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
|
||||
CaptureCreationError,
|
||||
> {
|
||||
match backend {
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
Backend::LayerShell => Ok(Box::new(layer_shell::LayerShellInputCapture::new()?)),
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
|
||||
#[cfg(windows)]
|
||||
@@ -302,7 +226,7 @@ async fn create_backend(
|
||||
async fn create(
|
||||
backend: Option<Backend>,
|
||||
) -> Result<
|
||||
Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
|
||||
Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
|
||||
CaptureCreationError,
|
||||
> {
|
||||
if let Some(backend) = backend {
|
||||
@@ -316,7 +240,7 @@ async fn create(
|
||||
for backend in [
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Backend::InputCapturePortal,
|
||||
#[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Backend::LayerShell,
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
Backend::X11,
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
use ashpd::{
|
||||
desktop::{
|
||||
input_capture::{
|
||||
Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
|
||||
Zones,
|
||||
},
|
||||
input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
|
||||
Session,
|
||||
},
|
||||
enumflags2::BitFlags,
|
||||
@@ -11,15 +8,14 @@ use ashpd::{
|
||||
use async_trait::async_trait;
|
||||
use futures::{FutureExt, StreamExt};
|
||||
use reis::{
|
||||
ei::{self, handshake::ContextType},
|
||||
event::{Connection, DeviceCapability, EiEvent},
|
||||
tokio::EiConvertEventStream,
|
||||
ei,
|
||||
event::{DeviceCapability, EiEvent},
|
||||
tokio::{EiConvertEventStream, EiEventStream},
|
||||
};
|
||||
use std::{
|
||||
cell::Cell,
|
||||
collections::HashMap,
|
||||
io,
|
||||
num::NonZeroU32,
|
||||
os::unix::net::UnixStream,
|
||||
pin::Pin,
|
||||
rc::Rc,
|
||||
@@ -36,14 +32,15 @@ use tokio::{
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use futures_core::Stream;
|
||||
use once_cell::sync::Lazy;
|
||||
|
||||
use input_event::Event;
|
||||
|
||||
use crate::CaptureEvent;
|
||||
|
||||
use super::{
|
||||
error::{CaptureError, LibeiCaptureCreationError},
|
||||
Capture as LanMouseInputCapture, Position,
|
||||
error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
|
||||
Capture as LanMouseInputCapture, CaptureHandle, Position,
|
||||
};
|
||||
|
||||
/* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
|
||||
@@ -53,21 +50,37 @@ use super::{
|
||||
/// events that necessitate restarting the capture session
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
enum LibeiNotifyEvent {
|
||||
Create(Position),
|
||||
Destroy(Position),
|
||||
Create(CaptureHandle, Position),
|
||||
Destroy(CaptureHandle),
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub struct LibeiInputCapture<'a> {
|
||||
input_capture: Pin<Box<InputCapture<'a>>>,
|
||||
capture_task: JoinHandle<Result<(), CaptureError>>,
|
||||
event_rx: Receiver<(Position, CaptureEvent)>,
|
||||
event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
|
||||
notify_capture: Sender<LibeiNotifyEvent>,
|
||||
notify_release: Arc<Notify>,
|
||||
cancellation_token: CancellationToken,
|
||||
terminated: bool,
|
||||
}
|
||||
|
||||
static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
|
||||
let mut m = HashMap::new();
|
||||
m.insert("ei_connection", 1);
|
||||
m.insert("ei_callback", 1);
|
||||
m.insert("ei_pingpong", 1);
|
||||
m.insert("ei_seat", 1);
|
||||
m.insert("ei_device", 2);
|
||||
m.insert("ei_pointer", 1);
|
||||
m.insert("ei_pointer_absolute", 1);
|
||||
m.insert("ei_scroll", 1);
|
||||
m.insert("ei_button", 1);
|
||||
m.insert("ei_keyboard", 1);
|
||||
m.insert("ei_touchscreen", 1);
|
||||
m
|
||||
});
|
||||
|
||||
/// returns (start pos, end pos), inclusive
|
||||
fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
|
||||
let (x, y) = (r.x_offset(), r.y_offset());
|
||||
@@ -104,37 +117,35 @@ impl From<ICBarrier> for Barrier {
|
||||
|
||||
fn select_barriers(
|
||||
zones: &Zones,
|
||||
clients: &[Position],
|
||||
next_barrier_id: &mut NonZeroU32,
|
||||
) -> (Vec<ICBarrier>, HashMap<BarrierID, Position>) {
|
||||
let mut pos_for_barrier = HashMap::new();
|
||||
clients: &[(CaptureHandle, Position)],
|
||||
next_barrier_id: &mut u32,
|
||||
) -> (Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>) {
|
||||
let mut client_for_barrier = HashMap::new();
|
||||
let mut barriers: Vec<ICBarrier> = vec![];
|
||||
|
||||
for pos in clients {
|
||||
for (handle, pos) in clients {
|
||||
let mut client_barriers = zones
|
||||
.regions()
|
||||
.iter()
|
||||
.map(|r| {
|
||||
let id = *next_barrier_id;
|
||||
*next_barrier_id = next_barrier_id
|
||||
.checked_add(1)
|
||||
.expect("barrier id out of range");
|
||||
*next_barrier_id = id + 1;
|
||||
let position = pos_to_barrier(r, *pos);
|
||||
pos_for_barrier.insert(id, *pos);
|
||||
client_for_barrier.insert(id, *handle);
|
||||
ICBarrier::new(id, position)
|
||||
})
|
||||
.collect();
|
||||
barriers.append(&mut client_barriers);
|
||||
}
|
||||
(barriers, pos_for_barrier)
|
||||
(barriers, client_for_barrier)
|
||||
}
|
||||
|
||||
async fn update_barriers(
|
||||
input_capture: &InputCapture<'_>,
|
||||
session: &Session<'_, InputCapture<'_>>,
|
||||
active_clients: &[Position],
|
||||
next_barrier_id: &mut NonZeroU32,
|
||||
) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> {
|
||||
active_clients: &[(CaptureHandle, Position)],
|
||||
next_barrier_id: &mut u32,
|
||||
) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>), ashpd::Error> {
|
||||
let zones = input_capture.zones(session).await?.response()?;
|
||||
log::debug!("zones: {zones:?}");
|
||||
|
||||
@@ -153,11 +164,11 @@ async fn update_barriers(
|
||||
|
||||
async fn create_session<'a>(
|
||||
input_capture: &'a InputCapture<'a>,
|
||||
) -> std::result::Result<(Session<'a, InputCapture<'a>>, BitFlags<Capabilities>), ashpd::Error> {
|
||||
) -> std::result::Result<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>), ashpd::Error> {
|
||||
log::debug!("creating input capture session");
|
||||
input_capture
|
||||
.create_session(
|
||||
None,
|
||||
&ashpd::WindowIdentifier::default(),
|
||||
Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
|
||||
)
|
||||
.await
|
||||
@@ -166,7 +177,7 @@ async fn create_session<'a>(
|
||||
async fn connect_to_eis(
|
||||
input_capture: &InputCapture<'_>,
|
||||
session: &Session<'_, InputCapture<'_>>,
|
||||
) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> {
|
||||
) -> Result<(ei::Context, EiConvertEventStream), CaptureError> {
|
||||
log::debug!("connect_to_eis");
|
||||
let fd = input_capture.connect_to_eis(session).await?;
|
||||
|
||||
@@ -176,32 +187,39 @@ async fn connect_to_eis(
|
||||
|
||||
// create ei context
|
||||
let context = ei::Context::new(stream)?;
|
||||
let (conn, event_stream) = context
|
||||
.handshake_tokio("de.feschber.LanMouse", ContextType::Receiver)
|
||||
.await?;
|
||||
let mut event_stream = EiEventStream::new(context.clone())?;
|
||||
let response = reis::tokio::ei_handshake(
|
||||
&mut event_stream,
|
||||
"de.feschber.LanMouse",
|
||||
ei::handshake::ContextType::Receiver,
|
||||
&INTERFACES,
|
||||
)
|
||||
.await?;
|
||||
let event_stream = EiConvertEventStream::new(event_stream, response.serial);
|
||||
|
||||
Ok((context, conn, event_stream))
|
||||
Ok((context, event_stream))
|
||||
}
|
||||
|
||||
async fn libei_event_handler(
|
||||
mut ei_event_stream: EiConvertEventStream,
|
||||
context: ei::Context,
|
||||
event_tx: Sender<(Position, CaptureEvent)>,
|
||||
event_tx: Sender<(CaptureHandle, CaptureEvent)>,
|
||||
release_session: Arc<Notify>,
|
||||
current_pos: Rc<Cell<Option<Position>>>,
|
||||
current_client: Rc<Cell<Option<CaptureHandle>>>,
|
||||
) -> Result<(), CaptureError> {
|
||||
loop {
|
||||
let ei_event = ei_event_stream
|
||||
.next()
|
||||
.await
|
||||
.ok_or(CaptureError::EndOfStream)??;
|
||||
.ok_or(CaptureError::EndOfStream)?
|
||||
.map_err(ReisConvertEventStreamError::from)?;
|
||||
log::trace!("from ei: {ei_event:?}");
|
||||
let client = current_pos.get();
|
||||
let client = current_client.get();
|
||||
handle_ei_event(ei_event, client, &context, &event_tx, &release_session).await?;
|
||||
}
|
||||
}
|
||||
|
||||
impl LibeiInputCapture<'_> {
|
||||
impl<'a> LibeiInputCapture<'a> {
|
||||
pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
|
||||
let input_capture = Box::pin(InputCapture::new().await?);
|
||||
let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
|
||||
@@ -242,15 +260,15 @@ async fn do_capture(
|
||||
mut capture_event: Receiver<LibeiNotifyEvent>,
|
||||
notify_release: Arc<Notify>,
|
||||
session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
|
||||
event_tx: Sender<(Position, CaptureEvent)>,
|
||||
event_tx: Sender<(CaptureHandle, CaptureEvent)>,
|
||||
cancellation_token: CancellationToken,
|
||||
) -> Result<(), CaptureError> {
|
||||
let mut session = session.map(|s| s.0);
|
||||
|
||||
/* safety: libei_task does not outlive Self */
|
||||
let input_capture = unsafe { &*input_capture };
|
||||
let mut active_clients: Vec<Position> = vec![];
|
||||
let mut next_barrier_id = NonZeroU32::new(1).expect("id must be non-zero");
|
||||
let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
|
||||
let mut next_barrier_id = 1u32;
|
||||
|
||||
let mut zones_changed = input_capture.receive_zones_changed().await?;
|
||||
|
||||
@@ -323,8 +341,8 @@ async fn do_capture(
|
||||
// update clients if requested
|
||||
if let Some(event) = capture_event_occured.take() {
|
||||
match event {
|
||||
LibeiNotifyEvent::Create(p) => active_clients.push(p),
|
||||
LibeiNotifyEvent::Destroy(p) => active_clients.retain(|&pos| pos != p),
|
||||
LibeiNotifyEvent::Create(c, p) => active_clients.push((c, p)),
|
||||
LibeiNotifyEvent::Destroy(c) => active_clients.retain(|(h, _)| *h != c),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -338,21 +356,21 @@ async fn do_capture(
|
||||
async fn do_capture_session(
|
||||
input_capture: &InputCapture<'_>,
|
||||
session: &mut Session<'_, InputCapture<'_>>,
|
||||
event_tx: &Sender<(Position, CaptureEvent)>,
|
||||
active_clients: &[Position],
|
||||
next_barrier_id: &mut NonZeroU32,
|
||||
event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
|
||||
active_clients: &[(CaptureHandle, Position)],
|
||||
next_barrier_id: &mut u32,
|
||||
notify_release: &Notify,
|
||||
cancel: (CancellationToken, CancellationToken),
|
||||
) -> Result<(), CaptureError> {
|
||||
let (cancel_session, cancel_update) = cancel;
|
||||
// current client
|
||||
let current_pos = Rc::new(Cell::new(None));
|
||||
let current_client = Rc::new(Cell::new(None));
|
||||
|
||||
// connect to eis server
|
||||
let (context, _conn, ei_event_stream) = connect_to_eis(input_capture, session).await?;
|
||||
let (context, ei_event_stream) = connect_to_eis(input_capture, session).await?;
|
||||
|
||||
// set barriers
|
||||
let (barriers, pos_for_barrier_id) =
|
||||
let (barriers, client_for_barrier_id) =
|
||||
update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
|
||||
|
||||
log::debug!("enabling session");
|
||||
@@ -364,7 +382,7 @@ async fn do_capture_session(
|
||||
// async event task
|
||||
let cancel_ei_handler = CancellationToken::new();
|
||||
let event_chan = event_tx.clone();
|
||||
let pos = current_pos.clone();
|
||||
let client = current_client.clone();
|
||||
let cancel_session_clone = cancel_session.clone();
|
||||
let release_session_clone = release_session.clone();
|
||||
let cancel_ei_handler_clone = cancel_ei_handler.clone();
|
||||
@@ -375,7 +393,7 @@ async fn do_capture_session(
|
||||
context,
|
||||
event_chan,
|
||||
release_session_clone,
|
||||
pos,
|
||||
client,
|
||||
) => {
|
||||
log::debug!("libei exited: {r:?} cancelling session task");
|
||||
cancel_session_clone.cancel();
|
||||
@@ -397,17 +415,17 @@ async fn do_capture_session(
|
||||
|
||||
// get barrier id from activation
|
||||
let barrier_id = match activated.barrier_id() {
|
||||
Some(ActivatedBarrier::Barrier(id)) => id,
|
||||
Some(bid) => bid,
|
||||
// workaround for KDE plasma not reporting barrier ids
|
||||
Some(ActivatedBarrier::UnknownBarrier) | None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
|
||||
None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
|
||||
};
|
||||
|
||||
// find client corresponding to barrier
|
||||
let pos = *pos_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
|
||||
current_pos.replace(Some(pos));
|
||||
let client = *client_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
|
||||
current_client.replace(Some(client));
|
||||
|
||||
// client entered => send event
|
||||
event_tx.send((pos, CaptureEvent::Begin)).await.expect("no channel");
|
||||
event_tx.send((client, CaptureEvent::Begin)).await.expect("no channel");
|
||||
|
||||
tokio::select! {
|
||||
_ = notify_release.notified() => { /* capture release */
|
||||
@@ -423,7 +441,7 @@ async fn do_capture_session(
|
||||
},
|
||||
}
|
||||
|
||||
release_capture(input_capture, session, activated, pos).await?;
|
||||
release_capture(input_capture, session, activated, client, active_clients).await?;
|
||||
|
||||
}
|
||||
_ = notify_release.notified() => { /* capture release -> we are not capturing anyway, so ignore */
|
||||
@@ -466,7 +484,8 @@ async fn release_capture<'a>(
|
||||
input_capture: &InputCapture<'a>,
|
||||
session: &Session<'a, InputCapture<'a>>,
|
||||
activated: Activated,
|
||||
current_pos: Position,
|
||||
current_client: CaptureHandle,
|
||||
active_clients: &[(CaptureHandle, Position)],
|
||||
) -> Result<(), CaptureError> {
|
||||
if let Some(activation_id) = activated.activation_id() {
|
||||
log::debug!("releasing input capture {activation_id}");
|
||||
@@ -475,7 +494,13 @@ async fn release_capture<'a>(
|
||||
.cursor_position()
|
||||
.expect("compositor did not report cursor position!");
|
||||
log::debug!("client entered @ ({x}, {y})");
|
||||
let (dx, dy) = match current_pos {
|
||||
let pos = active_clients
|
||||
.iter()
|
||||
.filter(|(c, _)| *c == current_client)
|
||||
.map(|(_, p)| p)
|
||||
.next()
|
||||
.unwrap(); // FIXME
|
||||
let (dx, dy) = match pos {
|
||||
// offset cursor position to not enter again immediately
|
||||
Position::Left => (1., 0.),
|
||||
Position::Right => (-1., 0.),
|
||||
@@ -529,9 +554,9 @@ static ALL_CAPABILITIES: &[DeviceCapability] = &[
|
||||
|
||||
async fn handle_ei_event(
|
||||
ei_event: EiEvent,
|
||||
current_client: Option<Position>,
|
||||
current_client: Option<CaptureHandle>,
|
||||
context: &ei::Context,
|
||||
event_tx: &Sender<(Position, CaptureEvent)>,
|
||||
event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
|
||||
release_session: &Notify,
|
||||
) -> Result<(), CaptureError> {
|
||||
match ei_event {
|
||||
@@ -550,9 +575,9 @@ async fn handle_ei_event(
|
||||
return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
|
||||
}
|
||||
_ => {
|
||||
if let Some(pos) = current_client {
|
||||
if let Some(handle) = current_client {
|
||||
for event in Event::from_ei_event(ei_event) {
|
||||
event_tx.send((pos, CaptureEvent::Input(event))).await.expect("no channel");
|
||||
event_tx.send((handle, CaptureEvent::Input(event))).await.expect("no channel");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -561,19 +586,19 @@ async fn handle_ei_event(
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl LanMouseInputCapture for LibeiInputCapture<'_> {
|
||||
async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
|
||||
async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
|
||||
let _ = self
|
||||
.notify_capture
|
||||
.send(LibeiNotifyEvent::Create(pos))
|
||||
.send(LibeiNotifyEvent::Create(handle, pos))
|
||||
.await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
|
||||
let _ = self
|
||||
.notify_capture
|
||||
.send(LibeiNotifyEvent::Destroy(pos))
|
||||
.send(LibeiNotifyEvent::Destroy(handle))
|
||||
.await;
|
||||
Ok(())
|
||||
}
|
||||
@@ -594,7 +619,7 @@ impl LanMouseInputCapture for LibeiInputCapture<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for LibeiInputCapture<'_> {
|
||||
impl<'a> Drop for LibeiInputCapture<'a> {
|
||||
fn drop(&mut self) {
|
||||
if !self.terminated {
|
||||
/* this workaround is needed until async drop is stabilized */
|
||||
@@ -603,8 +628,8 @@ impl Drop for LibeiInputCapture<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
impl Stream for LibeiInputCapture<'_> {
|
||||
type Item = Result<(Position, CaptureEvent), CaptureError>;
|
||||
impl<'a> Stream for LibeiInputCapture<'a> {
|
||||
type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
|
||||
|
||||
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||
match self.capture_task.poll_unpin(cx) {
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
use super::{error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
|
||||
use super::{
|
||||
error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle, Position,
|
||||
};
|
||||
use async_trait::async_trait;
|
||||
use bitflags::bitflags;
|
||||
use core_foundation::base::{kCFAllocatorDefault, CFRelease};
|
||||
@@ -18,14 +20,14 @@ use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_
|
||||
use keycode::{KeyMap, KeyMapping};
|
||||
use libc::c_void;
|
||||
use once_cell::unsync::Lazy;
|
||||
use std::collections::HashSet;
|
||||
use std::collections::HashMap;
|
||||
use std::ffi::{c_char, CString};
|
||||
use std::pin::Pin;
|
||||
use std::sync::Arc;
|
||||
use std::task::{ready, Context, Poll};
|
||||
use std::thread::{self};
|
||||
use tokio::sync::mpsc::{self, Receiver, Sender};
|
||||
use tokio::sync::{oneshot, Mutex};
|
||||
use tokio::sync::mpsc::{Receiver, Sender};
|
||||
use tokio::sync::Mutex;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
struct Bounds {
|
||||
@@ -37,44 +39,44 @@ struct Bounds {
|
||||
|
||||
#[derive(Debug)]
|
||||
struct InputCaptureState {
|
||||
active_clients: Lazy<HashSet<Position>>,
|
||||
current_pos: Option<Position>,
|
||||
client_for_pos: Lazy<HashMap<Position, CaptureHandle>>,
|
||||
current_client: Option<(CaptureHandle, Position)>,
|
||||
bounds: Bounds,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum ProducerEvent {
|
||||
Release,
|
||||
Create(Position),
|
||||
Destroy(Position),
|
||||
Grab(Position),
|
||||
Create(CaptureHandle, Position),
|
||||
Destroy(CaptureHandle),
|
||||
Grab((CaptureHandle, Position)),
|
||||
EventTapDisabled,
|
||||
}
|
||||
|
||||
impl InputCaptureState {
|
||||
fn new() -> Result<Self, MacosCaptureCreationError> {
|
||||
let mut res = Self {
|
||||
active_clients: Lazy::new(HashSet::new),
|
||||
current_pos: None,
|
||||
client_for_pos: Lazy::new(HashMap::new),
|
||||
current_client: None,
|
||||
bounds: Bounds::default(),
|
||||
};
|
||||
res.update_bounds()?;
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
fn crossed(&mut self, event: &CGEvent) -> Option<Position> {
|
||||
fn crossed(&mut self, event: &CGEvent) -> Option<(CaptureHandle, Position)> {
|
||||
let location = event.location();
|
||||
let relative_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X);
|
||||
let relative_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y);
|
||||
|
||||
for &position in self.active_clients.iter() {
|
||||
if (position == Position::Left && (location.x + relative_x) <= self.bounds.xmin)
|
||||
|| (position == Position::Right && (location.x + relative_x) >= self.bounds.xmax)
|
||||
|| (position == Position::Top && (location.y + relative_y) <= self.bounds.ymin)
|
||||
|| (position == Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
|
||||
for (position, client) in self.client_for_pos.iter() {
|
||||
if (position == &Position::Left && (location.x + relative_x) <= self.bounds.xmin)
|
||||
|| (position == &Position::Right && (location.x + relative_x) >= self.bounds.xmax)
|
||||
|| (position == &Position::Top && (location.y + relative_y) <= self.bounds.ymin)
|
||||
|| (position == &Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
|
||||
{
|
||||
log::debug!("Crossed barrier into position: {position:?}");
|
||||
return Some(position);
|
||||
log::debug!("Crossed barrier into client: {client}, {position:?}");
|
||||
return Some((*client, *position));
|
||||
}
|
||||
}
|
||||
None
|
||||
@@ -100,7 +102,7 @@ impl InputCaptureState {
|
||||
// to the edge of the screen, the cursor will be hidden but we dont want it to appear in a
|
||||
// random location when we exit the client
|
||||
fn reset_mouse_position(&self, event: &CGEvent) -> Result<(), CaptureError> {
|
||||
if let Some(pos) = self.current_pos {
|
||||
if let Some((_, pos)) = self.current_client {
|
||||
let location = event.location();
|
||||
let edge_offset = 1.0;
|
||||
|
||||
@@ -144,31 +146,40 @@ impl InputCaptureState {
|
||||
log::debug!("handling event: {producer_event:?}");
|
||||
match producer_event {
|
||||
ProducerEvent::Release => {
|
||||
if self.current_pos.is_some() {
|
||||
if self.current_client.is_some() {
|
||||
CGDisplay::show_cursor(&CGDisplay::main())
|
||||
.map_err(CaptureError::CoreGraphics)?;
|
||||
self.current_pos = None;
|
||||
self.current_client = None;
|
||||
}
|
||||
}
|
||||
ProducerEvent::Grab(pos) => {
|
||||
if self.current_pos.is_none() {
|
||||
ProducerEvent::Grab(client) => {
|
||||
if self.current_client.is_none() {
|
||||
CGDisplay::hide_cursor(&CGDisplay::main())
|
||||
.map_err(CaptureError::CoreGraphics)?;
|
||||
self.current_pos = Some(pos);
|
||||
self.current_client = Some(client);
|
||||
}
|
||||
}
|
||||
ProducerEvent::Create(p) => {
|
||||
self.active_clients.insert(p);
|
||||
ProducerEvent::Create(c, p) => {
|
||||
self.client_for_pos.insert(p, c);
|
||||
}
|
||||
ProducerEvent::Destroy(p) => {
|
||||
if let Some(current) = self.current_pos {
|
||||
if current == p {
|
||||
CGDisplay::show_cursor(&CGDisplay::main())
|
||||
.map_err(CaptureError::CoreGraphics)?;
|
||||
self.current_pos = None;
|
||||
};
|
||||
ProducerEvent::Destroy(c) => {
|
||||
for pos in [
|
||||
Position::Left,
|
||||
Position::Right,
|
||||
Position::Top,
|
||||
Position::Bottom,
|
||||
] {
|
||||
if let Some((current_c, _)) = self.current_client {
|
||||
if current_c == c {
|
||||
CGDisplay::show_cursor(&CGDisplay::main())
|
||||
.map_err(CaptureError::CoreGraphics)?;
|
||||
self.current_client = None;
|
||||
};
|
||||
}
|
||||
if self.client_for_pos.get(&pos).copied() == Some(c) {
|
||||
self.client_for_pos.remove(&pos);
|
||||
}
|
||||
}
|
||||
self.active_clients.remove(&p);
|
||||
}
|
||||
ProducerEvent::EventTapDisabled => return Err(CaptureError::EventTapDisabled),
|
||||
};
|
||||
@@ -322,11 +333,12 @@ fn get_events(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn create_event_tap<'a>(
|
||||
fn event_tap_thread(
|
||||
client_state: Arc<Mutex<InputCaptureState>>,
|
||||
event_tx: Sender<(CaptureHandle, CaptureEvent)>,
|
||||
notify_tx: Sender<ProducerEvent>,
|
||||
event_tx: Sender<(Position, CaptureEvent)>,
|
||||
) -> Result<CGEventTap<'a>, MacosCaptureCreationError> {
|
||||
exit: tokio::sync::oneshot::Sender<Result<(), &'static str>>,
|
||||
) {
|
||||
let cg_events_of_interest: Vec<CGEventType> = vec![
|
||||
CGEventType::LeftMouseDown,
|
||||
CGEventType::LeftMouseUp,
|
||||
@@ -344,11 +356,15 @@ fn create_event_tap<'a>(
|
||||
CGEventType::FlagsChanged,
|
||||
];
|
||||
|
||||
let event_tap_callback =
|
||||
move |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
|
||||
let tap = CGEventTap::new(
|
||||
CGEventTapLocation::Session,
|
||||
CGEventTapPlacement::HeadInsertEventTap,
|
||||
CGEventTapOptions::Default,
|
||||
cg_events_of_interest,
|
||||
|_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
|
||||
log::trace!("Got event from tap: {event_type:?}");
|
||||
let mut state = client_state.blocking_lock();
|
||||
let mut pos = None;
|
||||
let mut client = None;
|
||||
let mut res_events = vec![];
|
||||
|
||||
if matches!(
|
||||
@@ -364,8 +380,8 @@ fn create_event_tap<'a>(
|
||||
}
|
||||
|
||||
// Are we in a client?
|
||||
if let Some(current_pos) = state.current_pos {
|
||||
pos = Some(current_pos);
|
||||
if let Some((current_client, _)) = state.current_client {
|
||||
client = Some(current_client);
|
||||
get_events(&event_type, cg_ev, &mut res_events).unwrap_or_else(|e| {
|
||||
log::error!("Failed to get events: {e}");
|
||||
});
|
||||
@@ -379,19 +395,19 @@ fn create_event_tap<'a>(
|
||||
}
|
||||
// Did we cross a barrier?
|
||||
else if matches!(event_type, CGEventType::MouseMoved) {
|
||||
if let Some(new_pos) = state.crossed(cg_ev) {
|
||||
pos = Some(new_pos);
|
||||
if let Some((new_client, pos)) = state.crossed(cg_ev) {
|
||||
client = Some(new_client);
|
||||
res_events.push(CaptureEvent::Begin);
|
||||
notify_tx
|
||||
.blocking_send(ProducerEvent::Grab(new_pos))
|
||||
.blocking_send(ProducerEvent::Grab((new_client, pos)))
|
||||
.expect("Failed to send notification");
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(pos) = pos {
|
||||
if let Some(client) = client {
|
||||
res_events.iter().for_each(|e| {
|
||||
event_tx
|
||||
.blocking_send((pos, *e))
|
||||
.blocking_send((client, *e))
|
||||
.expect("Failed to send event");
|
||||
});
|
||||
// Returning None should stop the event from being processed
|
||||
@@ -399,16 +415,9 @@ fn create_event_tap<'a>(
|
||||
cg_ev.set_type(CGEventType::Null);
|
||||
}
|
||||
Some(cg_ev.to_owned())
|
||||
};
|
||||
|
||||
let tap = CGEventTap::new(
|
||||
CGEventTapLocation::Session,
|
||||
CGEventTapPlacement::HeadInsertEventTap,
|
||||
CGEventTapOptions::Default,
|
||||
cg_events_of_interest,
|
||||
event_tap_callback,
|
||||
},
|
||||
)
|
||||
.map_err(|_| MacosCaptureCreationError::EventTapCreation)?;
|
||||
.expect("Failed creating tap");
|
||||
|
||||
let tap_source: CFRunLoopSource = tap
|
||||
.mach_port
|
||||
@@ -419,43 +428,22 @@ fn create_event_tap<'a>(
|
||||
CFRunLoop::get_current().add_source(&tap_source, kCFRunLoopCommonModes);
|
||||
}
|
||||
|
||||
Ok(tap)
|
||||
}
|
||||
|
||||
fn event_tap_thread(
|
||||
client_state: Arc<Mutex<InputCaptureState>>,
|
||||
event_tx: Sender<(Position, CaptureEvent)>,
|
||||
notify_tx: Sender<ProducerEvent>,
|
||||
ready: std::sync::mpsc::Sender<Result<(), MacosCaptureCreationError>>,
|
||||
exit: oneshot::Sender<Result<(), &'static str>>,
|
||||
) {
|
||||
let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
|
||||
Err(e) => {
|
||||
ready.send(Err(e)).expect("channel closed");
|
||||
return;
|
||||
}
|
||||
Ok(tap) => {
|
||||
ready.send(Ok(())).expect("channel closed");
|
||||
tap
|
||||
}
|
||||
};
|
||||
CFRunLoop::run_current();
|
||||
|
||||
let _ = exit.send(Err("tap thread exited"));
|
||||
}
|
||||
|
||||
pub struct MacOSInputCapture {
|
||||
event_rx: Receiver<(Position, CaptureEvent)>,
|
||||
event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
|
||||
notify_tx: Sender<ProducerEvent>,
|
||||
}
|
||||
|
||||
impl MacOSInputCapture {
|
||||
pub async fn new() -> Result<Self, MacosCaptureCreationError> {
|
||||
let state = Arc::new(Mutex::new(InputCaptureState::new()?));
|
||||
let (event_tx, event_rx) = mpsc::channel(32);
|
||||
let (notify_tx, mut notify_rx) = mpsc::channel(32);
|
||||
let (ready_tx, ready_rx) = std::sync::mpsc::channel();
|
||||
let (tap_exit_tx, mut tap_exit_rx) = oneshot::channel();
|
||||
let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
|
||||
let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
|
||||
let (tap_exit_tx, mut tap_exit_rx) = tokio::sync::oneshot::channel();
|
||||
|
||||
unsafe {
|
||||
configure_cf_settings()?;
|
||||
@@ -469,14 +457,10 @@ impl MacOSInputCapture {
|
||||
event_tap_thread_state,
|
||||
event_tx,
|
||||
event_tap_notify,
|
||||
ready_tx,
|
||||
tap_exit_tx,
|
||||
)
|
||||
});
|
||||
|
||||
// wait for event tap creation result
|
||||
ready_rx.recv().expect("channel closed")?;
|
||||
|
||||
let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
|
||||
loop {
|
||||
tokio::select! {
|
||||
@@ -507,21 +491,21 @@ impl MacOSInputCapture {
|
||||
|
||||
#[async_trait]
|
||||
impl Capture for MacOSInputCapture {
|
||||
async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
|
||||
let notify_tx = self.notify_tx.clone();
|
||||
tokio::task::spawn_local(async move {
|
||||
log::debug!("creating capture, {pos}");
|
||||
let _ = notify_tx.send(ProducerEvent::Create(pos)).await;
|
||||
log::debug!("creating client {id}, {pos}");
|
||||
let _ = notify_tx.send(ProducerEvent::Create(id, pos)).await;
|
||||
log::debug!("done !");
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
|
||||
let notify_tx = self.notify_tx.clone();
|
||||
tokio::task::spawn_local(async move {
|
||||
log::debug!("destroying capture {pos}");
|
||||
let _ = notify_tx.send(ProducerEvent::Destroy(pos)).await;
|
||||
log::debug!("destroying client {id}");
|
||||
let _ = notify_tx.send(ProducerEvent::Destroy(id)).await;
|
||||
log::debug!("done !");
|
||||
});
|
||||
Ok(())
|
||||
@@ -542,7 +526,7 @@ impl Capture for MacOSInputCapture {
|
||||
}
|
||||
|
||||
impl Stream for MacOSInputCapture {
|
||||
type Item = Result<(Position, CaptureEvent), CaptureError>;
|
||||
type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
|
||||
|
||||
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||
match ready!(self.event_rx.poll_recv(cx)) {
|
||||
|
||||
@@ -64,7 +64,7 @@ use crate::{CaptureError, CaptureEvent};
|
||||
|
||||
use super::{
|
||||
error::{LayerShellCaptureCreationError, WaylandBindError},
|
||||
Capture, Position,
|
||||
Capture, CaptureHandle, Position,
|
||||
};
|
||||
|
||||
struct Globals {
|
||||
@@ -102,13 +102,13 @@ struct State {
|
||||
pointer_lock: Option<ZwpLockedPointerV1>,
|
||||
rel_pointer: Option<ZwpRelativePointerV1>,
|
||||
shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
|
||||
active_windows: Vec<Arc<Window>>,
|
||||
focused: Option<Arc<Window>>,
|
||||
client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
|
||||
focused: Option<(Arc<Window>, CaptureHandle)>,
|
||||
g: Globals,
|
||||
wayland_fd: RawFd,
|
||||
read_guard: Option<ReadEventsGuard>,
|
||||
qh: QueueHandle<Self>,
|
||||
pending_events: VecDeque<(Position, CaptureEvent)>,
|
||||
pending_events: VecDeque<(CaptureHandle, CaptureEvent)>,
|
||||
output_info: Vec<(WlOutput, OutputInfo)>,
|
||||
scroll_discrete_pending: bool,
|
||||
}
|
||||
@@ -124,7 +124,7 @@ impl AsRawFd for Inner {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct LayerShellInputCapture(AsyncFd<Inner>);
|
||||
pub struct WaylandInputCapture(AsyncFd<Inner>);
|
||||
|
||||
struct Window {
|
||||
buffer: wl_buffer::WlBuffer,
|
||||
@@ -256,7 +256,7 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
|
||||
}
|
||||
}
|
||||
|
||||
impl LayerShellInputCapture {
|
||||
impl WaylandInputCapture {
|
||||
pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
|
||||
let conn = Connection::connect_to_env()?;
|
||||
let (g, mut queue) = registry_queue_init::<State>(&conn)?;
|
||||
@@ -323,7 +323,7 @@ impl LayerShellInputCapture {
|
||||
pointer_lock: None,
|
||||
rel_pointer: None,
|
||||
shortcut_inhibitor: None,
|
||||
active_windows: Vec::new(),
|
||||
client_for_window: Vec::new(),
|
||||
focused: None,
|
||||
qh,
|
||||
wayland_fd,
|
||||
@@ -370,18 +370,23 @@ impl LayerShellInputCapture {
|
||||
|
||||
let inner = AsyncFd::new(Inner { queue, state })?;
|
||||
|
||||
Ok(LayerShellInputCapture(inner))
|
||||
Ok(WaylandInputCapture(inner))
|
||||
}
|
||||
|
||||
fn add_client(&mut self, pos: Position) {
|
||||
self.0.get_mut().state.add_client(pos);
|
||||
fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
|
||||
self.0.get_mut().state.add_client(handle, pos);
|
||||
}
|
||||
|
||||
fn delete_client(&mut self, pos: Position) {
|
||||
fn delete_client(&mut self, handle: CaptureHandle) {
|
||||
let inner = self.0.get_mut();
|
||||
// remove all windows corresponding to this client
|
||||
while let Some(i) = inner.state.active_windows.iter().position(|w| w.pos == pos) {
|
||||
inner.state.active_windows.remove(i);
|
||||
while let Some(i) = inner
|
||||
.state
|
||||
.client_for_window
|
||||
.iter()
|
||||
.position(|(_, c)| *c == handle)
|
||||
{
|
||||
inner.state.client_for_window.remove(i);
|
||||
inner.state.focused = None;
|
||||
}
|
||||
}
|
||||
@@ -395,7 +400,7 @@ impl State {
|
||||
serial: u32,
|
||||
qh: &QueueHandle<State>,
|
||||
) {
|
||||
let window = self.focused.as_ref().unwrap();
|
||||
let (window, _) = self.focused.as_ref().unwrap();
|
||||
|
||||
// hide the cursor
|
||||
pointer.set_cursor(serial, None, 0, 0);
|
||||
@@ -438,7 +443,7 @@ impl State {
|
||||
|
||||
fn ungrab(&mut self) {
|
||||
// get focused client
|
||||
let window = match self.focused.as_ref() {
|
||||
let (window, _client) = match self.focused.as_ref() {
|
||||
Some(focused) => focused,
|
||||
None => return,
|
||||
};
|
||||
@@ -468,23 +473,27 @@ impl State {
|
||||
}
|
||||
}
|
||||
|
||||
fn add_client(&mut self, pos: Position) {
|
||||
fn add_client(&mut self, client: CaptureHandle, pos: Position) {
|
||||
let outputs = get_output_configuration(self, pos);
|
||||
|
||||
log::debug!("outputs: {outputs:?}");
|
||||
outputs.iter().for_each(|(o, i)| {
|
||||
let window = Window::new(self, &self.qh, o, pos, i.size);
|
||||
let window = Arc::new(window);
|
||||
self.active_windows.push(window);
|
||||
self.client_for_window.push((window, client));
|
||||
});
|
||||
}
|
||||
|
||||
fn update_windows(&mut self) {
|
||||
log::debug!("updating windows");
|
||||
log::debug!("output info: {:?}", self.output_info);
|
||||
let clients: Vec<_> = self.active_windows.drain(..).map(|w| w.pos).collect();
|
||||
for pos in clients {
|
||||
self.add_client(pos);
|
||||
let clients: Vec<_> = self
|
||||
.client_for_window
|
||||
.drain(..)
|
||||
.map(|(w, c)| (c, w.pos))
|
||||
.collect();
|
||||
for (client, pos) in clients {
|
||||
self.add_client(client, pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -557,15 +566,15 @@ impl Inner {
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl Capture for LayerShellInputCapture {
|
||||
async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
self.add_client(pos);
|
||||
impl Capture for WaylandInputCapture {
|
||||
async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
|
||||
self.add_client(handle, pos);
|
||||
let inner = self.0.get_mut();
|
||||
Ok(inner.flush_events()?)
|
||||
}
|
||||
|
||||
async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
self.delete_client(pos);
|
||||
async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
|
||||
self.delete_client(handle);
|
||||
let inner = self.0.get_mut();
|
||||
Ok(inner.flush_events()?)
|
||||
}
|
||||
@@ -582,8 +591,8 @@ impl Capture for LayerShellInputCapture {
|
||||
}
|
||||
}
|
||||
|
||||
impl Stream for LayerShellInputCapture {
|
||||
type Item = Result<(Position, CaptureEvent), CaptureError>;
|
||||
impl Stream for WaylandInputCapture {
|
||||
type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
|
||||
|
||||
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||
if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
|
||||
@@ -648,16 +657,10 @@ impl Dispatch<wl_seat::WlSeat, ()> for State {
|
||||
capabilities: WEnum::Value(capabilities),
|
||||
} = event
|
||||
{
|
||||
if capabilities.contains(wl_seat::Capability::Pointer) {
|
||||
if let Some(p) = state.pointer.take() {
|
||||
p.release();
|
||||
}
|
||||
if capabilities.contains(wl_seat::Capability::Pointer) && state.pointer.is_none() {
|
||||
state.pointer.replace(seat.get_pointer(qh, ()));
|
||||
}
|
||||
if capabilities.contains(wl_seat::Capability::Keyboard) {
|
||||
if let Some(k) = state.keyboard.take() {
|
||||
k.release();
|
||||
}
|
||||
if capabilities.contains(wl_seat::Capability::Keyboard) && state.keyboard.is_none() {
|
||||
seat.get_keyboard(qh, ());
|
||||
}
|
||||
}
|
||||
@@ -682,20 +685,23 @@ impl Dispatch<WlPointer, ()> for State {
|
||||
} => {
|
||||
// get client corresponding to the focused surface
|
||||
{
|
||||
if let Some(window) = app.active_windows.iter().find(|w| w.surface == surface) {
|
||||
app.focused = Some(window.clone());
|
||||
if let Some((window, client)) = app
|
||||
.client_for_window
|
||||
.iter()
|
||||
.find(|(w, _c)| w.surface == surface)
|
||||
{
|
||||
app.focused = Some((window.clone(), *client));
|
||||
app.grab(&surface, pointer, serial, qh);
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
let pos = app
|
||||
.active_windows
|
||||
let (_, client) = app
|
||||
.client_for_window
|
||||
.iter()
|
||||
.find(|w| w.surface == surface)
|
||||
.map(|w| w.pos)
|
||||
.find(|(w, _c)| w.surface == surface)
|
||||
.unwrap();
|
||||
app.pending_events.push_back((pos, CaptureEvent::Begin));
|
||||
app.pending_events.push_back((*client, CaptureEvent::Begin));
|
||||
}
|
||||
wl_pointer::Event::Leave { .. } => {
|
||||
/* There are rare cases, where when a window is opened in
|
||||
@@ -716,9 +722,9 @@ impl Dispatch<WlPointer, ()> for State {
|
||||
button,
|
||||
state,
|
||||
} => {
|
||||
let window = app.focused.as_ref().unwrap();
|
||||
let (_, client) = app.focused.as_ref().unwrap();
|
||||
app.pending_events.push_back((
|
||||
window.pos,
|
||||
*client,
|
||||
CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
|
||||
time,
|
||||
button,
|
||||
@@ -727,7 +733,7 @@ impl Dispatch<WlPointer, ()> for State {
|
||||
));
|
||||
}
|
||||
wl_pointer::Event::Axis { time, axis, value } => {
|
||||
let window = app.focused.as_ref().unwrap();
|
||||
let (_, client) = app.focused.as_ref().unwrap();
|
||||
if app.scroll_discrete_pending {
|
||||
// each axisvalue120 event is coupled with
|
||||
// a corresponding axis event, which needs to
|
||||
@@ -735,7 +741,7 @@ impl Dispatch<WlPointer, ()> for State {
|
||||
app.scroll_discrete_pending = false;
|
||||
} else {
|
||||
app.pending_events.push_back((
|
||||
window.pos,
|
||||
*client,
|
||||
CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
|
||||
time,
|
||||
axis: u32::from(axis) as u8,
|
||||
@@ -745,10 +751,10 @@ impl Dispatch<WlPointer, ()> for State {
|
||||
}
|
||||
}
|
||||
wl_pointer::Event::AxisValue120 { axis, value120 } => {
|
||||
let window = app.focused.as_ref().unwrap();
|
||||
let (_, client) = app.focused.as_ref().unwrap();
|
||||
app.scroll_discrete_pending = true;
|
||||
app.pending_events.push_back((
|
||||
window.pos,
|
||||
*client,
|
||||
CaptureEvent::Input(Event::Pointer(PointerEvent::AxisDiscrete120 {
|
||||
axis: u32::from(axis) as u8,
|
||||
value: value120,
|
||||
@@ -774,7 +780,10 @@ impl Dispatch<WlKeyboard, ()> for State {
|
||||
_: &Connection,
|
||||
_: &QueueHandle<Self>,
|
||||
) {
|
||||
let window = &app.focused;
|
||||
let (_window, client) = match &app.focused {
|
||||
Some(focused) => (Some(&focused.0), Some(&focused.1)),
|
||||
None => (None, None),
|
||||
};
|
||||
match event {
|
||||
wl_keyboard::Event::Key {
|
||||
serial: _,
|
||||
@@ -782,9 +791,9 @@ impl Dispatch<WlKeyboard, ()> for State {
|
||||
key,
|
||||
state,
|
||||
} => {
|
||||
if let Some(window) = window {
|
||||
if let Some(client) = client {
|
||||
app.pending_events.push_back((
|
||||
window.pos,
|
||||
*client,
|
||||
CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
|
||||
time,
|
||||
key,
|
||||
@@ -800,9 +809,9 @@ impl Dispatch<WlKeyboard, ()> for State {
|
||||
mods_locked,
|
||||
group,
|
||||
} => {
|
||||
if let Some(window) = window {
|
||||
if let Some(client) = client {
|
||||
app.pending_events.push_back((
|
||||
window.pos,
|
||||
*client,
|
||||
CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Modifiers {
|
||||
depressed: mods_depressed,
|
||||
latched: mods_latched,
|
||||
@@ -834,10 +843,10 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
|
||||
..
|
||||
} = event
|
||||
{
|
||||
if let Some(window) = &app.focused {
|
||||
if let Some((_window, client)) = &app.focused {
|
||||
let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
|
||||
app.pending_events.push_back((
|
||||
window.pos,
|
||||
*client,
|
||||
CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { time, dx, dy })),
|
||||
));
|
||||
}
|
||||
@@ -855,10 +864,10 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
|
||||
_: &QueueHandle<Self>,
|
||||
) {
|
||||
if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
|
||||
if let Some(window) = app
|
||||
.active_windows
|
||||
if let Some((window, _client)) = app
|
||||
.client_for_window
|
||||
.iter()
|
||||
.find(|w| &w.layer_surface == layer_surface)
|
||||
.find(|(w, _c)| &w.layer_surface == layer_surface)
|
||||
{
|
||||
// client corresponding to the layer_surface
|
||||
let surface = &window.surface;
|
||||
@@ -1,36 +1,94 @@
|
||||
use async_trait::async_trait;
|
||||
use core::task::{Context, Poll};
|
||||
use event_thread::EventThread;
|
||||
use futures::Stream;
|
||||
use std::pin::Pin;
|
||||
use once_cell::unsync::Lazy;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::ptr::{addr_of, addr_of_mut};
|
||||
|
||||
use futures::executor::block_on;
|
||||
use std::default::Default;
|
||||
use std::sync::atomic::{AtomicU32, Ordering};
|
||||
use std::sync::{mpsc, Mutex};
|
||||
use std::task::ready;
|
||||
use tokio::sync::mpsc::{channel, Receiver};
|
||||
use std::{pin::Pin, thread};
|
||||
use tokio::sync::mpsc::{channel, Receiver, Sender};
|
||||
use windows::core::{w, PCWSTR};
|
||||
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,
|
||||
};
|
||||
use windows::Win32::System::LibraryLoader::GetModuleHandleW;
|
||||
use windows::Win32::System::Threading::GetCurrentThreadId;
|
||||
|
||||
use super::{Capture, CaptureError, CaptureEvent, Position};
|
||||
use windows::Win32::UI::WindowsAndMessaging::{
|
||||
CallNextHookEx, CreateWindowExW, DispatchMessageW, GetMessageW, PostThreadMessageW,
|
||||
RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HHOOK,
|
||||
HMENU, HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL,
|
||||
WH_MOUSE_LL, WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN,
|
||||
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,
|
||||
};
|
||||
|
||||
mod display_util;
|
||||
mod event_thread;
|
||||
use input_event::{
|
||||
scancode::{self, Linux},
|
||||
Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
|
||||
};
|
||||
|
||||
use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
|
||||
|
||||
enum Request {
|
||||
Create(CaptureHandle, Position),
|
||||
Destroy(CaptureHandle),
|
||||
}
|
||||
|
||||
pub struct WindowsInputCapture {
|
||||
event_rx: Receiver<(Position, CaptureEvent)>,
|
||||
event_thread: EventThread,
|
||||
event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
|
||||
msg_thread: Option<std::thread::JoinHandle<()>>,
|
||||
}
|
||||
|
||||
enum EventType {
|
||||
Request = 0,
|
||||
Release = 1,
|
||||
Exit = 2,
|
||||
}
|
||||
|
||||
unsafe fn signal_message_thread(event_type: EventType) {
|
||||
if let Some(event_tid) = get_event_tid() {
|
||||
PostThreadMessageW(event_tid, WM_USER, WPARAM(event_type as usize), LPARAM(0)).unwrap();
|
||||
} else {
|
||||
panic!();
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl Capture for WindowsInputCapture {
|
||||
async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
self.event_thread.create(pos);
|
||||
async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
|
||||
unsafe {
|
||||
{
|
||||
let mut requests = REQUEST_BUFFER.lock().unwrap();
|
||||
requests.push(Request::Create(handle, pos));
|
||||
}
|
||||
signal_message_thread(EventType::Request);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
|
||||
self.event_thread.destroy(pos);
|
||||
async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
|
||||
unsafe {
|
||||
{
|
||||
let mut requests = REQUEST_BUFFER.lock().unwrap();
|
||||
requests.push(Request::Destroy(handle));
|
||||
}
|
||||
signal_message_thread(EventType::Request);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn release(&mut self) -> Result<(), CaptureError> {
|
||||
self.event_thread.release_capture();
|
||||
unsafe { signal_message_thread(EventType::Release) };
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -39,19 +97,524 @@ impl Capture for WindowsInputCapture {
|
||||
}
|
||||
}
|
||||
|
||||
static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
|
||||
static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
|
||||
static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
|
||||
static mut EVENT_TX: Option<Sender<(CaptureHandle, CaptureEvent)>> = None;
|
||||
static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
|
||||
unsafe fn set_event_tid(tid: u32) {
|
||||
EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
|
||||
}
|
||||
unsafe fn get_event_tid() -> Option<u32> {
|
||||
match EVENT_THREAD_ID.load(Ordering::SeqCst) {
|
||||
0 => None,
|
||||
id => Some(id),
|
||||
}
|
||||
}
|
||||
|
||||
static mut ENTRY_POINT: (i32, i32) = (0, 0);
|
||||
|
||||
fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
|
||||
let mouse_low_level: MSLLHOOKSTRUCT = unsafe { *(lparam.0 as *const MSLLHOOKSTRUCT) };
|
||||
match wparam {
|
||||
WPARAM(p) if p == WM_LBUTTONDOWN as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_LEFT,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_MBUTTONDOWN as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_MIDDLE,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_RBUTTONDOWN as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_RIGHT,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_LBUTTONUP as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_LEFT,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_MBUTTONUP as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_MIDDLE,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_RBUTTONUP as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_RIGHT,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_MOUSEMOVE as usize => unsafe {
|
||||
let (x, y) = (mouse_low_level.pt.x, mouse_low_level.pt.y);
|
||||
let (ex, ey) = ENTRY_POINT;
|
||||
let (dx, dy) = (x - ex, y - ey);
|
||||
let (dx, dy) = (dx as f64, dy as f64);
|
||||
Some(PointerEvent::Motion { time: 0, dx, dy })
|
||||
},
|
||||
WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
|
||||
axis: 0,
|
||||
value: -(mouse_low_level.mouseData as i32 >> 16),
|
||||
}),
|
||||
WPARAM(p) if p == WM_XBUTTONDOWN as usize || p == WM_XBUTTONUP as usize => {
|
||||
let hb = mouse_low_level.mouseData >> 16;
|
||||
let button = match hb {
|
||||
1 => BTN_BACK,
|
||||
2 => BTN_FORWARD,
|
||||
_ => {
|
||||
log::warn!("unknown mouse button");
|
||||
return None;
|
||||
}
|
||||
};
|
||||
Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button,
|
||||
state: if p == WM_XBUTTONDOWN as usize { 1 } else { 0 },
|
||||
})
|
||||
}
|
||||
w => {
|
||||
log::warn!("unknown mouse event: {w:?}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn to_key_event(wparam: WPARAM, lparam: LPARAM) -> Option<KeyboardEvent> {
|
||||
let kybrdllhookstruct: KBDLLHOOKSTRUCT = *(lparam.0 as *const KBDLLHOOKSTRUCT);
|
||||
let mut scan_code = kybrdllhookstruct.scanCode;
|
||||
log::trace!("scan_code: {scan_code}");
|
||||
if kybrdllhookstruct.flags.contains(LLKHF_EXTENDED) {
|
||||
scan_code |= 0xE000;
|
||||
}
|
||||
let Ok(win_scan_code) = scancode::Windows::try_from(scan_code) else {
|
||||
log::warn!("failed to translate to windows scancode: {scan_code}");
|
||||
return None;
|
||||
};
|
||||
log::trace!("windows_scan: {win_scan_code:?}");
|
||||
let Ok(linux_scan_code): Result<Linux, ()> = win_scan_code.try_into() else {
|
||||
log::warn!("failed to translate into linux scancode: {win_scan_code:?}");
|
||||
return None;
|
||||
};
|
||||
log::trace!("windows_scan: {linux_scan_code:?}");
|
||||
let scan_code = linux_scan_code as u32;
|
||||
match wparam {
|
||||
WPARAM(p) if p == WM_KEYDOWN as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_KEYUP as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_SYSKEYDOWN as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_SYSKEYUP as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 1,
|
||||
}),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
///
|
||||
/// clamp point to display bounds
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `prev_point`: coordinates, the cursor was before entering, within bounds of a display
|
||||
/// * `entry_point`: point to clamp
|
||||
///
|
||||
/// returns: (i32, i32), the corrected entry point
|
||||
///
|
||||
fn clamp_to_display_bounds(prev_point: (i32, i32), point: (i32, i32)) -> (i32, i32) {
|
||||
/* find display where movement came from */
|
||||
let display_regions = unsafe { get_display_regions() };
|
||||
let display = display_regions
|
||||
.iter()
|
||||
.find(|&d| is_within_dp_region(prev_point, d))
|
||||
.unwrap();
|
||||
|
||||
/* clamp to bounds (inclusive) */
|
||||
let (x, y) = point;
|
||||
let (min_x, max_x) = (display.left, display.right - 1);
|
||||
let (min_y, max_y) = (display.top, display.bottom - 1);
|
||||
(x.clamp(min_x, max_x), y.clamp(min_y, max_y))
|
||||
}
|
||||
|
||||
unsafe fn send_blocking(event: CaptureEvent) {
|
||||
if let Some(active) = ACTIVE_CLIENT {
|
||||
block_on(async move {
|
||||
let _ = EVENT_TX.as_ref().unwrap().send((active, event)).await;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
|
||||
if wparam.0 != WM_MOUSEMOVE as usize {
|
||||
return ACTIVE_CLIENT.is_some();
|
||||
}
|
||||
let mouse_low_level: MSLLHOOKSTRUCT = *(lparam.0 as *const MSLLHOOKSTRUCT);
|
||||
static mut PREV_POS: Option<(i32, i32)> = None;
|
||||
let curr_pos = (mouse_low_level.pt.x, mouse_low_level.pt.y);
|
||||
let prev_pos = PREV_POS.unwrap_or(curr_pos);
|
||||
PREV_POS.replace(curr_pos);
|
||||
|
||||
/* next event is the first actual event */
|
||||
let ret = ACTIVE_CLIENT.is_some();
|
||||
|
||||
/* client already active, no need to check */
|
||||
if ACTIVE_CLIENT.is_some() {
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* check if a client was activated */
|
||||
let Some(pos) = entered_barrier(prev_pos, curr_pos, get_display_regions()) else {
|
||||
return ret;
|
||||
};
|
||||
|
||||
/* check if a client is registered for the barrier */
|
||||
let Some(client) = CLIENT_FOR_POS.get(&pos) else {
|
||||
return ret;
|
||||
};
|
||||
|
||||
/* update active client and entry point */
|
||||
ACTIVE_CLIENT.replace(*client);
|
||||
ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);
|
||||
|
||||
/* notify main thread */
|
||||
log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
|
||||
send_blocking(CaptureEvent::Begin);
|
||||
|
||||
ret
|
||||
}
|
||||
|
||||
unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
|
||||
let active = check_client_activation(wparam, lparam);
|
||||
|
||||
/* no client was active */
|
||||
if !active {
|
||||
return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
|
||||
}
|
||||
|
||||
/* get active client if any */
|
||||
let Some(client) = ACTIVE_CLIENT else {
|
||||
return LRESULT(1);
|
||||
};
|
||||
|
||||
/* convert to lan-mouse event */
|
||||
let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
|
||||
return LRESULT(1);
|
||||
};
|
||||
let event = (client, CaptureEvent::Input(Event::Pointer(pointer_event)));
|
||||
|
||||
/* notify mainthread (drop events if sending too fast) */
|
||||
if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
|
||||
log::warn!("e: {e}");
|
||||
}
|
||||
|
||||
/* don't pass event to applications */
|
||||
LRESULT(1)
|
||||
}
|
||||
|
||||
unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
|
||||
/* get active client if any */
|
||||
let Some(client) = ACTIVE_CLIENT else {
|
||||
return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
|
||||
};
|
||||
|
||||
/* convert to key event */
|
||||
let Some(key_event) = to_key_event(wparam, lparam) else {
|
||||
return LRESULT(1);
|
||||
};
|
||||
let event = (client, CaptureEvent::Input(Event::Keyboard(key_event)));
|
||||
|
||||
if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
|
||||
log::warn!("e: {e}");
|
||||
}
|
||||
|
||||
/* don't pass event to applications */
|
||||
LRESULT(1)
|
||||
}
|
||||
|
||||
unsafe extern "system" fn window_proc(
|
||||
_hwnd: HWND,
|
||||
uint: u32,
|
||||
_wparam: WPARAM,
|
||||
_lparam: LPARAM,
|
||||
) -> LRESULT {
|
||||
match uint {
|
||||
x if x == WM_DISPLAYCHANGE => {
|
||||
log::debug!("display resolution changed");
|
||||
DISPLAY_RESOLUTION_CHANGED = true;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
LRESULT(1)
|
||||
}
|
||||
|
||||
fn enumerate_displays() -> Vec<RECT> {
|
||||
unsafe {
|
||||
let mut display_rects = vec![];
|
||||
let mut devices = vec![];
|
||||
for i in 0.. {
|
||||
let mut device: DISPLAY_DEVICEW = std::mem::zeroed();
|
||||
device.cb = std::mem::size_of::<DISPLAY_DEVICEW>() as u32;
|
||||
let ret = EnumDisplayDevicesW(None, i, &mut device, EDD_GET_DEVICE_INTERFACE_NAME);
|
||||
if ret == FALSE {
|
||||
break;
|
||||
}
|
||||
if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
|
||||
devices.push(device.DeviceName);
|
||||
}
|
||||
}
|
||||
for device in devices {
|
||||
let mut dev_mode: DEVMODEW = std::mem::zeroed();
|
||||
dev_mode.dmSize = std::mem::size_of::<DEVMODEW>() as u16;
|
||||
let ret = EnumDisplaySettingsW(
|
||||
PCWSTR::from_raw(&device as *const _),
|
||||
ENUM_CURRENT_SETTINGS,
|
||||
&mut dev_mode,
|
||||
);
|
||||
if ret == FALSE {
|
||||
log::warn!("no display mode");
|
||||
}
|
||||
|
||||
let pos = dev_mode.Anonymous1.Anonymous2.dmPosition;
|
||||
let (x, y) = (pos.x, pos.y);
|
||||
let (width, height) = (dev_mode.dmPelsWidth, dev_mode.dmPelsHeight);
|
||||
|
||||
display_rects.push(RECT {
|
||||
left: x,
|
||||
right: x + width as i32,
|
||||
top: y,
|
||||
bottom: y + height as i32,
|
||||
});
|
||||
}
|
||||
display_rects
|
||||
}
|
||||
}
|
||||
|
||||
static mut DISPLAY_RESOLUTION_CHANGED: bool = true;
|
||||
|
||||
unsafe fn get_display_regions() -> &'static Vec<RECT> {
|
||||
static mut DISPLAYS: Vec<RECT> = vec![];
|
||||
if DISPLAY_RESOLUTION_CHANGED {
|
||||
DISPLAYS = enumerate_displays();
|
||||
DISPLAY_RESOLUTION_CHANGED = false;
|
||||
log::debug!("displays: {DISPLAYS:?}");
|
||||
}
|
||||
&*addr_of!(DISPLAYS)
|
||||
}
|
||||
|
||||
fn is_within_dp_region(point: (i32, i32), display: &RECT) -> bool {
|
||||
[
|
||||
Position::Left,
|
||||
Position::Right,
|
||||
Position::Top,
|
||||
Position::Bottom,
|
||||
]
|
||||
.iter()
|
||||
.all(|&pos| is_within_dp_boundary(point, display, pos))
|
||||
}
|
||||
fn is_within_dp_boundary(point: (i32, i32), display: &RECT, pos: Position) -> bool {
|
||||
let (x, y) = point;
|
||||
match pos {
|
||||
Position::Left => display.left <= x,
|
||||
Position::Right => display.right > x,
|
||||
Position::Top => display.top <= y,
|
||||
Position::Bottom => display.bottom > y,
|
||||
}
|
||||
}
|
||||
|
||||
/// returns whether the given position is within the display bounds with respect to the given
|
||||
/// barrier position
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `x`:
|
||||
/// * `y`:
|
||||
/// * `displays`:
|
||||
/// * `pos`:
|
||||
///
|
||||
/// returns: bool
|
||||
///
|
||||
fn in_bounds(point: (i32, i32), displays: &[RECT], pos: Position) -> bool {
|
||||
displays
|
||||
.iter()
|
||||
.any(|d| is_within_dp_boundary(point, d, pos))
|
||||
}
|
||||
|
||||
fn in_display_region(point: (i32, i32), displays: &[RECT]) -> bool {
|
||||
displays.iter().any(|d| is_within_dp_region(point, d))
|
||||
}
|
||||
|
||||
fn moved_across_boundary(
|
||||
prev_pos: (i32, i32),
|
||||
curr_pos: (i32, i32),
|
||||
displays: &[RECT],
|
||||
pos: Position,
|
||||
) -> bool {
|
||||
/* was within bounds, but is not anymore */
|
||||
in_display_region(prev_pos, displays) && !in_bounds(curr_pos, displays, pos)
|
||||
}
|
||||
|
||||
fn entered_barrier(
|
||||
prev_pos: (i32, i32),
|
||||
curr_pos: (i32, i32),
|
||||
displays: &[RECT],
|
||||
) -> Option<Position> {
|
||||
[
|
||||
Position::Left,
|
||||
Position::Right,
|
||||
Position::Top,
|
||||
Position::Bottom,
|
||||
]
|
||||
.into_iter()
|
||||
.find(|&pos| moved_across_boundary(prev_pos, curr_pos, displays, pos))
|
||||
}
|
||||
|
||||
fn get_msg() -> Option<MSG> {
|
||||
unsafe {
|
||||
let mut msg = std::mem::zeroed();
|
||||
let ret = GetMessageW(addr_of_mut!(msg), HWND::default(), 0, 0);
|
||||
match ret.0 {
|
||||
0 => None,
|
||||
x if x > 0 => Some(msg),
|
||||
_ => panic!("error in GetMessageW"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn message_thread(ready_tx: mpsc::Sender<()>) {
|
||||
unsafe {
|
||||
set_event_tid(GetCurrentThreadId());
|
||||
ready_tx.send(()).expect("channel closed");
|
||||
let mouse_proc: HOOKPROC = Some(mouse_proc);
|
||||
let kybrd_proc: HOOKPROC = Some(kybrd_proc);
|
||||
let window_proc: WNDPROC = Some(window_proc);
|
||||
|
||||
/* register hooks */
|
||||
let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
|
||||
let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
|
||||
|
||||
let instance = GetModuleHandleW(None).unwrap();
|
||||
let window_class: WNDCLASSW = WNDCLASSW {
|
||||
lpfnWndProc: window_proc,
|
||||
hInstance: instance.into(),
|
||||
lpszClassName: w!("lan-mouse-message-window-class"),
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let ret = RegisterClassW(&window_class);
|
||||
if ret == 0 {
|
||||
panic!("RegisterClassW");
|
||||
}
|
||||
|
||||
/* window is used ro receive WM_DISPLAYCHANGE messages */
|
||||
CreateWindowExW(
|
||||
Default::default(),
|
||||
w!("lan-mouse-message-window-class"),
|
||||
w!("lan-mouse-msg-window"),
|
||||
WINDOW_STYLE::default(),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
HWND::default(),
|
||||
HMENU::default(),
|
||||
instance,
|
||||
None,
|
||||
)
|
||||
.expect("CreateWindowExW");
|
||||
|
||||
/* run message loop */
|
||||
loop {
|
||||
// mouse / keybrd proc do not actually return a message
|
||||
let Some(msg) = get_msg() else {
|
||||
break;
|
||||
};
|
||||
if msg.hwnd.0.is_null() {
|
||||
/* messages sent via PostThreadMessage */
|
||||
match msg.wParam.0 {
|
||||
x if x == EventType::Exit as usize => break,
|
||||
x if x == EventType::Release as usize => {
|
||||
ACTIVE_CLIENT.take();
|
||||
}
|
||||
x if x == EventType::Request as usize => {
|
||||
let requests = {
|
||||
let mut res = vec![];
|
||||
let mut requests = REQUEST_BUFFER.lock().unwrap();
|
||||
for request in requests.drain(..) {
|
||||
res.push(request);
|
||||
}
|
||||
res
|
||||
};
|
||||
|
||||
for request in requests {
|
||||
update_clients(request)
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
} else {
|
||||
/* other messages for window_procs */
|
||||
let _ = TranslateMessage(&msg);
|
||||
DispatchMessageW(&msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn update_clients(request: Request) {
|
||||
match request {
|
||||
Request::Create(handle, pos) => {
|
||||
unsafe { CLIENT_FOR_POS.insert(pos, handle) };
|
||||
}
|
||||
Request::Destroy(handle) => unsafe {
|
||||
for pos in [
|
||||
Position::Left,
|
||||
Position::Right,
|
||||
Position::Top,
|
||||
Position::Bottom,
|
||||
] {
|
||||
if ACTIVE_CLIENT == Some(handle) {
|
||||
ACTIVE_CLIENT.take();
|
||||
}
|
||||
if CLIENT_FOR_POS.get(&pos).copied() == Some(handle) {
|
||||
CLIENT_FOR_POS.remove(&pos);
|
||||
}
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
impl WindowsInputCapture {
|
||||
pub(crate) fn new() -> Self {
|
||||
let (event_tx, event_rx) = channel(10);
|
||||
let event_thread = EventThread::new(event_tx);
|
||||
Self {
|
||||
event_thread,
|
||||
event_rx,
|
||||
unsafe {
|
||||
let (tx, rx) = channel(10);
|
||||
EVENT_TX.replace(tx);
|
||||
let (ready_tx, ready_rx) = mpsc::channel();
|
||||
let msg_thread = Some(thread::spawn(|| message_thread(ready_tx)));
|
||||
/* wait for thread to set its id */
|
||||
ready_rx.recv().expect("channel closed");
|
||||
Self {
|
||||
msg_thread,
|
||||
event_rx: rx,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Stream for WindowsInputCapture {
|
||||
type Item = Result<(Position, CaptureEvent), CaptureError>;
|
||||
type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
|
||||
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||
match ready!(self.event_rx.poll_recv(cx)) {
|
||||
None => Poll::Ready(None),
|
||||
@@ -59,3 +622,10 @@ impl Stream for WindowsInputCapture {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for WindowsInputCapture {
|
||||
fn drop(&mut self) {
|
||||
unsafe { signal_message_thread(EventType::Exit) };
|
||||
let _ = self.msg_thread.take().unwrap().join();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,99 +0,0 @@
|
||||
use windows::Win32::Foundation::RECT;
|
||||
|
||||
use crate::Position;
|
||||
|
||||
fn is_within_dp_region(point: (i32, i32), display: &RECT) -> bool {
|
||||
[
|
||||
Position::Left,
|
||||
Position::Right,
|
||||
Position::Top,
|
||||
Position::Bottom,
|
||||
]
|
||||
.iter()
|
||||
.all(|&pos| is_within_dp_boundary(point, display, pos))
|
||||
}
|
||||
|
||||
fn is_within_dp_boundary(point: (i32, i32), display: &RECT, pos: Position) -> bool {
|
||||
let (x, y) = point;
|
||||
match pos {
|
||||
Position::Left => display.left <= x,
|
||||
Position::Right => display.right > x,
|
||||
Position::Top => display.top <= y,
|
||||
Position::Bottom => display.bottom > y,
|
||||
}
|
||||
}
|
||||
|
||||
/// returns whether the given position is within the display bounds with respect to the given
|
||||
/// barrier position
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `x`:
|
||||
/// * `y`:
|
||||
/// * `displays`:
|
||||
/// * `pos`:
|
||||
///
|
||||
/// returns: bool
|
||||
///
|
||||
fn in_bounds(point: (i32, i32), displays: &[RECT], pos: Position) -> bool {
|
||||
displays
|
||||
.iter()
|
||||
.any(|d| is_within_dp_boundary(point, d, pos))
|
||||
}
|
||||
|
||||
fn in_display_region(point: (i32, i32), displays: &[RECT]) -> bool {
|
||||
displays.iter().any(|d| is_within_dp_region(point, d))
|
||||
}
|
||||
|
||||
fn moved_across_boundary(
|
||||
prev_pos: (i32, i32),
|
||||
curr_pos: (i32, i32),
|
||||
displays: &[RECT],
|
||||
pos: Position,
|
||||
) -> bool {
|
||||
/* was within bounds, but is not anymore */
|
||||
in_display_region(prev_pos, displays) && !in_bounds(curr_pos, displays, pos)
|
||||
}
|
||||
|
||||
pub(crate) fn entered_barrier(
|
||||
prev_pos: (i32, i32),
|
||||
curr_pos: (i32, i32),
|
||||
displays: &[RECT],
|
||||
) -> Option<Position> {
|
||||
[
|
||||
Position::Left,
|
||||
Position::Right,
|
||||
Position::Top,
|
||||
Position::Bottom,
|
||||
]
|
||||
.into_iter()
|
||||
.find(|&pos| moved_across_boundary(prev_pos, curr_pos, displays, pos))
|
||||
}
|
||||
|
||||
///
|
||||
/// clamp point to display bounds
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `prev_point`: coordinates, the cursor was before entering, within bounds of a display
|
||||
/// * `entry_point`: point to clamp
|
||||
///
|
||||
/// returns: (i32, i32), the corrected entry point
|
||||
///
|
||||
pub(crate) fn clamp_to_display_bounds(
|
||||
display_regions: &[RECT],
|
||||
prev_point: (i32, i32),
|
||||
point: (i32, i32),
|
||||
) -> (i32, i32) {
|
||||
/* find display where movement came from */
|
||||
let display = display_regions
|
||||
.iter()
|
||||
.find(|&d| is_within_dp_region(prev_point, d))
|
||||
.unwrap();
|
||||
|
||||
/* clamp to bounds (inclusive) */
|
||||
let (x, y) = point;
|
||||
let (min_x, max_x) = (display.left, display.right - 1);
|
||||
let (min_y, max_y) = (display.top, display.bottom - 1);
|
||||
(x.clamp(min_x, max_x), y.clamp(min_y, max_y))
|
||||
}
|
||||
@@ -1,545 +0,0 @@
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::collections::HashSet;
|
||||
use std::ptr::addr_of_mut;
|
||||
|
||||
use std::default::Default;
|
||||
use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
|
||||
use std::sync::{Arc, Condvar, Mutex};
|
||||
use std::thread;
|
||||
use tokio::sync::mpsc::error::TrySendError;
|
||||
use tokio::sync::mpsc::Sender;
|
||||
use windows::core::{w, PCWSTR};
|
||||
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,
|
||||
};
|
||||
use windows::Win32::System::LibraryLoader::GetModuleHandleW;
|
||||
use windows::Win32::System::Threading::GetCurrentThreadId;
|
||||
|
||||
use windows::Win32::UI::WindowsAndMessaging::{
|
||||
CallNextHookEx, CreateWindowExW, DispatchMessageW, GetMessageW, PostThreadMessageW,
|
||||
RegisterClassW, SetWindowsHookExW, TranslateMessage, EDD_GET_DEVICE_INTERFACE_NAME, HHOOK,
|
||||
HMENU, HOOKPROC, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, MSG, MSLLHOOKSTRUCT, WH_KEYBOARD_LL,
|
||||
WH_MOUSE_LL, WINDOW_STYLE, WM_DISPLAYCHANGE, WM_KEYDOWN, WM_KEYUP, WM_LBUTTONDOWN,
|
||||
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,
|
||||
};
|
||||
|
||||
use input_event::{
|
||||
scancode::{self, Linux},
|
||||
Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
|
||||
};
|
||||
|
||||
use super::{display_util, CaptureEvent, Position};
|
||||
|
||||
pub(crate) struct EventThread {
|
||||
request_buffer: Arc<Mutex<Vec<ClientUpdate>>>,
|
||||
thread: Option<thread::JoinHandle<()>>,
|
||||
thread_id: u32,
|
||||
}
|
||||
|
||||
impl EventThread {
|
||||
pub(crate) fn new(event_tx: Sender<(Position, CaptureEvent)>) -> Self {
|
||||
let request_buffer = Default::default();
|
||||
let (thread, thread_id) = start(event_tx, Arc::clone(&request_buffer));
|
||||
Self {
|
||||
request_buffer,
|
||||
thread: Some(thread),
|
||||
thread_id,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn release_capture(&self) {
|
||||
self.signal(RequestType::Release);
|
||||
}
|
||||
|
||||
pub(crate) fn create(&self, pos: Position) {
|
||||
self.client_update(ClientUpdate::Create(pos));
|
||||
}
|
||||
|
||||
pub(crate) fn destroy(&self, pos: Position) {
|
||||
self.client_update(ClientUpdate::Destroy(pos));
|
||||
}
|
||||
|
||||
fn exit(&self) {
|
||||
self.signal(RequestType::Exit);
|
||||
}
|
||||
|
||||
fn client_update(&self, request: ClientUpdate) {
|
||||
{
|
||||
let mut requests = self.request_buffer.lock().unwrap();
|
||||
requests.push(request);
|
||||
}
|
||||
self.signal(RequestType::ClientUpdate);
|
||||
}
|
||||
|
||||
fn signal(&self, event_type: RequestType) {
|
||||
let id = self.thread_id;
|
||||
unsafe { PostThreadMessageW(id, WM_USER, WPARAM(event_type as usize), LPARAM(0)).unwrap() };
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for EventThread {
|
||||
fn drop(&mut self) {
|
||||
self.exit();
|
||||
let _ = self.thread.take().expect("thread").join();
|
||||
}
|
||||
}
|
||||
|
||||
enum RequestType {
|
||||
ClientUpdate = 0,
|
||||
Release = 1,
|
||||
Exit = 2,
|
||||
}
|
||||
|
||||
enum ClientUpdate {
|
||||
Create(Position),
|
||||
Destroy(Position),
|
||||
}
|
||||
|
||||
fn blocking_send_event(pos: Position, event: CaptureEvent) {
|
||||
EVENT_TX.with_borrow_mut(|tx| tx.as_mut().unwrap().blocking_send((pos, event)).unwrap())
|
||||
}
|
||||
|
||||
fn try_send_event(
|
||||
pos: Position,
|
||||
event: CaptureEvent,
|
||||
) -> Result<(), TrySendError<(Position, CaptureEvent)>> {
|
||||
EVENT_TX.with_borrow_mut(|tx| tx.as_mut().unwrap().try_send((pos, event)))
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
/// all configured clients
|
||||
static CLIENTS: RefCell<HashSet<Position>> = RefCell::new(HashSet::new());
|
||||
/// currently active client
|
||||
static ACTIVE_CLIENT: Cell<Option<Position>> = const { Cell::new(None) };
|
||||
/// input event channel
|
||||
static EVENT_TX: RefCell<Option<Sender<(Position, CaptureEvent)>>> = const { RefCell::new(None) };
|
||||
/// position of barrier entry
|
||||
static ENTRY_POINT: Cell<(i32, i32)> = const { Cell::new((0, 0)) };
|
||||
/// previous mouse position
|
||||
static PREV_POS: Cell<Option<(i32, i32)>> = const { Cell::new(None) };
|
||||
/// displays and generation counter
|
||||
static DISPLAYS: RefCell<(Vec<RECT>, i32)> = const { RefCell::new((Vec::new(), 0)) };
|
||||
}
|
||||
|
||||
fn get_msg() -> Option<MSG> {
|
||||
unsafe {
|
||||
let mut msg = std::mem::zeroed();
|
||||
let ret = GetMessageW(addr_of_mut!(msg), HWND::default(), 0, 0);
|
||||
match ret.0 {
|
||||
0 => None,
|
||||
x if x > 0 => Some(msg),
|
||||
_ => panic!("error in GetMessageW"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn start(
|
||||
event_tx: Sender<(Position, CaptureEvent)>,
|
||||
request_buffer: Arc<Mutex<Vec<ClientUpdate>>>,
|
||||
) -> (thread::JoinHandle<()>, u32) {
|
||||
/* condition variable to wait for thead id */
|
||||
let thread_id = Arc::new((Condvar::new(), Mutex::new(None)));
|
||||
let thread_id_ = Arc::clone(&thread_id);
|
||||
|
||||
let msg_thread = thread::spawn(|| start_routine(thread_id_, event_tx, request_buffer));
|
||||
|
||||
/* wait for thread to set its id */
|
||||
let (cond, thread_id) = &*thread_id;
|
||||
let mut thread_id = thread_id.lock().unwrap();
|
||||
while (*thread_id).is_none() {
|
||||
thread_id = cond.wait(thread_id).expect("channel closed");
|
||||
}
|
||||
(msg_thread, thread_id.expect("thread id"))
|
||||
}
|
||||
|
||||
fn start_routine(
|
||||
ready: Arc<(Condvar, Mutex<Option<u32>>)>,
|
||||
event_tx: Sender<(Position, CaptureEvent)>,
|
||||
request_buffer: Arc<Mutex<Vec<ClientUpdate>>>,
|
||||
) {
|
||||
EVENT_TX.replace(Some(event_tx));
|
||||
/* communicate thread id */
|
||||
{
|
||||
let (cnd, mtx) = &*ready;
|
||||
let mut ready = mtx.lock().unwrap();
|
||||
*ready = Some(unsafe { GetCurrentThreadId() });
|
||||
cnd.notify_one();
|
||||
}
|
||||
|
||||
let mouse_proc: HOOKPROC = Some(mouse_proc);
|
||||
let kybrd_proc: HOOKPROC = Some(kybrd_proc);
|
||||
let window_proc: WNDPROC = Some(window_proc);
|
||||
|
||||
/* register hooks */
|
||||
unsafe {
|
||||
let _ = SetWindowsHookExW(WH_MOUSE_LL, mouse_proc, HINSTANCE::default(), 0).unwrap();
|
||||
let _ = SetWindowsHookExW(WH_KEYBOARD_LL, kybrd_proc, HINSTANCE::default(), 0).unwrap();
|
||||
}
|
||||
|
||||
let instance = unsafe { GetModuleHandleW(None).unwrap() };
|
||||
let window_class: WNDCLASSW = WNDCLASSW {
|
||||
lpfnWndProc: window_proc,
|
||||
hInstance: instance.into(),
|
||||
lpszClassName: w!("lan-mouse-message-window-class"),
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
static WINDOW_CLASS_REGISTERED: AtomicBool = AtomicBool::new(false);
|
||||
if WINDOW_CLASS_REGISTERED
|
||||
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
|
||||
.is_ok()
|
||||
{
|
||||
/* register window class if not yet done so */
|
||||
unsafe {
|
||||
let ret = RegisterClassW(&window_class);
|
||||
if ret == 0 {
|
||||
panic!("RegisterClassW");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* window is used ro receive WM_DISPLAYCHANGE messages */
|
||||
unsafe {
|
||||
CreateWindowExW(
|
||||
Default::default(),
|
||||
w!("lan-mouse-message-window-class"),
|
||||
w!("lan-mouse-msg-window"),
|
||||
WINDOW_STYLE::default(),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
HWND::default(),
|
||||
HMENU::default(),
|
||||
instance,
|
||||
None,
|
||||
)
|
||||
.expect("CreateWindowExW");
|
||||
}
|
||||
|
||||
/* run message loop */
|
||||
loop {
|
||||
// mouse / keybrd proc do not actually return a message
|
||||
let Some(msg) = get_msg() else {
|
||||
break;
|
||||
};
|
||||
if msg.hwnd.0.is_null() {
|
||||
/* messages sent via PostThreadMessage */
|
||||
match msg.wParam.0 {
|
||||
x if x == RequestType::Exit as usize => break,
|
||||
x if x == RequestType::Release as usize => {
|
||||
ACTIVE_CLIENT.take();
|
||||
}
|
||||
x if x == RequestType::ClientUpdate as usize => {
|
||||
let requests = {
|
||||
let mut res = vec![];
|
||||
let mut requests = request_buffer.lock().unwrap();
|
||||
for request in requests.drain(..) {
|
||||
res.push(request);
|
||||
}
|
||||
res
|
||||
};
|
||||
|
||||
for request in requests {
|
||||
update_clients(request)
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
} else {
|
||||
/* other messages for window_procs */
|
||||
unsafe {
|
||||
let _ = TranslateMessage(&msg);
|
||||
DispatchMessageW(&msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
|
||||
if wparam.0 != WM_MOUSEMOVE as usize {
|
||||
return ACTIVE_CLIENT.get().is_some();
|
||||
}
|
||||
let mouse_low_level: MSLLHOOKSTRUCT = unsafe { *(lparam.0 as *const MSLLHOOKSTRUCT) };
|
||||
let curr_pos = (mouse_low_level.pt.x, mouse_low_level.pt.y);
|
||||
let prev_pos = PREV_POS.get().unwrap_or(curr_pos);
|
||||
PREV_POS.replace(Some(curr_pos));
|
||||
|
||||
/* next event is the first actual event */
|
||||
let ret = ACTIVE_CLIENT.get().is_some();
|
||||
|
||||
/* client already active, no need to check */
|
||||
if ACTIVE_CLIENT.get().is_some() {
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* check if a client was activated */
|
||||
let entered = DISPLAYS.with_borrow_mut(|(displays, generation)| {
|
||||
update_display_regions(displays, generation);
|
||||
display_util::entered_barrier(prev_pos, curr_pos, displays)
|
||||
});
|
||||
|
||||
let Some(pos) = entered else {
|
||||
return ret;
|
||||
};
|
||||
|
||||
/* check if a client is registered for the barrier */
|
||||
if !CLIENTS.with_borrow(|clients| clients.contains(&pos)) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* update active client and entry point */
|
||||
ACTIVE_CLIENT.replace(Some(pos));
|
||||
let entry_point = DISPLAYS.with_borrow(|(displays, _)| {
|
||||
display_util::clamp_to_display_bounds(displays, prev_pos, curr_pos)
|
||||
});
|
||||
ENTRY_POINT.replace(entry_point);
|
||||
|
||||
/* notify main thread */
|
||||
log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
|
||||
let active = ACTIVE_CLIENT.get().expect("active client");
|
||||
blocking_send_event(active, CaptureEvent::Begin);
|
||||
|
||||
ret
|
||||
}
|
||||
|
||||
unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
|
||||
let active = check_client_activation(wparam, lparam);
|
||||
|
||||
/* no client was active */
|
||||
if !active {
|
||||
return CallNextHookEx(HHOOK::default(), ncode, wparam, lparam);
|
||||
}
|
||||
|
||||
/* get active client if any */
|
||||
let Some(pos) = ACTIVE_CLIENT.get() else {
|
||||
return LRESULT(1);
|
||||
};
|
||||
|
||||
/* convert to lan-mouse event */
|
||||
let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
|
||||
return LRESULT(1);
|
||||
};
|
||||
|
||||
/* notify mainthread (drop events if sending too fast) */
|
||||
if let Err(e) = try_send_event(pos, CaptureEvent::Input(Event::Pointer(pointer_event))) {
|
||||
log::warn!("e: {e}");
|
||||
}
|
||||
|
||||
/* don't pass event to applications */
|
||||
LRESULT(1)
|
||||
}
|
||||
|
||||
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(HHOOK::default(), ncode, wparam, lparam);
|
||||
};
|
||||
|
||||
/* convert to key event */
|
||||
let Some(key_event) = to_key_event(wparam, lparam) else {
|
||||
return LRESULT(1);
|
||||
};
|
||||
|
||||
if let Err(e) = try_send_event(client, CaptureEvent::Input(Event::Keyboard(key_event))) {
|
||||
log::warn!("e: {e}");
|
||||
}
|
||||
|
||||
/* don't pass event to applications */
|
||||
LRESULT(1)
|
||||
}
|
||||
|
||||
unsafe extern "system" fn window_proc(
|
||||
_hwnd: HWND,
|
||||
uint: u32,
|
||||
_wparam: WPARAM,
|
||||
_lparam: LPARAM,
|
||||
) -> LRESULT {
|
||||
if uint == WM_DISPLAYCHANGE {
|
||||
log::debug!("display resolution changed");
|
||||
DISPLAY_RESOLUTION_GENERATION.fetch_add(1, Ordering::Release);
|
||||
}
|
||||
LRESULT(1)
|
||||
}
|
||||
|
||||
static DISPLAY_RESOLUTION_GENERATION: AtomicI32 = AtomicI32::new(1);
|
||||
|
||||
fn update_display_regions(displays: &mut Vec<RECT>, generation: &mut i32) {
|
||||
let global_generation = DISPLAY_RESOLUTION_GENERATION.load(Ordering::Acquire);
|
||||
if *generation != global_generation {
|
||||
enumerate_displays(displays);
|
||||
log::debug!("displays: {displays:?}");
|
||||
*generation = global_generation;
|
||||
}
|
||||
}
|
||||
|
||||
fn enumerate_displays(display_rects: &mut Vec<RECT>) {
|
||||
display_rects.clear();
|
||||
unsafe {
|
||||
let mut devices = vec![];
|
||||
for i in 0.. {
|
||||
let mut device: DISPLAY_DEVICEW = std::mem::zeroed();
|
||||
device.cb = std::mem::size_of::<DISPLAY_DEVICEW>() as u32;
|
||||
let ret = EnumDisplayDevicesW(None, i, &mut device, EDD_GET_DEVICE_INTERFACE_NAME);
|
||||
if ret == FALSE {
|
||||
break;
|
||||
}
|
||||
if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
|
||||
devices.push(device.DeviceName);
|
||||
}
|
||||
}
|
||||
for device in devices {
|
||||
let mut dev_mode: DEVMODEW = std::mem::zeroed();
|
||||
dev_mode.dmSize = std::mem::size_of::<DEVMODEW>() as u16;
|
||||
let ret = EnumDisplaySettingsW(
|
||||
PCWSTR::from_raw(&device as *const _),
|
||||
ENUM_CURRENT_SETTINGS,
|
||||
&mut dev_mode,
|
||||
);
|
||||
if ret == FALSE {
|
||||
log::warn!("no display mode");
|
||||
}
|
||||
|
||||
let pos = dev_mode.Anonymous1.Anonymous2.dmPosition;
|
||||
let (x, y) = (pos.x, pos.y);
|
||||
let (width, height) = (dev_mode.dmPelsWidth, dev_mode.dmPelsHeight);
|
||||
|
||||
display_rects.push(RECT {
|
||||
left: x,
|
||||
right: x + width as i32,
|
||||
top: y,
|
||||
bottom: y + height as i32,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn update_clients(request: ClientUpdate) {
|
||||
match request {
|
||||
ClientUpdate::Create(pos) => {
|
||||
CLIENTS.with_borrow_mut(|clients| clients.insert(pos));
|
||||
}
|
||||
ClientUpdate::Destroy(pos) => {
|
||||
if let Some(active_pos) = ACTIVE_CLIENT.get() {
|
||||
if pos == active_pos {
|
||||
let _ = ACTIVE_CLIENT.take();
|
||||
}
|
||||
}
|
||||
CLIENTS.with_borrow_mut(|clients| clients.remove(&pos));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn to_key_event(wparam: WPARAM, lparam: LPARAM) -> Option<KeyboardEvent> {
|
||||
let kybrdllhookstruct: KBDLLHOOKSTRUCT = unsafe { *(lparam.0 as *const KBDLLHOOKSTRUCT) };
|
||||
let mut scan_code = kybrdllhookstruct.scanCode;
|
||||
log::trace!("scan_code: {scan_code}");
|
||||
if kybrdllhookstruct.flags.contains(LLKHF_EXTENDED) {
|
||||
scan_code |= 0xE000;
|
||||
}
|
||||
let Ok(win_scan_code) = scancode::Windows::try_from(scan_code) else {
|
||||
log::warn!("failed to translate to windows scancode: {scan_code}");
|
||||
return None;
|
||||
};
|
||||
log::trace!("windows_scan: {win_scan_code:?}");
|
||||
let Ok(linux_scan_code): Result<Linux, ()> = win_scan_code.try_into() else {
|
||||
log::warn!("failed to translate into linux scancode: {win_scan_code:?}");
|
||||
return None;
|
||||
};
|
||||
log::trace!("windows_scan: {linux_scan_code:?}");
|
||||
let scan_code = linux_scan_code as u32;
|
||||
match wparam {
|
||||
WPARAM(p) if p == WM_KEYDOWN as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_KEYUP as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_SYSKEYDOWN as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_SYSKEYUP as usize => Some(KeyboardEvent::Key {
|
||||
time: 0,
|
||||
key: scan_code,
|
||||
state: 0,
|
||||
}),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
|
||||
let mouse_low_level: MSLLHOOKSTRUCT = unsafe { *(lparam.0 as *const MSLLHOOKSTRUCT) };
|
||||
match wparam {
|
||||
WPARAM(p) if p == WM_LBUTTONDOWN as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_LEFT,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_MBUTTONDOWN as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_MIDDLE,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_RBUTTONDOWN as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_RIGHT,
|
||||
state: 1,
|
||||
}),
|
||||
WPARAM(p) if p == WM_LBUTTONUP as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_LEFT,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_MBUTTONUP as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_MIDDLE,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_RBUTTONUP as usize => Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button: BTN_RIGHT,
|
||||
state: 0,
|
||||
}),
|
||||
WPARAM(p) if p == WM_MOUSEMOVE as usize => {
|
||||
let (x, y) = (mouse_low_level.pt.x, mouse_low_level.pt.y);
|
||||
let (ex, ey) = ENTRY_POINT.get();
|
||||
let (dx, dy) = (x - ex, y - ey);
|
||||
let (dx, dy) = (dx as f64, dy as f64);
|
||||
Some(PointerEvent::Motion { time: 0, dx, dy })
|
||||
}
|
||||
WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
|
||||
axis: 0,
|
||||
value: -(mouse_low_level.mouseData as i32 >> 16),
|
||||
}),
|
||||
WPARAM(p) if p == WM_XBUTTONDOWN as usize || p == WM_XBUTTONUP as usize => {
|
||||
let hb = mouse_low_level.mouseData >> 16;
|
||||
let button = match hb {
|
||||
1 => BTN_BACK,
|
||||
2 => BTN_FORWARD,
|
||||
_ => {
|
||||
log::warn!("unknown mouse button");
|
||||
return None;
|
||||
}
|
||||
};
|
||||
Some(PointerEvent::Button {
|
||||
time: 0,
|
||||
button,
|
||||
state: if p == WM_XBUTTONDOWN as usize { 1 } else { 0 },
|
||||
})
|
||||
}
|
||||
w => {
|
||||
log::warn!("unknown mouse event: {w:?}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3,7 +3,10 @@ use std::task::Poll;
|
||||
use async_trait::async_trait;
|
||||
use futures_core::Stream;
|
||||
|
||||
use super::{error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
|
||||
use super::{
|
||||
error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle,
|
||||
Position,
|
||||
};
|
||||
|
||||
pub struct X11InputCapture {}
|
||||
|
||||
@@ -15,11 +18,11 @@ impl X11InputCapture {
|
||||
|
||||
#[async_trait]
|
||||
impl Capture for X11InputCapture {
|
||||
async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
|
||||
async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
|
||||
async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -33,7 +36,7 @@ impl Capture for X11InputCapture {
|
||||
}
|
||||
|
||||
impl Stream for X11InputCapture {
|
||||
type Item = Result<(Position, CaptureEvent), CaptureError>;
|
||||
type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
|
||||
|
||||
fn poll_next(
|
||||
self: std::pin::Pin<&mut Self>,
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[package]
|
||||
name = "input-emulation"
|
||||
description = "cross-platform input emulation library used by lan-mouse"
|
||||
version = "0.3.0"
|
||||
version = "0.2.1"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
@@ -10,8 +10,8 @@ repository = "https://github.com/feschber/lan-mouse"
|
||||
async-trait = "0.1.80"
|
||||
futures = "0.3.28"
|
||||
log = "0.4.22"
|
||||
input-event = { path = "../input-event", version = "0.3.0" }
|
||||
thiserror = "2.0.0"
|
||||
input-event = { path = "../input-event", version = "0.2.1" }
|
||||
thiserror = "1.0.61"
|
||||
tokio = { version = "1.32.0", features = [
|
||||
"io-util",
|
||||
"io-std",
|
||||
@@ -25,7 +25,6 @@ tokio = { version = "1.32.0", features = [
|
||||
once_cell = "1.19.0"
|
||||
|
||||
[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
|
||||
bitflags = "2.6.0"
|
||||
wayland-client = { version = "0.31.1", optional = true }
|
||||
wayland-protocols = { version = "0.32.1", features = [
|
||||
"client",
|
||||
@@ -39,14 +38,13 @@ wayland-protocols-misc = { version = "0.3.1", features = [
|
||||
"client",
|
||||
], optional = true }
|
||||
x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
|
||||
ashpd = { version = "0.10", default-features = false, features = [
|
||||
ashpd = { version = "0.9", default-features = false, features = [
|
||||
"tokio",
|
||||
], optional = true }
|
||||
reis = { version = "0.4", features = ["tokio"], optional = true }
|
||||
reis = { version = "0.2", features = ["tokio"], optional = true }
|
||||
|
||||
[target.'cfg(target_os="macos")'.dependencies]
|
||||
bitflags = "2.6.0"
|
||||
core-graphics = { version = "0.24.0", features = ["highsierra"] }
|
||||
core-graphics = { version = "0.23", features = ["highsierra"] }
|
||||
keycode = "0.4.0"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
@@ -61,13 +59,13 @@ windows = { version = "0.58.0", features = [
|
||||
] }
|
||||
|
||||
[features]
|
||||
default = ["wlroots", "x11", "remote_desktop_portal", "libei"]
|
||||
wlroots = [
|
||||
default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
|
||||
wayland = [
|
||||
"dep:wayland-client",
|
||||
"dep:wayland-protocols",
|
||||
"dep:wayland-protocols-wlr",
|
||||
"dep:wayland-protocols-misc",
|
||||
]
|
||||
x11 = ["dep:x11"]
|
||||
remote_desktop_portal = ["dep:ashpd"]
|
||||
xdg_desktop_portal = ["dep:ashpd"]
|
||||
libei = ["dep:reis", "dep:ashpd"]
|
||||
|
||||
@@ -6,35 +6,53 @@ pub enum InputEmulationError {
|
||||
Emulate(#[from] EmulationError),
|
||||
}
|
||||
|
||||
#[cfg(all(
|
||||
unix,
|
||||
any(feature = "remote_desktop_portal", feature = "libei"),
|
||||
not(target_os = "macos")
|
||||
))]
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
use ashpd::{desktop::ResponseError, Error::Response};
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
use reis::tokio::EiConvertEventStreamError;
|
||||
use std::io;
|
||||
use thiserror::Error;
|
||||
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
use wayland_client::{
|
||||
backend::WaylandError,
|
||||
globals::{BindError, GlobalError},
|
||||
ConnectError, DispatchError,
|
||||
};
|
||||
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
use reis::tokio::HandshakeError;
|
||||
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[derive(Debug, Error)]
|
||||
#[error("error in libei stream: {inner:?}")]
|
||||
pub struct ReisConvertStreamError {
|
||||
inner: EiConvertEventStreamError,
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
impl From<EiConvertEventStreamError> for ReisConvertStreamError {
|
||||
fn from(e: EiConvertEventStreamError) -> Self {
|
||||
Self { inner: e }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum EmulationError {
|
||||
#[error("event stream closed")]
|
||||
EndOfStream,
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[error("libei error: `{0}`")]
|
||||
Libei(#[from] reis::Error),
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[error("libei error flushing events: `{0}`")]
|
||||
Libei(#[from] reis::event::Error),
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[error("")]
|
||||
LibeiConvertStream(#[from] ReisConvertStreamError),
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
#[error("wayland error: `{0}`")]
|
||||
Wayland(#[from] wayland_client::backend::WaylandError),
|
||||
#[cfg(all(
|
||||
unix,
|
||||
any(feature = "remote_desktop_portal", feature = "libei"),
|
||||
any(feature = "xdg_desktop_portal", feature = "libei"),
|
||||
not(target_os = "macos")
|
||||
))]
|
||||
#[error("xdg-desktop-portal: `{0}`")]
|
||||
@@ -45,13 +63,13 @@ pub enum EmulationError {
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum EmulationCreationError {
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
#[error("wlroots backend: `{0}`")]
|
||||
Wlroots(#[from] WlrootsEmulationCreationError),
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
#[error("libei backend: `{0}`")]
|
||||
Libei(#[from] LibeiEmulationCreationError),
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
#[error("xdg-desktop-portal: `{0}`")]
|
||||
Xdp(#[from] XdpEmulationCreationError),
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
@@ -79,7 +97,7 @@ impl EmulationCreationError {
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
if matches!(
|
||||
self,
|
||||
EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
|
||||
@@ -92,7 +110,7 @@ impl EmulationCreationError {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
#[derive(Debug, Error)]
|
||||
pub enum WlrootsEmulationCreationError {
|
||||
#[error(transparent)]
|
||||
@@ -109,7 +127,7 @@ pub enum WlrootsEmulationCreationError {
|
||||
Io(#[from] std::io::Error),
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
#[derive(Debug, Error)]
|
||||
#[error("wayland protocol \"{protocol}\" not supported: {inner}")]
|
||||
pub struct WaylandBindError {
|
||||
@@ -117,7 +135,7 @@ pub struct WaylandBindError {
|
||||
protocol: &'static str,
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
impl WaylandBindError {
|
||||
pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
|
||||
Self { inner, protocol }
|
||||
@@ -132,10 +150,10 @@ pub enum LibeiEmulationCreationError {
|
||||
#[error(transparent)]
|
||||
Io(#[from] std::io::Error),
|
||||
#[error(transparent)]
|
||||
Reis(#[from] reis::Error),
|
||||
Handshake(#[from] HandshakeError),
|
||||
}
|
||||
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
#[derive(Debug, Error)]
|
||||
pub enum XdpEmulationCreationError {
|
||||
#[error(transparent)]
|
||||
|
||||
@@ -14,10 +14,10 @@ mod windows;
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
mod x11;
|
||||
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
mod wlroots;
|
||||
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
mod xdg_desktop_portal;
|
||||
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
@@ -34,11 +34,11 @@ pub type EmulationHandle = u64;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum Backend {
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Wlroots,
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Libei,
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
Xdp,
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
X11,
|
||||
@@ -52,11 +52,11 @@ pub enum Backend {
|
||||
impl Display for Backend {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Backend::Wlroots => write!(f, "wlroots"),
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Backend::Libei => write!(f, "libei"),
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
Backend::Xdp => write!(f, "xdg-desktop-portal"),
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
Backend::X11 => write!(f, "X11"),
|
||||
@@ -78,13 +78,13 @@ pub struct InputEmulation {
|
||||
impl InputEmulation {
|
||||
async fn with_backend(backend: Backend) -> Result<InputEmulation, EmulationCreationError> {
|
||||
let emulation: Box<dyn Emulation> = match backend {
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Backend::Wlroots => Box::new(wlroots::WlrootsEmulation::new()?),
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Backend::Libei => Box::new(libei::LibeiEmulation::new().await?),
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
Backend::X11 => Box::new(x11::X11Emulation::new()?),
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
Backend::Xdp => Box::new(xdg_desktop_portal::DesktopPortalEmulation::new().await?),
|
||||
#[cfg(windows)]
|
||||
Backend::Windows => Box::new(windows::WindowsEmulation::new()?),
|
||||
@@ -109,11 +109,11 @@ impl InputEmulation {
|
||||
}
|
||||
|
||||
for backend in [
|
||||
#[cfg(all(unix, feature = "wlroots", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Backend::Wlroots,
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Backend::Libei,
|
||||
#[cfg(all(unix, feature = "remote_desktop_portal", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
Backend::Xdp,
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
Backend::X11,
|
||||
@@ -217,13 +217,15 @@ impl InputEmulation {
|
||||
return false;
|
||||
};
|
||||
|
||||
if state == 0 {
|
||||
let ret = if state == 0 {
|
||||
// currently pressed => can release
|
||||
pressed_keys.remove(&key)
|
||||
} else {
|
||||
// currently not pressed => can press
|
||||
pressed_keys.insert(key)
|
||||
}
|
||||
};
|
||||
log::info!("client {handle}: pressed keys: {:?}", pressed_keys);
|
||||
ret
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,18 +1,23 @@
|
||||
use futures::{future, StreamExt};
|
||||
use once_cell::sync::Lazy;
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
io,
|
||||
os::{fd::OwnedFd, unix::net::UnixStream},
|
||||
sync::{
|
||||
atomic::{AtomicBool, Ordering},
|
||||
atomic::{AtomicBool, AtomicU32, Ordering},
|
||||
Arc, Mutex, RwLock,
|
||||
},
|
||||
time::{SystemTime, UNIX_EPOCH},
|
||||
};
|
||||
use tokio::task::JoinHandle;
|
||||
|
||||
use ashpd::desktop::{
|
||||
remote_desktop::{DeviceType, RemoteDesktop},
|
||||
PersistMode, Session,
|
||||
use ashpd::{
|
||||
desktop::{
|
||||
remote_desktop::{DeviceType, RemoteDesktop},
|
||||
PersistMode, Session,
|
||||
},
|
||||
WindowIdentifier,
|
||||
};
|
||||
use async_trait::async_trait;
|
||||
|
||||
@@ -21,16 +26,32 @@ use reis::{
|
||||
self, button::ButtonState, handshake::ContextType, keyboard::KeyState, Button, Keyboard,
|
||||
Pointer, Scroll,
|
||||
},
|
||||
event::{self, Connection, DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
|
||||
tokio::EiConvertEventStream,
|
||||
event::{DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
|
||||
tokio::{ei_handshake, EiConvertEventStream, EiEventStream},
|
||||
};
|
||||
|
||||
use input_event::{Event, KeyboardEvent, PointerEvent};
|
||||
|
||||
use crate::error::EmulationError;
|
||||
use crate::error::{EmulationError, ReisConvertStreamError};
|
||||
|
||||
use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};
|
||||
|
||||
static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
|
||||
let mut m = HashMap::new();
|
||||
m.insert("ei_connection", 1);
|
||||
m.insert("ei_callback", 1);
|
||||
m.insert("ei_pingpong", 1);
|
||||
m.insert("ei_seat", 1);
|
||||
m.insert("ei_device", 2);
|
||||
m.insert("ei_pointer", 1);
|
||||
m.insert("ei_pointer_absolute", 1);
|
||||
m.insert("ei_scroll", 1);
|
||||
m.insert("ei_button", 1);
|
||||
m.insert("ei_keyboard", 1);
|
||||
m.insert("ei_touchscreen", 1);
|
||||
m
|
||||
});
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
struct Devices {
|
||||
pointer: Arc<RwLock<Option<(ei::Device, ei::Pointer)>>>,
|
||||
@@ -41,11 +62,11 @@ struct Devices {
|
||||
|
||||
pub(crate) struct LibeiEmulation<'a> {
|
||||
context: ei::Context,
|
||||
conn: event::Connection,
|
||||
devices: Devices,
|
||||
ei_task: JoinHandle<()>,
|
||||
error: Arc<Mutex<Option<EmulationError>>>,
|
||||
libei_error: Arc<AtomicBool>,
|
||||
serial: AtomicU32,
|
||||
_remote_desktop: RemoteDesktop<'a>,
|
||||
session: Session<'a, RemoteDesktop<'a>>,
|
||||
}
|
||||
@@ -68,27 +89,35 @@ async fn get_ei_fd<'a>(
|
||||
.await?;
|
||||
|
||||
log::info!("requesting permission for input emulation");
|
||||
let _devices = remote_desktop.start(&session, None).await?.response()?;
|
||||
let _devices = remote_desktop
|
||||
.start(&session, &WindowIdentifier::default())
|
||||
.await?
|
||||
.response()?;
|
||||
|
||||
let fd = remote_desktop.connect_to_eis(&session).await?;
|
||||
Ok((remote_desktop, session, fd))
|
||||
}
|
||||
|
||||
impl LibeiEmulation<'_> {
|
||||
impl<'a> LibeiEmulation<'a> {
|
||||
pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
|
||||
let (_remote_desktop, session, eifd) = get_ei_fd().await?;
|
||||
let stream = UnixStream::from(eifd);
|
||||
stream.set_nonblocking(true)?;
|
||||
let context = ei::Context::new(stream)?;
|
||||
let (conn, events) = context
|
||||
.handshake_tokio("de.feschber.LanMouse", ContextType::Sender)
|
||||
.await?;
|
||||
let mut events = EiEventStream::new(context.clone())?;
|
||||
let handshake = ei_handshake(
|
||||
&mut events,
|
||||
"de.feschber.LanMouse",
|
||||
ContextType::Sender,
|
||||
&INTERFACES,
|
||||
)
|
||||
.await?;
|
||||
let events = EiConvertEventStream::new(events, handshake.serial);
|
||||
let devices = Devices::default();
|
||||
let libei_error = Arc::new(AtomicBool::default());
|
||||
let error = Arc::new(Mutex::new(None));
|
||||
let ei_handler = ei_task(
|
||||
events,
|
||||
conn.clone(),
|
||||
context.clone(),
|
||||
devices.clone(),
|
||||
libei_error.clone(),
|
||||
@@ -96,27 +125,29 @@ impl LibeiEmulation<'_> {
|
||||
);
|
||||
let ei_task = tokio::task::spawn_local(ei_handler);
|
||||
|
||||
let serial = AtomicU32::new(handshake.serial);
|
||||
|
||||
Ok(Self {
|
||||
context,
|
||||
conn,
|
||||
devices,
|
||||
ei_task,
|
||||
error,
|
||||
libei_error,
|
||||
serial,
|
||||
_remote_desktop,
|
||||
session,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for LibeiEmulation<'_> {
|
||||
impl<'a> Drop for LibeiEmulation<'a> {
|
||||
fn drop(&mut self) {
|
||||
self.ei_task.abort();
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl Emulation for LibeiEmulation<'_> {
|
||||
impl<'a> Emulation for LibeiEmulation<'a> {
|
||||
async fn consume(
|
||||
&mut self,
|
||||
event: Event,
|
||||
@@ -138,7 +169,7 @@ impl Emulation for LibeiEmulation<'_> {
|
||||
let pointer_device = self.devices.pointer.read().unwrap();
|
||||
if let Some((d, p)) = pointer_device.as_ref() {
|
||||
p.motion_relative(dx as f32, dy as f32);
|
||||
d.frame(self.conn.serial(), now);
|
||||
d.frame(self.serial.load(Ordering::SeqCst), now);
|
||||
}
|
||||
}
|
||||
PointerEvent::Button {
|
||||
@@ -155,7 +186,7 @@ impl Emulation for LibeiEmulation<'_> {
|
||||
_ => ButtonState::Press,
|
||||
},
|
||||
);
|
||||
d.frame(self.conn.serial(), now);
|
||||
d.frame(self.serial.load(Ordering::SeqCst), now);
|
||||
}
|
||||
}
|
||||
PointerEvent::Axis {
|
||||
@@ -169,7 +200,7 @@ impl Emulation for LibeiEmulation<'_> {
|
||||
0 => s.scroll(0., value as f32),
|
||||
_ => s.scroll(value as f32, 0.),
|
||||
}
|
||||
d.frame(self.conn.serial(), now);
|
||||
d.frame(self.serial.load(Ordering::SeqCst), now);
|
||||
}
|
||||
}
|
||||
PointerEvent::AxisDiscrete120 { axis, value } => {
|
||||
@@ -179,7 +210,7 @@ impl Emulation for LibeiEmulation<'_> {
|
||||
0 => s.scroll_discrete(0, value),
|
||||
_ => s.scroll_discrete(value, 0),
|
||||
}
|
||||
d.frame(self.conn.serial(), now);
|
||||
d.frame(self.serial.load(Ordering::SeqCst), now);
|
||||
}
|
||||
}
|
||||
},
|
||||
@@ -198,7 +229,7 @@ impl Emulation for LibeiEmulation<'_> {
|
||||
_ => KeyState::Press,
|
||||
},
|
||||
);
|
||||
d.frame(self.conn.serial(), now);
|
||||
d.frame(self.serial.load(Ordering::SeqCst), now);
|
||||
}
|
||||
}
|
||||
KeyboardEvent::Modifiers { .. } => {}
|
||||
@@ -221,7 +252,6 @@ impl Emulation for LibeiEmulation<'_> {
|
||||
|
||||
async fn ei_task(
|
||||
mut events: EiConvertEventStream,
|
||||
_conn: Connection,
|
||||
context: ei::Context,
|
||||
devices: Devices,
|
||||
libei_error: Arc<AtomicBool>,
|
||||
@@ -246,7 +276,11 @@ async fn ei_event_handler(
|
||||
devices: &Devices,
|
||||
) -> Result<(), EmulationError> {
|
||||
loop {
|
||||
let event = events.next().await.ok_or(EmulationError::EndOfStream)??;
|
||||
let event = events
|
||||
.next()
|
||||
.await
|
||||
.ok_or(EmulationError::EndOfStream)?
|
||||
.map_err(ReisConvertStreamError::from)?;
|
||||
const CAPABILITIES: &[DeviceCapability] = &[
|
||||
DeviceCapability::Pointer,
|
||||
DeviceCapability::PointerAbsolute,
|
||||
|
||||
@@ -1,23 +1,18 @@
|
||||
use super::{error::EmulationError, Emulation, EmulationHandle};
|
||||
use async_trait::async_trait;
|
||||
use bitflags::bitflags;
|
||||
use core_graphics::base::CGFloat;
|
||||
use core_graphics::display::{
|
||||
CGDirectDisplayID, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
|
||||
};
|
||||
use core_graphics::event::{
|
||||
CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField,
|
||||
ScrollEventUnit,
|
||||
CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
|
||||
};
|
||||
use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
|
||||
use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
|
||||
use input_event::{Event, KeyboardEvent, PointerEvent};
|
||||
use keycode::{KeyMap, KeyMapping};
|
||||
use std::cell::Cell;
|
||||
use std::ops::{Index, IndexMut};
|
||||
use std::rc::Rc;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tokio::{sync::Notify, task::JoinHandle};
|
||||
use tokio::task::AbortHandle;
|
||||
|
||||
use super::error::MacOSEmulationCreationError;
|
||||
|
||||
@@ -26,10 +21,8 @@ const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
|
||||
|
||||
pub(crate) struct MacOSEmulation {
|
||||
event_source: CGEventSource,
|
||||
repeat_task: Option<JoinHandle<()>>,
|
||||
repeat_task: Option<AbortHandle>,
|
||||
button_state: ButtonState,
|
||||
modifier_state: Rc<Cell<XMods>>,
|
||||
notify_repeat_task: Arc<Notify>,
|
||||
}
|
||||
|
||||
struct ButtonState {
|
||||
@@ -75,8 +68,6 @@ impl MacOSEmulation {
|
||||
event_source,
|
||||
button_state,
|
||||
repeat_task: None,
|
||||
notify_repeat_task: Arc::new(Notify::new()),
|
||||
modifier_state: Rc::new(Cell::new(XMods::empty())),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -88,40 +79,25 @@ impl MacOSEmulation {
|
||||
async fn spawn_repeat_task(&mut self, key: u16) {
|
||||
// there can only be one repeating key and it's
|
||||
// always the last to be pressed
|
||||
self.cancel_repeat_task().await;
|
||||
self.kill_repeat_task();
|
||||
let event_source = self.event_source.clone();
|
||||
let notify = self.notify_repeat_task.clone();
|
||||
let modifiers = self.modifier_state.clone();
|
||||
let repeat_task = tokio::task::spawn_local(async move {
|
||||
let stop = tokio::select! {
|
||||
_ = tokio::time::sleep(DEFAULT_REPEAT_DELAY) => false,
|
||||
_ = notify.notified() => true,
|
||||
};
|
||||
if !stop {
|
||||
loop {
|
||||
key_event(event_source.clone(), key, 1, modifiers.get());
|
||||
tokio::select! {
|
||||
_ = tokio::time::sleep(DEFAULT_REPEAT_INTERVAL) => {},
|
||||
_ = notify.notified() => break,
|
||||
}
|
||||
}
|
||||
tokio::time::sleep(DEFAULT_REPEAT_DELAY).await;
|
||||
loop {
|
||||
key_event(event_source.clone(), key, 1);
|
||||
tokio::time::sleep(DEFAULT_REPEAT_INTERVAL).await;
|
||||
}
|
||||
// release key when cancelled
|
||||
update_modifiers(&modifiers, key as u32, 0);
|
||||
key_event(event_source.clone(), key, 0, modifiers.get());
|
||||
});
|
||||
self.repeat_task = Some(repeat_task);
|
||||
self.repeat_task = Some(repeat_task.abort_handle());
|
||||
}
|
||||
|
||||
async fn cancel_repeat_task(&mut self) {
|
||||
fn kill_repeat_task(&mut self) {
|
||||
if let Some(task) = self.repeat_task.take() {
|
||||
self.notify_repeat_task.notify_waiters();
|
||||
let _ = task.await;
|
||||
task.abort();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods) {
|
||||
fn key_event(event_source: CGEventSource, key: u16, state: u8) {
|
||||
let event = match CGEvent::new_keyboard_event(event_source, key, state != 0) {
|
||||
Ok(e) => e,
|
||||
Err(_) => {
|
||||
@@ -129,21 +105,7 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods)
|
||||
return;
|
||||
}
|
||||
};
|
||||
event.set_flags(to_cgevent_flags(modifiers));
|
||||
event.post(CGEventTapLocation::HID);
|
||||
log::trace!("key event: {key} {state}");
|
||||
}
|
||||
|
||||
fn modifier_event(event_source: CGEventSource, depressed: XMods) {
|
||||
let Ok(event) = CGEvent::new(event_source) else {
|
||||
log::warn!("could not create CGEvent");
|
||||
return;
|
||||
};
|
||||
let flags = to_cgevent_flags(depressed);
|
||||
event.set_type(CGEventType::FlagsChanged);
|
||||
event.set_flags(flags);
|
||||
event.post(CGEventTapLocation::HID);
|
||||
log::trace!("modifiers updated: {depressed:?}");
|
||||
}
|
||||
|
||||
fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
|
||||
@@ -170,7 +132,7 @@ fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
|
||||
return Option::None;
|
||||
}
|
||||
|
||||
displays.first().copied()
|
||||
return displays.first().copied();
|
||||
}
|
||||
|
||||
fn get_display_bounds(display: CGDirectDisplayID) -> (CGFloat, CGFloat, CGFloat, CGFloat) {
|
||||
@@ -384,25 +346,11 @@ impl Emulation for MacOSEmulation {
|
||||
match state {
|
||||
// pressed
|
||||
1 => self.spawn_repeat_task(code).await,
|
||||
_ => self.cancel_repeat_task().await,
|
||||
_ => self.kill_repeat_task(),
|
||||
}
|
||||
update_modifiers(&self.modifier_state, key, state);
|
||||
key_event(
|
||||
self.event_source.clone(),
|
||||
code,
|
||||
state,
|
||||
self.modifier_state.get(),
|
||||
);
|
||||
}
|
||||
KeyboardEvent::Modifiers {
|
||||
depressed,
|
||||
latched,
|
||||
locked,
|
||||
group,
|
||||
} => {
|
||||
set_modifiers(&self.modifier_state, depressed, latched, locked, group);
|
||||
modifier_event(self.event_source.clone(), self.modifier_state.get());
|
||||
key_event(self.event_source.clone(), code, state)
|
||||
}
|
||||
KeyboardEvent::Modifiers { .. } => {}
|
||||
},
|
||||
}
|
||||
// FIXME
|
||||
@@ -415,81 +363,3 @@ impl Emulation for MacOSEmulation {
|
||||
|
||||
async fn terminate(&mut self) {}
|
||||
}
|
||||
|
||||
fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
|
||||
if let Ok(key) = scancode::Linux::try_from(key) {
|
||||
let mask = match key {
|
||||
scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
|
||||
scancode::Linux::KeyCapsLock => XMods::LockMask,
|
||||
scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
|
||||
scancode::Linux::KeyLeftAlt | scancode::Linux::KeyRightalt => XMods::Mod1Mask,
|
||||
scancode::Linux::KeyLeftMeta | scancode::Linux::KeyRightmeta => XMods::Mod4Mask,
|
||||
_ => XMods::empty(),
|
||||
};
|
||||
// unchanged
|
||||
if mask.is_empty() {
|
||||
return false;
|
||||
}
|
||||
let mut mods = modifiers.get();
|
||||
match state {
|
||||
1 => mods.insert(mask),
|
||||
_ => mods.remove(mask),
|
||||
}
|
||||
modifiers.set(mods);
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fn set_modifiers(
|
||||
active_modifiers: &Cell<XMods>,
|
||||
depressed: u32,
|
||||
latched: u32,
|
||||
locked: u32,
|
||||
group: u32,
|
||||
) {
|
||||
let depressed = XMods::from_bits(depressed).unwrap_or_default();
|
||||
let _latched = XMods::from_bits(latched).unwrap_or_default();
|
||||
let _locked = XMods::from_bits(locked).unwrap_or_default();
|
||||
let _group = XMods::from_bits(group).unwrap_or_default();
|
||||
|
||||
// we only care about the depressed modifiers for now
|
||||
active_modifiers.replace(depressed);
|
||||
}
|
||||
|
||||
fn to_cgevent_flags(depressed: XMods) -> CGEventFlags {
|
||||
let mut flags = CGEventFlags::empty();
|
||||
if depressed.contains(XMods::ShiftMask) {
|
||||
flags |= CGEventFlags::CGEventFlagShift;
|
||||
}
|
||||
if depressed.contains(XMods::LockMask) {
|
||||
flags |= CGEventFlags::CGEventFlagAlphaShift;
|
||||
}
|
||||
if depressed.contains(XMods::ControlMask) {
|
||||
flags |= CGEventFlags::CGEventFlagControl;
|
||||
}
|
||||
if depressed.contains(XMods::Mod1Mask) {
|
||||
flags |= CGEventFlags::CGEventFlagAlternate;
|
||||
}
|
||||
if depressed.contains(XMods::Mod4Mask) {
|
||||
flags |= CGEventFlags::CGEventFlagCommand;
|
||||
}
|
||||
flags
|
||||
}
|
||||
|
||||
// From X11/X.h
|
||||
bitflags! {
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||
struct XMods: u32 {
|
||||
const ShiftMask = (1<<0);
|
||||
const LockMask = (1<<1);
|
||||
const ControlMask = (1<<2);
|
||||
const Mod1Mask = (1<<3);
|
||||
const Mod2Mask = (1<<4);
|
||||
const Mod3Mask = (1<<5);
|
||||
const Mod4Mask = (1<<6);
|
||||
const Mod5Mask = (1<<7);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,12 +2,9 @@ use crate::error::EmulationError;
|
||||
|
||||
use super::{error::WlrootsEmulationCreationError, Emulation};
|
||||
use async_trait::async_trait;
|
||||
use bitflags::bitflags;
|
||||
use std::collections::HashMap;
|
||||
use std::io;
|
||||
use std::os::fd::{AsFd, OwnedFd};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::{SystemTime, UNIX_EPOCH};
|
||||
use wayland_client::backend::WaylandError;
|
||||
use wayland_client::WEnum;
|
||||
|
||||
@@ -31,7 +28,7 @@ use wayland_client::{
|
||||
Connection, Dispatch, EventQueue, QueueHandle,
|
||||
};
|
||||
|
||||
use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
|
||||
use input_event::{Event, KeyboardEvent, PointerEvent};
|
||||
|
||||
use super::error::WaylandBindError;
|
||||
use super::EmulationHandle;
|
||||
@@ -105,11 +102,7 @@ impl State {
|
||||
panic!("no keymap");
|
||||
}
|
||||
|
||||
let vinput = VirtualInput {
|
||||
pointer,
|
||||
keyboard,
|
||||
modifiers: Arc::new(Mutex::new(XMods::empty())),
|
||||
};
|
||||
let vinput = VirtualInput { pointer, keyboard };
|
||||
|
||||
self.input_for_client.insert(client, vinput);
|
||||
}
|
||||
@@ -180,16 +173,10 @@ impl Emulation for WlrootsEmulation {
|
||||
struct VirtualInput {
|
||||
pointer: Vp,
|
||||
keyboard: Vk,
|
||||
modifiers: Arc<Mutex<XMods>>,
|
||||
}
|
||||
|
||||
impl VirtualInput {
|
||||
fn consume_event(&self, event: Event) -> Result<(), ()> {
|
||||
let now: u32 = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_millis() as u32;
|
||||
|
||||
match event {
|
||||
Event::Pointer(e) => {
|
||||
match e {
|
||||
@@ -210,7 +197,7 @@ impl VirtualInput {
|
||||
PointerEvent::AxisDiscrete120 { axis, value } => {
|
||||
let axis: Axis = (axis as u32).try_into()?;
|
||||
self.pointer
|
||||
.axis_discrete(now, axis, value as f64 / 6., value / 120);
|
||||
.axis_discrete(0, axis, value as f64 / 6., value / 120);
|
||||
self.pointer.frame();
|
||||
}
|
||||
}
|
||||
@@ -219,17 +206,6 @@ impl VirtualInput {
|
||||
Event::Keyboard(e) => match e {
|
||||
KeyboardEvent::Key { time, key, state } => {
|
||||
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);
|
||||
self.keyboard.modifiers(
|
||||
mods.mask_pressed().bits(),
|
||||
0,
|
||||
mods.mask_locks().bits(),
|
||||
0,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
KeyboardEvent::Modifiers {
|
||||
depressed: mods_depressed,
|
||||
@@ -237,10 +213,6 @@ impl VirtualInput {
|
||||
locked: mods_locked,
|
||||
group,
|
||||
} => {
|
||||
// Synchronize internal modifier state, assuming server is authoritative
|
||||
if let Ok(mut mods) = self.modifiers.lock() {
|
||||
mods.update_by_mods_event(e);
|
||||
}
|
||||
self.keyboard
|
||||
.modifiers(mods_depressed, mods_latched, mods_locked, group);
|
||||
}
|
||||
@@ -301,74 +273,3 @@ impl Dispatch<WlSeat, ()> for State {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// From X11/X.h
|
||||
bitflags! {
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||
struct XMods: u32 {
|
||||
const ShiftMask = (1<<0);
|
||||
const LockMask = (1<<1);
|
||||
const ControlMask = (1<<2);
|
||||
const Mod1Mask = (1<<3);
|
||||
const Mod2Mask = (1<<4);
|
||||
const Mod3Mask = (1<<5);
|
||||
const Mod4Mask = (1<<6);
|
||||
const Mod5Mask = (1<<7);
|
||||
}
|
||||
}
|
||||
|
||||
impl XMods {
|
||||
fn update_by_mods_event(&mut self, evt: KeyboardEvent) {
|
||||
if let KeyboardEvent::Modifiers {
|
||||
depressed, locked, ..
|
||||
} = evt
|
||||
{
|
||||
*self = XMods::from_bits_truncate(depressed) | XMods::from_bits_truncate(locked);
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
let pressed_mask = match key {
|
||||
scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
|
||||
scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
|
||||
scancode::Linux::KeyLeftAlt | scancode::Linux::KeyRightalt => XMods::Mod1Mask,
|
||||
scancode::Linux::KeyLeftMeta | scancode::Linux::KeyRightmeta => XMods::Mod4Mask,
|
||||
_ => XMods::empty(),
|
||||
};
|
||||
|
||||
let locked_mask = match key {
|
||||
scancode::Linux::KeyCapsLock => XMods::LockMask,
|
||||
scancode::Linux::KeyNumlock => XMods::Mod2Mask,
|
||||
scancode::Linux::KeyScrollLock => XMods::Mod3Mask,
|
||||
_ => XMods::empty(),
|
||||
};
|
||||
|
||||
// unchanged
|
||||
if pressed_mask.is_empty() && locked_mask.is_empty() {
|
||||
log::trace!("{:#?} is not a modifier key", key);
|
||||
return false;
|
||||
}
|
||||
match state {
|
||||
1 => self.insert(pressed_mask),
|
||||
_ => {
|
||||
self.remove(pressed_mask);
|
||||
self.toggle(locked_mask);
|
||||
}
|
||||
}
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fn mask_locks(&self) -> XMods {
|
||||
*self & (XMods::LockMask | XMods::Mod2Mask | XMods::Mod3Mask)
|
||||
}
|
||||
|
||||
fn mask_pressed(&self) -> XMods {
|
||||
*self & (XMods::ShiftMask | XMods::ControlMask | XMods::Mod1Mask | XMods::Mod4Mask)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,6 +4,7 @@ use ashpd::{
|
||||
PersistMode, Session,
|
||||
},
|
||||
zbus::AsyncDrop,
|
||||
WindowIdentifier,
|
||||
};
|
||||
use async_trait::async_trait;
|
||||
|
||||
@@ -42,7 +43,10 @@ impl<'a> DesktopPortalEmulation<'a> {
|
||||
.await?;
|
||||
|
||||
log::info!("requesting permission for input emulation");
|
||||
let _devices = proxy.start(&session, None).await?.response()?;
|
||||
let _devices = proxy
|
||||
.start(&session, &WindowIdentifier::default())
|
||||
.await?
|
||||
.response()?;
|
||||
|
||||
log::debug!("started session");
|
||||
let session = session;
|
||||
@@ -52,7 +56,7 @@ impl<'a> DesktopPortalEmulation<'a> {
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl Emulation for DesktopPortalEmulation<'_> {
|
||||
impl<'a> Emulation for DesktopPortalEmulation<'a> {
|
||||
async fn consume(
|
||||
&mut self,
|
||||
event: input_event::Event,
|
||||
@@ -141,7 +145,7 @@ impl Emulation for DesktopPortalEmulation<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
impl AsyncDrop for DesktopPortalEmulation<'_> {
|
||||
impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {
|
||||
#[doc = r" Perform the async cleanup."]
|
||||
#[must_use]
|
||||
#[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[package]
|
||||
name = "input-event"
|
||||
description = "cross-platform input-event types for input-capture / input-emulation"
|
||||
version = "0.3.0"
|
||||
version = "0.2.1"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
@@ -11,10 +11,10 @@ futures-core = "0.3.30"
|
||||
log = "0.4.22"
|
||||
num_enum = "0.7.2"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
thiserror = "2.0.0"
|
||||
thiserror = "1.0.61"
|
||||
|
||||
[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
|
||||
reis = { version = "0.4", optional = true }
|
||||
reis = { version = "0.2.0", optional = true }
|
||||
|
||||
[features]
|
||||
default = ["libei"]
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
[package]
|
||||
name = "lan-mouse-cli"
|
||||
description = "CLI Frontend for lan-mouse"
|
||||
version = "0.2.0"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
|
||||
[dependencies]
|
||||
futures = "0.3.30"
|
||||
lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
|
||||
lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
|
||||
tokio = { version = "1.32.0", features = [
|
||||
"io-util",
|
||||
"io-std",
|
||||
|
||||
@@ -274,17 +274,6 @@ impl Cli {
|
||||
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(..) => {}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[package]
|
||||
name = "lan-mouse-gtk"
|
||||
description = "GTK4 / Libadwaita Frontend for lan-mouse"
|
||||
version = "0.2.0"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
@@ -12,7 +12,7 @@ adw = { package = "libadwaita", version = "0.7.0", features = ["v1_1"] }
|
||||
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" }
|
||||
lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
|
||||
|
||||
[build-dependencies]
|
||||
glib-build-tools = { version = "0.20.0" }
|
||||
|
||||
@@ -1,101 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<interface>
|
||||
<requires lib="gtk" version="4.0"/>
|
||||
<requires lib="libadwaita" version="1.0"/>
|
||||
<template class="FingerprintWindow" parent="AdwWindow">
|
||||
<property name="modal">True</property>
|
||||
<property name="width-request">880</property>
|
||||
<property name="default-width">880</property>
|
||||
<property name="height-request">380</property>
|
||||
<property name="default-height">380</property>
|
||||
<property name="title" translatable="yes">Add Certificate Fingerprint</property>
|
||||
<property name="content">
|
||||
<object class="AdwToolbarView">
|
||||
<child type="top">
|
||||
<object class="AdwHeaderBar"/>
|
||||
</child>
|
||||
<property name="content">
|
||||
<object class="AdwClamp">
|
||||
<property name="maximum-size">770</property>
|
||||
<property name="tightening-threshold">0</property>
|
||||
<property name="child">
|
||||
<object class="GtkBox">
|
||||
<property name="orientation">vertical</property>
|
||||
<property name="spacing">18</property>
|
||||
<child>
|
||||
<object class="GtkLabel">
|
||||
<property name="label">The certificate fingerprint serves as a unique identifier for your device.</property>
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="GtkLabel">
|
||||
<property name="label">You can find it under the `General` section of the device you want to connect</property>
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="AdwPreferencesGroup">
|
||||
<property name="title">description</property>
|
||||
<child>
|
||||
<object class="AdwActionRow">
|
||||
<property name="child">
|
||||
<object class="GtkText" id="description">
|
||||
<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="enable-undo">True</property>
|
||||
<property name="hexpand">True</property>
|
||||
<property name="vexpand">True</property>
|
||||
<property name="max-length">0</property>
|
||||
</object>
|
||||
</property>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="AdwPreferencesGroup">
|
||||
<property name="title">sha256 fingerprint</property>
|
||||
<child>
|
||||
<object class="AdwActionRow">
|
||||
<property name="child">
|
||||
<object class="GtkText" id="fingerprint">
|
||||
<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="enable-undo">True</property>
|
||||
<property name="hexpand">True</property>
|
||||
<property name="vexpand">True</property>
|
||||
<property name="max-length">0</property>
|
||||
</object>
|
||||
</property>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="GtkBox">
|
||||
<property name="orientation">vertical</property>
|
||||
<property name="halign">center</property>
|
||||
<child>
|
||||
<object class="GtkButton" id="confirm_button">
|
||||
<signal name="clicked" handler="handle_confirm" swapped="true"/>
|
||||
<property name="label" translatable="yes">Confirm</property>
|
||||
<property name="can-shrink">True</property>
|
||||
<style>
|
||||
<class name="pill"/>
|
||||
<class name="suggested-action"/>
|
||||
</style>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</property>
|
||||
</object>
|
||||
</property>
|
||||
</object>
|
||||
</property>
|
||||
</template>
|
||||
</interface>
|
||||
@@ -1,16 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<interface>
|
||||
<template class="KeyRow" parent="AdwActionRow">
|
||||
<child type="prefix">
|
||||
<object class="GtkButton" id="delete_button">
|
||||
<property name="valign">center</property>
|
||||
<property name="halign">end</property>
|
||||
<property name="tooltip-text" translatable="yes">revoke authorization</property>
|
||||
<property name="icon-name">edit-delete-symbolic</property>
|
||||
<style>
|
||||
<class name="flat"/>
|
||||
</style>
|
||||
</object>
|
||||
</child>
|
||||
</template>
|
||||
</interface>
|
||||
@@ -2,9 +2,7 @@
|
||||
<gresources>
|
||||
<gresource prefix="/de/feschber/LanMouse">
|
||||
<file compressed="true" preprocess="xml-stripblanks">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>
|
||||
</gresource>
|
||||
<gresource prefix="/de/feschber/LanMouse/icons">
|
||||
<file compressed="true" preprocess="xml-stripblanks">de.feschber.LanMouse.svg</file>
|
||||
|
||||
@@ -121,31 +121,7 @@
|
||||
-->
|
||||
<child>
|
||||
<object class="AdwActionRow">
|
||||
<property name="title">hostname &amp; port</property>
|
||||
<child>
|
||||
<object class="GtkButton" id="copy-hostname-button">
|
||||
<!--<property name="icon-name">edit-copy-symbolic</property>-->
|
||||
<property name="valign">center</property>
|
||||
<signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
|
||||
<child>
|
||||
<object class="GtkBox">
|
||||
<property name="spacing">30</property>
|
||||
<child>
|
||||
<object class="GtkLabel" id="hostname_label">
|
||||
<property name="label"><span font_style="italic" font_weight="light" foreground="darkgrey">could not determine hostname</span></property>
|
||||
<property name="use-markup">true</property>
|
||||
<property name="valign">center</property>
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="GtkImage" id="hostname_copy_icon">
|
||||
<property name="icon-name">edit-copy-symbolic</property>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</child>
|
||||
<property name="title">port</property>
|
||||
<child>
|
||||
<object class="GtkEntry" id="port_entry">
|
||||
<property name="max-width-chars">5</property>
|
||||
@@ -184,14 +160,20 @@
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="AdwActionRow" id="fingerprint_row">
|
||||
<property name="title">certificate fingerprint</property>
|
||||
<property name="icon-name">auth-fingerprint-symbolic</property>
|
||||
<object class="AdwActionRow">
|
||||
<property name="title">hostname</property>
|
||||
<child>
|
||||
<object class="GtkButton" id="copy-fingerprint-button">
|
||||
<object class="GtkLabel" id="hostname_label">
|
||||
<property name="label"><span font_style="italic" font_weight="light" foreground="darkgrey">could not determine hostname</span></property>
|
||||
<property name="use-markup">true</property>
|
||||
<property name="valign">center</property>
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="GtkButton" id="copy-hostname-button">
|
||||
<property name="icon-name">edit-copy-symbolic</property>
|
||||
<property name="valign">center</property>
|
||||
<signal name="clicked" handler="handle_copy_fingerprint" swapped="true"/>
|
||||
<signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
@@ -231,39 +213,6 @@
|
||||
</child>
|
||||
</object>
|
||||
</child>
|
||||
<child>
|
||||
<object class="AdwPreferencesGroup">
|
||||
<property name="title" translatable="yes">Incoming Connections</property>
|
||||
<property name="header-suffix">
|
||||
<object class="GtkButton">
|
||||
<signal name="clicked" handler="handle_add_cert_fingerprint" swapped="true"/>
|
||||
<property name="child">
|
||||
<object class="AdwButtonContent">
|
||||
<property name="icon-name">auth-fingerprint-symbolic</property>
|
||||
<property name="label" translatable="yes">Authorize</property>
|
||||
</object>
|
||||
</property>
|
||||
<style>
|
||||
<class name="flat"/>
|
||||
</style>
|
||||
</object>
|
||||
</property>
|
||||
<child>
|
||||
<object class="GtkListBox" id="authorized_list">
|
||||
<property name="selection-mode">none</property>
|
||||
<child type="placeholder">
|
||||
<object class="AdwActionRow" id="authorized_placeholder">
|
||||
<property name="title">no devices registered!</property>
|
||||
<property name="subtitle">authorize a new device via the "Authorize" button</property>
|
||||
</object>
|
||||
</child>
|
||||
<style>
|
||||
<class name="boxed-list" />
|
||||
</style>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</child>
|
||||
</object>
|
||||
</property>
|
||||
</object>
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
mod imp;
|
||||
|
||||
use glib::Object;
|
||||
use gtk::{gio, glib};
|
||||
|
||||
glib::wrapper! {
|
||||
pub struct FingerprintWindow(ObjectSubclass<imp::FingerprintWindow>)
|
||||
@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 FingerprintWindow {
|
||||
pub(crate) fn new() -> Self {
|
||||
let window: Self = Object::builder().build();
|
||||
window
|
||||
}
|
||||
}
|
||||
@@ -1,64 +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, Text,
|
||||
};
|
||||
|
||||
#[derive(CompositeTemplate, Default)]
|
||||
#[template(resource = "/de/feschber/LanMouse/fingerprint_window.ui")]
|
||||
pub struct FingerprintWindow {
|
||||
#[template_child]
|
||||
pub description: TemplateChild<Text>,
|
||||
#[template_child]
|
||||
pub fingerprint: TemplateChild<Text>,
|
||||
#[template_child]
|
||||
pub confirm_button: TemplateChild<Button>,
|
||||
}
|
||||
|
||||
#[glib::object_subclass]
|
||||
impl ObjectSubclass for FingerprintWindow {
|
||||
const NAME: &'static str = "FingerprintWindow";
|
||||
const ABSTRACT: bool = false;
|
||||
|
||||
type Type = super::FingerprintWindow;
|
||||
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 FingerprintWindow {
|
||||
#[template_callback]
|
||||
fn handle_confirm(&self, _button: Button) {
|
||||
let desc = self.description.text().as_str().trim().to_owned();
|
||||
let fp = self.fingerprint.text().as_str().trim().to_owned();
|
||||
self.obj().emit_by_name("confirm-clicked", &[&desc, &fp])
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectImpl for FingerprintWindow {
|
||||
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(), String::static_type()])
|
||||
.build()]
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl WidgetImpl for FingerprintWindow {}
|
||||
impl WindowImpl for FingerprintWindow {}
|
||||
impl ApplicationWindowImpl for FingerprintWindow {}
|
||||
impl AdwWindowImpl for FingerprintWindow {}
|
||||
@@ -1,25 +0,0 @@
|
||||
mod imp;
|
||||
|
||||
use adw::subclass::prelude::*;
|
||||
use gtk::glib::{self, Object};
|
||||
|
||||
glib::wrapper! {
|
||||
pub struct KeyObject(ObjectSubclass<imp::KeyObject>);
|
||||
}
|
||||
|
||||
impl KeyObject {
|
||||
pub fn new(desc: String, fp: String) -> Self {
|
||||
Object::builder()
|
||||
.property("description", desc)
|
||||
.property("fingerprint", fp)
|
||||
.build()
|
||||
}
|
||||
|
||||
pub fn get_description(&self) -> String {
|
||||
self.imp().description.borrow().clone()
|
||||
}
|
||||
|
||||
pub fn get_fingerprint(&self) -> String {
|
||||
self.imp().fingerprint.borrow().clone()
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
use std::cell::RefCell;
|
||||
|
||||
use glib::Properties;
|
||||
use gtk::glib;
|
||||
use gtk::prelude::*;
|
||||
use gtk::subclass::prelude::*;
|
||||
|
||||
#[derive(Properties, Default)]
|
||||
#[properties(wrapper_type = super::KeyObject)]
|
||||
pub struct KeyObject {
|
||||
#[property(name = "description", get, set, type = String)]
|
||||
pub description: RefCell<String>,
|
||||
#[property(name = "fingerprint", get, set, type = String)]
|
||||
pub fingerprint: RefCell<String>,
|
||||
}
|
||||
|
||||
#[glib::object_subclass]
|
||||
impl ObjectSubclass for KeyObject {
|
||||
const NAME: &'static str = "KeyObject";
|
||||
type Type = super::KeyObject;
|
||||
}
|
||||
|
||||
#[glib::derived_properties]
|
||||
impl ObjectImpl for KeyObject {}
|
||||
@@ -1,48 +0,0 @@
|
||||
mod imp;
|
||||
|
||||
use adw::prelude::*;
|
||||
use adw::subclass::prelude::*;
|
||||
use gtk::glib::{self, Object};
|
||||
|
||||
use super::KeyObject;
|
||||
|
||||
glib::wrapper! {
|
||||
pub struct KeyRow(ObjectSubclass<imp::KeyRow>)
|
||||
@extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
|
||||
@implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
|
||||
}
|
||||
|
||||
impl Default for KeyRow {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl KeyRow {
|
||||
pub fn new() -> Self {
|
||||
Object::builder().build()
|
||||
}
|
||||
|
||||
pub fn bind(&self, key_object: &KeyObject) {
|
||||
let mut bindings = self.imp().bindings.borrow_mut();
|
||||
|
||||
let title_binding = key_object
|
||||
.bind_property("description", self, "title")
|
||||
.sync_create()
|
||||
.build();
|
||||
|
||||
let subtitle_binding = key_object
|
||||
.bind_property("fingerprint", self, "subtitle")
|
||||
.sync_create()
|
||||
.build();
|
||||
|
||||
bindings.push(title_binding);
|
||||
bindings.push(subtitle_binding);
|
||||
}
|
||||
|
||||
pub fn unbind(&self) {
|
||||
for binding in self.imp().bindings.borrow_mut().drain(..) {
|
||||
binding.unbind();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
use std::cell::RefCell;
|
||||
|
||||
use adw::subclass::prelude::*;
|
||||
use adw::{prelude::*, ActionRow};
|
||||
use glib::{subclass::InitializingObject, Binding};
|
||||
use gtk::glib::clone;
|
||||
use gtk::glib::subclass::Signal;
|
||||
use gtk::{glib, Button, CompositeTemplate};
|
||||
use std::sync::OnceLock;
|
||||
|
||||
#[derive(CompositeTemplate, Default)]
|
||||
#[template(resource = "/de/feschber/LanMouse/key_row.ui")]
|
||||
pub struct KeyRow {
|
||||
#[template_child]
|
||||
pub delete_button: TemplateChild<gtk::Button>,
|
||||
pub bindings: RefCell<Vec<Binding>>,
|
||||
}
|
||||
|
||||
#[glib::object_subclass]
|
||||
impl ObjectSubclass for KeyRow {
|
||||
// `NAME` needs to match `class` attribute of template
|
||||
const NAME: &'static str = "KeyRow";
|
||||
const ABSTRACT: bool = false;
|
||||
|
||||
type Type = super::KeyRow;
|
||||
type ParentType = ActionRow;
|
||||
|
||||
fn class_init(klass: &mut Self::Class) {
|
||||
klass.bind_template();
|
||||
klass.bind_template_callbacks();
|
||||
}
|
||||
|
||||
fn instance_init(obj: &InitializingObject<Self>) {
|
||||
obj.init_template();
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectImpl for KeyRow {
|
||||
fn constructed(&self) {
|
||||
self.parent_constructed();
|
||||
self.delete_button.connect_clicked(clone!(
|
||||
#[weak(rename_to = row)]
|
||||
self,
|
||||
move |button| {
|
||||
row.handle_delete(button);
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
fn signals() -> &'static [glib::subclass::Signal] {
|
||||
static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
|
||||
SIGNALS.get_or_init(|| vec![Signal::builder("request-delete").build()])
|
||||
}
|
||||
}
|
||||
|
||||
#[gtk::template_callbacks]
|
||||
impl KeyRow {
|
||||
#[template_callback]
|
||||
fn handle_delete(&self, _button: &Button) {
|
||||
self.obj().emit_by_name::<()>("request-delete", &[]);
|
||||
}
|
||||
}
|
||||
|
||||
impl WidgetImpl for KeyRow {}
|
||||
impl BoxImpl for KeyRow {}
|
||||
impl ListBoxRowImpl for KeyRow {}
|
||||
impl PreferencesRowImpl for KeyRow {}
|
||||
impl ActionRowImpl for KeyRow {}
|
||||
@@ -1,8 +1,5 @@
|
||||
mod client_object;
|
||||
mod client_row;
|
||||
mod fingerprint_window;
|
||||
mod key_object;
|
||||
mod key_row;
|
||||
mod window;
|
||||
|
||||
use std::{env, process, str};
|
||||
@@ -18,7 +15,6 @@ use gtk::{
|
||||
use gtk::{gio, glib, prelude::ApplicationExt};
|
||||
|
||||
use self::client_object::ClientObject;
|
||||
use self::key_object::KeyObject;
|
||||
|
||||
pub fn run() -> glib::ExitCode {
|
||||
log::debug!("running gtk frontend");
|
||||
@@ -136,14 +132,6 @@ 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::IncomingConnected(..) => {}
|
||||
FrontendEvent::IncomingDisconnected(..) => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,7 +1,5 @@
|
||||
mod imp;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use adw::prelude::*;
|
||||
use adw::subclass::prelude::*;
|
||||
use glib::{clone, Object};
|
||||
@@ -16,8 +14,6 @@ use lan_mouse_ipc::{
|
||||
DEFAULT_PORT,
|
||||
};
|
||||
|
||||
use crate::{fingerprint_window::FingerprintWindow, key_object::KeyObject, key_row::KeyRow};
|
||||
|
||||
use super::{client_object::ClientObject, client_row::ClientRow};
|
||||
|
||||
glib::wrapper! {
|
||||
@@ -46,55 +42,10 @@ impl Window {
|
||||
.expect("Could not get clients")
|
||||
}
|
||||
|
||||
pub fn authorized(&self) -> gio::ListStore {
|
||||
self.imp()
|
||||
.authorized
|
||||
.borrow()
|
||||
.clone()
|
||||
.expect("Could not get authorized")
|
||||
}
|
||||
|
||||
fn client_by_idx(&self, idx: u32) -> Option<ClientObject> {
|
||||
self.clients().item(idx).map(|o| o.downcast().unwrap())
|
||||
}
|
||||
|
||||
fn authorized_by_idx(&self, idx: u32) -> Option<KeyObject> {
|
||||
self.authorized().item(idx).map(|o| o.downcast().unwrap())
|
||||
}
|
||||
|
||||
fn setup_authorized(&self) {
|
||||
let store = gio::ListStore::new::<KeyObject>();
|
||||
self.imp().authorized.replace(Some(store));
|
||||
let selection_model = NoSelection::new(Some(self.authorized()));
|
||||
self.imp().authorized_list.bind_model(
|
||||
Some(&selection_model),
|
||||
clone!(
|
||||
#[weak(rename_to = window)]
|
||||
self,
|
||||
#[upgrade_or_panic]
|
||||
move |obj| {
|
||||
let key_obj = obj.downcast_ref().expect("object of type `KeyObject`");
|
||||
let row = window.create_key_row(key_obj);
|
||||
row.connect_closure(
|
||||
"request-delete",
|
||||
false,
|
||||
closure_local!(
|
||||
#[strong]
|
||||
window,
|
||||
move |row: KeyRow| {
|
||||
if let Some(key_obj) = window.authorized_by_idx(row.index() as u32)
|
||||
{
|
||||
window.request_fingerprint_remove(key_obj.get_fingerprint());
|
||||
}
|
||||
}
|
||||
),
|
||||
);
|
||||
row.upcast()
|
||||
}
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
fn setup_clients(&self) {
|
||||
let model = gio::ListStore::new::<ClientObject>();
|
||||
self.imp().clients.replace(Some(model));
|
||||
@@ -163,8 +114,7 @@ impl Window {
|
||||
/// workaround for a bug in libadwaita that shows an ugly line beneath
|
||||
/// the last element if a placeholder is set.
|
||||
/// https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/6308
|
||||
pub fn update_placeholder_visibility(&self) {
|
||||
let visible = self.clients().n_items() == 0;
|
||||
pub fn set_placeholder_visible(&self, visible: bool) {
|
||||
let placeholder = self.imp().client_placeholder.get();
|
||||
self.imp().client_list.set_placeholder(match visible {
|
||||
true => Some(&placeholder),
|
||||
@@ -172,15 +122,6 @@ impl Window {
|
||||
});
|
||||
}
|
||||
|
||||
pub fn update_auth_placeholder_visibility(&self) {
|
||||
let visible = self.authorized().n_items() == 0;
|
||||
let placeholder = self.imp().authorized_placeholder.get();
|
||||
self.imp().authorized_list.set_placeholder(match visible {
|
||||
true => Some(&placeholder),
|
||||
false => None,
|
||||
});
|
||||
}
|
||||
|
||||
fn setup_icon(&self) {
|
||||
self.set_icon_name(Some("de.feschber.LanMouse"));
|
||||
}
|
||||
@@ -191,16 +132,10 @@ impl Window {
|
||||
row
|
||||
}
|
||||
|
||||
fn create_key_row(&self, key_object: &KeyObject) -> KeyRow {
|
||||
let row = KeyRow::new();
|
||||
row.bind(key_object);
|
||||
row
|
||||
}
|
||||
|
||||
pub fn new_client(&self, handle: ClientHandle, client: ClientConfig, state: ClientState) {
|
||||
let client = ClientObject::new(handle, client, state.clone());
|
||||
self.clients().append(&client);
|
||||
self.update_placeholder_visibility();
|
||||
self.set_placeholder_visible(false);
|
||||
self.update_dns_state(handle, !state.ips.is_empty());
|
||||
}
|
||||
|
||||
@@ -222,7 +157,7 @@ impl Window {
|
||||
|
||||
self.clients().remove(idx as u32);
|
||||
if self.clients().n_items() == 0 {
|
||||
self.update_placeholder_visibility();
|
||||
self.set_placeholder_visible(true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -351,32 +286,6 @@ impl Window {
|
||||
self.request(FrontendRequest::Delete(client.handle()));
|
||||
}
|
||||
|
||||
pub fn open_fingerprint_dialog(&self) {
|
||||
let window = FingerprintWindow::new();
|
||||
window.set_transient_for(Some(self));
|
||||
window.connect_closure(
|
||||
"confirm-clicked",
|
||||
false,
|
||||
closure_local!(
|
||||
#[strong(rename_to = parent)]
|
||||
self,
|
||||
move |w: FingerprintWindow, desc: String, fp: String| {
|
||||
parent.request_fingerprint_add(desc, fp);
|
||||
w.close();
|
||||
}
|
||||
),
|
||||
);
|
||||
window.present();
|
||||
}
|
||||
|
||||
pub fn request_fingerprint_add(&self, desc: String, fp: String) {
|
||||
self.request(FrontendRequest::AuthorizeKey(desc, fp));
|
||||
}
|
||||
|
||||
pub fn request_fingerprint_remove(&self, fp: String) {
|
||||
self.request(FrontendRequest::RemoveAuthorizedKey(fp));
|
||||
}
|
||||
|
||||
pub fn request(&self, request: FrontendRequest) {
|
||||
let mut requester = self.imp().frontend_request_writer.borrow_mut();
|
||||
let requester = requester.as_mut().unwrap();
|
||||
@@ -410,20 +319,4 @@ impl Window {
|
||||
.capture_emulation_group
|
||||
.set_visible(!capture || !emulation);
|
||||
}
|
||||
|
||||
pub(crate) fn set_authorized_keys(&self, fingerprints: HashMap<String, String>) {
|
||||
let authorized = self.authorized();
|
||||
// clear list
|
||||
authorized.remove_all();
|
||||
// insert fingerprints
|
||||
for (fingerprint, description) in fingerprints {
|
||||
let key_obj = KeyObject::new(description, fingerprint);
|
||||
authorized.append(&key_obj);
|
||||
}
|
||||
self.update_auth_placeholder_visibility();
|
||||
}
|
||||
|
||||
pub(crate) fn set_pk_fp(&self, fingerprint: &str) {
|
||||
self.imp().fingerprint_row.set_subtitle(fingerprint);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,17 +4,13 @@ use adw::subclass::prelude::*;
|
||||
use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
|
||||
use glib::subclass::InitializingObject;
|
||||
use gtk::glib::clone;
|
||||
use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Image, Label, ListBox};
|
||||
use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};
|
||||
|
||||
use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};
|
||||
|
||||
#[derive(CompositeTemplate, Default)]
|
||||
#[template(resource = "/de/feschber/LanMouse/window.ui")]
|
||||
pub struct Window {
|
||||
#[template_child]
|
||||
pub authorized_placeholder: TemplateChild<ActionRow>,
|
||||
#[template_child]
|
||||
pub fingerprint_row: TemplateChild<ActionRow>,
|
||||
#[template_child]
|
||||
pub port_edit_apply: TemplateChild<Button>,
|
||||
#[template_child]
|
||||
@@ -26,8 +22,6 @@ pub struct Window {
|
||||
#[template_child]
|
||||
pub port_entry: TemplateChild<Entry>,
|
||||
#[template_child]
|
||||
pub hostname_copy_icon: TemplateChild<Image>,
|
||||
#[template_child]
|
||||
pub hostname_label: TemplateChild<Label>,
|
||||
#[template_child]
|
||||
pub toast_overlay: TemplateChild<ToastOverlay>,
|
||||
@@ -41,10 +35,7 @@ pub struct Window {
|
||||
pub input_emulation_button: TemplateChild<Button>,
|
||||
#[template_child]
|
||||
pub input_capture_button: TemplateChild<Button>,
|
||||
#[template_child]
|
||||
pub authorized_list: TemplateChild<ListBox>,
|
||||
pub clients: RefCell<Option<gio::ListStore>>,
|
||||
pub authorized: RefCell<Option<gio::ListStore>>,
|
||||
pub frontend_request_writer: RefCell<Option<FrontendRequestWriter>>,
|
||||
pub port: Cell<u16>,
|
||||
pub capture_active: Cell<bool>,
|
||||
@@ -78,45 +69,25 @@ impl Window {
|
||||
}
|
||||
|
||||
#[template_callback]
|
||||
fn handle_copy_hostname(&self, _: &Button) {
|
||||
fn handle_copy_hostname(&self, button: &Button) {
|
||||
if let Ok(hostname) = hostname::get() {
|
||||
let display = gdk::Display::default().unwrap();
|
||||
let clipboard = display.clipboard();
|
||||
clipboard.set_text(hostname.to_str().expect("hostname: invalid utf8"));
|
||||
let icon = self.hostname_copy_icon.clone();
|
||||
icon.set_icon_name(Some("emblem-ok-symbolic"));
|
||||
icon.set_css_classes(&["success"]);
|
||||
button.set_icon_name("emblem-ok-symbolic");
|
||||
button.set_css_classes(&["success"]);
|
||||
glib::spawn_future_local(clone!(
|
||||
#[weak]
|
||||
icon,
|
||||
button,
|
||||
async move {
|
||||
glib::timeout_future_seconds(1).await;
|
||||
icon.set_icon_name(Some("edit-copy-symbolic"));
|
||||
icon.set_css_classes(&[]);
|
||||
button.set_icon_name("edit-copy-symbolic");
|
||||
button.set_css_classes(&[]);
|
||||
}
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
#[template_callback]
|
||||
fn handle_copy_fingerprint(&self, button: &Button) {
|
||||
let fingerprint: String = self.fingerprint_row.property("subtitle");
|
||||
let display = gdk::Display::default().unwrap();
|
||||
let clipboard = display.clipboard();
|
||||
clipboard.set_text(&fingerprint);
|
||||
button.set_icon_name("emblem-ok-symbolic");
|
||||
button.set_css_classes(&["success"]);
|
||||
glib::spawn_future_local(clone!(
|
||||
#[weak]
|
||||
button,
|
||||
async move {
|
||||
glib::timeout_future_seconds(1).await;
|
||||
button.set_icon_name("edit-copy-symbolic");
|
||||
button.set_css_classes(&[]);
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
#[template_callback]
|
||||
fn handle_port_changed(&self, _entry: &Entry) {
|
||||
self.port_edit_apply.set_visible(true);
|
||||
@@ -147,11 +118,6 @@ impl Window {
|
||||
self.obj().request_capture();
|
||||
}
|
||||
|
||||
#[template_callback]
|
||||
fn handle_add_cert_fingerprint(&self, _button: &Button) {
|
||||
self.obj().open_fingerprint_dialog();
|
||||
}
|
||||
|
||||
pub fn set_port(&self, port: u16) {
|
||||
self.port.set(port);
|
||||
if port == DEFAULT_PORT {
|
||||
@@ -175,7 +141,6 @@ impl ObjectImpl for Window {
|
||||
let obj = self.obj();
|
||||
obj.setup_icon();
|
||||
obj.setup_clients();
|
||||
obj.setup_authorized();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[package]
|
||||
name = "lan-mouse-ipc"
|
||||
description = "library for communication between lan-mouse service and frontends"
|
||||
version = "0.2.0"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
@@ -11,6 +11,6 @@ futures = "0.3.30"
|
||||
log = "0.4.22"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
serde_json = "1.0.107"
|
||||
thiserror = "2.0.0"
|
||||
thiserror = "1.0.63"
|
||||
tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
|
||||
tokio-stream = { version = "0.1.15", features = ["io-util"] }
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use std::{
|
||||
collections::{HashMap, HashSet},
|
||||
collections::HashSet,
|
||||
env::VarError,
|
||||
fmt::Display,
|
||||
io,
|
||||
@@ -33,7 +33,7 @@ pub enum ConnectionError {
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum IpcListenerCreationError {
|
||||
pub enum ListenerCreationError {
|
||||
#[error("could not determine socket-path: `{0}`")]
|
||||
SocketPath(#[from] SocketPathError),
|
||||
#[error("service already running!")]
|
||||
@@ -51,7 +51,7 @@ pub enum IpcError {
|
||||
#[error(transparent)]
|
||||
Connection(#[from] ConnectionError),
|
||||
#[error(transparent)]
|
||||
Listen(#[from] IpcListenerCreationError),
|
||||
Listen(#[from] ListenerCreationError),
|
||||
}
|
||||
|
||||
pub const DEFAULT_PORT: u16 = 4242;
|
||||
@@ -65,17 +65,6 @@ pub enum Position {
|
||||
Bottom,
|
||||
}
|
||||
|
||||
impl Position {
|
||||
pub fn opposite(&self) -> Self {
|
||||
match self {
|
||||
Position::Left => Position::Right,
|
||||
Position::Right => Position::Left,
|
||||
Position::Top => Position::Bottom,
|
||||
Position::Bottom => Position::Top,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
#[error("not a valid position: {pos}")]
|
||||
pub struct PositionParseError {
|
||||
@@ -161,7 +150,7 @@ pub struct ClientState {
|
||||
/// This should generally be the socket address where data
|
||||
/// was last received from.
|
||||
pub active_addr: Option<SocketAddr>,
|
||||
/// tracks whether or not the client is available for emulation
|
||||
/// tracks whether or not the client is responding to pings
|
||||
pub alive: bool,
|
||||
/// ips from dns
|
||||
pub dns_ips: Vec<IpAddr>,
|
||||
@@ -197,14 +186,6 @@ pub enum FrontendEvent {
|
||||
CaptureStatus(Status),
|
||||
/// emulation status
|
||||
EmulationStatus(Status),
|
||||
/// authorized public key fingerprints have been updated
|
||||
AuthorizedUpdated(HashMap<String, String>),
|
||||
/// public key fingerprint of this device
|
||||
PublicKeyFingerprint(String),
|
||||
/// incoming connected
|
||||
IncomingConnected(String, SocketAddr, Position),
|
||||
/// incoming disconnected
|
||||
IncomingDisconnected(SocketAddr),
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
|
||||
@@ -237,13 +218,9 @@ pub enum FrontendRequest {
|
||||
EnableEmulation,
|
||||
/// synchronize all state
|
||||
Sync,
|
||||
/// authorize fingerprint (description, fingerprint)
|
||||
AuthorizeKey(String, String),
|
||||
/// remove fingerprint (fingerprint)
|
||||
RemoveAuthorizedKey(String),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]
|
||||
#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
|
||||
pub enum Status {
|
||||
#[default]
|
||||
Disabled,
|
||||
|
||||
@@ -20,7 +20,7 @@ use tokio::net::TcpListener;
|
||||
#[cfg(windows)]
|
||||
use tokio::net::TcpStream;
|
||||
|
||||
use crate::{FrontendEvent, FrontendRequest, IpcError, IpcListenerCreationError};
|
||||
use crate::{FrontendEvent, FrontendRequest, IpcError, ListenerCreationError};
|
||||
|
||||
pub struct AsyncFrontendListener {
|
||||
#[cfg(windows)]
|
||||
@@ -40,7 +40,7 @@ pub struct AsyncFrontendListener {
|
||||
}
|
||||
|
||||
impl AsyncFrontendListener {
|
||||
pub async fn new() -> Result<Self, IpcListenerCreationError> {
|
||||
pub async fn new() -> Result<Self, ListenerCreationError> {
|
||||
#[cfg(unix)]
|
||||
let (socket_path, listener) = {
|
||||
let socket_path = crate::default_socket_path()?;
|
||||
@@ -51,7 +51,7 @@ impl AsyncFrontendListener {
|
||||
// of lan-mouse is already running
|
||||
match UnixStream::connect(&socket_path).await {
|
||||
// connected -> lan-mouse is already running
|
||||
Ok(_) => return Err(IpcListenerCreationError::AlreadyRunning),
|
||||
Ok(_) => return Err(ListenerCreationError::AlreadyRunning),
|
||||
// lan-mouse is not running but a socket was left behind
|
||||
Err(e) => {
|
||||
log::debug!("{socket_path:?}: {e} - removing left behind socket");
|
||||
@@ -63,9 +63,9 @@ impl AsyncFrontendListener {
|
||||
Ok(ls) => ls,
|
||||
// some other lan-mouse instance has bound the socket in the meantime
|
||||
Err(e) if e.kind() == ErrorKind::AddrInUse => {
|
||||
return Err(IpcListenerCreationError::AlreadyRunning)
|
||||
return Err(ListenerCreationError::AlreadyRunning)
|
||||
}
|
||||
Err(e) => return Err(IpcListenerCreationError::Bind(e)),
|
||||
Err(e) => return Err(ListenerCreationError::Bind(e)),
|
||||
};
|
||||
(socket_path, listener)
|
||||
};
|
||||
@@ -75,9 +75,9 @@ impl AsyncFrontendListener {
|
||||
Ok(ls) => ls,
|
||||
// some other lan-mouse instance has bound the socket in the meantime
|
||||
Err(e) if e.kind() == ErrorKind::AddrInUse => {
|
||||
return Err(IpcListenerCreationError::AlreadyRunning)
|
||||
return Err(ListenerCreationError::AlreadyRunning)
|
||||
}
|
||||
Err(e) => return Err(IpcListenerCreationError::Bind(e)),
|
||||
Err(e) => return Err(ListenerCreationError::Bind(e)),
|
||||
};
|
||||
|
||||
let adapter = Self {
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
[package]
|
||||
name = "lan-mouse-proto"
|
||||
description = "network protocol for lan-mouse"
|
||||
version = "0.2.0"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://github.com/feschber/lan-mouse"
|
||||
|
||||
[dependencies]
|
||||
num_enum = "0.7.2"
|
||||
thiserror = "2.0.0"
|
||||
input-event = { path = "../input-event", version = "0.3.0" }
|
||||
thiserror = "1.0.61"
|
||||
input-event = { path = "../input-event", version = "0.2.1" }
|
||||
paste = "1.0"
|
||||
|
||||
@@ -2,7 +2,7 @@ use input_event::{Event as InputEvent, KeyboardEvent, PointerEvent};
|
||||
use num_enum::{IntoPrimitive, TryFromPrimitive, TryFromPrimitiveError};
|
||||
use paste::paste;
|
||||
use std::{
|
||||
fmt::{Debug, Display, Formatter},
|
||||
fmt::{Debug, Display},
|
||||
mem::size_of,
|
||||
};
|
||||
use thiserror::Error;
|
||||
@@ -18,39 +18,14 @@ pub enum ProtocolError {
|
||||
/// event type does not exist
|
||||
#[error("invalid event id: `{0}`")]
|
||||
InvalidEventId(#[from] TryFromPrimitiveError<EventType>),
|
||||
/// position type does not exist
|
||||
#[error("invalid event id: `{0}`")]
|
||||
InvalidPosition(#[from] TryFromPrimitiveError<Position>),
|
||||
}
|
||||
|
||||
/// Position of a client
|
||||
#[derive(Clone, Copy, Debug, TryFromPrimitive, IntoPrimitive)]
|
||||
#[repr(u8)]
|
||||
pub enum Position {
|
||||
Left,
|
||||
Right,
|
||||
Top,
|
||||
Bottom,
|
||||
}
|
||||
|
||||
impl Display for Position {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
||||
let pos = match self {
|
||||
Position::Left => "left",
|
||||
Position::Right => "right",
|
||||
Position::Top => "top",
|
||||
Position::Bottom => "bottom",
|
||||
};
|
||||
write!(f, "{pos}")
|
||||
}
|
||||
}
|
||||
|
||||
/// main lan-mouse protocol event type
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum ProtoEvent {
|
||||
/// notify a client that the cursor entered its region at the given position
|
||||
/// notify a client that the cursor entered its region
|
||||
/// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
|
||||
Enter(Position),
|
||||
Enter(u32),
|
||||
/// notify a client that the cursor left its region
|
||||
/// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
|
||||
Leave(u32),
|
||||
@@ -61,25 +36,19 @@ pub enum ProtoEvent {
|
||||
/// Ping event for tracking unresponsive clients.
|
||||
/// A client has to respond with [`ProtoEvent::Pong`].
|
||||
Ping,
|
||||
/// Response to [`ProtoEvent::Ping`], true if emulation is enabled / available
|
||||
Pong(bool),
|
||||
/// Response to [`ProtoEvent::Ping`]
|
||||
Pong,
|
||||
}
|
||||
|
||||
impl Display for ProtoEvent {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
ProtoEvent::Enter(s) => write!(f, "Enter({s})"),
|
||||
ProtoEvent::Leave(s) => write!(f, "Leave({s})"),
|
||||
ProtoEvent::Ack(s) => write!(f, "Ack({s})"),
|
||||
ProtoEvent::Input(e) => write!(f, "{e}"),
|
||||
ProtoEvent::Ping => write!(f, "ping"),
|
||||
ProtoEvent::Pong(alive) => {
|
||||
write!(
|
||||
f,
|
||||
"pong: {}",
|
||||
if *alive { "alive" } else { "not available" }
|
||||
)
|
||||
}
|
||||
ProtoEvent::Pong => write!(f, "pong"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -116,7 +85,7 @@ impl ProtoEvent {
|
||||
},
|
||||
},
|
||||
ProtoEvent::Ping => EventType::Ping,
|
||||
ProtoEvent::Pong(_) => EventType::Pong,
|
||||
ProtoEvent::Pong => EventType::Pong,
|
||||
ProtoEvent::Enter(_) => EventType::Enter,
|
||||
ProtoEvent::Leave(_) => EventType::Leave,
|
||||
ProtoEvent::Ack(_) => EventType::Ack,
|
||||
@@ -170,8 +139,8 @@ impl TryFrom<[u8; MAX_EVENT_SIZE]> for ProtoEvent {
|
||||
},
|
||||
))),
|
||||
EventType::Ping => Ok(Self::Ping),
|
||||
EventType::Pong => Ok(Self::Pong(decode_u8(&mut buf)? != 0)),
|
||||
EventType::Enter => Ok(Self::Enter(decode_u8(&mut buf)?.try_into()?)),
|
||||
EventType::Pong => Ok(Self::Pong),
|
||||
EventType::Enter => Ok(Self::Enter(decode_u32(&mut buf)?)),
|
||||
EventType::Leave => Ok(Self::Leave(decode_u32(&mut buf)?)),
|
||||
EventType::Ack => Ok(Self::Ack(decode_u32(&mut buf)?)),
|
||||
}
|
||||
@@ -234,8 +203,8 @@ impl From<ProtoEvent> for ([u8; MAX_EVENT_SIZE], usize) {
|
||||
},
|
||||
},
|
||||
ProtoEvent::Ping => {}
|
||||
ProtoEvent::Pong(alive) => encode_u8(buf, len, alive as u8),
|
||||
ProtoEvent::Enter(pos) => encode_u8(buf, len, pos as u8),
|
||||
ProtoEvent::Pong => {}
|
||||
ProtoEvent::Enter(serial) => encode_u32(buf, len, serial),
|
||||
ProtoEvent::Leave(serial) => encode_u32(buf, len, serial),
|
||||
ProtoEvent::Ack(serial) => encode_u32(buf, len, serial),
|
||||
}
|
||||
|
||||
@@ -44,9 +44,6 @@ rustPlatform.buildRustPackage {
|
||||
postInstall = ''
|
||||
wrapProgram "$out/bin/lan-mouse" \
|
||||
--set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
|
||||
|
||||
install -Dm444 *.desktop -t $out/share/applications
|
||||
install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps
|
||||
'';
|
||||
|
||||
meta = with lib; {
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 57 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 58 KiB |
418
src/capture.rs
418
src/capture.rs
@@ -1,418 +0,0 @@
|
||||
use std::{
|
||||
cell::{Cell, RefCell},
|
||||
rc::Rc,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use futures::StreamExt;
|
||||
use input_capture::{
|
||||
CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
|
||||
};
|
||||
use input_event::scancode;
|
||||
use lan_mouse_proto::ProtoEvent;
|
||||
use local_channel::mpsc::{channel, Receiver, Sender};
|
||||
use tokio::task::{spawn_local, JoinHandle};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::connect::LanMouseConnection;
|
||||
|
||||
pub(crate) struct Capture {
|
||||
cancellation_token: CancellationToken,
|
||||
request_tx: Sender<CaptureRequest>,
|
||||
task: JoinHandle<()>,
|
||||
event_rx: Receiver<ICaptureEvent>,
|
||||
}
|
||||
|
||||
pub(crate) enum ICaptureEvent {
|
||||
/// a client was entered
|
||||
CaptureBegin(CaptureHandle),
|
||||
/// capture disabled
|
||||
CaptureDisabled,
|
||||
/// capture disabled
|
||||
CaptureEnabled,
|
||||
/// A (new) client was entered.
|
||||
/// In contrast to [`ICaptureEvent::CaptureBegin`] this
|
||||
/// event is only triggered when the capture was
|
||||
/// explicitly released in the meantime by
|
||||
/// either the remote client leaving its device region,
|
||||
/// a new device entering the screen or the release bind.
|
||||
ClientEntered(u64),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) enum CaptureType {
|
||||
/// a normal input capture
|
||||
Default,
|
||||
/// A capture only interested in [`CaptureEvent::Begin`] events.
|
||||
/// The capture is released immediately, if there is no
|
||||
/// Default capture at the same position.
|
||||
EnterOnly,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
enum CaptureRequest {
|
||||
/// capture must release the mouse
|
||||
Release,
|
||||
/// add a capture client
|
||||
Create(CaptureHandle, Position, CaptureType),
|
||||
/// destory a capture client
|
||||
Destroy(CaptureHandle),
|
||||
/// reenable input capture
|
||||
Reenable,
|
||||
}
|
||||
|
||||
impl Capture {
|
||||
pub(crate) fn new(
|
||||
backend: Option<input_capture::Backend>,
|
||||
conn: LanMouseConnection,
|
||||
release_bind: Vec<scancode::Linux>,
|
||||
) -> Self {
|
||||
let (request_tx, request_rx) = channel();
|
||||
let (event_tx, event_rx) = channel();
|
||||
let cancellation_token = CancellationToken::new();
|
||||
let capture_task = CaptureTask {
|
||||
active_client: None,
|
||||
backend,
|
||||
cancellation_token: cancellation_token.clone(),
|
||||
captures: Default::default(),
|
||||
conn,
|
||||
event_tx,
|
||||
request_rx,
|
||||
release_bind: Rc::new(RefCell::new(release_bind)),
|
||||
state: Default::default(),
|
||||
};
|
||||
let task = spawn_local(capture_task.run());
|
||||
Self {
|
||||
cancellation_token,
|
||||
request_tx,
|
||||
task,
|
||||
event_rx,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn reenable(&self) {
|
||||
self.request_tx
|
||||
.send(CaptureRequest::Reenable)
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
pub(crate) async fn terminate(&mut self) {
|
||||
self.cancellation_token.cancel();
|
||||
log::debug!("terminating capture");
|
||||
if let Err(e) = (&mut self.task).await {
|
||||
log::warn!("{e}");
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn create(
|
||||
&self,
|
||||
handle: CaptureHandle,
|
||||
pos: lan_mouse_ipc::Position,
|
||||
capture_type: CaptureType,
|
||||
) {
|
||||
let pos = to_capture_pos(pos);
|
||||
self.request_tx
|
||||
.send(CaptureRequest::Create(handle, pos, capture_type))
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
pub(crate) fn destroy(&self, handle: CaptureHandle) {
|
||||
self.request_tx
|
||||
.send(CaptureRequest::Destroy(handle))
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
pub(crate) fn release(&self) {
|
||||
self.request_tx
|
||||
.send(CaptureRequest::Release)
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
pub(crate) async fn event(&mut self) -> ICaptureEvent {
|
||||
self.event_rx.recv().await.expect("channel closed")
|
||||
}
|
||||
}
|
||||
|
||||
/// debounce a statement `$st`, i.e. the statement is executed only if the
|
||||
/// time since the previous execution is at least `$dur`.
|
||||
/// `$prev` is used to keep track of this timestamp
|
||||
macro_rules! debounce {
|
||||
($prev:ident, $dur:expr, $st:stmt) => {
|
||||
let exec = match $prev.get() {
|
||||
None => true,
|
||||
Some(instant) if instant.elapsed() > $dur => true,
|
||||
_ => false,
|
||||
};
|
||||
if exec {
|
||||
$prev.replace(Some(Instant::now()));
|
||||
$st
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
struct CaptureTask {
|
||||
active_client: Option<CaptureHandle>,
|
||||
backend: Option<input_capture::Backend>,
|
||||
cancellation_token: CancellationToken,
|
||||
captures: Vec<(CaptureHandle, Position, CaptureType)>,
|
||||
conn: LanMouseConnection,
|
||||
event_tx: Sender<ICaptureEvent>,
|
||||
release_bind: Rc<RefCell<Vec<scancode::Linux>>>,
|
||||
request_rx: Receiver<CaptureRequest>,
|
||||
state: State,
|
||||
}
|
||||
|
||||
impl CaptureTask {
|
||||
fn add_capture(&mut self, handle: CaptureHandle, pos: Position, capture_type: CaptureType) {
|
||||
self.captures.push((handle, pos, capture_type));
|
||||
}
|
||||
|
||||
fn remove_capture(&mut self, handle: CaptureHandle) {
|
||||
self.captures.retain(|&(h, ..)| handle != h);
|
||||
}
|
||||
|
||||
fn is_default_capture_at(&self, pos: Position) -> bool {
|
||||
self.captures
|
||||
.iter()
|
||||
.any(|&(_, p, t)| p == pos && t == CaptureType::Default)
|
||||
}
|
||||
|
||||
fn get_pos(&self, handle: CaptureHandle) -> Position {
|
||||
self.captures
|
||||
.iter()
|
||||
.find(|(h, ..)| *h == handle)
|
||||
.expect("no such capture")
|
||||
.1
|
||||
}
|
||||
|
||||
fn get_type(&self, handle: CaptureHandle) -> CaptureType {
|
||||
self.captures
|
||||
.iter()
|
||||
.find(|(h, ..)| *h == handle)
|
||||
.expect("no such capture")
|
||||
.2
|
||||
}
|
||||
|
||||
async fn run(mut self) {
|
||||
loop {
|
||||
if let Err(e) = self.do_capture().await {
|
||||
log::warn!("input capture exited: {e}");
|
||||
}
|
||||
loop {
|
||||
tokio::select! {
|
||||
r = self.request_rx.recv() => match r.expect("channel closed") {
|
||||
CaptureRequest::Reenable => break,
|
||||
CaptureRequest::Create(h, p, t) => self.add_capture(h, p, t),
|
||||
CaptureRequest::Destroy(h) => self.remove_capture(h),
|
||||
CaptureRequest::Release => { /* nothing to do */ }
|
||||
},
|
||||
_ = self.cancellation_token.cancelled() => return,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_capture(&mut self) -> Result<(), InputCaptureError> {
|
||||
/* allow cancelling capture request */
|
||||
let mut capture = tokio::select! {
|
||||
r = InputCapture::new(self.backend) => r?,
|
||||
_ = self.cancellation_token.cancelled() => return Ok(()),
|
||||
};
|
||||
|
||||
let _capture_guard = DropGuard::new(
|
||||
self.event_tx.clone(),
|
||||
ICaptureEvent::CaptureEnabled,
|
||||
ICaptureEvent::CaptureDisabled,
|
||||
);
|
||||
|
||||
/* create barriers for active clients */
|
||||
let r = self.create_captures(&mut capture).await;
|
||||
if let Err(e) = r {
|
||||
capture.terminate().await?;
|
||||
return Err(e.into());
|
||||
}
|
||||
|
||||
let r = self.do_capture_session(&mut capture).await;
|
||||
|
||||
// FIXME replace with async drop when stabilized
|
||||
capture.terminate().await?;
|
||||
|
||||
r
|
||||
}
|
||||
|
||||
async fn create_captures(&mut self, capture: &mut InputCapture) -> Result<(), CaptureError> {
|
||||
let captures = self.captures.clone();
|
||||
for (handle, pos, _type) in captures {
|
||||
tokio::select! {
|
||||
r = capture.create(handle, pos) => r?,
|
||||
_ = self.cancellation_token.cancelled() => return Ok(()),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn do_capture_session(
|
||||
&mut self,
|
||||
capture: &mut InputCapture,
|
||||
) -> Result<(), InputCaptureError> {
|
||||
loop {
|
||||
tokio::select! {
|
||||
event = capture.next() => match event {
|
||||
Some(event) => self.handle_capture_event(capture, event?).await?,
|
||||
None => return Ok(()),
|
||||
},
|
||||
(handle, event) = self.conn.recv() => {
|
||||
if let Some(active) = self.active_client {
|
||||
if handle != active {
|
||||
// we only care about events coming from the client we are currently connected to
|
||||
// only `Ack` and `Leave` are relevant
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
match event {
|
||||
// connection acknowlegded => set state to Sending
|
||||
ProtoEvent::Ack(_) => {
|
||||
log::info!("client {handle} acknowledged the connection!");
|
||||
self.state = State::Sending;
|
||||
}
|
||||
// client disconnected
|
||||
ProtoEvent::Leave(_) => {
|
||||
log::info!("releasing capture: left remote client device region");
|
||||
self.release_capture(capture).await?;
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
},
|
||||
e = self.request_rx.recv() => match e.expect("channel closed") {
|
||||
CaptureRequest::Reenable => { /* already active */ },
|
||||
CaptureRequest::Release => self.release_capture(capture).await?,
|
||||
CaptureRequest::Create(h, p, t) => {
|
||||
self.add_capture(h, p, t);
|
||||
capture.create(h, p).await?;
|
||||
}
|
||||
CaptureRequest::Destroy(h) => {
|
||||
self.remove_capture(h);
|
||||
capture.destroy(h).await?;
|
||||
}
|
||||
},
|
||||
_ = self.cancellation_token.cancelled() => break,
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn handle_capture_event(
|
||||
&mut self,
|
||||
capture: &mut InputCapture,
|
||||
event: (CaptureHandle, CaptureEvent),
|
||||
) -> Result<(), CaptureError> {
|
||||
let (handle, event) = event;
|
||||
log::trace!("({handle}): {event:?}");
|
||||
|
||||
if capture.keys_pressed(&self.release_bind.borrow()) {
|
||||
log::info!("releasing capture: release-bind pressed");
|
||||
return self.release_capture(capture).await;
|
||||
}
|
||||
|
||||
if event == CaptureEvent::Begin {
|
||||
self.event_tx
|
||||
.send(ICaptureEvent::CaptureBegin(handle))
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
// enter only capture (for incoming connections)
|
||||
if self.get_type(handle) == CaptureType::EnterOnly {
|
||||
// if there is no active outgoing connection at the current capture,
|
||||
// we release the capture
|
||||
if !self.is_default_capture_at(self.get_pos(handle)) {
|
||||
log::info!("releasing capture: no active client at this position");
|
||||
capture.release().await?;
|
||||
}
|
||||
// we dont care about events from incoming handles except for releasing the capture
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// activated a new client
|
||||
if event == CaptureEvent::Begin && Some(handle) != self.active_client {
|
||||
self.state = State::WaitingForAck;
|
||||
self.active_client.replace(handle);
|
||||
self.event_tx
|
||||
.send(ICaptureEvent::ClientEntered(handle))
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
let opposite_pos = to_proto_pos(self.get_pos(handle).opposite());
|
||||
|
||||
let event = match event {
|
||||
CaptureEvent::Begin => ProtoEvent::Enter(opposite_pos),
|
||||
CaptureEvent::Input(e) => match self.state {
|
||||
// connection not acknowledged, repeat `Enter` event
|
||||
State::WaitingForAck => ProtoEvent::Enter(opposite_pos),
|
||||
State::Sending => ProtoEvent::Input(e),
|
||||
},
|
||||
};
|
||||
|
||||
if let Err(e) = self.conn.send(event, handle).await {
|
||||
const DUR: Duration = Duration::from_millis(500);
|
||||
debounce!(PREV_LOG, DUR, log::warn!("releasing capture: {e}"));
|
||||
capture.release().await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn release_capture(&mut self, capture: &mut InputCapture) -> Result<(), CaptureError> {
|
||||
self.active_client.take();
|
||||
capture.release().await
|
||||
}
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
static PREV_LOG: Cell<Option<Instant>> = const { Cell::new(None) };
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
enum State {
|
||||
#[default]
|
||||
WaitingForAck,
|
||||
Sending,
|
||||
}
|
||||
|
||||
fn to_capture_pos(pos: lan_mouse_ipc::Position) -> input_capture::Position {
|
||||
match pos {
|
||||
lan_mouse_ipc::Position::Left => input_capture::Position::Left,
|
||||
lan_mouse_ipc::Position::Right => input_capture::Position::Right,
|
||||
lan_mouse_ipc::Position::Top => input_capture::Position::Top,
|
||||
lan_mouse_ipc::Position::Bottom => input_capture::Position::Bottom,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_proto_pos(pos: input_capture::Position) -> lan_mouse_proto::Position {
|
||||
match pos {
|
||||
input_capture::Position::Left => lan_mouse_proto::Position::Left,
|
||||
input_capture::Position::Right => lan_mouse_proto::Position::Right,
|
||||
input_capture::Position::Top => lan_mouse_proto::Position::Top,
|
||||
input_capture::Position::Bottom => lan_mouse_proto::Position::Bottom,
|
||||
}
|
||||
}
|
||||
|
||||
struct DropGuard<T> {
|
||||
tx: Sender<T>,
|
||||
on_drop: Option<T>,
|
||||
}
|
||||
|
||||
impl<T> DropGuard<T> {
|
||||
fn new(tx: Sender<T>, on_new: T, on_drop: T) -> Self {
|
||||
tx.send(on_new).expect("channel closed");
|
||||
let on_drop = Some(on_drop);
|
||||
Self { tx, on_drop }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Drop for DropGuard<T> {
|
||||
fn drop(&mut self) {
|
||||
self.tx
|
||||
.send(self.on_drop.take().expect("item"))
|
||||
.expect("channel closed");
|
||||
}
|
||||
}
|
||||
@@ -11,7 +11,6 @@ pub async fn run(config: Config) -> Result<(), InputCaptureError> {
|
||||
let mut input_capture = InputCapture::new(backend).await?;
|
||||
log::info!("creating clients");
|
||||
input_capture.create(0, Position::Left).await?;
|
||||
input_capture.create(4, Position::Left).await?;
|
||||
input_capture.create(1, Position::Right).await?;
|
||||
input_capture.create(2, Position::Top).await?;
|
||||
input_capture.create(3, Position::Bottom).await?;
|
||||
@@ -29,13 +28,12 @@ async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError
|
||||
.await
|
||||
.ok_or(CaptureError::EndOfStream)??;
|
||||
let pos = match client {
|
||||
0 | 4 => Position::Left,
|
||||
0 => Position::Left,
|
||||
1 => Position::Right,
|
||||
2 => Position::Top,
|
||||
3 => Position::Bottom,
|
||||
_ => panic!(),
|
||||
_ => Position::Bottom,
|
||||
};
|
||||
log::info!("position: {client} ({pos}), event: {event}");
|
||||
log::info!("position: {pos}, event: {event}");
|
||||
if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key: 1, .. })) = event {
|
||||
input_capture.release().await?;
|
||||
break Ok(());
|
||||
|
||||
237
src/client.rs
237
src/client.rs
@@ -1,63 +1,18 @@
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
collections::HashSet,
|
||||
net::{IpAddr, SocketAddr},
|
||||
rc::Rc,
|
||||
};
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use slab::Slab;
|
||||
|
||||
use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState, Position};
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
#[derive(Default)]
|
||||
pub struct ClientManager {
|
||||
clients: Rc<RefCell<Slab<(ClientConfig, ClientState)>>>,
|
||||
clients: Slab<(ClientConfig, ClientState)>,
|
||||
}
|
||||
|
||||
impl ClientManager {
|
||||
/// add a new client to this manager
|
||||
pub fn add_client(&self) -> ClientHandle {
|
||||
self.clients.borrow_mut().insert(Default::default()) as ClientHandle
|
||||
}
|
||||
|
||||
/// set the config of the given client
|
||||
pub fn set_config(&self, handle: ClientHandle, config: ClientConfig) {
|
||||
if let Some((c, _)) = self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
*c = config;
|
||||
}
|
||||
}
|
||||
|
||||
/// set the state of the given client
|
||||
pub fn set_state(&self, handle: ClientHandle, state: ClientState) {
|
||||
if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
*s = state;
|
||||
}
|
||||
}
|
||||
|
||||
/// activate the given client
|
||||
/// returns, whether the client was activated
|
||||
pub fn activate_client(&self, handle: ClientHandle) -> bool {
|
||||
let mut clients = self.clients.borrow_mut();
|
||||
match clients.get_mut(handle as usize) {
|
||||
Some((_, s)) if !s.active => {
|
||||
s.active = true;
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// deactivate the given client
|
||||
/// returns, whether the client was deactivated
|
||||
pub fn deactivate_client(&self, handle: ClientHandle) -> bool {
|
||||
let mut clients = self.clients.borrow_mut();
|
||||
match clients.get_mut(handle as usize) {
|
||||
Some((_, s)) if s.active => {
|
||||
s.active = false;
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
pub fn add_client(&mut self) -> ClientHandle {
|
||||
self.clients.insert(Default::default()) as ClientHandle
|
||||
}
|
||||
|
||||
/// find a client by its address
|
||||
@@ -65,7 +20,6 @@ impl ClientManager {
|
||||
// since there shouldn't be more than a handful of clients at any given
|
||||
// time this is likely faster than using a HashMap
|
||||
self.clients
|
||||
.borrow()
|
||||
.iter()
|
||||
.find_map(|(k, (_, s))| {
|
||||
if s.active && s.ips.contains(&addr.ip()) {
|
||||
@@ -77,10 +31,8 @@ impl ClientManager {
|
||||
.map(|p| p as ClientHandle)
|
||||
}
|
||||
|
||||
/// get the client at the given position
|
||||
pub fn client_at(&self, pos: Position) -> Option<ClientHandle> {
|
||||
pub fn find_client(&self, pos: Position) -> Option<ClientHandle> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.iter()
|
||||
.find_map(|(k, (c, s))| {
|
||||
if s.active && c.pos == pos {
|
||||
@@ -92,176 +44,31 @@ impl ClientManager {
|
||||
.map(|p| p as ClientHandle)
|
||||
}
|
||||
|
||||
pub(crate) fn get_hostname(&self, handle: ClientHandle) -> Option<String> {
|
||||
self.clients
|
||||
.borrow_mut()
|
||||
.get_mut(handle as usize)
|
||||
.and_then(|(c, _)| c.hostname.clone())
|
||||
}
|
||||
|
||||
/// get the position of the corresponding client
|
||||
pub(crate) fn get_pos(&self, handle: ClientHandle) -> Option<Position> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.get(handle as usize)
|
||||
.map(|(c, _)| c.pos)
|
||||
}
|
||||
|
||||
/// remove a client from the list
|
||||
pub fn remove_client(&self, client: ClientHandle) -> Option<(ClientConfig, ClientState)> {
|
||||
pub fn remove_client(&mut self, client: ClientHandle) -> Option<(ClientConfig, ClientState)> {
|
||||
// remove id from occupied ids
|
||||
self.clients.borrow_mut().try_remove(client as usize)
|
||||
self.clients.try_remove(client as usize)
|
||||
}
|
||||
|
||||
/// get the config & state of the given client
|
||||
pub fn get_state(&self, handle: ClientHandle) -> Option<(ClientConfig, ClientState)> {
|
||||
self.clients.borrow().get(handle as usize).cloned()
|
||||
// returns an immutable reference to the client state corresponding to `client`
|
||||
pub fn get(&self, handle: ClientHandle) -> Option<&(ClientConfig, ClientState)> {
|
||||
self.clients.get(handle as usize)
|
||||
}
|
||||
|
||||
/// get the current config & state of all clients
|
||||
pub fn get_client_states(&self) -> Vec<(ClientHandle, ClientConfig, ClientState)> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.iter()
|
||||
.map(|(k, v)| (k as ClientHandle, v.0.clone(), v.1.clone()))
|
||||
.collect()
|
||||
/// returns a mutable reference to the client state corresponding to `client`
|
||||
pub fn get_mut(&mut self, handle: ClientHandle) -> Option<&mut (ClientConfig, ClientState)> {
|
||||
self.clients.get_mut(handle as usize)
|
||||
}
|
||||
|
||||
/// update the fix ips of the client
|
||||
pub fn set_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
|
||||
if let Some((c, _)) = self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
c.fix_ips = fix_ips
|
||||
}
|
||||
self.update_ips(handle);
|
||||
pub fn get_client_states(
|
||||
&self,
|
||||
) -> impl Iterator<Item = (ClientHandle, &(ClientConfig, ClientState))> {
|
||||
self.clients.iter().map(|(k, v)| (k as ClientHandle, v))
|
||||
}
|
||||
|
||||
/// update the dns-ips of the client
|
||||
pub fn set_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
|
||||
if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
s.dns_ips = dns_ips
|
||||
}
|
||||
self.update_ips(handle);
|
||||
}
|
||||
|
||||
fn update_ips(&self, handle: ClientHandle) {
|
||||
if let Some((c, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
s.ips = c
|
||||
.fix_ips
|
||||
.iter()
|
||||
.cloned()
|
||||
.chain(s.dns_ips.iter().cloned())
|
||||
.collect::<HashSet<_>>();
|
||||
}
|
||||
}
|
||||
|
||||
/// update the hostname of the given client
|
||||
/// this automatically clears the active ip address and ips from dns
|
||||
pub fn set_hostname(&self, handle: ClientHandle, hostname: Option<String>) -> bool {
|
||||
let mut clients = self.clients.borrow_mut();
|
||||
let Some((c, s)) = clients.get_mut(handle as usize) else {
|
||||
return false;
|
||||
};
|
||||
|
||||
// hostname changed
|
||||
if c.hostname != hostname {
|
||||
c.hostname = hostname;
|
||||
s.active_addr = None;
|
||||
s.dns_ips.clear();
|
||||
drop(clients);
|
||||
self.update_ips(handle);
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// update the port of the client
|
||||
pub(crate) fn set_port(&self, handle: ClientHandle, port: u16) {
|
||||
match self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
Some((c, s)) if c.port != port => {
|
||||
c.port = port;
|
||||
s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
|
||||
}
|
||||
_ => {}
|
||||
};
|
||||
}
|
||||
|
||||
/// update the position of the client
|
||||
/// returns true, if a change in capture position is required (pos changed & client is active)
|
||||
pub(crate) fn set_pos(&self, handle: ClientHandle, pos: Position) -> bool {
|
||||
match self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
Some((c, s)) if c.pos != pos => {
|
||||
log::info!("update pos {handle} {} -> {}", c.pos, pos);
|
||||
c.pos = pos;
|
||||
s.active
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// 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) {
|
||||
s.resolving = status;
|
||||
}
|
||||
}
|
||||
|
||||
/// get the enter hook command
|
||||
pub(crate) fn get_enter_cmd(&self, handle: ClientHandle) -> Option<String> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.get(handle as usize)
|
||||
.and_then(|(c, _)| c.cmd.clone())
|
||||
}
|
||||
|
||||
/// returns all clients that are currently active
|
||||
pub(crate) fn active_clients(&self) -> Vec<ClientHandle> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.iter()
|
||||
.filter(|(_, (_, s))| s.active)
|
||||
.map(|(h, _)| h as ClientHandle)
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub(crate) fn set_active_addr(&self, handle: ClientHandle, addr: Option<SocketAddr>) {
|
||||
if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
s.active_addr = addr;
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn set_alive(&self, handle: ClientHandle, alive: bool) {
|
||||
if let Some((_, s)) = self.clients.borrow_mut().get_mut(handle as usize) {
|
||||
s.alive = alive;
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn active_addr(&self, handle: ClientHandle) -> Option<SocketAddr> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.get(handle as usize)
|
||||
.and_then(|(_, s)| s.active_addr)
|
||||
}
|
||||
|
||||
pub(crate) fn alive(&self, handle: ClientHandle) -> bool {
|
||||
self.clients
|
||||
.borrow()
|
||||
.get(handle as usize)
|
||||
.map(|(_, s)| s.alive)
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
pub(crate) fn get_port(&self, handle: ClientHandle) -> Option<u16> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.get(handle as usize)
|
||||
.map(|(c, _)| c.port)
|
||||
}
|
||||
|
||||
pub(crate) fn get_ips(&self, handle: ClientHandle) -> Option<HashSet<IpAddr>> {
|
||||
self.clients
|
||||
.borrow()
|
||||
.get(handle as usize)
|
||||
.map(|(_, s)| s.ips.clone())
|
||||
pub fn get_client_states_mut(
|
||||
&mut self,
|
||||
) -> impl Iterator<Item = (ClientHandle, &mut (ClientConfig, ClientState))> {
|
||||
self.clients.iter_mut().map(|(k, v)| (k as ClientHandle, v))
|
||||
}
|
||||
}
|
||||
|
||||
119
src/config.rs
119
src/config.rs
@@ -1,11 +1,9 @@
|
||||
use clap::{Parser, ValueEnum};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::HashMap;
|
||||
use std::env::{self, VarError};
|
||||
use std::fmt::Display;
|
||||
use std::fs;
|
||||
use std::net::IpAddr;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::{collections::HashSet, io};
|
||||
use thiserror::Error;
|
||||
use toml;
|
||||
@@ -17,10 +15,6 @@ use input_event::scancode::{
|
||||
Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
|
||||
};
|
||||
|
||||
use shadow_rs::shadow;
|
||||
|
||||
shadow!(build);
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug)]
|
||||
pub struct ConfigToml {
|
||||
pub capture_backend: Option<CaptureBackend>,
|
||||
@@ -28,12 +22,10 @@ pub struct ConfigToml {
|
||||
pub port: Option<u16>,
|
||||
pub frontend: Option<Frontend>,
|
||||
pub release_bind: Option<Vec<scancode::Linux>>,
|
||||
pub cert_path: Option<PathBuf>,
|
||||
pub left: Option<TomlClient>,
|
||||
pub right: Option<TomlClient>,
|
||||
pub top: Option<TomlClient>,
|
||||
pub bottom: Option<TomlClient>,
|
||||
pub authorized_fingerprints: Option<HashMap<String, String>>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
|
||||
@@ -48,14 +40,15 @@ pub struct TomlClient {
|
||||
}
|
||||
|
||||
impl ConfigToml {
|
||||
pub fn new(path: &Path) -> Result<ConfigToml, ConfigError> {
|
||||
pub fn new(path: &str) -> Result<ConfigToml, ConfigError> {
|
||||
let config = fs::read_to_string(path)?;
|
||||
log::info!("using config: \"{path}\"");
|
||||
Ok(toml::from_str::<_>(&config)?)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Parser, Debug)]
|
||||
#[command(author, version=build::CLAP_LONG_VERSION, about, long_about = None)]
|
||||
#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None)]
|
||||
struct CliArgs {
|
||||
/// the listen port for lan-mouse
|
||||
#[arg(short, long)]
|
||||
@@ -88,41 +81,31 @@ struct CliArgs {
|
||||
/// emulation backend override
|
||||
#[arg(long)]
|
||||
emulation_backend: Option<EmulationBackend>,
|
||||
|
||||
/// path to non-default certificate location
|
||||
#[arg(long)]
|
||||
cert_path: Option<PathBuf>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
|
||||
pub enum CaptureBackend {
|
||||
#[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
|
||||
#[serde(rename = "input-capture-portal")]
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
InputCapturePortal,
|
||||
#[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
|
||||
#[serde(rename = "layer-shell")]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
LayerShell,
|
||||
#[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
|
||||
#[serde(rename = "x11")]
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
X11,
|
||||
#[cfg(windows)]
|
||||
#[serde(rename = "windows")]
|
||||
Windows,
|
||||
#[cfg(target_os = "macos")]
|
||||
#[serde(rename = "macos")]
|
||||
MacOs,
|
||||
#[serde(rename = "dummy")]
|
||||
Dummy,
|
||||
}
|
||||
|
||||
impl Display for CaptureBackend {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
#[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
CaptureBackend::InputCapturePortal => write!(f, "input-capture-portal"),
|
||||
#[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
CaptureBackend::LayerShell => write!(f, "layer-shell"),
|
||||
#[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
CaptureBackend::X11 => write!(f, "X11"),
|
||||
#[cfg(windows)]
|
||||
CaptureBackend::Windows => write!(f, "windows"),
|
||||
@@ -136,11 +119,11 @@ impl Display for CaptureBackend {
|
||||
impl From<CaptureBackend> for input_capture::Backend {
|
||||
fn from(backend: CaptureBackend) -> Self {
|
||||
match backend {
|
||||
#[cfg(all(unix, feature = "libei_capture", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
CaptureBackend::InputCapturePortal => Self::InputCapturePortal,
|
||||
#[cfg(all(unix, feature = "layer_shell_capture", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
CaptureBackend::LayerShell => Self::LayerShell,
|
||||
#[cfg(all(unix, feature = "x11_capture", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
CaptureBackend::X11 => Self::X11,
|
||||
#[cfg(windows)]
|
||||
CaptureBackend::Windows => Self::Windows,
|
||||
@@ -153,38 +136,31 @@ impl From<CaptureBackend> for input_capture::Backend {
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
|
||||
pub enum EmulationBackend {
|
||||
#[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
|
||||
#[serde(rename = "wlroots")]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
Wlroots,
|
||||
#[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
|
||||
#[serde(rename = "libei")]
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
Libei,
|
||||
#[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
|
||||
#[serde(rename = "xdp")]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
Xdp,
|
||||
#[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
|
||||
#[serde(rename = "x11")]
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
X11,
|
||||
#[cfg(windows)]
|
||||
#[serde(rename = "windows")]
|
||||
Windows,
|
||||
#[cfg(target_os = "macos")]
|
||||
#[serde(rename = "macos")]
|
||||
MacOs,
|
||||
#[serde(rename = "dummy")]
|
||||
Dummy,
|
||||
}
|
||||
|
||||
impl From<EmulationBackend> for input_emulation::Backend {
|
||||
fn from(backend: EmulationBackend) -> Self {
|
||||
match backend {
|
||||
#[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
EmulationBackend::Wlroots => Self::Wlroots,
|
||||
#[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
EmulationBackend::Libei => Self::Libei,
|
||||
#[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
EmulationBackend::Xdp => Self::Xdp,
|
||||
#[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
EmulationBackend::X11 => Self::X11,
|
||||
#[cfg(windows)]
|
||||
EmulationBackend::Windows => Self::Windows,
|
||||
@@ -198,13 +174,13 @@ impl From<EmulationBackend> for input_emulation::Backend {
|
||||
impl Display for EmulationBackend {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
#[cfg(all(unix, feature = "wlroots_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
|
||||
EmulationBackend::Wlroots => write!(f, "wlroots"),
|
||||
#[cfg(all(unix, feature = "libei_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
|
||||
EmulationBackend::Libei => write!(f, "libei"),
|
||||
#[cfg(all(unix, feature = "rdp_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
|
||||
EmulationBackend::Xdp => write!(f, "xdg-desktop-portal"),
|
||||
#[cfg(all(unix, feature = "x11_emulation", not(target_os = "macos")))]
|
||||
#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
|
||||
EmulationBackend::X11 => write!(f, "X11"),
|
||||
#[cfg(windows)]
|
||||
EmulationBackend::Windows => write!(f, "windows"),
|
||||
@@ -217,9 +193,7 @@ impl Display for EmulationBackend {
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
|
||||
pub enum Frontend {
|
||||
#[serde(rename = "gtk")]
|
||||
Gtk,
|
||||
#[serde(rename = "cli")]
|
||||
Cli,
|
||||
}
|
||||
|
||||
@@ -235,30 +209,15 @@ impl Default for Frontend {
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Config {
|
||||
/// the path to the configuration file used
|
||||
pub path: PathBuf,
|
||||
/// public key fingerprints authorized for connection
|
||||
pub authorized_fingerprints: HashMap<String, String>,
|
||||
/// optional input-capture backend override
|
||||
pub capture_backend: Option<CaptureBackend>,
|
||||
/// optional input-emulation backend override
|
||||
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 {
|
||||
@@ -286,32 +245,27 @@ const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
|
||||
impl Config {
|
||||
pub fn new() -> Result<Self, ConfigError> {
|
||||
let args = CliArgs::parse();
|
||||
const CONFIG_FILE_NAME: &str = "config.toml";
|
||||
const CERT_FILE_NAME: &str = "lan-mouse.pem";
|
||||
|
||||
let config_file = "config.toml";
|
||||
#[cfg(unix)]
|
||||
let config_path = {
|
||||
let xdg_config_home =
|
||||
env::var("XDG_CONFIG_HOME").unwrap_or(format!("{}/.config", env::var("HOME")?));
|
||||
format!("{xdg_config_home}/lan-mouse/")
|
||||
format!("{xdg_config_home}/lan-mouse/{config_file}")
|
||||
};
|
||||
|
||||
#[cfg(not(unix))]
|
||||
let config_path = {
|
||||
let app_data =
|
||||
env::var("LOCALAPPDATA").unwrap_or(format!("{}/.config", env::var("USERPROFILE")?));
|
||||
format!("{app_data}\\lan-mouse\\")
|
||||
format!("{app_data}\\lan-mouse\\{config_file}")
|
||||
};
|
||||
|
||||
let config_path = PathBuf::from(config_path);
|
||||
let config_file = config_path.join(CONFIG_FILE_NAME);
|
||||
|
||||
// --config <file> overrules default location
|
||||
let config_file = args.config.map(PathBuf::from).unwrap_or(config_file);
|
||||
let config_path = args.config.unwrap_or(config_path);
|
||||
|
||||
let mut config_toml = match ConfigToml::new(&config_file) {
|
||||
let config_toml = match ConfigToml::new(config_path.as_str()) {
|
||||
Err(e) => {
|
||||
log::warn!("{config_file:?}: {e}");
|
||||
log::warn!("{config_path}: {e}");
|
||||
log::warn!("Continuing without config file ...");
|
||||
None
|
||||
}
|
||||
@@ -341,16 +295,6 @@ impl Config {
|
||||
.emulation_backend
|
||||
.or(config_toml.as_ref().and_then(|c| c.emulation_backend));
|
||||
|
||||
let cert_path = args
|
||||
.cert_path
|
||||
.or(config_toml.as_ref().and_then(|c| c.cert_path.clone()))
|
||||
.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 {
|
||||
@@ -373,8 +317,6 @@ impl Config {
|
||||
let test_emulation = args.test_emulation;
|
||||
|
||||
Ok(Config {
|
||||
path: config_path,
|
||||
authorized_fingerprints,
|
||||
capture_backend,
|
||||
emulation_backend,
|
||||
daemon,
|
||||
@@ -384,7 +326,6 @@ impl Config {
|
||||
release_bind,
|
||||
test_capture,
|
||||
test_emulation,
|
||||
cert_path,
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
281
src/connect.rs
281
src/connect.rs
@@ -1,281 +0,0 @@
|
||||
use crate::client::ClientManager;
|
||||
use lan_mouse_ipc::{ClientHandle, DEFAULT_PORT};
|
||||
use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
|
||||
use local_channel::mpsc::{channel, Receiver, Sender};
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
collections::{HashMap, HashSet},
|
||||
io,
|
||||
net::SocketAddr,
|
||||
rc::Rc,
|
||||
sync::Arc,
|
||||
time::Duration,
|
||||
};
|
||||
use thiserror::Error;
|
||||
use tokio::{
|
||||
net::UdpSocket,
|
||||
sync::Mutex,
|
||||
task::{spawn_local, JoinSet},
|
||||
};
|
||||
use webrtc_dtls::{
|
||||
config::{Config, ExtendedMasterSecretType},
|
||||
conn::DTLSConn,
|
||||
crypto::Certificate,
|
||||
};
|
||||
use webrtc_util::Conn;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub(crate) enum LanMouseConnectionError {
|
||||
#[error(transparent)]
|
||||
Bind(#[from] io::Error),
|
||||
#[error(transparent)]
|
||||
Dtls(#[from] webrtc_dtls::Error),
|
||||
#[error(transparent)]
|
||||
Webrtc(#[from] webrtc_util::Error),
|
||||
#[error("not connected")]
|
||||
NotConnected,
|
||||
#[error("emulation is disabled on the target device")]
|
||||
TargetEmulationDisabled,
|
||||
#[error("Connection timed out")]
|
||||
Timeout,
|
||||
}
|
||||
|
||||
const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
|
||||
async fn connect(
|
||||
addr: SocketAddr,
|
||||
cert: Certificate,
|
||||
) -> Result<(Arc<dyn Conn + Sync + Send>, SocketAddr), (SocketAddr, LanMouseConnectionError)> {
|
||||
log::info!("connecting to {addr} ...");
|
||||
let conn = Arc::new(
|
||||
UdpSocket::bind("0.0.0.0:0")
|
||||
.await
|
||||
.map_err(|e| (addr, e.into()))?,
|
||||
);
|
||||
conn.connect(addr).await.map_err(|e| (addr, e.into()))?;
|
||||
let config = Config {
|
||||
certificates: vec![cert],
|
||||
server_name: "ignored".to_owned(),
|
||||
insecure_skip_verify: true,
|
||||
extended_master_secret: ExtendedMasterSecretType::Require,
|
||||
..Default::default()
|
||||
};
|
||||
let timeout = tokio::time::sleep(DEFAULT_CONNECTION_TIMEOUT);
|
||||
tokio::select! {
|
||||
_ = timeout => Err((addr, LanMouseConnectionError::Timeout)),
|
||||
result = DTLSConn::new(conn, config, true, None) => match result {
|
||||
Ok(dtls_conn) => Ok((Arc::new(dtls_conn), addr)),
|
||||
Err(e) => Err((addr, e.into())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn connect_any(
|
||||
addrs: &[SocketAddr],
|
||||
cert: Certificate,
|
||||
) -> Result<(Arc<dyn Conn + Send + Sync>, SocketAddr), LanMouseConnectionError> {
|
||||
let mut joinset = JoinSet::new();
|
||||
for &addr in addrs {
|
||||
joinset.spawn_local(connect(addr, cert.clone()));
|
||||
}
|
||||
loop {
|
||||
match joinset.join_next().await {
|
||||
None => return Err(LanMouseConnectionError::NotConnected),
|
||||
Some(r) => match r.expect("join error") {
|
||||
Ok(conn) => return Ok(conn),
|
||||
Err((a, e)) => {
|
||||
log::warn!("failed to connect to {a}: `{e}`")
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct LanMouseConnection {
|
||||
cert: Certificate,
|
||||
client_manager: ClientManager,
|
||||
conns: Rc<Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>>,
|
||||
connecting: Rc<Mutex<HashSet<ClientHandle>>>,
|
||||
recv_rx: Receiver<(ClientHandle, ProtoEvent)>,
|
||||
recv_tx: Sender<(ClientHandle, ProtoEvent)>,
|
||||
ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
|
||||
}
|
||||
|
||||
impl LanMouseConnection {
|
||||
pub(crate) fn new(cert: Certificate, client_manager: ClientManager) -> Self {
|
||||
let (recv_tx, recv_rx) = channel();
|
||||
Self {
|
||||
cert,
|
||||
client_manager,
|
||||
conns: Default::default(),
|
||||
connecting: Default::default(),
|
||||
recv_rx,
|
||||
recv_tx,
|
||||
ping_response: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn recv(&mut self) -> (ClientHandle, ProtoEvent) {
|
||||
self.recv_rx.recv().await.expect("channel closed")
|
||||
}
|
||||
|
||||
pub(crate) async fn send(
|
||||
&self,
|
||||
event: ProtoEvent,
|
||||
handle: ClientHandle,
|
||||
) -> Result<(), LanMouseConnectionError> {
|
||||
let (buf, len): ([u8; MAX_EVENT_SIZE], usize) = event.into();
|
||||
let buf = &buf[..len];
|
||||
if let Some(addr) = self.client_manager.active_addr(handle) {
|
||||
let conn = {
|
||||
let conns = self.conns.lock().await;
|
||||
conns.get(&addr).cloned()
|
||||
};
|
||||
if let Some(conn) = conn {
|
||||
if !self.client_manager.alive(handle) {
|
||||
return Err(LanMouseConnectionError::TargetEmulationDisabled);
|
||||
}
|
||||
match conn.send(buf).await {
|
||||
Ok(_) => {}
|
||||
Err(e) => {
|
||||
log::warn!("client {handle} failed to send: {e}");
|
||||
disconnect(&self.client_manager, handle, addr, &self.conns).await;
|
||||
}
|
||||
}
|
||||
log::trace!("{event} >->->->->- {addr}");
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
// check if we are already trying to connect
|
||||
let mut connecting = self.connecting.lock().await;
|
||||
if !connecting.contains(&handle) {
|
||||
connecting.insert(handle);
|
||||
// connect in the background
|
||||
spawn_local(connect_to_handle(
|
||||
self.client_manager.clone(),
|
||||
self.cert.clone(),
|
||||
handle,
|
||||
self.conns.clone(),
|
||||
self.connecting.clone(),
|
||||
self.recv_tx.clone(),
|
||||
self.ping_response.clone(),
|
||||
));
|
||||
}
|
||||
Err(LanMouseConnectionError::NotConnected)
|
||||
}
|
||||
}
|
||||
|
||||
async fn connect_to_handle(
|
||||
client_manager: ClientManager,
|
||||
cert: Certificate,
|
||||
handle: ClientHandle,
|
||||
conns: Rc<Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>>,
|
||||
connecting: Rc<Mutex<HashSet<ClientHandle>>>,
|
||||
tx: Sender<(ClientHandle, ProtoEvent)>,
|
||||
ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
|
||||
) -> Result<(), LanMouseConnectionError> {
|
||||
log::info!("client {handle} connecting ...");
|
||||
// sending did not work, figure out active conn.
|
||||
if let Some(addrs) = client_manager.get_ips(handle) {
|
||||
let port = client_manager.get_port(handle).unwrap_or(DEFAULT_PORT);
|
||||
let addrs = addrs
|
||||
.into_iter()
|
||||
.map(|a| SocketAddr::new(a, port))
|
||||
.collect::<Vec<_>>();
|
||||
log::info!("client ({handle}) connecting ... (ips: {addrs:?})");
|
||||
let res = connect_any(&addrs, cert).await;
|
||||
let (conn, addr) = match res {
|
||||
Ok(c) => c,
|
||||
Err(e) => {
|
||||
connecting.lock().await.remove(&handle);
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
log::info!("client ({handle}) connected @ {addr}");
|
||||
client_manager.set_active_addr(handle, Some(addr));
|
||||
conns.lock().await.insert(addr, conn.clone());
|
||||
connecting.lock().await.remove(&handle);
|
||||
|
||||
// poll connection for active
|
||||
spawn_local(ping_pong(addr, conn.clone(), ping_response.clone()));
|
||||
|
||||
// receiver
|
||||
spawn_local(receive_loop(
|
||||
client_manager,
|
||||
handle,
|
||||
addr,
|
||||
conn,
|
||||
conns,
|
||||
tx,
|
||||
ping_response.clone(),
|
||||
));
|
||||
return Ok(());
|
||||
}
|
||||
connecting.lock().await.remove(&handle);
|
||||
Err(LanMouseConnectionError::NotConnected)
|
||||
}
|
||||
|
||||
async fn ping_pong(
|
||||
addr: SocketAddr,
|
||||
conn: Arc<dyn Conn + Send + Sync>,
|
||||
ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
|
||||
) {
|
||||
loop {
|
||||
let (buf, len) = ProtoEvent::Ping.into();
|
||||
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");
|
||||
let _ = conn.close().await;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn receive_loop(
|
||||
client_manager: ClientManager,
|
||||
handle: ClientHandle,
|
||||
addr: SocketAddr,
|
||||
conn: Arc<dyn Conn + Send + Sync>,
|
||||
conns: Rc<Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>>,
|
||||
tx: Sender<(ClientHandle, ProtoEvent)>,
|
||||
ping_response: Rc<RefCell<HashSet<SocketAddr>>>,
|
||||
) {
|
||||
let mut buf = [0u8; MAX_EVENT_SIZE];
|
||||
while conn.recv(&mut buf).await.is_ok() {
|
||||
if let Ok(event) = buf.try_into() {
|
||||
log::trace!("{addr} <==<==<== {event}");
|
||||
match event {
|
||||
ProtoEvent::Pong(b) => {
|
||||
client_manager.set_active_addr(handle, Some(addr));
|
||||
client_manager.set_alive(handle, b);
|
||||
ping_response.borrow_mut().insert(addr);
|
||||
}
|
||||
event => tx.send((handle, event)).expect("channel closed"),
|
||||
}
|
||||
}
|
||||
}
|
||||
log::warn!("recv error");
|
||||
disconnect(&client_manager, handle, addr, &conns).await;
|
||||
}
|
||||
|
||||
async fn disconnect(
|
||||
client_manager: &ClientManager,
|
||||
handle: ClientHandle,
|
||||
addr: SocketAddr,
|
||||
conns: &Mutex<HashMap<SocketAddr, Arc<dyn Conn + Send + Sync>>>,
|
||||
) {
|
||||
log::warn!("client ({handle}) @ {addr} connection closed");
|
||||
conns.lock().await.remove(&addr);
|
||||
client_manager.set_active_addr(handle, None);
|
||||
let active: Vec<SocketAddr> = conns.lock().await.keys().copied().collect();
|
||||
log::info!("active connections: {active:?}");
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
use std::fs;
|
||||
use std::io::{self, BufWriter, Read, Write};
|
||||
use std::path::Path;
|
||||
use std::{fs::File, io::BufReader};
|
||||
|
||||
#[cfg(unix)]
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
use sha2::{Digest, Sha256};
|
||||
use thiserror::Error;
|
||||
use webrtc_dtls::crypto::Certificate;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum Error {
|
||||
#[error(transparent)]
|
||||
Io(#[from] io::Error),
|
||||
#[error(transparent)]
|
||||
Dtls(#[from] webrtc_dtls::Error),
|
||||
}
|
||||
|
||||
pub fn generate_fingerprint(cert: &[u8]) -> String {
|
||||
let mut hash = Sha256::new();
|
||||
hash.update(cert);
|
||||
let bytes = hash
|
||||
.finalize()
|
||||
.iter()
|
||||
.map(|x| format!("{x:02x}"))
|
||||
.collect::<Vec<_>>();
|
||||
bytes.join(":").to_lowercase()
|
||||
}
|
||||
|
||||
pub fn certificate_fingerprint(cert: &Certificate) -> String {
|
||||
let certificate = cert.certificate.first().expect("certificate missing");
|
||||
generate_fingerprint(certificate)
|
||||
}
|
||||
|
||||
/// load certificate from file
|
||||
pub fn load_certificate(path: &Path) -> Result<Certificate, Error> {
|
||||
let f = File::open(path)?;
|
||||
|
||||
let mut reader = BufReader::new(f);
|
||||
let mut pem = String::new();
|
||||
reader.read_to_string(&mut pem)?;
|
||||
Ok(Certificate::from_pem(pem.as_str())?)
|
||||
}
|
||||
|
||||
pub(crate) fn load_or_generate_key_and_cert(path: &Path) -> Result<Certificate, Error> {
|
||||
if path.exists() && path.is_file() {
|
||||
Ok(load_certificate(path)?)
|
||||
} else {
|
||||
generate_key_and_cert(path)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn generate_key_and_cert(path: &Path) -> Result<Certificate, Error> {
|
||||
let cert = Certificate::generate_self_signed(["ignored".to_owned()])?;
|
||||
let serialized = cert.serialize_pem();
|
||||
let parent = path.parent().expect("is a path");
|
||||
fs::create_dir_all(parent)?;
|
||||
let f = File::create(path)?;
|
||||
#[cfg(unix)]
|
||||
{
|
||||
let mut perm = f.metadata()?.permissions();
|
||||
perm.set_mode(0o400); /* r-- --- --- */
|
||||
f.set_permissions(perm)?;
|
||||
}
|
||||
/* FIXME windows permissions */
|
||||
let mut writer = BufWriter::new(f);
|
||||
writer.write_all(serialized.as_bytes())?;
|
||||
Ok(cert)
|
||||
}
|
||||
111
src/dns.rs
111
src/dns.rs
@@ -1,106 +1,63 @@
|
||||
use local_channel::mpsc::Receiver;
|
||||
use std::net::IpAddr;
|
||||
|
||||
use local_channel::mpsc::{channel, Receiver, Sender};
|
||||
use tokio::task::{spawn_local, JoinHandle};
|
||||
|
||||
use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::server::Server;
|
||||
use lan_mouse_ipc::ClientHandle;
|
||||
|
||||
pub(crate) struct DnsResolver {
|
||||
cancellation_token: CancellationToken,
|
||||
task: Option<JoinHandle<()>>,
|
||||
request_tx: Sender<DnsRequest>,
|
||||
event_rx: Receiver<DnsEvent>,
|
||||
}
|
||||
|
||||
struct DnsRequest {
|
||||
handle: ClientHandle,
|
||||
hostname: String,
|
||||
}
|
||||
|
||||
pub(crate) enum DnsEvent {
|
||||
Resolving(ClientHandle),
|
||||
Resolved(ClientHandle, String, Result<Vec<IpAddr>, ResolveError>),
|
||||
}
|
||||
|
||||
struct DnsTask {
|
||||
resolver: TokioAsyncResolver,
|
||||
request_rx: Receiver<DnsRequest>,
|
||||
event_tx: Sender<DnsEvent>,
|
||||
cancellation_token: CancellationToken,
|
||||
dns_request: Receiver<ClientHandle>,
|
||||
}
|
||||
|
||||
impl DnsResolver {
|
||||
pub(crate) fn new() -> Result<Self, ResolveError> {
|
||||
pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
|
||||
let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
|
||||
let (request_tx, request_rx) = channel();
|
||||
let (event_tx, event_rx) = channel();
|
||||
let cancellation_token = CancellationToken::new();
|
||||
let dns_task = DnsTask {
|
||||
resolver,
|
||||
request_rx,
|
||||
event_tx,
|
||||
cancellation_token: cancellation_token.clone(),
|
||||
};
|
||||
let task = Some(spawn_local(dns_task.run()));
|
||||
Ok(Self {
|
||||
cancellation_token,
|
||||
task,
|
||||
event_rx,
|
||||
request_tx,
|
||||
resolver,
|
||||
dns_request,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn resolve(&self, handle: ClientHandle, hostname: String) {
|
||||
let request = DnsRequest { handle, hostname };
|
||||
self.request_tx.send(request).expect("channel closed");
|
||||
async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
|
||||
let response = self.resolver.lookup_ip(host).await?;
|
||||
for ip in response.iter() {
|
||||
log::info!("{host}: adding ip {ip}");
|
||||
}
|
||||
Ok(response.iter().collect())
|
||||
}
|
||||
|
||||
pub(crate) async fn event(&mut self) -> DnsEvent {
|
||||
self.event_rx.recv().await.expect("channel closed")
|
||||
}
|
||||
|
||||
pub(crate) async fn terminate(&mut self) {
|
||||
self.cancellation_token.cancel();
|
||||
self.task.take().expect("task").await.expect("join error");
|
||||
}
|
||||
}
|
||||
|
||||
impl DnsTask {
|
||||
async fn run(mut self) {
|
||||
let cancellation_token = self.cancellation_token.clone();
|
||||
pub(crate) async fn run(mut self, server: Server) {
|
||||
tokio::select! {
|
||||
_ = self.do_dns() => {},
|
||||
_ = cancellation_token.cancelled() => {},
|
||||
_ = server.cancelled() => {},
|
||||
_ = self.do_dns(&server) => {},
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_dns(&mut self) {
|
||||
while let Some(dns_request) = self.request_rx.recv().await {
|
||||
let DnsRequest { handle, hostname } = dns_request;
|
||||
async fn do_dns(&mut self, server: &Server) {
|
||||
loop {
|
||||
let handle = self.dns_request.recv().await.expect("channel closed");
|
||||
|
||||
self.event_tx
|
||||
.send(DnsEvent::Resolving(handle))
|
||||
.expect("channel closed");
|
||||
/* update resolving status */
|
||||
let hostname = match server.get_hostname(handle) {
|
||||
Some(hostname) => hostname,
|
||||
None => continue,
|
||||
};
|
||||
|
||||
/* spawn task for dns request */
|
||||
let event_tx = self.event_tx.clone();
|
||||
let resolver = self.resolver.clone();
|
||||
let cancellation_token = self.cancellation_token.clone();
|
||||
log::info!("resolving ({handle}) `{hostname}` ...");
|
||||
server.set_resolving(handle, true);
|
||||
|
||||
tokio::task::spawn_local(async move {
|
||||
tokio::select! {
|
||||
ips = resolver.lookup_ip(&hostname) => {
|
||||
let ips = ips.map(|ips| ips.iter().collect::<Vec<_>>());
|
||||
event_tx
|
||||
.send(DnsEvent::Resolved(handle, hostname, ips))
|
||||
.expect("channel closed");
|
||||
}
|
||||
_ = cancellation_token.cancelled() => {},
|
||||
let ips = match self.resolve(&hostname).await {
|
||||
Ok(ips) => ips,
|
||||
Err(e) => {
|
||||
log::warn!("could not resolve host '{hostname}': {e}");
|
||||
vec![]
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
server.update_dns_ips(handle, ips);
|
||||
server.set_resolving(handle, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
407
src/emulation.rs
407
src/emulation.rs
@@ -1,407 +0,0 @@
|
||||
use crate::listen::{LanMouseListener, ListenerCreationError};
|
||||
use futures::StreamExt;
|
||||
use input_emulation::{EmulationHandle, InputEmulation, InputEmulationError};
|
||||
use input_event::Event;
|
||||
use lan_mouse_proto::{Position, ProtoEvent};
|
||||
use local_channel::mpsc::{channel, Receiver, Sender};
|
||||
use std::{
|
||||
cell::Cell,
|
||||
collections::HashMap,
|
||||
net::SocketAddr,
|
||||
rc::Rc,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use tokio::{
|
||||
select,
|
||||
task::{spawn_local, JoinHandle},
|
||||
};
|
||||
|
||||
/// emulation handling events received from a listener
|
||||
pub(crate) struct Emulation {
|
||||
task: JoinHandle<()>,
|
||||
request_tx: Sender<EmulationRequest>,
|
||||
event_rx: Receiver<EmulationEvent>,
|
||||
}
|
||||
|
||||
pub(crate) enum EmulationEvent {
|
||||
/// new connection
|
||||
Connected {
|
||||
/// address of the connection
|
||||
addr: SocketAddr,
|
||||
/// position of the connection
|
||||
pos: lan_mouse_ipc::Position,
|
||||
/// certificate fingerprint of the connection
|
||||
fingerprint: String,
|
||||
},
|
||||
/// connection closed
|
||||
Disconnected { addr: SocketAddr },
|
||||
/// the port of the listener has changed
|
||||
PortChanged(Result<u16, ListenerCreationError>),
|
||||
/// emulation was disabled
|
||||
EmulationDisabled,
|
||||
/// emulation was enabled
|
||||
EmulationEnabled,
|
||||
/// capture should be released
|
||||
ReleaseNotify,
|
||||
}
|
||||
|
||||
enum EmulationRequest {
|
||||
Reenable,
|
||||
Release(SocketAddr),
|
||||
ChangePort(u16),
|
||||
Terminate,
|
||||
}
|
||||
|
||||
impl Emulation {
|
||||
pub(crate) fn new(
|
||||
backend: Option<input_emulation::Backend>,
|
||||
listener: LanMouseListener,
|
||||
) -> Self {
|
||||
let emulation_proxy = EmulationProxy::new(backend);
|
||||
let (request_tx, request_rx) = channel();
|
||||
let (event_tx, event_rx) = channel();
|
||||
let emulation_task = ListenTask {
|
||||
listener,
|
||||
emulation_proxy,
|
||||
request_rx,
|
||||
event_tx,
|
||||
};
|
||||
let task = spawn_local(emulation_task.run());
|
||||
Self {
|
||||
task,
|
||||
request_tx,
|
||||
event_rx,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn send_leave_event(&self, addr: SocketAddr) {
|
||||
self.request_tx
|
||||
.send(EmulationRequest::Release(addr))
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
pub(crate) fn reenable(&self) {
|
||||
self.request_tx
|
||||
.send(EmulationRequest::Reenable)
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
pub(crate) fn request_port_change(&self, port: u16) {
|
||||
self.request_tx
|
||||
.send(EmulationRequest::ChangePort(port))
|
||||
.expect("channel closed")
|
||||
}
|
||||
|
||||
pub(crate) async fn event(&mut self) -> EmulationEvent {
|
||||
self.event_rx.recv().await.expect("channel closed")
|
||||
}
|
||||
|
||||
/// wait for termination
|
||||
pub(crate) async fn terminate(&mut self) {
|
||||
log::debug!("terminating emulation");
|
||||
self.request_tx
|
||||
.send(EmulationRequest::Terminate)
|
||||
.expect("channel closed");
|
||||
if let Err(e) = (&mut self.task).await {
|
||||
log::warn!("{e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct ListenTask {
|
||||
listener: LanMouseListener,
|
||||
emulation_proxy: EmulationProxy,
|
||||
request_rx: Receiver<EmulationRequest>,
|
||||
event_tx: Sender<EmulationEvent>,
|
||||
}
|
||||
|
||||
impl ListenTask {
|
||||
async fn run(mut self) {
|
||||
let mut interval = tokio::time::interval(Duration::from_secs(5));
|
||||
let mut last_response = HashMap::new();
|
||||
loop {
|
||||
select! {
|
||||
e = self.listener.next() => {
|
||||
let (event, addr) = match e {
|
||||
Some(e) => e,
|
||||
None => break,
|
||||
};
|
||||
log::trace!("{event} <-<-<-<-<- {addr}");
|
||||
last_response.insert(addr, Instant::now());
|
||||
match event {
|
||||
ProtoEvent::Enter(pos) => {
|
||||
if let Some(fingerprint) = self.listener.get_certificate_fingerprint(addr).await {
|
||||
log::info!("releasing capture: {addr} entered this device");
|
||||
self.event_tx.send(EmulationEvent::ReleaseNotify).expect("channel closed");
|
||||
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::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,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
event = self.emulation_proxy.event() => {
|
||||
self.event_tx.send(event).expect("channel closed");
|
||||
}
|
||||
request = self.request_rx.recv() => match request.expect("channel closed") {
|
||||
// reenable emulation
|
||||
EmulationRequest::Reenable => self.emulation_proxy.reenable(),
|
||||
// notify the other end that we hit a barrier (should release capture)
|
||||
EmulationRequest::Release(addr) => self.listener.reply(addr, ProtoEvent::Leave(0)).await,
|
||||
EmulationRequest::ChangePort(port) => {
|
||||
self.listener.request_port_change(port);
|
||||
let result = self.listener.port_changed().await;
|
||||
self.event_tx.send(EmulationEvent::PortChanged(result)).expect("channel closed");
|
||||
}
|
||||
EmulationRequest::Terminate => break,
|
||||
},
|
||||
_ = interval.tick() => {
|
||||
last_response.retain(|&addr,instant| {
|
||||
if instant.elapsed() > Duration::from_secs(1) {
|
||||
log::warn!("releasing keys: {addr} not responding!");
|
||||
self.emulation_proxy.remove(addr);
|
||||
self.event_tx.send(EmulationEvent::Disconnected { addr }).expect("channel closed");
|
||||
false
|
||||
} else {
|
||||
true
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
self.listener.terminate().await;
|
||||
self.emulation_proxy.terminate().await;
|
||||
}
|
||||
}
|
||||
|
||||
/// proxy handling the actual input emulation,
|
||||
/// discarding events when it is disabled
|
||||
pub(crate) struct EmulationProxy {
|
||||
emulation_active: Rc<Cell<bool>>,
|
||||
exit_requested: Rc<Cell<bool>>,
|
||||
request_tx: Sender<ProxyRequest>,
|
||||
event_rx: Receiver<EmulationEvent>,
|
||||
task: JoinHandle<()>,
|
||||
}
|
||||
|
||||
enum ProxyRequest {
|
||||
Input(Event, SocketAddr),
|
||||
Remove(SocketAddr),
|
||||
Terminate,
|
||||
Reenable,
|
||||
}
|
||||
|
||||
impl EmulationProxy {
|
||||
fn new(backend: Option<input_emulation::Backend>) -> Self {
|
||||
let (request_tx, request_rx) = channel();
|
||||
let (event_tx, event_rx) = channel();
|
||||
let emulation_active = Rc::new(Cell::new(false));
|
||||
let exit_requested = Rc::new(Cell::new(false));
|
||||
let emulation_task = EmulationTask {
|
||||
backend,
|
||||
exit_requested: exit_requested.clone(),
|
||||
request_rx,
|
||||
event_tx,
|
||||
handles: Default::default(),
|
||||
next_id: 0,
|
||||
};
|
||||
let task = spawn_local(emulation_task.run());
|
||||
Self {
|
||||
emulation_active,
|
||||
exit_requested,
|
||||
request_tx,
|
||||
task,
|
||||
event_rx,
|
||||
}
|
||||
}
|
||||
|
||||
async fn event(&mut self) -> EmulationEvent {
|
||||
let event = self.event_rx.recv().await.expect("channel closed");
|
||||
if let EmulationEvent::EmulationEnabled = event {
|
||||
self.emulation_active.replace(true);
|
||||
}
|
||||
if let EmulationEvent::EmulationDisabled = event {
|
||||
self.emulation_active.replace(false);
|
||||
}
|
||||
event
|
||||
}
|
||||
|
||||
fn consume(&self, event: Event, addr: SocketAddr) {
|
||||
// ignore events if emulation is currently disabled
|
||||
if self.emulation_active.get() {
|
||||
self.request_tx
|
||||
.send(ProxyRequest::Input(event, addr))
|
||||
.expect("channel closed");
|
||||
}
|
||||
}
|
||||
|
||||
fn remove(&self, addr: SocketAddr) {
|
||||
self.request_tx
|
||||
.send(ProxyRequest::Remove(addr))
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
fn reenable(&self) {
|
||||
self.request_tx
|
||||
.send(ProxyRequest::Reenable)
|
||||
.expect("channel closed");
|
||||
}
|
||||
|
||||
async fn terminate(&mut self) {
|
||||
self.exit_requested.replace(true);
|
||||
self.request_tx
|
||||
.send(ProxyRequest::Terminate)
|
||||
.expect("channel closed");
|
||||
let _ = (&mut self.task).await;
|
||||
}
|
||||
}
|
||||
|
||||
struct EmulationTask {
|
||||
backend: Option<input_emulation::Backend>,
|
||||
exit_requested: Rc<Cell<bool>>,
|
||||
request_rx: Receiver<ProxyRequest>,
|
||||
event_tx: Sender<EmulationEvent>,
|
||||
handles: HashMap<SocketAddr, EmulationHandle>,
|
||||
next_id: EmulationHandle,
|
||||
}
|
||||
|
||||
impl EmulationTask {
|
||||
async fn run(mut self) {
|
||||
loop {
|
||||
if let Err(e) = self.do_emulation().await {
|
||||
log::warn!("input emulation exited: {e}");
|
||||
}
|
||||
if self.exit_requested.get() {
|
||||
break;
|
||||
}
|
||||
// wait for reenable request
|
||||
loop {
|
||||
match self.request_rx.recv().await.expect("channel closed") {
|
||||
ProxyRequest::Reenable => break,
|
||||
ProxyRequest::Terminate => return,
|
||||
ProxyRequest::Input(..) => { /* emulation inactive => ignore */ }
|
||||
ProxyRequest::Remove(..) => { /* emulation inactive => ignore */ }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_emulation(&mut self) -> Result<(), InputEmulationError> {
|
||||
log::info!("creating input emulation ...");
|
||||
let mut emulation = tokio::select! {
|
||||
r = InputEmulation::new(self.backend) => r?,
|
||||
// allow termination event while requesting input emulation
|
||||
_ = wait_for_termination(&mut self.request_rx) => return Ok(()),
|
||||
};
|
||||
|
||||
// used to send enabled and disabled events
|
||||
let _emulation_guard = DropGuard::new(
|
||||
self.event_tx.clone(),
|
||||
EmulationEvent::EmulationEnabled,
|
||||
EmulationEvent::EmulationDisabled,
|
||||
);
|
||||
|
||||
// create active handles
|
||||
if let Err(e) = self.create_clients(&mut emulation).await {
|
||||
emulation.terminate().await;
|
||||
return Err(e);
|
||||
}
|
||||
|
||||
let res = self.do_emulation_session(&mut emulation).await;
|
||||
// FIXME replace with async drop when stabilized
|
||||
emulation.terminate().await;
|
||||
res
|
||||
}
|
||||
|
||||
async fn create_clients(
|
||||
&mut self,
|
||||
emulation: &mut InputEmulation,
|
||||
) -> Result<(), InputEmulationError> {
|
||||
for handle in self.handles.values() {
|
||||
tokio::select! {
|
||||
_ = emulation.create(*handle) => {},
|
||||
_ = wait_for_termination(&mut self.request_rx) => return Ok(()),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn do_emulation_session(
|
||||
&mut self,
|
||||
emulation: &mut InputEmulation,
|
||||
) -> Result<(), InputEmulationError> {
|
||||
loop {
|
||||
tokio::select! {
|
||||
e = self.request_rx.recv() => match e.expect("channel closed") {
|
||||
ProxyRequest::Input(event, addr) => {
|
||||
let handle = match self.handles.get(&addr) {
|
||||
Some(&handle) => handle,
|
||||
None => {
|
||||
let handle = self.next_id;
|
||||
self.next_id += 1;
|
||||
emulation.create(handle).await;
|
||||
self.handles.insert(addr, handle);
|
||||
handle
|
||||
}
|
||||
};
|
||||
emulation.consume(event, handle).await?;
|
||||
},
|
||||
ProxyRequest::Remove(addr) => {
|
||||
if let Some(handle) = self.handles.remove(&addr) {
|
||||
emulation.destroy(handle).await;
|
||||
}
|
||||
}
|
||||
ProxyRequest::Terminate => break Ok(()),
|
||||
ProxyRequest::Reenable => continue,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn to_ipc_pos(pos: Position) -> lan_mouse_ipc::Position {
|
||||
match pos {
|
||||
Position::Left => lan_mouse_ipc::Position::Left,
|
||||
Position::Right => lan_mouse_ipc::Position::Right,
|
||||
Position::Top => lan_mouse_ipc::Position::Top,
|
||||
Position::Bottom => lan_mouse_ipc::Position::Bottom,
|
||||
}
|
||||
}
|
||||
|
||||
async fn wait_for_termination(rx: &mut Receiver<ProxyRequest>) {
|
||||
loop {
|
||||
match rx.recv().await.expect("channel closed") {
|
||||
ProxyRequest::Terminate => return,
|
||||
ProxyRequest::Input(_, _) => continue,
|
||||
ProxyRequest::Remove(_) => continue,
|
||||
ProxyRequest::Reenable => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct DropGuard<T> {
|
||||
tx: Sender<T>,
|
||||
on_drop: Option<T>,
|
||||
}
|
||||
|
||||
impl<T> DropGuard<T> {
|
||||
fn new(tx: Sender<T>, on_new: T, on_drop: T) -> Self {
|
||||
tx.send(on_new).expect("channel closed");
|
||||
let on_drop = Some(on_drop);
|
||||
Self { tx, on_drop }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Drop for DropGuard<T> {
|
||||
fn drop(&mut self) {
|
||||
self.tx
|
||||
.send(self.on_drop.take().expect("item"))
|
||||
.expect("channel closed");
|
||||
}
|
||||
}
|
||||
12
src/lib.rs
12
src/lib.rs
@@ -1,11 +1,7 @@
|
||||
mod capture;
|
||||
pub mod capture_test;
|
||||
pub mod client;
|
||||
pub mod config;
|
||||
mod connect;
|
||||
mod crypto;
|
||||
mod dns;
|
||||
mod emulation;
|
||||
pub mod dns;
|
||||
pub mod server;
|
||||
|
||||
pub mod capture_test;
|
||||
pub mod emulation_test;
|
||||
mod listen;
|
||||
pub mod service;
|
||||
|
||||
224
src/listen.rs
224
src/listen.rs
@@ -1,224 +0,0 @@
|
||||
use futures::{Stream, StreamExt};
|
||||
use lan_mouse_proto::{ProtoEvent, MAX_EVENT_SIZE};
|
||||
use local_channel::mpsc::{channel, Receiver, Sender};
|
||||
use rustls::pki_types::CertificateDer;
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
net::SocketAddr,
|
||||
rc::Rc,
|
||||
sync::{Arc, RwLock},
|
||||
time::Duration,
|
||||
};
|
||||
use thiserror::Error;
|
||||
use tokio::{
|
||||
sync::Mutex,
|
||||
task::{spawn_local, JoinHandle},
|
||||
};
|
||||
use webrtc_dtls::{
|
||||
config::{ClientAuthType::RequireAnyClientCert, Config, ExtendedMasterSecretType},
|
||||
conn::DTLSConn,
|
||||
crypto::Certificate,
|
||||
listener::listen,
|
||||
};
|
||||
use webrtc_util::{conn::Listener, Conn, Error};
|
||||
|
||||
use crate::crypto;
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum ListenerCreationError {
|
||||
#[error(transparent)]
|
||||
WebrtcUtil(#[from] webrtc_util::Error),
|
||||
#[error(transparent)]
|
||||
WebrtcDtls(#[from] webrtc_dtls::Error),
|
||||
}
|
||||
|
||||
type ArcConn = Arc<dyn Conn + Send + Sync>;
|
||||
|
||||
pub(crate) struct LanMouseListener {
|
||||
listen_rx: Receiver<(ProtoEvent, SocketAddr)>,
|
||||
listen_tx: Sender<(ProtoEvent, SocketAddr)>,
|
||||
listen_task: JoinHandle<()>,
|
||||
conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
|
||||
request_port_change: Sender<u16>,
|
||||
port_changed: Receiver<Result<u16, ListenerCreationError>>,
|
||||
}
|
||||
|
||||
type VerifyPeerCertificateFn = Arc<
|
||||
dyn (Fn(&[Vec<u8>], &[CertificateDer<'static>]) -> Result<(), webrtc_dtls::Error>)
|
||||
+ Send
|
||||
+ Sync,
|
||||
>;
|
||||
|
||||
impl LanMouseListener {
|
||||
pub(crate) async fn new(
|
||||
port: u16,
|
||||
cert: Certificate,
|
||||
authorized_keys: Arc<RwLock<HashMap<String, String>>>,
|
||||
) -> Result<Self, ListenerCreationError> {
|
||||
let (listen_tx, listen_rx) = channel();
|
||||
let (request_port_change, mut request_port_change_rx) = channel();
|
||||
let (port_changed_tx, port_changed) = channel();
|
||||
|
||||
let authorized = authorized_keys.clone();
|
||||
let verify_peer_certificate: Option<VerifyPeerCertificateFn> = Some(Arc::new(
|
||||
move |certs: &[Vec<u8>], _chains: &[CertificateDer<'static>]| {
|
||||
assert!(certs.len() == 1);
|
||||
let fingerprints = certs
|
||||
.iter()
|
||||
.map(|c| crypto::generate_fingerprint(c))
|
||||
.collect::<Vec<_>>();
|
||||
if authorized
|
||||
.read()
|
||||
.expect("lock")
|
||||
.contains_key(&fingerprints[0])
|
||||
{
|
||||
Ok(())
|
||||
} else {
|
||||
Err(webrtc_dtls::Error::ErrVerifyDataMismatch)
|
||||
}
|
||||
},
|
||||
));
|
||||
let cfg = Config {
|
||||
certificates: vec![cert.clone()],
|
||||
extended_master_secret: ExtendedMasterSecretType::Require,
|
||||
client_auth: RequireAnyClientCert,
|
||||
verify_peer_certificate,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
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<Mutex<Vec<(SocketAddr, ArcConn)>>> = Rc::new(Mutex::new(Vec::new()));
|
||||
|
||||
let conns_clone = conns.clone();
|
||||
let tx = listen_tx.clone();
|
||||
let listen_task: JoinHandle<()> = spawn_local(async move {
|
||||
loop {
|
||||
let sleep = tokio::time::sleep(Duration::from_secs(2));
|
||||
tokio::select! {
|
||||
/* workaround for https://github.com/webrtc-rs/webrtc/issues/614 */
|
||||
_ = sleep => continue,
|
||||
c = listener.accept() => match c {
|
||||
Ok((conn, addr)) => {
|
||||
log::info!("dtls client connected, ip: {addr}");
|
||||
let mut conns = conns_clone.lock().await;
|
||||
conns.push((addr, conn.clone()));
|
||||
spawn_local(read_loop(conns_clone.clone(), addr, conn, tx.clone()));
|
||||
},
|
||||
Err(e) => log::warn!("accept: {e}"),
|
||||
},
|
||||
port = request_port_change_rx.recv() => {
|
||||
let port = port.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,
|
||||
listen_rx,
|
||||
listen_tx,
|
||||
listen_task,
|
||||
port_changed,
|
||||
request_port_change,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn request_port_change(&mut self, port: u16) {
|
||||
self.request_port_change.send(port).expect("channel closed");
|
||||
}
|
||||
|
||||
pub(crate) async fn port_changed(&mut self) -> Result<u16, ListenerCreationError> {
|
||||
self.port_changed.recv().await.expect("channel closed")
|
||||
}
|
||||
|
||||
pub(crate) async fn terminate(&mut self) {
|
||||
self.listen_task.abort();
|
||||
let conns = self.conns.lock().await;
|
||||
for (_, conn) in conns.iter() {
|
||||
let _ = conn.close().await;
|
||||
}
|
||||
self.listen_tx.close();
|
||||
}
|
||||
|
||||
pub(crate) async fn reply(&self, addr: SocketAddr, event: ProtoEvent) {
|
||||
log::trace!("reply {event} >=>=>=>=>=> {addr}");
|
||||
let (buf, len): ([u8; MAX_EVENT_SIZE], usize) = event.into();
|
||||
let conns = self.conns.lock().await;
|
||||
for (a, conn) in conns.iter() {
|
||||
if *a == addr {
|
||||
let _ = conn.send(&buf[..len]).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn get_certificate_fingerprint(&self, addr: SocketAddr) -> Option<String> {
|
||||
if let Some(conn) = self
|
||||
.conns
|
||||
.lock()
|
||||
.await
|
||||
.iter()
|
||||
.find(|(a, _)| *a == addr)
|
||||
.map(|(_, c)| c.clone())
|
||||
{
|
||||
let conn: &DTLSConn = conn.as_any().downcast_ref().expect("dtls conn");
|
||||
let certs = conn.connection_state().await.peer_certificates;
|
||||
let cert = certs.first()?;
|
||||
let fingerprint = crypto::generate_fingerprint(cert);
|
||||
Some(fingerprint)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Stream for LanMouseListener {
|
||||
type Item = (ProtoEvent, SocketAddr);
|
||||
|
||||
fn poll_next(
|
||||
mut self: std::pin::Pin<&mut Self>,
|
||||
cx: &mut std::task::Context<'_>,
|
||||
) -> std::task::Poll<Option<Self::Item>> {
|
||||
self.listen_rx.poll_next_unpin(cx)
|
||||
}
|
||||
}
|
||||
|
||||
async fn read_loop(
|
||||
conns: Rc<Mutex<Vec<(SocketAddr, ArcConn)>>>,
|
||||
addr: SocketAddr,
|
||||
conn: ArcConn,
|
||||
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.send((event, addr)).expect("channel closed"),
|
||||
Err(e) => {
|
||||
log::warn!("error receiving event: {e}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
log::info!("dtls client disconnected {:?}", addr);
|
||||
let mut conns = conns.lock().await;
|
||||
let index = conns
|
||||
.iter()
|
||||
.position(|(a, _)| *a == addr)
|
||||
.expect("connection not found");
|
||||
conns.remove(index);
|
||||
Ok(())
|
||||
}
|
||||
20
src/main.rs
20
src/main.rs
@@ -5,9 +5,9 @@ use lan_mouse::{
|
||||
capture_test,
|
||||
config::{Config, ConfigError, Frontend},
|
||||
emulation_test,
|
||||
service::{Service, ServiceError},
|
||||
server::{Server, ServiceError},
|
||||
};
|
||||
use lan_mouse_ipc::{IpcError, IpcListenerCreationError};
|
||||
use lan_mouse_ipc::IpcError;
|
||||
use std::{
|
||||
future::Future,
|
||||
io,
|
||||
@@ -32,7 +32,7 @@ enum LanMouseError {
|
||||
Emulation(#[from] InputEmulationError),
|
||||
}
|
||||
|
||||
fn main() {
|
||||
pub fn main() {
|
||||
// init logging
|
||||
let env = Env::default().filter_or("LAN_MOUSE_LOG_LEVEL", "info");
|
||||
env_logger::init_from_env(env);
|
||||
@@ -46,18 +46,16 @@ fn main() {
|
||||
fn run() -> Result<(), LanMouseError> {
|
||||
// parse config file + cli args
|
||||
let config = Config::new()?;
|
||||
log::debug!("{config:?}");
|
||||
log::info!("release bind: {:?}", config.release_bind);
|
||||
|
||||
if config.test_capture {
|
||||
run_async(capture_test::run(config))?;
|
||||
} else if config.test_emulation {
|
||||
run_async(emulation_test::run(config))?;
|
||||
} else if config.daemon {
|
||||
// if daemon is specified we run the service
|
||||
match run_async(run_service(config)) {
|
||||
Err(LanMouseError::Service(ServiceError::IpcListen(
|
||||
IpcListenerCreationError::AlreadyRunning,
|
||||
))) => log::info!("service already running!"),
|
||||
r => r?,
|
||||
}
|
||||
run_async(run_service(config))?;
|
||||
} else {
|
||||
// otherwise start the service as a child process and
|
||||
// run a frontend
|
||||
@@ -102,10 +100,8 @@ fn start_service() -> Result<Child, io::Error> {
|
||||
}
|
||||
|
||||
async fn run_service(config: Config) -> Result<(), ServiceError> {
|
||||
log::info!("using config: {:?}", config.path);
|
||||
log::info!("Press {:?} to release the mouse", config.release_bind);
|
||||
let mut service = Service::new(config).await?;
|
||||
service.run().await?;
|
||||
Server::new(config).run().await?;
|
||||
log::info!("service exited!");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
562
src/server.rs
Normal file
562
src/server.rs
Normal file
@@ -0,0 +1,562 @@
|
||||
use capture_task::CaptureRequest;
|
||||
use emulation_task::EmulationRequest;
|
||||
use futures::StreamExt;
|
||||
use hickory_resolver::error::ResolveError;
|
||||
use local_channel::mpsc::{channel, Sender};
|
||||
use log;
|
||||
use std::{
|
||||
cell::{Cell, RefCell},
|
||||
collections::{HashSet, VecDeque},
|
||||
io,
|
||||
net::{IpAddr, SocketAddr},
|
||||
rc::Rc,
|
||||
};
|
||||
use thiserror::Error;
|
||||
use tokio::{join, signal, sync::Notify};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::{client::ClientManager, config::Config, dns::DnsResolver};
|
||||
|
||||
use lan_mouse_ipc::{
|
||||
AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
|
||||
ListenerCreationError, Position, Status,
|
||||
};
|
||||
|
||||
mod capture_task;
|
||||
mod emulation_task;
|
||||
mod network_task;
|
||||
mod ping_task;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
enum State {
|
||||
/// Currently sending events to another device
|
||||
Sending,
|
||||
/// Currently receiving events from other devices
|
||||
Receiving,
|
||||
/// Entered the deadzone of another device but waiting
|
||||
/// for acknowledgement (Leave event) from the device
|
||||
AwaitAck,
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum ServiceError {
|
||||
#[error(transparent)]
|
||||
Dns(#[from] ResolveError),
|
||||
#[error(transparent)]
|
||||
Listen(#[from] ListenerCreationError),
|
||||
#[error(transparent)]
|
||||
Io(#[from] io::Error),
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Server {
|
||||
active_client: Rc<Cell<Option<ClientHandle>>>,
|
||||
pub(crate) client_manager: Rc<RefCell<ClientManager>>,
|
||||
port: Rc<Cell<u16>>,
|
||||
state: Rc<Cell<State>>,
|
||||
release_bind: Vec<input_event::scancode::Linux>,
|
||||
notifies: Rc<Notifies>,
|
||||
config: Rc<Config>,
|
||||
pending_frontend_events: Rc<RefCell<VecDeque<FrontendEvent>>>,
|
||||
capture_status: Rc<Cell<Status>>,
|
||||
emulation_status: Rc<Cell<Status>>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Notifies {
|
||||
capture: Notify,
|
||||
emulation: Notify,
|
||||
ping: Notify,
|
||||
port_changed: Notify,
|
||||
frontend_event_pending: Notify,
|
||||
cancel: CancellationToken,
|
||||
}
|
||||
|
||||
impl Server {
|
||||
pub fn new(config: Config) -> Self {
|
||||
let active_client = Rc::new(Cell::new(None));
|
||||
let client_manager = Rc::new(RefCell::new(ClientManager::default()));
|
||||
let state = Rc::new(Cell::new(State::Receiving));
|
||||
let port = Rc::new(Cell::new(config.port));
|
||||
for config_client in config.get_clients() {
|
||||
let client = ClientConfig {
|
||||
hostname: config_client.hostname,
|
||||
fix_ips: config_client.ips.into_iter().collect(),
|
||||
port: config_client.port,
|
||||
pos: config_client.pos,
|
||||
cmd: config_client.enter_hook,
|
||||
};
|
||||
let state = ClientState {
|
||||
active: config_client.active,
|
||||
ips: HashSet::from_iter(client.fix_ips.iter().cloned()),
|
||||
..Default::default()
|
||||
};
|
||||
let mut client_manager = client_manager.borrow_mut();
|
||||
let handle = client_manager.add_client();
|
||||
let c = client_manager.get_mut(handle).expect("invalid handle");
|
||||
*c = (client, state);
|
||||
}
|
||||
|
||||
// task notification tokens
|
||||
let notifies = Rc::new(Notifies::default());
|
||||
let release_bind = config.release_bind.clone();
|
||||
|
||||
let config = Rc::new(config);
|
||||
|
||||
Self {
|
||||
config,
|
||||
active_client,
|
||||
client_manager,
|
||||
port,
|
||||
state,
|
||||
release_bind,
|
||||
notifies,
|
||||
pending_frontend_events: Rc::new(RefCell::new(VecDeque::new())),
|
||||
capture_status: Default::default(),
|
||||
emulation_status: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn run(&mut self) -> Result<(), ServiceError> {
|
||||
// create frontend communication adapter, exit if already running
|
||||
let mut frontend = match AsyncFrontendListener::new().await {
|
||||
Ok(f) => f,
|
||||
Err(ListenerCreationError::AlreadyRunning) => {
|
||||
log::info!("service already running, exiting");
|
||||
return Ok(());
|
||||
}
|
||||
e => e?,
|
||||
};
|
||||
|
||||
let (capture_tx, capture_rx) = channel(); /* requests for input capture */
|
||||
let (emulation_tx, emulation_rx) = channel(); /* emulation requests */
|
||||
let (udp_recv_tx, udp_recv_rx) = channel(); /* udp receiver */
|
||||
let (udp_send_tx, udp_send_rx) = channel(); /* udp sender */
|
||||
let (dns_tx, dns_rx) = channel(); /* dns requests */
|
||||
|
||||
let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
|
||||
let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
|
||||
let emulation =
|
||||
emulation_task::new(self.clone(), emulation_rx, udp_recv_rx, udp_send_tx.clone());
|
||||
let resolver = DnsResolver::new(dns_rx)?;
|
||||
let dns_task = tokio::task::spawn_local(resolver.run(self.clone()));
|
||||
|
||||
// task that pings clients to see if they are responding
|
||||
let ping = ping_task::new(
|
||||
self.clone(),
|
||||
udp_send_tx.clone(),
|
||||
emulation_tx.clone(),
|
||||
capture_tx.clone(),
|
||||
);
|
||||
|
||||
for handle in self.active_clients() {
|
||||
dns_tx.send(handle).expect("channel closed");
|
||||
}
|
||||
|
||||
loop {
|
||||
tokio::select! {
|
||||
request = frontend.next() => {
|
||||
let request = match request {
|
||||
Some(Ok(r)) => r,
|
||||
Some(Err(e)) => {
|
||||
log::error!("error receiving request: {e}");
|
||||
continue;
|
||||
}
|
||||
None => break,
|
||||
};
|
||||
log::debug!("handle frontend request: {request:?}");
|
||||
self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request, &dns_tx);
|
||||
}
|
||||
_ = self.notifies.frontend_event_pending.notified() => {
|
||||
while let Some(event) = {
|
||||
/* need to drop borrow before next iteration! */
|
||||
let event = self.pending_frontend_events.borrow_mut().pop_front();
|
||||
event
|
||||
} {
|
||||
frontend.broadcast(event).await;
|
||||
}
|
||||
},
|
||||
_ = self.cancelled() => break,
|
||||
r = signal::ctrl_c() => {
|
||||
r.expect("failed to wait for CTRL+C");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log::info!("terminating service");
|
||||
|
||||
self.cancel();
|
||||
let _ = join!(capture, dns_task, emulation, network, ping);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn notify_frontend(&self, event: FrontendEvent) {
|
||||
self.pending_frontend_events.borrow_mut().push_back(event);
|
||||
self.notifies.frontend_event_pending.notify_one();
|
||||
}
|
||||
|
||||
fn cancel(&self) {
|
||||
self.notifies.cancel.cancel();
|
||||
}
|
||||
|
||||
pub(crate) async fn cancelled(&self) {
|
||||
self.notifies.cancel.cancelled().await
|
||||
}
|
||||
|
||||
fn is_cancelled(&self) -> bool {
|
||||
self.notifies.cancel.is_cancelled()
|
||||
}
|
||||
|
||||
fn notify_capture(&self) {
|
||||
log::info!("received capture enable request");
|
||||
self.notifies.capture.notify_waiters()
|
||||
}
|
||||
|
||||
async fn capture_enabled(&self) {
|
||||
self.notifies.capture.notified().await
|
||||
}
|
||||
|
||||
fn notify_emulation(&self) {
|
||||
log::info!("received emulation enable request");
|
||||
self.notifies.emulation.notify_waiters()
|
||||
}
|
||||
|
||||
async fn emulation_notified(&self) {
|
||||
self.notifies.emulation.notified().await
|
||||
}
|
||||
|
||||
fn restart_ping_timer(&self) {
|
||||
self.notifies.ping.notify_waiters()
|
||||
}
|
||||
|
||||
async fn ping_timer_notified(&self) {
|
||||
self.notifies.ping.notified().await
|
||||
}
|
||||
|
||||
fn request_port_change(&self, port: u16) {
|
||||
self.port.replace(port);
|
||||
self.notifies.port_changed.notify_one();
|
||||
}
|
||||
|
||||
fn notify_port_changed(&self, port: u16, msg: Option<String>) {
|
||||
self.port.replace(port);
|
||||
self.notify_frontend(FrontendEvent::PortChanged(port, msg));
|
||||
}
|
||||
|
||||
pub(crate) fn client_updated(&self, handle: ClientHandle) {
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
}
|
||||
|
||||
fn active_clients(&self) -> Vec<ClientHandle> {
|
||||
self.client_manager
|
||||
.borrow()
|
||||
.get_client_states()
|
||||
.filter(|(_, (_, s))| s.active)
|
||||
.map(|(h, _)| h)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn handle_request(
|
||||
&self,
|
||||
capture: &Sender<CaptureRequest>,
|
||||
emulate: &Sender<EmulationRequest>,
|
||||
event: FrontendRequest,
|
||||
dns: &Sender<ClientHandle>,
|
||||
) -> bool {
|
||||
log::debug!("frontend: {event:?}");
|
||||
match event {
|
||||
FrontendRequest::EnableCapture => self.notify_capture(),
|
||||
FrontendRequest::EnableEmulation => self.notify_emulation(),
|
||||
FrontendRequest::Create => {
|
||||
self.add_client();
|
||||
}
|
||||
FrontendRequest::Activate(handle, active) => {
|
||||
if active {
|
||||
self.activate_client(capture, emulate, handle);
|
||||
} else {
|
||||
self.deactivate_client(capture, emulate, handle);
|
||||
}
|
||||
}
|
||||
FrontendRequest::ChangePort(port) => self.request_port_change(port),
|
||||
FrontendRequest::Delete(handle) => {
|
||||
self.remove_client(capture, emulate, handle);
|
||||
self.notify_frontend(FrontendEvent::Deleted(handle));
|
||||
}
|
||||
FrontendRequest::Enumerate() => self.enumerate(),
|
||||
FrontendRequest::GetState(handle) => self.broadcast_client(handle),
|
||||
FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
|
||||
FrontendRequest::UpdateHostname(handle, host) => {
|
||||
self.update_hostname(handle, host, dns)
|
||||
}
|
||||
FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
|
||||
FrontendRequest::UpdatePosition(handle, pos) => {
|
||||
self.update_pos(handle, capture, emulate, pos)
|
||||
}
|
||||
FrontendRequest::ResolveDns(handle) => dns.send(handle).expect("channel closed"),
|
||||
FrontendRequest::Sync => {
|
||||
self.enumerate();
|
||||
self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status.get()));
|
||||
self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status.get()));
|
||||
self.notify_frontend(FrontendEvent::PortChanged(self.port.get(), None));
|
||||
}
|
||||
};
|
||||
false
|
||||
}
|
||||
|
||||
fn enumerate(&self) {
|
||||
let clients = self
|
||||
.client_manager
|
||||
.borrow()
|
||||
.get_client_states()
|
||||
.map(|(h, (c, s))| (h, c.clone(), s.clone()))
|
||||
.collect();
|
||||
self.notify_frontend(FrontendEvent::Enumerate(clients));
|
||||
}
|
||||
|
||||
fn add_client(&self) -> ClientHandle {
|
||||
let handle = self.client_manager.borrow_mut().add_client();
|
||||
log::info!("added client {handle}");
|
||||
let (c, s) = self.client_manager.borrow().get(handle).unwrap().clone();
|
||||
self.notify_frontend(FrontendEvent::Created(handle, c, s));
|
||||
handle
|
||||
}
|
||||
|
||||
fn deactivate_client(
|
||||
&self,
|
||||
capture: &Sender<CaptureRequest>,
|
||||
emulate: &Sender<EmulationRequest>,
|
||||
handle: ClientHandle,
|
||||
) {
|
||||
match self.client_manager.borrow_mut().get_mut(handle) {
|
||||
None => return,
|
||||
Some((_, s)) if !s.active => return,
|
||||
Some((_, s)) => s.active = false,
|
||||
};
|
||||
|
||||
let _ = capture.send(CaptureRequest::Destroy(handle));
|
||||
let _ = emulate.send(EmulationRequest::Destroy(handle));
|
||||
self.client_updated(handle);
|
||||
log::info!("deactivated client {handle}");
|
||||
}
|
||||
|
||||
fn activate_client(
|
||||
&self,
|
||||
capture: &Sender<CaptureRequest>,
|
||||
emulate: &Sender<EmulationRequest>,
|
||||
handle: ClientHandle,
|
||||
) {
|
||||
/* deactivate potential other client at this position */
|
||||
let pos = match self.client_manager.borrow().get(handle) {
|
||||
None => return,
|
||||
Some((_, s)) if s.active => return,
|
||||
Some((client, _)) => client.pos,
|
||||
};
|
||||
|
||||
let other = self.client_manager.borrow_mut().find_client(pos);
|
||||
if let Some(other) = other {
|
||||
self.deactivate_client(capture, emulate, other);
|
||||
}
|
||||
|
||||
/* activate the client */
|
||||
if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
|
||||
s.active = true;
|
||||
} else {
|
||||
return;
|
||||
};
|
||||
|
||||
/* notify emulation, capture and frontends */
|
||||
let _ = capture.send(CaptureRequest::Create(handle, to_capture_pos(pos)));
|
||||
let _ = emulate.send(EmulationRequest::Create(handle));
|
||||
|
||||
self.client_updated(handle);
|
||||
|
||||
log::info!("activated client {handle} ({pos})");
|
||||
}
|
||||
|
||||
fn remove_client(
|
||||
&self,
|
||||
capture: &Sender<CaptureRequest>,
|
||||
emulate: &Sender<EmulationRequest>,
|
||||
handle: ClientHandle,
|
||||
) {
|
||||
let Some(active) = self
|
||||
.client_manager
|
||||
.borrow_mut()
|
||||
.remove_client(handle)
|
||||
.map(|(_, s)| s.active)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
|
||||
if active {
|
||||
let _ = capture.send(CaptureRequest::Destroy(handle));
|
||||
let _ = emulate.send(EmulationRequest::Destroy(handle));
|
||||
}
|
||||
}
|
||||
|
||||
fn update_pressed_keys(&self, handle: ClientHandle, has_pressed_keys: bool) {
|
||||
if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
|
||||
s.has_pressed_keys = has_pressed_keys;
|
||||
}
|
||||
}
|
||||
|
||||
fn update_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
|
||||
if let Some((c, _)) = self.client_manager.borrow_mut().get_mut(handle) {
|
||||
c.fix_ips = fix_ips;
|
||||
};
|
||||
self.update_ips(handle);
|
||||
self.client_updated(handle);
|
||||
}
|
||||
|
||||
pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
|
||||
if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
|
||||
s.dns_ips = dns_ips;
|
||||
};
|
||||
self.update_ips(handle);
|
||||
self.client_updated(handle);
|
||||
}
|
||||
|
||||
fn update_ips(&self, handle: ClientHandle) {
|
||||
if let Some((c, s)) = self.client_manager.borrow_mut().get_mut(handle) {
|
||||
s.ips = c
|
||||
.fix_ips
|
||||
.iter()
|
||||
.cloned()
|
||||
.chain(s.dns_ips.iter().cloned())
|
||||
.collect::<HashSet<_>>();
|
||||
}
|
||||
}
|
||||
|
||||
fn update_hostname(
|
||||
&self,
|
||||
handle: ClientHandle,
|
||||
hostname: Option<String>,
|
||||
dns: &Sender<ClientHandle>,
|
||||
) {
|
||||
let mut client_manager = self.client_manager.borrow_mut();
|
||||
let Some((c, s)) = client_manager.get_mut(handle) else {
|
||||
return;
|
||||
};
|
||||
|
||||
// hostname changed
|
||||
if c.hostname != hostname {
|
||||
c.hostname = hostname;
|
||||
s.active_addr = None;
|
||||
s.dns_ips.clear();
|
||||
drop(client_manager);
|
||||
self.update_ips(handle);
|
||||
dns.send(handle).expect("channel closed");
|
||||
}
|
||||
self.client_updated(handle);
|
||||
}
|
||||
|
||||
fn update_port(&self, handle: ClientHandle, port: u16) {
|
||||
let mut client_manager = self.client_manager.borrow_mut();
|
||||
let Some((c, s)) = client_manager.get_mut(handle) else {
|
||||
return;
|
||||
};
|
||||
|
||||
if c.port != port {
|
||||
c.port = port;
|
||||
s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
|
||||
}
|
||||
}
|
||||
|
||||
fn update_pos(
|
||||
&self,
|
||||
handle: ClientHandle,
|
||||
capture: &Sender<CaptureRequest>,
|
||||
emulate: &Sender<EmulationRequest>,
|
||||
pos: Position,
|
||||
) {
|
||||
let (changed, active) = {
|
||||
let mut client_manager = self.client_manager.borrow_mut();
|
||||
let Some((c, s)) = client_manager.get_mut(handle) else {
|
||||
return;
|
||||
};
|
||||
|
||||
let changed = c.pos != pos;
|
||||
if changed {
|
||||
log::info!("update pos {handle} {} -> {}", c.pos, pos);
|
||||
}
|
||||
c.pos = pos;
|
||||
(changed, s.active)
|
||||
};
|
||||
|
||||
// update state in event input emulator & input capture
|
||||
if changed {
|
||||
self.deactivate_client(capture, emulate, handle);
|
||||
if active {
|
||||
self.activate_client(capture, emulate, handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn broadcast_client(&self, handle: ClientHandle) {
|
||||
let client = self.client_manager.borrow().get(handle).cloned();
|
||||
let event = if let Some((config, state)) = client {
|
||||
FrontendEvent::State(handle, config, state)
|
||||
} else {
|
||||
FrontendEvent::NoSuchClient(handle)
|
||||
};
|
||||
self.notify_frontend(event);
|
||||
}
|
||||
|
||||
fn set_emulation_status(&self, status: Status) {
|
||||
self.emulation_status.replace(status);
|
||||
let status = FrontendEvent::EmulationStatus(status);
|
||||
self.notify_frontend(status);
|
||||
}
|
||||
|
||||
fn set_capture_status(&self, status: Status) {
|
||||
self.capture_status.replace(status);
|
||||
let status = FrontendEvent::CaptureStatus(status);
|
||||
self.notify_frontend(status);
|
||||
}
|
||||
|
||||
pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
|
||||
if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
|
||||
s.resolving = status;
|
||||
}
|
||||
self.client_updated(handle);
|
||||
}
|
||||
|
||||
pub(crate) fn get_hostname(&self, handle: ClientHandle) -> Option<String> {
|
||||
self.client_manager
|
||||
.borrow_mut()
|
||||
.get_mut(handle)
|
||||
.and_then(|(c, _)| c.hostname.clone())
|
||||
}
|
||||
|
||||
fn get_state(&self) -> State {
|
||||
self.state.get()
|
||||
}
|
||||
|
||||
fn set_state(&self, state: State) {
|
||||
log::debug!("state => {state:?}");
|
||||
self.state.replace(state);
|
||||
}
|
||||
|
||||
fn set_active(&self, handle: Option<ClientHandle>) {
|
||||
log::debug!("active client => {handle:?}");
|
||||
self.active_client.replace(handle);
|
||||
}
|
||||
|
||||
fn active_addr(&self, handle: ClientHandle) -> Option<SocketAddr> {
|
||||
self.client_manager
|
||||
.borrow()
|
||||
.get(handle)
|
||||
.and_then(|(_, s)| s.active_addr)
|
||||
}
|
||||
}
|
||||
|
||||
fn to_capture_pos(pos: Position) -> input_capture::Position {
|
||||
match pos {
|
||||
Position::Left => input_capture::Position::Left,
|
||||
Position::Right => input_capture::Position::Right,
|
||||
Position::Top => input_capture::Position::Top,
|
||||
Position::Bottom => input_capture::Position::Bottom,
|
||||
}
|
||||
}
|
||||
206
src/server/capture_task.rs
Normal file
206
src/server/capture_task.rs
Normal file
@@ -0,0 +1,206 @@
|
||||
use futures::StreamExt;
|
||||
use lan_mouse_proto::ProtoEvent;
|
||||
use local_channel::mpsc::{Receiver, Sender};
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use tokio::{process::Command, task::JoinHandle};
|
||||
|
||||
use input_capture::{
|
||||
self, CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
|
||||
};
|
||||
|
||||
use crate::server::State;
|
||||
use lan_mouse_ipc::{ClientHandle, Status};
|
||||
|
||||
use super::Server;
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(crate) enum CaptureRequest {
|
||||
/// capture must release the mouse
|
||||
Release,
|
||||
/// add a capture client
|
||||
Create(CaptureHandle, Position),
|
||||
/// destory a capture client
|
||||
Destroy(CaptureHandle),
|
||||
}
|
||||
|
||||
pub(crate) fn new(
|
||||
server: Server,
|
||||
capture_rx: Receiver<CaptureRequest>,
|
||||
udp_send: Sender<(ProtoEvent, SocketAddr)>,
|
||||
) -> JoinHandle<()> {
|
||||
let backend = server.config.capture_backend.map(|b| b.into());
|
||||
tokio::task::spawn_local(capture_task(server, backend, udp_send, capture_rx))
|
||||
}
|
||||
|
||||
async fn capture_task(
|
||||
server: Server,
|
||||
backend: Option<input_capture::Backend>,
|
||||
sender_tx: Sender<(ProtoEvent, SocketAddr)>,
|
||||
mut notify_rx: Receiver<CaptureRequest>,
|
||||
) {
|
||||
loop {
|
||||
if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await {
|
||||
log::warn!("input capture exited: {e}");
|
||||
}
|
||||
server.set_capture_status(Status::Disabled);
|
||||
if server.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
|
||||
// allow cancellation
|
||||
loop {
|
||||
tokio::select! {
|
||||
_ = notify_rx.recv() => continue, /* need to ignore requests here! */
|
||||
_ = server.capture_enabled() => break,
|
||||
_ = server.cancelled() => return,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_capture(
|
||||
backend: Option<input_capture::Backend>,
|
||||
server: &Server,
|
||||
sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
|
||||
notify_rx: &mut Receiver<CaptureRequest>,
|
||||
) -> Result<(), InputCaptureError> {
|
||||
/* allow cancelling capture request */
|
||||
let mut capture = tokio::select! {
|
||||
r = InputCapture::new(backend) => r?,
|
||||
_ = server.cancelled() => return Ok(()),
|
||||
};
|
||||
|
||||
server.set_capture_status(Status::Enabled);
|
||||
|
||||
let clients = server.active_clients();
|
||||
let clients = clients.iter().copied().map(|handle| {
|
||||
(
|
||||
handle,
|
||||
server
|
||||
.client_manager
|
||||
.borrow()
|
||||
.get(handle)
|
||||
.map(|(c, _)| c.pos)
|
||||
.expect("no such client"),
|
||||
)
|
||||
});
|
||||
for (handle, pos) in clients {
|
||||
capture.create(handle, to_capture_pos(pos)).await?;
|
||||
}
|
||||
|
||||
loop {
|
||||
tokio::select! {
|
||||
event = capture.next() => match event {
|
||||
Some(event) => handle_capture_event(server, &mut capture, sender_tx, event?).await?,
|
||||
None => return Ok(()),
|
||||
},
|
||||
e = notify_rx.recv() => {
|
||||
log::debug!("input capture notify rx: {e:?}");
|
||||
match e {
|
||||
Some(e) => match e {
|
||||
CaptureRequest::Release => {
|
||||
capture.release().await?;
|
||||
server.state.replace(State::Receiving);
|
||||
}
|
||||
CaptureRequest::Create(h, p) => capture.create(h, p).await?,
|
||||
CaptureRequest::Destroy(h) => capture.destroy(h).await?,
|
||||
},
|
||||
None => break,
|
||||
}
|
||||
}
|
||||
_ = server.cancelled() => break,
|
||||
}
|
||||
}
|
||||
capture.terminate().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn handle_capture_event(
|
||||
server: &Server,
|
||||
capture: &mut InputCapture,
|
||||
sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
|
||||
event: (CaptureHandle, CaptureEvent),
|
||||
) -> Result<(), CaptureError> {
|
||||
let (handle, event) = event;
|
||||
log::trace!("({handle}) {event:?}");
|
||||
|
||||
// capture started
|
||||
if event == CaptureEvent::Begin {
|
||||
// wait for remote to acknowlegde enter
|
||||
server.set_state(State::AwaitAck);
|
||||
server.set_active(Some(handle));
|
||||
// restart ping timer to release capture if unreachable
|
||||
server.restart_ping_timer();
|
||||
// spawn enter hook cmd
|
||||
spawn_hook_command(server, handle);
|
||||
}
|
||||
|
||||
// release capture if emulation set state to Receiveing
|
||||
if server.get_state() == State::Receiving {
|
||||
capture.release().await?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// check release bind
|
||||
if capture.keys_pressed(&server.release_bind) {
|
||||
capture.release().await?;
|
||||
server.set_state(State::Receiving);
|
||||
}
|
||||
|
||||
if let Some(addr) = server.active_addr(handle) {
|
||||
let event = match server.get_state() {
|
||||
State::Sending => match event {
|
||||
CaptureEvent::Begin => ProtoEvent::Enter(0),
|
||||
CaptureEvent::Input(e) => ProtoEvent::Input(e),
|
||||
},
|
||||
/* send additional enter events until acknowleged */
|
||||
State::AwaitAck => ProtoEvent::Enter(0),
|
||||
/* released capture */
|
||||
State::Receiving => ProtoEvent::Leave(0),
|
||||
};
|
||||
sender_tx.send((event, addr)).expect("sender closed");
|
||||
};
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn spawn_hook_command(server: &Server, handle: ClientHandle) {
|
||||
let Some(cmd) = server
|
||||
.client_manager
|
||||
.borrow()
|
||||
.get(handle)
|
||||
.and_then(|(c, _)| c.cmd.clone())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
tokio::task::spawn_local(async move {
|
||||
log::info!("spawning command!");
|
||||
let mut child = match Command::new("sh").arg("-c").arg(cmd.as_str()).spawn() {
|
||||
Ok(c) => c,
|
||||
Err(e) => {
|
||||
log::warn!("could not execute cmd: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
match child.wait().await {
|
||||
Ok(s) => {
|
||||
if s.success() {
|
||||
log::info!("{cmd} exited successfully");
|
||||
} else {
|
||||
log::warn!("{cmd} exited with {s}");
|
||||
}
|
||||
}
|
||||
Err(e) => log::warn!("{cmd}: {e}"),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn to_capture_pos(pos: lan_mouse_ipc::Position) -> input_capture::Position {
|
||||
match pos {
|
||||
lan_mouse_ipc::Position::Left => input_capture::Position::Left,
|
||||
lan_mouse_ipc::Position::Right => input_capture::Position::Right,
|
||||
lan_mouse_ipc::Position::Top => input_capture::Position::Top,
|
||||
lan_mouse_ipc::Position::Bottom => input_capture::Position::Bottom,
|
||||
}
|
||||
}
|
||||
188
src/server/emulation_task.rs
Normal file
188
src/server/emulation_task.rs
Normal file
@@ -0,0 +1,188 @@
|
||||
use local_channel::mpsc::{Receiver, Sender};
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use lan_mouse_proto::ProtoEvent;
|
||||
use tokio::task::JoinHandle;
|
||||
|
||||
use lan_mouse_ipc::ClientHandle;
|
||||
|
||||
use crate::{client::ClientManager, server::State};
|
||||
use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
|
||||
use lan_mouse_ipc::Status;
|
||||
|
||||
use super::{network_task::NetworkError, Server};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) enum EmulationRequest {
|
||||
/// create a new client
|
||||
Create(EmulationHandle),
|
||||
/// destroy a client
|
||||
Destroy(EmulationHandle),
|
||||
/// input emulation must release keys for client
|
||||
ReleaseKeys(ClientHandle),
|
||||
}
|
||||
|
||||
pub(crate) fn new(
|
||||
server: Server,
|
||||
emulation_rx: Receiver<EmulationRequest>,
|
||||
udp_rx: Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
|
||||
sender_tx: Sender<(ProtoEvent, SocketAddr)>,
|
||||
) -> JoinHandle<()> {
|
||||
let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx);
|
||||
tokio::task::spawn_local(emulation_task)
|
||||
}
|
||||
|
||||
async fn emulation_task(
|
||||
server: Server,
|
||||
mut rx: Receiver<EmulationRequest>,
|
||||
mut udp_rx: Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
|
||||
sender_tx: Sender<(ProtoEvent, SocketAddr)>,
|
||||
) {
|
||||
loop {
|
||||
if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_tx).await {
|
||||
log::warn!("input emulation exited: {e}");
|
||||
}
|
||||
server.set_emulation_status(Status::Disabled);
|
||||
if server.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
|
||||
// allow cancellation
|
||||
loop {
|
||||
tokio::select! {
|
||||
_ = rx.recv() => continue, /* need to ignore requests here! */
|
||||
_ = server.emulation_notified() => break,
|
||||
_ = server.cancelled() => return,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_emulation(
|
||||
server: &Server,
|
||||
rx: &mut Receiver<EmulationRequest>,
|
||||
udp_rx: &mut Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
|
||||
sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
|
||||
) -> Result<(), InputEmulationError> {
|
||||
let backend = server.config.emulation_backend.map(|b| b.into());
|
||||
log::info!("creating input emulation...");
|
||||
let mut emulation = tokio::select! {
|
||||
r = InputEmulation::new(backend) => r?,
|
||||
_ = server.cancelled() => return Ok(()),
|
||||
};
|
||||
|
||||
server.set_emulation_status(Status::Enabled);
|
||||
|
||||
// add clients
|
||||
for handle in server.active_clients() {
|
||||
emulation.create(handle).await;
|
||||
}
|
||||
|
||||
let res = do_emulation_session(server, &mut emulation, rx, udp_rx, sender_tx).await;
|
||||
emulation.terminate().await; // manual drop
|
||||
res
|
||||
}
|
||||
|
||||
async fn do_emulation_session(
|
||||
server: &Server,
|
||||
emulation: &mut InputEmulation,
|
||||
rx: &mut Receiver<EmulationRequest>,
|
||||
udp_rx: &mut Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
|
||||
sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
|
||||
) -> Result<(), InputEmulationError> {
|
||||
let mut last_ignored = None;
|
||||
|
||||
loop {
|
||||
tokio::select! {
|
||||
udp_event = udp_rx.recv() => {
|
||||
let udp_event = match udp_event.expect("channel closed") {
|
||||
Ok(e) => e,
|
||||
Err(e) => {
|
||||
log::warn!("network error: {e}");
|
||||
continue;
|
||||
}
|
||||
};
|
||||
handle_incoming_event(server, emulation, sender_tx, &mut last_ignored, udp_event).await?;
|
||||
}
|
||||
emulate_event = rx.recv() => {
|
||||
match emulate_event.expect("channel closed") {
|
||||
EmulationRequest::Create(h) => { let _ = emulation.create(h).await; },
|
||||
EmulationRequest::Destroy(h) => emulation.destroy(h).await,
|
||||
EmulationRequest::ReleaseKeys(c) => emulation.release_keys(c).await?,
|
||||
}
|
||||
}
|
||||
_ = server.notifies.cancel.cancelled() => break Ok(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn handle_incoming_event(
|
||||
server: &Server,
|
||||
emulate: &mut InputEmulation,
|
||||
sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
|
||||
last_ignored: &mut Option<SocketAddr>,
|
||||
event: (ProtoEvent, SocketAddr),
|
||||
) -> Result<(), EmulationError> {
|
||||
let (event, addr) = event;
|
||||
|
||||
log::trace!("{:20} <-<-<-<------ {addr}", event.to_string());
|
||||
|
||||
// get client handle for addr
|
||||
let Some(handle) =
|
||||
activate_client_if_exists(&mut server.client_manager.borrow_mut(), addr, last_ignored)
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
match (event, addr) {
|
||||
(ProtoEvent::Pong, _) => { /* ignore pong events */ }
|
||||
(ProtoEvent::Ping, addr) => {
|
||||
let _ = sender_tx.send((ProtoEvent::Pong, addr));
|
||||
}
|
||||
(ProtoEvent::Leave(_), _) => emulate.release_keys(handle).await?,
|
||||
(ProtoEvent::Ack(_), _) => server.set_state(State::Sending),
|
||||
(ProtoEvent::Enter(_), _) => {
|
||||
server.set_state(State::Receiving);
|
||||
sender_tx
|
||||
.send((ProtoEvent::Ack(0), addr))
|
||||
.expect("no channel")
|
||||
}
|
||||
(ProtoEvent::Input(e), _) => {
|
||||
if let State::Receiving = server.get_state() {
|
||||
log::trace!("{event} => emulate");
|
||||
emulate.consume(e, handle).await?;
|
||||
let has_pressed_keys = emulate.has_pressed_keys(handle);
|
||||
server.update_pressed_keys(handle, has_pressed_keys);
|
||||
if has_pressed_keys {
|
||||
server.restart_ping_timer();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn activate_client_if_exists(
|
||||
client_manager: &mut ClientManager,
|
||||
addr: SocketAddr,
|
||||
last_ignored: &mut Option<SocketAddr>,
|
||||
) -> Option<ClientHandle> {
|
||||
let Some(handle) = client_manager.get_client(addr) else {
|
||||
// log ignored if it is the first event from the client in a series
|
||||
if last_ignored.is_none() || last_ignored.is_some() && last_ignored.unwrap() != addr {
|
||||
log::warn!("ignoring events from client {addr}");
|
||||
last_ignored.replace(addr);
|
||||
}
|
||||
return None;
|
||||
};
|
||||
// next event can be logged as ignored again
|
||||
last_ignored.take();
|
||||
|
||||
let (_, client_state) = client_manager.get_mut(handle)?;
|
||||
|
||||
// reset ttl for client
|
||||
client_state.alive = true;
|
||||
// set addr as new default for this client
|
||||
client_state.active_addr = Some(addr);
|
||||
Some(handle)
|
||||
}
|
||||
99
src/server/network_task.rs
Normal file
99
src/server/network_task.rs
Normal file
@@ -0,0 +1,99 @@
|
||||
use local_channel::mpsc::{Receiver, Sender};
|
||||
use std::{io, net::SocketAddr};
|
||||
|
||||
use thiserror::Error;
|
||||
use tokio::{net::UdpSocket, task::JoinHandle};
|
||||
|
||||
use super::Server;
|
||||
use lan_mouse_proto::{ProtoEvent, ProtocolError};
|
||||
|
||||
pub(crate) async fn new(
|
||||
server: Server,
|
||||
udp_recv_tx: Sender<Result<(ProtoEvent, SocketAddr), NetworkError>>,
|
||||
udp_send_rx: Receiver<(ProtoEvent, SocketAddr)>,
|
||||
) -> io::Result<JoinHandle<()>> {
|
||||
// bind the udp socket
|
||||
let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), server.port.get());
|
||||
let mut socket = UdpSocket::bind(listen_addr).await?;
|
||||
|
||||
Ok(tokio::task::spawn_local(async move {
|
||||
let mut sender_rx = udp_send_rx;
|
||||
loop {
|
||||
let udp_receiver = udp_receiver(&socket, &udp_recv_tx);
|
||||
let udp_sender = udp_sender(&socket, &mut sender_rx);
|
||||
tokio::select! {
|
||||
_ = udp_receiver => break, /* channel closed */
|
||||
_ = udp_sender => break, /* channel closed */
|
||||
_ = server.notifies.port_changed.notified() => update_port(&server, &mut socket).await,
|
||||
_ = server.cancelled() => break, /* cancellation requested */
|
||||
}
|
||||
}
|
||||
}))
|
||||
}
|
||||
|
||||
async fn update_port(server: &Server, socket: &mut UdpSocket) {
|
||||
let new_port = server.port.get();
|
||||
let current_port = socket.local_addr().expect("socket not bound").port();
|
||||
|
||||
// if port is the same, we dont need to change it
|
||||
if current_port == new_port {
|
||||
return;
|
||||
}
|
||||
|
||||
// bind new socket
|
||||
let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), new_port);
|
||||
let new_socket = UdpSocket::bind(listen_addr).await;
|
||||
let err = match new_socket {
|
||||
Ok(new_socket) => {
|
||||
*socket = new_socket;
|
||||
None
|
||||
}
|
||||
Err(e) => Some(e.to_string()),
|
||||
};
|
||||
|
||||
// notify frontend of the actual port
|
||||
let port = socket.local_addr().expect("socket not bound").port();
|
||||
server.notify_port_changed(port, err);
|
||||
}
|
||||
|
||||
async fn udp_receiver(
|
||||
socket: &UdpSocket,
|
||||
receiver_tx: &Sender<Result<(ProtoEvent, SocketAddr), NetworkError>>,
|
||||
) {
|
||||
loop {
|
||||
let event = receive_event(socket).await;
|
||||
receiver_tx.send(event).expect("channel closed");
|
||||
}
|
||||
}
|
||||
|
||||
async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(ProtoEvent, SocketAddr)>) {
|
||||
loop {
|
||||
let (event, addr) = rx.recv().await.expect("channel closed");
|
||||
if let Err(e) = send_event(socket, event, addr) {
|
||||
log::warn!("udp send failed: {e}");
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub(crate) enum NetworkError {
|
||||
#[error(transparent)]
|
||||
Protocol(#[from] ProtocolError),
|
||||
#[error("network error: `{0}`")]
|
||||
Io(#[from] io::Error),
|
||||
}
|
||||
|
||||
async fn receive_event(socket: &UdpSocket) -> Result<(ProtoEvent, SocketAddr), NetworkError> {
|
||||
let mut buf = [0u8; lan_mouse_proto::MAX_EVENT_SIZE];
|
||||
let (_len, src) = socket.recv_from(&mut buf).await?;
|
||||
let event = ProtoEvent::try_from(buf)?;
|
||||
Ok((event, src))
|
||||
}
|
||||
|
||||
fn send_event(sock: &UdpSocket, e: ProtoEvent, addr: SocketAddr) -> Result<usize, NetworkError> {
|
||||
log::trace!("{:20} ------>->->-> {addr}", e.to_string());
|
||||
let (data, len): ([u8; lan_mouse_proto::MAX_EVENT_SIZE], usize) = e.into();
|
||||
// When udp blocks, we dont want to block the event loop.
|
||||
// Dropping events is better than potentially crashing the input capture.
|
||||
Ok(sock.try_send_to(&data[..len], addr)?)
|
||||
}
|
||||
138
src/server/ping_task.rs
Normal file
138
src/server/ping_task.rs
Normal file
@@ -0,0 +1,138 @@
|
||||
use std::{net::SocketAddr, time::Duration};
|
||||
|
||||
use lan_mouse_proto::ProtoEvent;
|
||||
use local_channel::mpsc::Sender;
|
||||
use tokio::task::JoinHandle;
|
||||
|
||||
use lan_mouse_ipc::ClientHandle;
|
||||
|
||||
use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State};
|
||||
|
||||
const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);
|
||||
|
||||
pub(crate) fn new(
|
||||
server: Server,
|
||||
sender_ch: Sender<(ProtoEvent, SocketAddr)>,
|
||||
emulate_notify: Sender<EmulationRequest>,
|
||||
capture_notify: Sender<CaptureRequest>,
|
||||
) -> JoinHandle<()> {
|
||||
// timer task
|
||||
tokio::task::spawn_local(async move {
|
||||
tokio::select! {
|
||||
_ = server.notifies.cancel.cancelled() => {}
|
||||
_ = ping_task(&server, sender_ch, emulate_notify, capture_notify) => {}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
async fn ping_task(
|
||||
server: &Server,
|
||||
sender_ch: Sender<(ProtoEvent, SocketAddr)>,
|
||||
emulate_notify: Sender<EmulationRequest>,
|
||||
capture_notify: Sender<CaptureRequest>,
|
||||
) {
|
||||
loop {
|
||||
// wait for wake up signal
|
||||
server.ping_timer_notified().await;
|
||||
loop {
|
||||
let receiving = server.state.get() == State::Receiving;
|
||||
let (ping_clients, ping_addrs) = {
|
||||
let mut client_manager = server.client_manager.borrow_mut();
|
||||
|
||||
let ping_clients: Vec<ClientHandle> = if receiving {
|
||||
// if receiving we care about clients with pressed keys
|
||||
client_manager
|
||||
.get_client_states()
|
||||
.filter(|(_, (_, s))| s.has_pressed_keys)
|
||||
.map(|(h, _)| h)
|
||||
.collect()
|
||||
} else {
|
||||
// if sending we care about the active client
|
||||
server.active_client.get().iter().cloned().collect()
|
||||
};
|
||||
|
||||
// get relevant socket addrs for clients
|
||||
let ping_addrs: Vec<SocketAddr> = {
|
||||
ping_clients
|
||||
.iter()
|
||||
.flat_map(|&h| client_manager.get(h))
|
||||
.flat_map(|(c, s)| {
|
||||
if s.alive && s.active_addr.is_some() {
|
||||
vec![s.active_addr.unwrap()]
|
||||
} else {
|
||||
s.ips
|
||||
.iter()
|
||||
.cloned()
|
||||
.map(|ip| SocketAddr::new(ip, c.port))
|
||||
.collect()
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
|
||||
// reset alive
|
||||
for (_, (_, s)) in client_manager.get_client_states_mut() {
|
||||
s.alive = false;
|
||||
}
|
||||
|
||||
(ping_clients, ping_addrs)
|
||||
};
|
||||
|
||||
if receiving && ping_clients.is_empty() {
|
||||
// receiving and no client has pressed keys
|
||||
// -> no need to keep pinging
|
||||
break;
|
||||
}
|
||||
|
||||
// ping clients
|
||||
for addr in ping_addrs {
|
||||
if sender_ch.send((ProtoEvent::Ping, addr)).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// give clients time to resond
|
||||
if receiving {
|
||||
log::trace!(
|
||||
"waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ..."
|
||||
);
|
||||
} else {
|
||||
log::trace!(
|
||||
"state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
|
||||
server.state.get()
|
||||
);
|
||||
}
|
||||
|
||||
tokio::time::sleep(MAX_RESPONSE_TIME).await;
|
||||
|
||||
// when anything is received from a client,
|
||||
// the alive flag gets set
|
||||
let unresponsive_clients: Vec<_> = {
|
||||
let client_manager = server.client_manager.borrow();
|
||||
ping_clients
|
||||
.iter()
|
||||
.filter_map(|&h| match client_manager.get(h) {
|
||||
Some((_, s)) if !s.alive => Some(h),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
|
||||
// we may not be receiving anymore but we should respond
|
||||
// to the original state and not the "new" one
|
||||
if receiving {
|
||||
for h in unresponsive_clients {
|
||||
log::warn!("device not responding, releasing keys!");
|
||||
let _ = emulate_notify.send(EmulationRequest::ReleaseKeys(h));
|
||||
}
|
||||
} else {
|
||||
// release pointer if the active client has not responded
|
||||
if !unresponsive_clients.is_empty() {
|
||||
log::warn!("client not responding, releasing pointer!");
|
||||
server.state.replace(State::Receiving);
|
||||
let _ = capture_notify.send(CaptureRequest::Release);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
513
src/service.rs
513
src/service.rs
@@ -1,513 +0,0 @@
|
||||
use crate::{
|
||||
capture::{Capture, CaptureType, ICaptureEvent},
|
||||
client::ClientManager,
|
||||
config::Config,
|
||||
connect::LanMouseConnection,
|
||||
crypto,
|
||||
dns::{DnsEvent, DnsResolver},
|
||||
emulation::{Emulation, EmulationEvent},
|
||||
listen::{LanMouseListener, ListenerCreationError},
|
||||
};
|
||||
use futures::StreamExt;
|
||||
use hickory_resolver::error::ResolveError;
|
||||
use lan_mouse_ipc::{
|
||||
AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
|
||||
IpcError, IpcListenerCreationError, Position, Status,
|
||||
};
|
||||
use log;
|
||||
use std::{
|
||||
collections::{HashMap, HashSet, VecDeque},
|
||||
io,
|
||||
net::{IpAddr, SocketAddr},
|
||||
sync::{Arc, RwLock},
|
||||
};
|
||||
use thiserror::Error;
|
||||
use tokio::{process::Command, signal, sync::Notify};
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum ServiceError {
|
||||
#[error(transparent)]
|
||||
Dns(#[from] ResolveError),
|
||||
#[error(transparent)]
|
||||
IpcListen(#[from] IpcListenerCreationError),
|
||||
#[error(transparent)]
|
||||
Io(#[from] io::Error),
|
||||
#[error(transparent)]
|
||||
ListenError(#[from] ListenerCreationError),
|
||||
#[error("failed to load certificate: `{0}`")]
|
||||
Certificate(#[from] crypto::Error),
|
||||
}
|
||||
|
||||
pub struct Service {
|
||||
/// input capture
|
||||
capture: Capture,
|
||||
/// input emulation
|
||||
emulation: Emulation,
|
||||
/// dns resolver
|
||||
resolver: DnsResolver,
|
||||
/// frontend listener
|
||||
frontend_listener: AsyncFrontendListener,
|
||||
/// authorized public key sha256 fingerprints
|
||||
authorized_keys: Arc<RwLock<HashMap<String, String>>>,
|
||||
/// (outgoing) client information
|
||||
client_manager: ClientManager,
|
||||
/// current port
|
||||
port: u16,
|
||||
/// the public key fingerprint for (D)TLS
|
||||
public_key_fingerprint: String,
|
||||
/// notify for pending frontend events
|
||||
frontend_event_pending: Notify,
|
||||
/// frontend events queued for sending
|
||||
pending_frontend_events: VecDeque<FrontendEvent>,
|
||||
/// status of input capture (enabled / disabled)
|
||||
capture_status: Status,
|
||||
/// status of input emulation (enabled / disabled)
|
||||
emulation_status: Status,
|
||||
/// keep track of registered connections to avoid duplicate barriers
|
||||
incoming_conns: HashSet<SocketAddr>,
|
||||
/// map from capture handle to connection info
|
||||
incoming_conn_info: HashMap<ClientHandle, Incoming>,
|
||||
next_trigger_handle: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Incoming {
|
||||
fingerprint: String,
|
||||
addr: SocketAddr,
|
||||
pos: Position,
|
||||
}
|
||||
|
||||
impl Service {
|
||||
pub async fn new(config: Config) -> Result<Self, ServiceError> {
|
||||
let client_manager = ClientManager::default();
|
||||
for client in config.get_clients() {
|
||||
let config = ClientConfig {
|
||||
hostname: client.hostname,
|
||||
fix_ips: client.ips.into_iter().collect(),
|
||||
port: client.port,
|
||||
pos: client.pos,
|
||||
cmd: client.enter_hook,
|
||||
};
|
||||
let state = ClientState {
|
||||
active: client.active,
|
||||
ips: HashSet::from_iter(config.fix_ips.iter().cloned()),
|
||||
..Default::default()
|
||||
};
|
||||
let handle = client_manager.add_client();
|
||||
client_manager.set_config(handle, config);
|
||||
client_manager.set_state(handle, state);
|
||||
}
|
||||
|
||||
// load certificate
|
||||
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.clone()));
|
||||
// listener + connection
|
||||
let listener =
|
||||
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 = Capture::new(capture_backend, conn, config.release_bind.clone());
|
||||
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 service = Self {
|
||||
capture,
|
||||
emulation,
|
||||
frontend_listener,
|
||||
resolver,
|
||||
authorized_keys,
|
||||
public_key_fingerprint,
|
||||
client_manager,
|
||||
frontend_event_pending: Default::default(),
|
||||
port,
|
||||
pending_frontend_events: Default::default(),
|
||||
capture_status: Default::default(),
|
||||
emulation_status: Default::default(),
|
||||
incoming_conn_info: Default::default(),
|
||||
incoming_conns: Default::default(),
|
||||
next_trigger_handle: 0,
|
||||
};
|
||||
Ok(service)
|
||||
}
|
||||
|
||||
pub async fn run(&mut self) -> Result<(), ServiceError> {
|
||||
for handle in self.client_manager.active_clients() {
|
||||
// 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.activate_client(handle);
|
||||
}
|
||||
|
||||
loop {
|
||||
tokio::select! {
|
||||
request = self.frontend_listener.next() => self.handle_frontend_request(request),
|
||||
_ = self.frontend_event_pending.notified() => self.handle_frontend_pending().await,
|
||||
event = self.emulation.event() => self.handle_emulation_event(event),
|
||||
event = self.capture.event() => self.handle_capture_event(event),
|
||||
event = self.resolver.event() => self.handle_resolver_event(event),
|
||||
r = signal::ctrl_c() => break r.expect("failed to wait for CTRL+C"),
|
||||
}
|
||||
}
|
||||
|
||||
log::info!("terminating service ...");
|
||||
log::debug!("terminating capture ...");
|
||||
self.capture.terminate().await;
|
||||
log::debug!("terminating emulation ...");
|
||||
self.emulation.terminate().await;
|
||||
log::debug!("terminating dns resolver ...");
|
||||
self.resolver.terminate().await;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn handle_frontend_request(&mut self, request: Option<Result<FrontendRequest, IpcError>>) {
|
||||
let request = match request.expect("frontend listener closed") {
|
||||
Ok(r) => r,
|
||||
Err(e) => return log::error!("error receiving request: {e}"),
|
||||
};
|
||||
match request {
|
||||
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(),
|
||||
FrontendRequest::Delete(handle) => self.remove_client(handle),
|
||||
FrontendRequest::EnableCapture => self.capture.reenable(),
|
||||
FrontendRequest::EnableEmulation => self.emulation.reenable(),
|
||||
FrontendRequest::Enumerate() => self.enumerate(),
|
||||
FrontendRequest::GetState(handle) => self.broadcast_client(handle),
|
||||
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),
|
||||
}
|
||||
}
|
||||
|
||||
async fn handle_frontend_pending(&mut self) {
|
||||
while let Some(event) = self.pending_frontend_events.pop_front() {
|
||||
self.frontend_listener.broadcast(event).await;
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_emulation_event(&mut self, event: EmulationEvent) {
|
||||
match event {
|
||||
EmulationEvent::Connected {
|
||||
addr,
|
||||
pos,
|
||||
fingerprint,
|
||||
} => {
|
||||
// check if already registered
|
||||
if !self.incoming_conns.contains(&addr) {
|
||||
self.add_incoming(addr, pos, fingerprint.clone());
|
||||
self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
|
||||
} else {
|
||||
self.update_incoming(addr, pos, fingerprint);
|
||||
}
|
||||
}
|
||||
EmulationEvent::Disconnected { addr } => {
|
||||
if let Some(addr) = self.remove_incoming(addr) {
|
||||
self.notify_frontend(FrontendEvent::IncomingDisconnected(addr));
|
||||
}
|
||||
}
|
||||
EmulationEvent::PortChanged(port) => match port {
|
||||
Ok(port) => {
|
||||
self.port = port;
|
||||
self.notify_frontend(FrontendEvent::PortChanged(port, None));
|
||||
}
|
||||
Err(e) => self
|
||||
.notify_frontend(FrontendEvent::PortChanged(self.port, Some(format!("{e}")))),
|
||||
},
|
||||
EmulationEvent::EmulationDisabled => {
|
||||
self.emulation_status = Status::Disabled;
|
||||
self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
|
||||
}
|
||||
EmulationEvent::EmulationEnabled => {
|
||||
self.emulation_status = Status::Enabled;
|
||||
self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
|
||||
}
|
||||
EmulationEvent::ReleaseNotify => self.capture.release(),
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_capture_event(&mut self, event: ICaptureEvent) {
|
||||
match event {
|
||||
ICaptureEvent::CaptureBegin(handle) => {
|
||||
// we entered the capture zone for an incoming connection
|
||||
// => notify it that its capture should be released
|
||||
if let Some(incoming) = self.incoming_conn_info.get(&handle) {
|
||||
self.emulation.send_leave_event(incoming.addr);
|
||||
}
|
||||
}
|
||||
ICaptureEvent::CaptureDisabled => {
|
||||
self.capture_status = Status::Disabled;
|
||||
self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status));
|
||||
}
|
||||
ICaptureEvent::CaptureEnabled => {
|
||||
self.capture_status = Status::Enabled;
|
||||
self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status));
|
||||
}
|
||||
ICaptureEvent::ClientEntered(handle) => {
|
||||
log::info!("entering client {handle} ...");
|
||||
self.spawn_hook_command(handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_resolver_event(&mut self, event: DnsEvent) {
|
||||
let handle = match event {
|
||||
DnsEvent::Resolving(handle) => {
|
||||
self.client_manager.set_resolving(handle, true);
|
||||
handle
|
||||
}
|
||||
DnsEvent::Resolved(handle, hostname, ips) => {
|
||||
self.client_manager.set_resolving(handle, false);
|
||||
if let Err(e) = &ips {
|
||||
log::warn!("could not resolve {hostname}: {e}");
|
||||
}
|
||||
let ips = ips.unwrap_or_default();
|
||||
self.client_manager.set_dns_ips(handle, ips);
|
||||
handle
|
||||
}
|
||||
};
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
}
|
||||
|
||||
fn resolve(&self, handle: ClientHandle) {
|
||||
if let Some(hostname) = self.client_manager.get_hostname(handle) {
|
||||
self.resolver.resolve(handle, hostname);
|
||||
}
|
||||
}
|
||||
|
||||
fn sync_frontend(&mut self) {
|
||||
self.enumerate();
|
||||
self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status));
|
||||
self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status));
|
||||
self.notify_frontend(FrontendEvent::PortChanged(self.port, None));
|
||||
self.notify_frontend(FrontendEvent::PublicKeyFingerprint(
|
||||
self.public_key_fingerprint.clone(),
|
||||
));
|
||||
let keys = self.authorized_keys.read().expect("lock").clone();
|
||||
self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
|
||||
}
|
||||
|
||||
const ENTER_HANDLE_BEGIN: u64 = u64::MAX / 2 + 1;
|
||||
|
||||
fn add_incoming(&mut self, addr: SocketAddr, pos: Position, fingerprint: String) {
|
||||
let handle = Self::ENTER_HANDLE_BEGIN + self.next_trigger_handle;
|
||||
self.next_trigger_handle += 1;
|
||||
self.capture.create(handle, pos, CaptureType::EnterOnly);
|
||||
self.incoming_conns.insert(addr);
|
||||
self.incoming_conn_info.insert(
|
||||
handle,
|
||||
Incoming {
|
||||
fingerprint,
|
||||
addr,
|
||||
pos,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
fn update_incoming(&mut self, addr: SocketAddr, pos: Position, fingerprint: String) {
|
||||
let incoming = self
|
||||
.incoming_conn_info
|
||||
.iter_mut()
|
||||
.find(|(_, i)| i.addr == addr)
|
||||
.map(|(_, i)| i)
|
||||
.expect("no such client");
|
||||
let mut changed = false;
|
||||
if incoming.fingerprint != fingerprint {
|
||||
incoming.fingerprint = fingerprint.clone();
|
||||
changed = true;
|
||||
}
|
||||
if incoming.pos != pos {
|
||||
incoming.pos = pos;
|
||||
changed = true;
|
||||
}
|
||||
if changed {
|
||||
self.remove_incoming(addr);
|
||||
self.add_incoming(addr, pos, fingerprint.clone());
|
||||
self.notify_frontend(FrontendEvent::IncomingDisconnected(addr));
|
||||
self.notify_frontend(FrontendEvent::IncomingConnected(fingerprint, addr, pos));
|
||||
}
|
||||
}
|
||||
|
||||
fn remove_incoming(&mut self, addr: SocketAddr) -> Option<SocketAddr> {
|
||||
let handle = self
|
||||
.incoming_conn_info
|
||||
.iter()
|
||||
.find(|(_, incoming)| incoming.addr == addr)
|
||||
.map(|(k, _)| *k)?;
|
||||
self.capture.destroy(handle);
|
||||
self.incoming_conns.remove(&addr);
|
||||
self.incoming_conn_info
|
||||
.remove(&handle)
|
||||
.map(|incoming| incoming.addr)
|
||||
}
|
||||
|
||||
fn notify_frontend(&mut self, event: FrontendEvent) {
|
||||
self.pending_frontend_events.push_back(event);
|
||||
self.frontend_event_pending.notify_one();
|
||||
}
|
||||
|
||||
fn add_authorized_key(&mut self, desc: String, fp: String) {
|
||||
self.authorized_keys.write().expect("lock").insert(fp, desc);
|
||||
let keys = self.authorized_keys.read().expect("lock").clone();
|
||||
self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
|
||||
}
|
||||
|
||||
fn remove_authorized_key(&mut self, fp: String) {
|
||||
self.authorized_keys.write().expect("lock").remove(&fp);
|
||||
let keys = self.authorized_keys.read().expect("lock").clone();
|
||||
self.notify_frontend(FrontendEvent::AuthorizedUpdated(keys));
|
||||
}
|
||||
|
||||
fn enumerate(&mut self) {
|
||||
let clients = self.client_manager.get_client_states();
|
||||
self.notify_frontend(FrontendEvent::Enumerate(clients));
|
||||
}
|
||||
|
||||
fn add_client(&mut self) {
|
||||
let handle = self.client_manager.add_client();
|
||||
log::info!("added client {handle}");
|
||||
let (c, s) = self.client_manager.get_state(handle).unwrap();
|
||||
self.notify_frontend(FrontendEvent::Created(handle, c, s));
|
||||
}
|
||||
|
||||
fn set_client_active(&mut self, handle: ClientHandle, active: bool) {
|
||||
if active {
|
||||
self.activate_client(handle);
|
||||
} else {
|
||||
self.deactivate_client(handle);
|
||||
}
|
||||
}
|
||||
|
||||
fn deactivate_client(&mut self, handle: ClientHandle) {
|
||||
log::debug!("deactivating client {handle}");
|
||||
if self.client_manager.deactivate_client(handle) {
|
||||
self.capture.destroy(handle);
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
log::info!("deactivated client {handle}");
|
||||
}
|
||||
}
|
||||
|
||||
fn activate_client(&mut self, handle: ClientHandle) {
|
||||
log::debug!("activating client");
|
||||
|
||||
/* resolve dns on activate */
|
||||
self.resolve(handle);
|
||||
|
||||
/* deactivate potential other client at this position */
|
||||
let Some(pos) = self.client_manager.get_pos(handle) else {
|
||||
return;
|
||||
};
|
||||
|
||||
if let Some(other) = self.client_manager.client_at(pos) {
|
||||
if other != handle {
|
||||
self.deactivate_client(other);
|
||||
}
|
||||
}
|
||||
|
||||
/* activate the client */
|
||||
if self.client_manager.activate_client(handle) {
|
||||
/* notify capture and frontends */
|
||||
self.capture.create(handle, pos, CaptureType::Default);
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
log::info!("activated client {handle} ({pos})");
|
||||
}
|
||||
}
|
||||
|
||||
fn change_port(&mut self, port: u16) {
|
||||
if self.port != port {
|
||||
self.emulation.request_port_change(port);
|
||||
} else {
|
||||
self.notify_frontend(FrontendEvent::PortChanged(self.port, None));
|
||||
}
|
||||
}
|
||||
|
||||
fn remove_client(&mut self, handle: ClientHandle) {
|
||||
if self
|
||||
.client_manager
|
||||
.remove_client(handle)
|
||||
.map(|(_, s)| s.active)
|
||||
.unwrap_or(false)
|
||||
{
|
||||
self.capture.destroy(handle);
|
||||
}
|
||||
self.notify_frontend(FrontendEvent::Deleted(handle));
|
||||
}
|
||||
|
||||
fn update_fix_ips(&mut self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
|
||||
self.client_manager.set_fix_ips(handle, fix_ips);
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
}
|
||||
|
||||
fn update_hostname(&mut self, handle: ClientHandle, hostname: Option<String>) {
|
||||
if self.client_manager.set_hostname(handle, hostname.clone()) {
|
||||
self.resolve(handle);
|
||||
}
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
}
|
||||
|
||||
fn update_port(&mut self, handle: ClientHandle, port: u16) {
|
||||
self.client_manager.set_port(handle, port);
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
}
|
||||
|
||||
fn update_pos(&mut self, handle: ClientHandle, pos: Position) {
|
||||
// update state in event input emulator & input capture
|
||||
if self.client_manager.set_pos(handle, pos) {
|
||||
self.deactivate_client(handle);
|
||||
self.activate_client(handle);
|
||||
}
|
||||
self.notify_frontend(FrontendEvent::Changed(handle));
|
||||
}
|
||||
|
||||
fn broadcast_client(&mut self, handle: ClientHandle) {
|
||||
let event = self
|
||||
.client_manager
|
||||
.get_state(handle)
|
||||
.map(|(c, s)| FrontendEvent::State(handle, c, s))
|
||||
.unwrap_or(FrontendEvent::NoSuchClient(handle));
|
||||
self.notify_frontend(event);
|
||||
}
|
||||
|
||||
fn spawn_hook_command(&self, handle: ClientHandle) {
|
||||
let Some(cmd) = self.client_manager.get_enter_cmd(handle) else {
|
||||
return;
|
||||
};
|
||||
tokio::task::spawn_local(async move {
|
||||
log::info!("spawning command!");
|
||||
let mut child = match Command::new("sh").arg("-c").arg(cmd.as_str()).spawn() {
|
||||
Ok(c) => c,
|
||||
Err(e) => {
|
||||
log::warn!("could not execute cmd: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
match child.wait().await {
|
||||
Ok(s) => {
|
||||
if s.success() {
|
||||
log::info!("{cmd} exited successfully");
|
||||
} else {
|
||||
log::warn!("{cmd} exited with {s}");
|
||||
}
|
||||
}
|
||||
Err(e) => log::warn!("{cmd}: {e}"),
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user