Compare commits

...
25 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 5089c0343c Release v0.2.20: QR sign-in matches the official client (#68)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 17:03:13 +08:00
VallierDevandClaude Opus 5.5 5fdb98b0f5 QR login follows the official client: status_query_ticket, 60 s long poll, stop on failure (#68)
From the official Mac client (UURemote 4.42; QRCodeGenLoginResponse decodes only qrcode_jump_url
and status_query_ticket, the status/by_qrcode bodies carry that ticket under "token"):
- gen/login is sent without a body; the status ticket is status_query_ticket (older token as fallback).
- The status long poll re-asks right after each answer with a 60 s request timeout (was 12 s).
- Status 3 regenerates at once, status 0 after 0.35 s, 4 logs in (3 no longer calls by_qrcode).
- Errors such as HTTP 400 code 1190 and timeouts stop polling until the user clicks the new
  刷新二维码 button (Enter in a terminal; one minute when neither exists). This replaces the
  v0.2.19 backoff and the re-register hint.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 16:58:00 +08:00
VallierDevandClaude Opus 5.5 89abae2369 Release v0.2.19: headless Wayland, custom bitrate, show and login fixes
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 16:34:37 +08:00
VallierDevandClaude Opus 5.5 0afc602e66 Login polling backoff and a hint for instantly expiring QR codes (#68); bitrate unit safeguard; doctor wording
- Never spin on immediate unchanged status answers or transport errors (2 s backoff); repeated
  QR codes that expire within seconds back off exponentially and point to re-registering the
  device identity, which recovered a flagged device in #68.
- Custom bitrate field 8 is bit/s (#67); values that can only be Mbit/s or kbit/s are scaled
  instead of capping the encoder at 1 kbit/s.
- doctor: without DISPLAY the X11 engine still tries :0/:1, so the #66 warning says that.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 16:29:57 +08:00
ZoranandJuanZoran 762cfccc44 Custom video bitrate is bits per second (#67)
Co-authored-by: JuanZoran <[email protected]>
2026-10-20 16:28:56 +08:00
axlrose 9520b69730 doctor: say so when the session has no screen to capture (#66)
Without DISPLAY and without WAYLAND_DISPLAY the desktop backend cannot
capture anything: the host logs 'Desktop unavailable ... x11_init failed'.
The report named X11 as the selected backend and nothing else, which reads
like a working setup. Name the missing display and note that the terminal,
file transfer and port mapping tools still work.
2026-10-20 16:28:51 +08:00
axlrose c45e4749b5 Wayland: a failed output-power handshake must not block screencopy (#65)
Output power management is optional: the engine comment already says so, but
uu_wl_wake() only tolerated a *missing* power manager. When the compositor
offers zwlr_output_power_manager_v1 and then refuses the mode (headless
outputs, outputs without DPMS), power_failed is set and the function
reported an error. capture::keep_display_awake() propagates that error and
video.rs aborts the whole capture task with '?', so a client could connect
but never received a frame.

Treat a failed power handshake like a missing one: skip waking the screen
and keep streaming.
2026-10-20 16:28:46 +08:00
VallierDevandClaude Opus 5.5 c1b8bfe1b3 show: report a skipped or crash-looping service instead of waiting 30 s (#62); document FFmpeg 6.x for inproc-av (#63)
systemctl start returns 0 when the unit is skipped by a Condition or keeps crashing under
Restart=; show now reads ActiveState/SubState/ConditionResult while waiting and names the real
problem. ffmpeg-sys-next's build script runs before ours, so FFmpeg >= 7 cannot be caught in
build.rs; the README and AGENTS state the 6.x requirement next to the build commands.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 15:24:33 +08:00
VallierDevandClaude Opus 5.5 03d2311649 Release v0.2.18: Debian packages, experimental WOL helper
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:48:13 +08:00
VallierDevandClaude Opus 5.5 5949314e55 Experimental WOL helper (UU_WOL_HELPER=1); doctor keeps logs quiet
Mirrors the official Windows host (GameViewerServer reportLanInfo / PushMessageHandler::wakeOnLan /
send_wol): report the LAN identity after sign-in and answer wake_on_lan pushes with a magic packet
to the target's subnet broadcast. Field names come from the official log strings; off by default
and unverified end to end. wake_on_lan push key names are always logged for evidence.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:43:13 +08:00
VallierDevandClaude Opus 5.5 8389fc4eed Debian package: binaries, engine plugins, systemd user unit, menu entries
Built and install-tested in the release workflow (and CI) with dependencies taken from the
binaries by dpkg-shlibdeps. The unit starts with graphical-session.target; uinput access stays
opt-in (the udev rule ships under /usr/share/doc).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:38:39 +08:00
VallierDevandClaude Opus 5.5 b8de665593 Release v0.2.17: doctor diagnostic report
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:34:06 +08:00
VallierDevandClaude Opus 5.5 554cbe806a doctor: one paste-safe diagnostic report for issues
Session, selected backend (and the X11-inside-Wayland trap), engine plugin load results, uinput
and render-node access, FFmpeg encoders/version, the default codec, sign-in and service state.
Prints booleans, names and versions only; home directory and user name are masked. The issue
template and READMEs ask for it.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:30:01 +08:00
VallierDevandClaude Opus 5.5 a91f0024d3 Release v0.2.16: KDE idle inhibition, lock hints (#60, #61)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:16:15 +08:00
VallierDevandClaude Opus 5.5 68ad9759bd KDE idle inhibition during remote sessions; lock and X11-in-Wayland hints (#61)
- KDE portal sessions hold an org.freedesktop.ScreenSaver inhibitor while a desktop connection
  is active (GNOME keeps SessionManager.Inhibit), so the idle timeout no longer locks mid-session.
- Log a hint when the desktop locks: viewers only see black frames until it is unlocked.
- Warn when the X11 backend is selected while a Wayland session is running (XWayland root
  capture is all black without any error).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:12:28 +08:00
Jeff Zhangandferstar 169edf2224 inproc: pad odd native captures to even for the in-process encoder (#60)
The in-process encoder opened its context at the raw capture size, so an
odd logical desktop (e.g. two stacked 150% monitors, 2560x2507) made every
H.264/HEVC/NVENC encoder fail to open. The encoder size is now rounded up to
even, and a native capture is copied into a zeroed frame of that size so the
extra row/column stays black. Scaled output paths are unchanged.

Co-authored-by: ferstar <[email protected]>
2026-10-20 07:23:54 +08:00
VallierDevandClaude Opus 5.5 9994279b29 Release v0.2.15: aarch64 package, H.264 default on CPU hosts (#58, #59)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 01:33:23 +08:00
VallierDevandClaude Opus 5.5 6733a117a2 CPU hosts default to H.264; aarch64 release package (#59)
libx265 is about ten times slower than libx264 (15 vs 155 fps at 1080p on a 4-core Ampere A1),
so without NVENC/VAAPI the host now picks H.264 even when both sides offer H.265;
UU_VIDEO_CODEC=h265 still forces it. The release workflow builds x86_64 and aarch64 packages
(each with both engine plugins) and publishes them from a single job.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 01:28:38 +08:00
Delicious233andCodex e3cab32c75 ci: build and test on linux/arm64 (#58)
Co-authored-by: Codex <[email protected]>
2026-10-20 01:28:17 +08:00
VallierDevandClaude Opus 5.5 57e1a5d07c Release v0.2.14: Hyprland output-bound pointer and monitor switching (#57)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 00:33:59 +08:00
ZoranandJuanZoran d90b4bccde Hyprland: bind absolute pointer to the captured output; opt-in monitor switching (#57)
Co-authored-by: JuanZoran <[email protected]>
2026-10-20 00:33:31 +08:00
VallierDevandClaude Opus 5.5 fa7fe733a6 Release v0.2.13: Wayland and portal engines in the release package
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-19 22:13:27 +08:00
VallierDevandClaude Opus 5.5 65c04e796a One release package for every desktop: Wayland and portal engines as runtime plugins
The release tarball was X11 only, so Hyprland/niri and GNOME/KDE Wayland users had to build from
source (#43, #54). With --features engine-plugins the wayland and portal engines are built as
libuu-wayland.so / libuu-portal.so and dlopen'ed only when the session selects them, so X11 hosts
need none of their libraries. The wayland plugin is built on Ubuntu 22.04 with the main binary;
the portal plugin needs libei >= 1.1 and is built on 24.04 (glibc >= 2.39). Source builds without
engine-plugins keep linking the engines statically.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-19 22:10:11 +08:00
VallierDevandClaude Opus 5.5 3480318089 portal: say how to get a picture when the build lacks portal support (#43)
Release packages are X11 only; on GNOME/KDE Wayland auto selection picks the
portal backend, which then failed every 5 s with the opaque "portal
unavailable (code 2)".

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-19 19:44:13 +08:00
VallierDevandClaude Opus 5.5 949acaac30 docs: niri row, non-template unit name, uinput dedicated-group example (#55)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-19 16:23:52 +08:00
41 changed files with 1753 additions and 132 deletions

No files matched your search

+1
View File
@@ -37,6 +37,7 @@ body:
```sh
{
echo "== doctor (v0.2.17+)"; uuremote-server doctor
echo "== 系统"; grep PRETTY_NAME /etc/os-release; uname -rm
echo "== 桌面"; echo "session=$XDG_SESSION_TYPE desktop=$XDG_CURRENT_DESKTOP"
echo "== 显示器"; xrandr --listmonitors 2>/dev/null
+47 -1
View File
@@ -24,10 +24,25 @@ jobs:
run: |
sudo apt-get update
sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \
libwayland-dev libwayland-bin libxkbcommon-dev
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- run: cargo test --locked
# Same as the release job: the wayland plugin is built on 22.04; libei is unavailable here, so
# the portal plugin is skipped with a warning (release builds it on 24.04).
- name: Release feature set
run: |
cargo build --locked --features wayland,portal,engine-plugins --bin uuremote-server
test -f target/debug/libuu-wayland.so
- name: Debian package installs
run: |
packaging/deb/build-deb.sh 0.0.0~ci target/debug /tmp/deb
dpkg-deb -I /tmp/deb/*.deb | grep -E 'Depends|Recommends'
sudo apt-get install -y /tmp/deb/*.deb
uuremote-server --help | head -1
test -f /usr/lib/uu-remote-linux/libuu-wayland.so
systemd-analyze verify /usr/lib/systemd/user/uuremote-native.service
test-viewer:
runs-on: ubuntu-22.04
@@ -56,6 +71,12 @@ jobs:
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- run: cargo test --locked --features wayland,portal
# Release layout: engines as runtime-loaded plugins; uuremote-server must not link them.
- name: Engine plugins
run: |
cargo build --locked --features wayland,portal,engine-plugins --bin uuremote-server
for lib in libuu-wayland.so libuu-portal.so; do test -f "target/debug/$lib"; done
! readelf -d target/debug/uuremote-server | grep NEEDED | grep -E 'libei|libpipewire|libwayland-client|libxkbcommon'
- name: Native portal and EIS regression tests (ASan/UBSan)
env:
ASAN_OPTIONS: detect_leaks=1
@@ -82,3 +103,28 @@ jobs:
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- run: cargo test --locked --features inproc-av
test-linux-arm64:
# aarch64 hosts (Ampere A1, arm64 VMs, Apple-silicon VMs) build from source, so keep that
# build honest on a native arm64 runner instead of letting it rot between releases.
runs-on: ubuntu-24.04-arm
steps:
- uses: actions/checkout@v4
- name: Install build dependencies
run: |
sudo apt-get update
sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \
libwayland-dev libwayland-bin libxkbcommon-dev libglib2.0-dev libpipewire-0.3-dev libei-dev
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- run: cargo test --locked
- name: Release binary
run: |
cargo build --locked --release --bin uuremote-server
file target/release/uuremote-server
# The aarch64 release package ships both engine plugins.
- name: Release feature set
run: |
cargo build --locked --features wayland,portal,engine-plugins --bin uuremote-server
for lib in libuu-wayland.so libuu-portal.so; do test -f "target/debug/$lib"; done
+72 -8
View File
@@ -9,35 +9,99 @@ permissions:
packages: write
jobs:
release:
# Built on 22.04 so the binary also runs on Ubuntu 22.04/24.04 and newer Debian (glibc >= 2.35).
runs-on: ubuntu-22.04
# GNOME/KDE Wayland engine: libei >= 1.1 first ships in Ubuntu 24.04, so this plugin needs
# glibc >= 2.39. It is only loaded on portal sessions; X11 and wlroots hosts never open it.
portal-plugin:
strategy:
matrix:
include:
- { arch: x86_64, runner: ubuntu-24.04 }
- { arch: aarch64, runner: ubuntu-24.04-arm }
runs-on: ${{ matrix.runner }}
steps:
- uses: actions/checkout@v4
- name: Install build dependencies
run: |
sudo apt-get update
sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev libsdl2-dev
libx11-dev libxext-dev libxtst-dev libxfixes-dev libglib2.0-dev libpipewire-0.3-dev libei-dev
- uses: dtolnay/rust-toolchain@stable
- run: UU_NO_GTK=1 cargo build --release --locked --features portal,engine-plugins --bin uuremote-server
- uses: actions/upload-artifact@v4
with:
name: libuu-portal-${{ matrix.arch }}
path: target/release/libuu-portal.so
build:
needs: portal-plugin
strategy:
matrix:
include:
- { arch: x86_64, runner: ubuntu-22.04 }
- { arch: aarch64, runner: ubuntu-22.04-arm }
# Built on 22.04 so the binary also runs on Ubuntu 22.04/24.04 and newer Debian (glibc >= 2.35).
runs-on: ${{ matrix.runner }}
steps:
- uses: actions/checkout@v4
- name: Install build dependencies
run: |
sudo apt-get update
sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev libsdl2-dev \
libwayland-dev libwayland-bin libxkbcommon-dev
- uses: dtolnay/rust-toolchain@stable
- run: cargo test --release --locked
- run: cargo build --release --locked
# Experimental viewer; built after the host so uuremote-server keeps the default features.
# One package for every desktop: Wayland (wlroots) and GNOME/KDE portal engines are plugins
# opened at runtime (engine-plugins), so X11 hosts need none of their libraries.
- run: cargo build --release --locked --features wayland,portal,engine-plugins
- uses: actions/download-artifact@v4
with:
name: libuu-portal-${{ matrix.arch }}
path: target/release
# Experimental viewer; built after the host so uuremote-server keeps the release features.
- run: cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
- name: Package
run: |
name=uu-remote-linux-${GITHUB_REF_NAME}-x86_64-linux
name=uu-remote-linux-${GITHUB_REF_NAME}-${{ matrix.arch }}-linux
mkdir -p "$name"
cp target/release/uuremote-server target/release/uuremote-viewer LICENSE README.md README.en.md config.example.json "$name/"
cp target/release/uuremote-server target/release/uuremote-viewer target/release/libuu-wayland.so target/release/libuu-portal.so \
LICENSE README.md README.en.md config.example.json "$name/"
cp -r contrib "$name/"
tar czf "$name.tar.gz" "$name"
sha256sum "$name.tar.gz" > "$name.tar.gz.sha256"
- name: Debian package
run: |
packaging/deb/build-deb.sh "${GITHUB_REF_NAME#v}" target/release .
deb=$(ls uu-remote-linux_*.deb)
sha256sum "$deb" > "$deb.sha256"
sudo apt-get install -y "./$deb"
uuremote-server --help | head -1
systemd-analyze verify /usr/lib/systemd/user/uuremote-native.service
- uses: actions/upload-artifact@v4
with:
name: package-${{ matrix.arch }}
path: |
uu-remote-linux-*.tar.gz*
uu-remote-linux_*.deb*
# One publisher, so the matrix legs never race to create the release.
release:
needs: build
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v4
- uses: actions/download-artifact@v4
with:
pattern: package-*
merge-multiple: true
- uses: softprops/action-gh-release@v2
with:
body_path: docs/release-notes/${{ github.ref_name }}.md
files: |
uu-remote-linux-*.tar.gz
uu-remote-linux-*.tar.gz.sha256
uu-remote-linux_*.deb
uu-remote-linux_*.deb.sha256
# Headless NAS image (docker/), built from the release tarball published by the job above.
docker:
+7 -2
View File
@@ -39,7 +39,8 @@ Dependencies (Ubuntu/Debian):
sudo apt install build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libavcodec-dev libavformat-dev libavdevice-dev libswscale-dev libclang-dev libgtk-3-dev ffmpeg
# --features inproc-av: libavcodec-dev libavformat-dev libavdevice-dev libswscale-dev libclang-dev
# (FFmpeg 6.x; in-process capture/encoding, Ubuntu 24.04 ships it)
# (FFmpeg 6.x only; in-process capture/encoding, Ubuntu 24.04 ships it. FFmpeg >= 7
# fails in ffmpeg-sys-next with "avfft.h file not found", before our build.rs runs)
# --features wayland: libwayland-dev libxkbcommon-dev wl-clipboard
# --features wayland,portal: + libglib2.0-dev libpipewire-0.3-dev libei-dev (libei >= 1.1)
```
@@ -116,6 +117,8 @@ viewer does not reconnect them automatically.
| `UU_FFMPEG_ROOT` | FFmpeg prefix (`bin/ffmpeg`, libs in `lib/x86_64-linux-gnu`) |
| `UU_AUDIO=0`, `UU_AUDIO_SOURCE` | disable sound / choose the Pulse source (default `@DEFAULT_MONITOR@`) |
| `UU_LOGIN_WINDOW=0` | don't auto-open the login window |
| `UU_ENGINE_DIR` | directory holding `libuu-wayland.so` / `libuu-portal.so` (`--features engine-plugins`, used by release packages: engines are dlopen'ed only on Wayland sessions; also searched next to the binary, `../lib/uu-remote-linux`, `~/.local/lib/uu-remote-linux`, `/usr/lib/uu-remote-linux`) |
| `UU_WOL_HELPER=1` | experimental: report LAN info (`api-ipv4…/api/v1/device/wake_on_lan/info` {mac, ip, subnet_mask}) after sign-in and answer `wake_on_lan` pushes (`target_device` {mac, ip, subnet_mask}) with a magic packet, like the official Windows host (field names from its log strings; not verified end to end). `wake_on_lan` push key names are always logged |
| `UU_USE_PROXY=1` | honor HTTP/SOCKS proxy env vars; cloud API clients bypass env proxies by default |
| `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors |
@@ -143,6 +146,7 @@ every 60 s.
| `src/initialization.rs`, `src/control_protocol.rs`, `src/protocol.rs` | protobuf encoders/decoders for CONTROL |
| `src/session_ice.rs`, `src/network_diagnostics.rs` | cloud ICE servers, address-free path diagnostics |
| `src/desktop_backend.rs`, `src/wayland.rs`, `src/portal*.rs` | backend selection, Hyprland, GNOME/KDE portal |
| `src/engine_plugin.rs` | `engine_ffi!`: engine C functions linked statically, or dlsym-resolved from runtime plugins with `engine-plugins` |
| `c_engine/portal_eis.inc` | scaled GNOME input through the existing Portal session's EIS connection; all input must use EIS once connected |
| `c_engine/x11_engine.c`, `c_engine/clipboard.c` | X11 capture/input/selection |
| `c_engine/wayland_engine.c`, `c_engine/portal_engine.c` | Wayland and portal engines |
@@ -150,7 +154,8 @@ every 60 s.
| `src/viewer_main.rs`, `src/viewer/` | experimental viewer (`--features native-viewer,viewer-sdl`): cloud join, WebRTC offer side, SDL desktop window (ffmpeg CLI decode), files/terminal/portmap/power/assist tools, device removal (`POST /api/v1/device/{id}/unbind`, verified live; shared devices use `/api/v1/device/share/{id}/unbind`, strings only), GTK launcher |
| `c_engine/viewer_window.c`, `c_engine/viewer_tools.c` | viewer GTK launcher and tool windows (files, port mapping, terminal list) |
Diagnostic subcommands: `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoders,
default codec, sign-in/service state; booleans and names only), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
`desktop-probe [new.png]`, `desktop-video-probe` (`UU_PROBE_FPS`, `UU_PROBE_FRAMES`, `UU_PROBE_QUALITY` 1-5 = viewer bitrate preset, 5 auto; `UU_PROBE_INPUT` fixed video/image sequence, `UU_PROBE_LOOP=1` repeats), `wayland-input-probe`, `clipboard-acceptance`,
`portal-acceptance`, `help`. Unknown arguments exit with code 2. Builds up to v0.1.0 did **not** reject them and
started a second full host server instead, so check that a subcommand exists in the binary you run.
Generated
+1 -1
View File
@@ -2741,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.2.12"
version = "0.2.20"
dependencies = [
"async-trait",
"base64 0.22.1",
+3 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.2.12"
version = "0.2.20"
edition = "2021"
default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"]
@@ -28,6 +28,8 @@ wayland = []
# Experimental direct linear framebuffer capture; never enabled in release builds.
kms = []
portal = []
# Build the wayland/portal engines as runtime-loaded libuu-wayland.so / libuu-portal.so (release packages).
engine-plugins = []
# In-process capture and encoding through FFmpeg 6 libraries (libavcodec/libavdevice dev packages).
# Off by default so release binaries do not link the build machine's libav.
inproc-av = ["dep:ffmpeg-next", "dep:x11rb"]
+65 -5
View File
@@ -73,13 +73,15 @@ authorized session. Independent file/terminal tool peers do not reset input.
| Xfce | X11 | ✅ Tested in a VM | default |
| Cinnamon / MATE | X11 | ✅ Tested in a VM | default |
| Hyprland | Wayland (native wlroots protocols) | 🧪 Experimental, tested in a VM (some features limited, see below) | `--features wayland` |
| niri | Wayland (native wlroots protocols) | 🧪 Experimental; protocol support confirmed from niri sources, not yet tested on hardware (#55) | `--features wayland` |
| GNOME / KDE Plasma | Wayland (xdg-desktop-portal) | 🧪 Experimental; validation scope and limits below | `--features wayland,portal` |
The GNOME Wayland Portal/EIS path has been checked for video and mouse/keyboard input on Ubuntu 26.04, GNOME 50, with one 4K screen at 200% scale; auto unlock after a cold locked connection is verified with the official Mac and iPhone 4.42.0 viewers, while other lock recovery and reconnection still need hardware acceptance testing. Apart from that path and GNOME on X11, desktop testing has primarily used virtual machines. If something goes wrong on
real hardware, please [open an issue](../../issues) with your distribution, desktop, GPU and the relevant lines from
real hardware, please [open an issue](../../issues) with the output of `uuremote-server doctor` (v0.2.17+; session, backend,
plugins, permissions and encoders only, no account data, tokens or addresses) and the relevant lines from
`journalctl --user -u uuremote-native.service`.
Wayland limits: single screen, fixed resolution. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
Wayland limits: captures one screen by default; Hyprland can enable monitor switching as described below. Resolution is fixed. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
permission; the permission is remembered once granted.
Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery keeps the encoder frame dimensions fixed but accepts logical-size changes after scaling. On GNOME, a display-change notification enables earlier recovery when previously streaming Portal capture remains paused without a valid format for a 200 ms grace after both conditions are present. Healthy renegotiation cancels the early check; repeated notifications do not postpone the same interruption. The five-second fallback remains without a related notification. Static video and valid-format pauses do not trigger recovery. Tested while connected on Ubuntu 26.04, GNOME Wayland, one 3840x2160 display: 200% -> 166.67% -> 200%, with continuously updating video and full-screen pointer control after recovery. Switching briefly freezes and goes black before recovering; five seconds is the fallback threshold, not total recovery time. See [#35](../../pull/35) for timing measurements and validation limits. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping.
@@ -102,11 +104,19 @@ failure falls back to SHM. The virgl VM verified fallback only: successful impor
mapping and hardware acceleration remain unverified. This is not zero-copy VAAPI;
`UU_VIDEO_ENCODER=vaapi` still uploads CPU frames through FFmpeg.
### Hyprland monitor switching (experimental)
Native Wayland absolute pointer motion now targets the captured output by default, fixing multi-monitor click offsets. uinput may still handle keyboard, buttons and relative motion.
Set `UU_WAYLAND_MULTISCREEN=1` to select physical monitors from the phone client. `UU_WAYLAND_OUTPUT` chooses the initial output. Capture and absolute pointer targeting switch together across different resolutions, scales and desktop positions.
Switching reuses one video track and pauses input until the new source sends a frame. Capture/encoder failure or a first-frame timeout requests restoration of the previous source. The inventory uses `hyprctl` and supports unrotated outputs; restart the host after monitor hotplug or layout changes. Phone-side switching and clicks were tested on Omarchy / Hyprland with 2560×1440 at 125% and 1920×1080 at 133.33%.
## Not implemented / not supported
| Feature | Status |
|---|---|
| Switching between multiple monitors | In progress |
| Switching between multiple monitors | Experimental on native Hyprland Wayland; see above |
| True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; VAAPI and `inproc-av` stay 4:2:0 and report that to the client |
| HDR | Not implemented |
| Super screen / virtual display | Not implemented |
@@ -119,6 +129,39 @@ mapping and hardware acceleration remain unverified. This is not zero-copy VAAPI
## Installation
### 0. Prebuilt release package (recommended, x86_64 / aarch64)
**Ubuntu / Debian (v0.2.18+)**: download `uu-remote-linux_<version>_amd64.deb` (ARM64: `arm64`), then:
```sh
sudo apt install ./uu-remote-linux_<version>_amd64.deb
uuremote-server login # scan the QR code with the UU Remote app
systemctl --user enable --now uuremote-native.service # start with the graphical session
```
The deb installs the binaries, plugins, a systemd user unit and menu entries; uinput access stays opt-in (step 5).
GNOME and KDE pass the display environment to the unit; on desktops that don't (e.g. Xfce) add `DISPLAY` as in step 4.
**Other distributions**: download `uu-remote-linux-<version>-x86_64-linux.tar.gz` (ARM64: `aarch64-linux`) from [Releases](../../releases/latest), extract it, then:
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
install -Dm644 libuu-wayland.so libuu-portal.so -t ~/.local/lib/uu-remote-linux/
```
One package covers X11, wlroots compositors (Hyprland, Sway, niri) and GNOME/KDE Wayland: the backend is chosen from the
running session at startup, and the matching `libuu-*.so` is loaded only on Wayland, so X11 hosts need no Wayland libraries.
| Session | Requirements |
|---|---|
| X11 | glibc >= 2.35 (Ubuntu 22.04, Debian 12 and newer) |
| wlroots (Hyprland / Sway / niri) | the same, plus `libwayland-client` and `libxkbcommon` (present on Wayland desktops) |
| GNOME / KDE Wayland | glibc >= 2.39 (Ubuntu 24.04, Fedora 40, Debian 13 and newer), libei >= 1.1 and PipeWire |
Plugins are found next to `uuremote-server`, in `../lib/uu-remote-linux/`, `~/.local/lib/uu-remote-linux/` or
`/usr/lib/uu-remote-linux/` (`UU_ENGINE_DIR` overrides); a missing library or too old glibc is reported in the log.
Continue with step 3 (login). Other architectures: build from source below.
### 1. Dependencies (Ubuntu / Debian)
```sh
@@ -144,6 +187,11 @@ cargo build --release --features wayland # + Hyprland
cargo build --release --features wayland,portal # + GNOME/KDE on Wayland
```
The optional `--features inproc-av` (in-process encoding) and the viewer's `viewer-ffmpeg` support **FFmpeg 6.x only**
(`pkg-config --modversion libavcodec` = 60.x). FFmpeg 7+ fails inside the `ffmpeg-sys-next` dependency with
`avfft.h file not found`; its build script runs before this project's, so no clearer check is possible (#63). The default
build and the release packages need neither feature.
### 3. Log in
Run inside your graphical session:
@@ -278,6 +326,8 @@ Common environment variables:
|---|---|
| `UU_CONFIG` | Config file path (default `~/.config/uuremote/config.json`) |
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless) |
| `UU_WAYLAND_MULTISCREEN=1` | Enable Hyprland physical monitor switching (off by default) |
| `UU_WAYLAND_OUTPUT` | Initial native Wayland output name, e.g. `HDMI-A-1` |
| `UU_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` |
| `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset: NVENC only when an NVIDIA driver is loaded, else CPU |
@@ -288,11 +338,14 @@ Common environment variables:
| `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) |
| `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing |
| `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) |
| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (not verified end to end) |
| `UU_USE_PROXY=1` | Honor HTTP/SOCKS proxy environment variables; by default proxies are ignored and NetEase servers are reached directly |
Host settings such as "lock after remote session" and "mute host" are stored in
`~/.config/uuremote/host_settings.json`.
Custom bitrate follows the Mbps value selected in the client; for example, 1 Mbps sets an encoder cap of 1000 kbit/s.
With external FFmpeg CPU encoding, the bitrate presets (Original / Ultra / HD / custom) use average bitrate (ABR) to avoid gray keyframes at 4K and low bitrates; Auto keeps constant rate factor (CRF).
## Let an AI agent install or develop it
@@ -350,7 +403,7 @@ Released under the [GPL-3.0](LICENSE): you may use, modify and redistribute it,
### H.265 / HEVC
When both sides support H.265 the host uses it (as the official host does: the host picks the codec from both
When both sides support H.265 and the host has a hardware encoder (NVENC / explicit VAAPI), the host uses it (as the official host does: the host picks the codec from both
capability lists; the official Mac viewer lists H265 first in its SDP). The first desktop connection probes a
synthetic frame and announces encoder support with CodecNegotiation. `hevc_nvenc`, `libx265` and explicit
`UU_VIDEO_ENCODER=vaapi` (`hevc_vaapi`); hardware failure falls back to software HEVC, then to H.264.
@@ -358,6 +411,9 @@ synthetic frame and announces encoder support with CodecNegotiation. `hevc_nvenc
Verified with the official Mac viewer on an RTX 3090 (hevc_nvenc, including 4:4:4) and with the official Android
viewer on Intel Alder Lake-P (iHD): 2560x1440 fully hardware-encoded, 58 fps decoded at about 10 ms. libx265 is
still not verified against a real viewer.
With CPU-only encoding the default is H.264: libx265 is about ten times slower than libx264 (measured ~15 vs ~155 fps
at 1080p on a 4-core ARM host, #59); `UU_VIDEO_CODEC=h265` forces H.265. The applied frame rate comes from the viewer's
quality/fps menu; `UU_DISPLAY_FPS` only changes the reported display refresh rate.
HEVC access units are split on RFC 7798 picture boundaries instead of AUDs: `hevc_vaapi` with `-aud 1` writes an
AUD only at IRAPs and drops every other picture from the bitstream, so an AUD-based reader turns a whole GOP into
@@ -415,13 +471,17 @@ Omarchy uses Hyprland: run in its user session, select `UU_DESKTOP_BACKEND=wayla
and retain `WAYLAND_DISPLAY` / `XDG_RUNTIME_DIR`. This requires wlr-screencopy and the
virtual input protocols supported by Hyprland; other compositors may need `--features wayland,portal`.
For uinput, load `uinput` (at boot: `echo uinput | sudo tee /etc/modules-load.d/uinput.conf`) and apply the uaccess rule above; seat ACLs require an active login.
For unattended accounts, explicitly restrict `/dev/uinput` access to a dedicated group.
For unattended accounts, explicitly restrict `/dev/uinput` access to a dedicated group, e.g. `z /dev/uinput 0660 root uinput`
in `/etc/tmpfiles.d/uinput.conf` plus `sudo usermod -aG uinput <user>` (dedicated account only).
This permission can inject into the whole seat, including lock/greeter screens.
`UU_INPUT_BACKEND=uinput` requests kernel devices; verify startup actually reports uinput.
In Hyprland / uwsm sessions `default.target` may start before the compositor exports `WAYLAND_DISPLAY`;
tie the unit to the graphical session instead (community-verified autostart on Omarchy):
`After=` and `PartOf=graphical-session.target`, `ConditionEnvironment=WAYLAND_DISPLAY`,
`Environment=UU_DESKTOP_BACKEND=wayland` (no `DISPLAY`), and `WantedBy=graphical-session.target`.
Keep the unit name `uuremote-native.service` (not a template `[email protected]`): the desktop icon and
`uuremote-server show` always start that name (override with `UU_SERVICE_UNIT`). `niri --session` also imports
`WAYLAND_DISPLAY` before it is ready, so the same unit applies to niri (#55).
Optional VAAPI: `intel-media-driver` (modern Intel) or `libva-mesa-driver` (AMD), `libva-utils`
for `vainfo`. Optional KMS: `libdrm`. Virtual Xfce: `xorg-server-xvfb xorg-xauth xorg-xdpyinfo
xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`.
+65 -7
View File
@@ -65,12 +65,15 @@ Portal 仅作用于本服务获授权的会话。文件传输、终端等独立
| Xfce | X11 | ✅ 虚拟机测试通过 | 默认 |
| Cinnamon / MATE | X11 | ✅ 虚拟机测试通过 | 默认 |
| Hyprland | Wayland(wlroots 原生协议) | 🧪 实验性,虚拟机测试(部分功能受限,见下) | `--features wayland` |
| niri | Wayland(wlroots 原生协议) | 🧪 实验性,协议支持已按 niri 源码确认,尚未实机验收(#55) | `--features wayland` |
| GNOME / KDE Plasma | Wayland(xdg-desktop-portal) | 🧪 实验性,验证范围与限制见下 | `--features wayland,portal` |
GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/200% 缩放下验证画面和键鼠;锁屏冷连接自动解锁已用 Mac 和 iPhone 4.42.0 客户端实机验证,其余锁屏恢复及重连仍待验收。除 GNOME 的上述路径和 X11 外,其余桌面目前主要在虚拟机里测试。如果你在真机上遇到问题,欢迎[提交 issue](../../issues),
请附上发行版、桌面环境、显卡型号和 `journalctl --user -u uuremote-native.service` 里的相关日志。
最后一列是源码编译方式;Release 预编译包已包含全部后端,直接使用即可(见[安装](#0-直接用-release-预编译包推荐x86_64))。
Wayland 下的限制:只支持单屏、固定分辨率;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/200% 缩放下验证画面和键鼠;锁屏冷连接自动解锁已用 Mac 和 iPhone 4.42.0 客户端实机验证,其余锁屏恢复及重连仍待验收。除 GNOME 的上述路径和 X11 外,其余桌面目前主要在虚拟机里测试。如果你在真机上遇到问题,欢迎[提交 issue](../../issues),
请附上 `uuremote-server doctor` 的输出(v0.2.17 起;只含会话、后端、插件、权限、编码器等状态,不含账号、令牌或地址,可直接粘贴)和 `journalctl --user -u uuremote-native.service` 里的相关日志。
Wayland 下的限制:默认采集单屏,Hyprland 可按上文启用切屏;分辨率固定;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时保持编码器的采集帧尺寸不变,允许缩放后的逻辑尺寸变化。GNOME 显示配置变化后,已推流的 Portal 采集若持续「暂停且无有效格式」,会在关联通知后的 200 毫秒宽限结束后提前进入现有恢复流程;正常重协商恢复会取消提前判定,连续通知不会推迟同次异常的判定。未收到相关通知时保留五秒兜底;静态画面或有效格式下的暂停不会触发恢复。Ubuntu 26.04、GNOME Wayland 单屏 3840×2160 已实测保持连接切换 200%→166.67%→200%,恢复后画面持续更新且鼠标可控制全屏;切换期间会短暂停顿、黑屏后恢复,五秒是兜底判定阈值,并非总恢复时间。提前恢复的测量结果和验证范围见 [#35](../../pull/35)。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射。
@@ -87,11 +90,19 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
原生 Wayland 实验选项:`UU_WAYLAND_PIPELINE=0` 可关闭流水线做对照。`UU_WAYLAND_DMABUF=1` 显式尝试 dma-buf→GBM CPU 映射(默认关闭,需要运行时 libgbm;可用 `UU_WAYLAND_DMABUF_DEVICE` 指定 render node,默认 `/dev/dri/renderD128`)。仅支持显式线性修饰符、单平面 8-bit RGB,失败回退 SHM;virgl VM 中只验证了回退,成功导入/映射和硬件加速均未验证。这不是零拷贝 VAAPI 路径;选择 `UU_VIDEO_ENCODER=vaapi` 时仍由 FFmpeg 上传 CPU 帧。
首次连接时,桌面会弹窗请求「远程桌面 / 屏幕共享」授权,同意后会记住授权。
### Hyprland 多显示器切换(实验性)
原生 Wayland 的绝对鼠标定位默认绑定正在采集的输出,修复双屏桌面下的点击偏移。uinput 可继续用于键盘、按键和相对移动。
设置 `UU_WAYLAND_MULTISCREEN=1` 后,手机端可选择并切换物理显示器;`UU_WAYLAND_OUTPUT` 指定默认屏幕。画面与绝对鼠标定位同步切换,支持不同分辨率、缩放和桌面位置。
切屏复用同一条视频轨道,过渡期间暂停输入,发送新屏首帧后恢复;采集或编码失败、等待首帧超时会请求恢复原屏。当前通过 `hyprctl` 枚举未旋转的显示器,显示器插拔或布局变化后需重启服务。已在 Omarchy / Hyprland 上用官方手机客户端实测 2560×1440(125%)与 1920×1080(133.33%)双屏切换及点击。
## 尚未实现 / 不支持
| 功能 | 状态 |
|---|---|
| 多显示器切换 | 开发中 |
| 多显示器切换 | Hyprland 原生 Wayland 后端实验性支持,见上文 |
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;VAAPI 和 `inproc-av` 管线仍为 4:2:0,并如实回报给客户端 |
| HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 |
@@ -104,6 +115,38 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
## 安装
### 0. 直接用 Release 预编译包(推荐,x86_64 / aarch64)
**Ubuntu / Debian(v0.2.18 起)**:下载 `uu-remote-linux_<版本>_amd64.deb`(ARM64 选 `arm64`)后:
```sh
sudo apt install ./uu-remote-linux_<版本>_amd64.deb
uuremote-server login # 用 UU 远程 App 扫码
systemctl --user enable --now uuremote-native.service # 随图形会话启动
```
deb 会安装程序、插件、用户级 systemd 服务和应用菜单图标;uinput 权限不会自动开启(见第 5 步)。
GNOME / KDE 会把显示环境自动传给服务;Xfce 等不传的桌面需按第 4 步补 `DISPLAY`。
**其他发行版**:从 [Releases](../../releases/latest) 下载 `uu-remote-linux-<版本>-x86_64-linux.tar.gz`(ARM64 选 `aarch64-linux`),解压后:
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
install -Dm644 libuu-wayland.so libuu-portal.so -t ~/.local/lib/uu-remote-linux/
```
同一个包支持 X11、Hyprland 等 wlroots 合成器和 GNOME/KDE Wayland:程序启动时按当前会话自动选择后端,只在 Wayland 会话里
才加载对应的 `libuu-*.so`,X11 用户不需要任何 Wayland 库。系统要求:
| 会话 | 要求 |
|---|---|
| X11 | glibc ≥ 2.35(Ubuntu 22.04、Debian 12 及更新) |
| Hyprland / Sway / niri 等 wlroots | 同上,另需 `libwayland-client`、`libxkbcommon`(Wayland 桌面自带) |
| GNOME / KDE Wayland | glibc ≥ 2.39(Ubuntu 24.04、Fedora 40、Debian 13 及更新),以及 libei ≥ 1.1、PipeWire |
插件放在 `uuremote-server` 同目录、`../lib/uu-remote-linux/`、`~/.local/lib/uu-remote-linux/` 或 `/usr/lib/uu-remote-linux/` 都能找到
(`UU_ENGINE_DIR` 可指定)。缺库或版本太旧时日志会写明原因。之后从第 3 步「登录」继续;其他架构请按下面源码编译。
### 1. 依赖(Ubuntu / Debian)
```sh
@@ -128,6 +171,10 @@ cargo build --release --features wayland # + Hyprland
cargo build --release --features wayland,portal # + GNOME/KDE Wayland
```
可选的 `--features inproc-av`(进程内编码)和控制端的 `viewer-ffmpeg` 只支持 **FFmpeg 6.x**(`pkg-config --modversion libavcodec` 为 60.x)。
FFmpeg 7 及以上会在依赖 `ffmpeg-sys-next` 里报 `avfft.h file not found`——它的构建脚本先于本项目运行,所以无法提前给出更清楚的提示(#63)。
默认构建和预编译包都不需要这两个特性。
### 3. 登录
在图形桌面里运行:
@@ -248,6 +295,8 @@ systemctl --user restart uuremote-native.service
|---|---|
| `UU_CONFIG` | 配置文件路径(默认 `~/.config/uuremote/config.json`) |
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) |
| `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland 物理显示器切换(默认关闭) |
| `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` |
| `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` |
| `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 |
| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置时检测到 NVIDIA 驱动才用 NVENC,否则用 CPU |
@@ -258,10 +307,13 @@ systemctl --user restart uuremote-native.service
| `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) |
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) |
| `UU_USE_PROXY=1` | 使用环境变量里的 HTTP/SOCKS 代理;默认忽略代理、直连网易服务器 |
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。
自定义码率按客户端选择的 Mbps 生效,例如 1 Mbps 对应 1000 kbit/s 的编码上限。
选择码率档(原画 / 超清 / 高清 / 自定义)时,外部 FFmpeg 的 CPU 编码以平均码率(ABR)为目标,避免 4K 低码率下关键帧发灰;「自动」档仍使用恒定质量(CRF)。
本地编码诊断 `desktop-video-probe [output.h264]` 可设置 `UU_PROBE_FPS`、`UU_PROBE_FRAMES`(默认 5)和 `UU_PROBE_QUALITY`(1–5);设置 `UU_PROBE_INPUT=clip.y4m`(也支持 `.mp4`、`frames/%05d.png`)可绕过桌面采集,以相同的生产 FFmpeg 编码参数测量固定输入并打印分辨率和编码统计,`UU_PROBE_LOOP=1` 循环到指定帧数,输入无法打开或帧数不足时以非零状态退出(固定输入始终使用外部 FFmpeg 管线)。
@@ -312,8 +364,9 @@ flowchart LR
### H.265 / HEVC
控制端和主机都支持 H.265 时,主机自动使用 H.265(与官方主机一致,由主机按双方能力选择;官方 Mac 客户端在 SDP
中优先列出 H.265)。首次桌面连接会用合成帧探测实际编码能力,并通过 CodecNegotiation 告知客户端。支持 `hevc_nvenc`、
控制端和主机都支持 H.265、且主机使用硬件编码器(NVENC / 显式 VAAPI)时,主机自动使用 H.265(与官方主机一致,由主机按双方能力选择;官方 Mac 客户端在 SDP
中优先列出 H.265)。**只有 CPU 编码时默认用 H.264**:libx265 比 libx264 慢约 10 倍(4 核 ARM 上 1080p 实测约 15 帧对 155 帧,#59),
可用 `UU_VIDEO_CODEC=h265` 强制 H.265。实际帧率由控制端的「画质/帧率」菜单决定;`UU_DISPLAY_FPS` 只改上报的显示器刷新率。首次桌面连接会用合成帧探测实际编码能力,并通过 CodecNegotiation 告知客户端。支持 `hevc_nvenc`、
`libx265`、显式 `UU_VIDEO_ENCODER=vaapi` 的 `hevc_vaapi`;硬件失败先回落软件 HEVC,再回落 H.264。
`UU_VIDEO_CODEC=h264` 强制使用 H.264。8-bit;真彩 4:4:4 使用 hevc_nvenc `rext` / libx265 `main444-8`。
已用官方 Mac 客户端在 RTX 3090(hevc_nvenc,含 4:4:4)实机验收;`hevc_vaapi` 配官方 Android 客户端也已实机验收
@@ -365,7 +418,8 @@ cargo build --release --features wayland
Omarchy 使用 Hyprland:在其用户会话中运行,设置 `UU_DESKTOP_BACKEND=wayland`,保留
`WAYLAND_DISPLAY` 和 `XDG_RUNTIME_DIR`。其他合成器可能需要 `--features wayland,portal`。
uinput 需加载内核模块(开机自动加载:`echo uinput | sudo tee /etc/modules-load.d/uinput.conf`)并应用上文 uaccess 规则;无人登录账号需要专用组的受限授权。
uinput 需加载内核模块(开机自动加载:`echo uinput | sudo tee /etc/modules-load.d/uinput.conf`)并应用上文 uaccess 规则;无人登录账号需要专用组的受限授权,
例如 `/etc/tmpfiles.d/uinput.conf` 写入 `z /dev/uinput 0660 root uinput`,再 `sudo usermod -aG uinput <用户>`(只加专用账号)。
该权限能向整个 seat(包括锁屏/登录界面)注入输入。设置 `UU_INPUT_BACKEND=uinput` 后,
仍须确认启动日志实际选择了 uinput。
@@ -386,6 +440,10 @@ Environment=UU_DESKTOP_BACKEND=wayland
WantedBy=graphical-session.target
```
单元名请保持 `uuremote-native.service`,不要写成模板单元 `[email protected]`:桌面图标和 `uuremote-server show`
固定启动这个名字(`UU_SERVICE_UNIT` 可覆盖),systemd 不会把它解析到模板实例。niri 的 `niri --session` 同样会在就绪前导入
`WAYLAND_DISPLAY`,上面的写法也适用(#55)。
VAAPI 可选包:Intel 新显卡用 `intel-media-driver`,AMD 用 `libva-mesa-driver`,`libva-utils` 提供
`vainfo`。KMS 依赖 `libdrm`。虚拟 Xfce 依赖 `xorg-server-xvfb xorg-xauth xorg-xdpyinfo
xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
+44 -5
View File
@@ -50,7 +50,15 @@ fn main() {
}
None => println!("cargo:warning=gtk+-3.0 not found: building without the login window"),
}
if std::env::var_os("CARGO_FEATURE_PORTAL").is_some() {
let plugins = std::env::var_os("CARGO_FEATURE_ENGINE_PLUGINS").is_some();
if plugins && std::env::var_os("CARGO_FEATURE_PORTAL").is_some() {
// Runtime-loaded libuu-portal.so; skipped (with a warning) where libei >= 1.1 is unavailable.
for file in ["portal_engine.c", "portal_engine.h", "portal_eis.inc", "desktop_power.c"] { println!("cargo:rerun-if-changed=c_engine/{file}"); }
match pkg_config(&["gio-2.0", "gio-unix-2.0", "libpipewire-0.3", "libei-1.0 >= 1.1"]) {
Some((cflags, libs)) => shared_engine("libuu-portal.so", &["c_engine/portal_engine.c", "c_engine/desktop_power.c"], &[], &cflags, &libs),
None => println!("cargo:warning=GIO/PipeWire/libei >= 1.1 not found: libuu-portal.so not built"),
}
} else if std::env::var_os("CARGO_FEATURE_PORTAL").is_some() {
println!("cargo:rerun-if-changed=c_engine/portal_engine.c");
println!("cargo:rerun-if-changed=c_engine/portal_engine.h");
println!("cargo:rerun-if-changed=c_engine/portal_eis.inc");
@@ -76,6 +84,7 @@ fn main() {
let mut build = cc::Build::new();
build.flag_if_supported("-Wno-unused-parameter"); // protocol listener signatures
build.file("c_engine/wayland_engine.c").include(&out);
let mut sources = vec!["c_engine/wayland_engine.c".to_owned()];
for name in ["wlr-screencopy-unstable-v1", "wlr-virtual-pointer-unstable-v1", "virtual-keyboard-unstable-v1", "wlr-output-power-management-unstable-v1", "linux-dmabuf-unstable-v1"] {
let xml = format!("c_engine/wayland-protocols/{name}.xml");
println!("cargo:rerun-if-changed={xml}");
@@ -84,13 +93,43 @@ fn main() {
let status = std::process::Command::new("wayland-scanner").args([mode, &xml]).arg(&target).status()
.expect("Install wayland-scanner to build the Wayland backend");
assert!(status.success(), "wayland-scanner failed");
if mode == "private-code" { build.file(target); }
if mode == "private-code" { sources.push(target.to_string_lossy().into_owned()); build.file(target); }
}
}
println!("cargo:rerun-if-changed=c_engine/wayland_engine.c");
build.compile("uu_wayland_engine");
println!("cargo:rustc-link-lib=wayland-client");
println!("cargo:rustc-link-lib=xkbcommon");
if plugins {
let sources: Vec<&str> = sources.iter().map(String::as_str).collect();
match pkg_config(&["wayland-client", "xkbcommon"]) {
Some((cflags, libs)) => shared_engine("libuu-wayland.so", &sources, &[out.as_path()], &cflags, &libs),
None => println!("cargo:warning=wayland-client/xkbcommon not found: libuu-wayland.so not built"),
}
} else {
build.compile("uu_wayland_engine");
println!("cargo:rustc-link-lib=wayland-client");
println!("cargo:rustc-link-lib=xkbcommon");
}
}
}
}
/// `pkg-config --cflags` / `--libs` for `packages`, or None when any is missing.
fn pkg_config(packages: &[&str]) -> Option<(String, String)> {
let run = |kind: &str| std::process::Command::new("pkg-config").arg(kind).args(packages).output().ok()
.filter(|o| o.status.success()).map(|o| String::from_utf8_lossy(&o.stdout).into_owned());
run("--cflags").zip(run("--libs"))
}
/// Builds an engine as a shared library for engine-plugins and places it next to the binaries
/// (target/<profile>/), where the release workflow packages it. Not linked into uuremote-server.
fn shared_engine(name: &str, sources: &[&str], includes: &[&std::path::Path], cflags: &str, libs: &str) {
let out = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
let library = out.join(name);
let mut command = cc::Build::new().pic(true).opt_level(2).get_compiler().to_command();
command.args(["-shared", "-fPIC", "-Wno-unused-parameter", "-Wl,-z,defs"]).arg(format!("-Wl,-soname,{name}")).arg("-o").arg(&library);
for include in includes { command.arg("-I").arg(include); }
command.args(cflags.split_whitespace()).args(sources).args(libs.split_whitespace()).arg("-lpthread");
let status = command.status().expect("C compiler for the engine plugin");
assert!(status.success(), "building {name} failed");
// OUT_DIR = target/<profile>/build/<package>-<hash>/out
if let Some(profile) = out.ancestors().nth(3) { std::fs::copy(&library, profile.join(name)).expect("copy engine plugin"); }
}
+19 -1
View File
@@ -46,7 +46,10 @@ static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
static GtkWidget *window, *allow_switch, *id_label, *code_label, *eye_button, *share_button, *hint_label, *verify_combo, *note_label;
static GtkWidget *refresh_items[5], *footer_label;
// Account card: QR login before sign-in, user info (+ logout) after.
static GtkWidget *assist_card, *account_card, *account_stack, *qr_stack, *qr_image, *login_status, *user_label;
static GtkWidget *assist_card, *account_card, *account_stack, *qr_stack, *qr_image, *login_status, *user_label, *qr_refresh;
/* Like the official client, a failed or timed-out QR stays until the user asks for a new one. */
static atomic_int qr_refresh_requested;
static void on_qr_refresh(GtkButton *b, gpointer d) { (void)b; (void)d; atomic_store(&qr_refresh_requested, 1); gtk_widget_hide(qr_refresh); }
static int show_assist = 1, show_account;
// Tray (host service only): AppIndicator via dlopen (no build dependency), else GtkStatusIcon.
static GtkWidget *tray_menu, *tray_allow;
@@ -250,6 +253,11 @@ static GtkWidget *build_account_card(void) {
login_status = label("", "status");
gtk_label_set_line_wrap(GTK_LABEL(login_status), TRUE);
gtk_box_pack_start(GTK_BOX(qr_text), login_status, FALSE, FALSE, 0);
qr_refresh = gtk_button_new_with_label("刷新二维码");
gtk_widget_set_halign(qr_refresh, GTK_ALIGN_START);
gtk_widget_set_no_show_all(qr_refresh, TRUE);
g_signal_connect(qr_refresh, "clicked", G_CALLBACK(on_qr_refresh), NULL);
gtk_box_pack_start(GTK_BOX(qr_text), qr_refresh, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(qr_page), qr_text, TRUE, TRUE, 0);
gtk_stack_add_named(GTK_STACK(account_stack), qr_page, "qr");
@@ -641,6 +649,16 @@ void uu_ui_set_user(const char *name) {
if (!ui_started || init_state != 1) return;
g_idle_add(apply_user, g_strdup(name ? name : ""));
}
static gboolean apply_qr_refresh(gpointer data) {
if (window && qr_refresh) { if (GPOINTER_TO_INT(data)) gtk_widget_show(qr_refresh); else gtk_widget_hide(qr_refresh); }
return G_SOURCE_REMOVE;
}
void uu_login_ui_offer_refresh(int visible) {
if (!ui_started || init_state != 1 || atomic_load(&closed)) return;
atomic_store(&qr_refresh_requested, 0);
g_idle_add(apply_qr_refresh, GINT_TO_POINTER(visible != 0));
}
int uu_login_ui_take_refresh(void) { return atomic_exchange(&qr_refresh_requested, 0); }
void uu_login_ui_set_done(const char *text) { uu_ui_set_user(text); }
int uu_login_ui_closed(void) { return atomic_load(&closed); }
void uu_login_ui_close(void) { uu_assist_ui_close(); }
+39 -4
View File
@@ -7,6 +7,8 @@
#define SESSION_DEST "org.gnome.SessionManager"
#define SESSION_PATH "/org/gnome/SessionManager"
#define SESSION_IFACE "org.gnome.SessionManager"
#define SCREENSAVER_DEST "org.freedesktop.ScreenSaver"
#define SCREENSAVER_PATH "/org/freedesktop/ScreenSaver"
enum {
UU_POWER_OK = 0,
@@ -17,6 +19,7 @@ enum {
struct uu_idle_inhibitor {
GDBusConnection *connection;
guint32 cookie;
int freedesktop; /* org.freedesktop.ScreenSaver (KDE) instead of org.gnome.SessionManager */
};
struct setup_timeout {
@@ -138,13 +141,45 @@ struct uu_idle_inhibitor *uu_desktop_idle_inhibitor_acquire(int *error_code) {
return inhibitor;
}
/* KDE (and other desktops implementing the freedesktop idle-inhibition spec): the inhibition is
also dropped by the screensaver when this private connection closes. */
struct uu_idle_inhibitor *uu_desktop_screensaver_inhibitor_acquire(int *error_code) {
if (!error_code) return NULL;
*error_code = UU_POWER_OK;
GDBusConnection *connection = private_session_bus(error_code);
if (!connection) return NULL;
GError *error = NULL;
GVariant *reply = g_dbus_connection_call_sync(
connection, SCREENSAVER_DEST, SCREENSAVER_PATH, SCREENSAVER_DEST, "Inhibit",
g_variant_new("(ss)", "uu-remote-linux", "Remote desktop session is active"),
G_VARIANT_TYPE("(u)"), G_DBUS_CALL_FLAGS_NONE, CALL_TIMEOUT_MS, NULL, &error);
g_clear_error(&error);
struct uu_idle_inhibitor *inhibitor = reply ? calloc(1, sizeof(*inhibitor)) : NULL;
if (!inhibitor) {
*error_code = UU_POWER_CALL_FAILED;
if (reply) g_variant_unref(reply);
close_private_bus(connection);
return NULL;
}
g_variant_get(reply, "(u)", &inhibitor->cookie);
g_variant_unref(reply);
inhibitor->connection = connection;
inhibitor->freedesktop = 1;
return inhibitor;
}
void uu_desktop_idle_inhibitor_release(struct uu_idle_inhibitor *inhibitor) {
if (!inhibitor) return;
GError *error = NULL;
GVariant *reply = g_dbus_connection_call_sync(
inhibitor->connection, SESSION_DEST, SESSION_PATH, SESSION_IFACE, "Uninhibit",
g_variant_new("(u)", inhibitor->cookie), G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE, CALL_TIMEOUT_MS, NULL, &error);
GVariant *reply = inhibitor->freedesktop
? g_dbus_connection_call_sync(
inhibitor->connection, SCREENSAVER_DEST, SCREENSAVER_PATH, SCREENSAVER_DEST, "UnInhibit",
g_variant_new("(u)", inhibitor->cookie), G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE, CALL_TIMEOUT_MS, NULL, &error)
: g_dbus_connection_call_sync(
inhibitor->connection, SESSION_DEST, SESSION_PATH, SESSION_IFACE, "Uninhibit",
g_variant_new("(u)", inhibitor->cookie), G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE, CALL_TIMEOUT_MS, NULL, &error);
if (reply) g_variant_unref(reply);
g_clear_error(&error);
+32 -1
View File
@@ -571,10 +571,41 @@ end:
if(result!=0) reset();
pthread_mutex_unlock(&lock); return result;
}
/* Switch the pointer binding and main-process capture atomically; encoder subprocesses
select their own output via UU_WAYLAND_OUTPUT. Keyboard identity stays unchanged. */
int uu_wl_select_output(const char *name,uint32_t expected_w,uint32_t expected_h) {
pthread_mutex_lock(&lock); int result=-1;
if(!initialized || !name || sync_display()!=0) goto end;
unsigned target;
for(target=0;target<output_count;target++) if(!strcmp(outputs[target].name,name)) break;
if(target==output_count || outputs[target].transform!=WL_OUTPUT_TRANSFORM_NORMAL) goto end;
uint32_t w=outputs[target].width,h=outputs[target].height;
if(w!=expected_w || h!=expected_h || !w || !h || w>16384 || h>16384 || (uint64_t)w*h*4>256*1024*1024) goto end;
struct zwlr_virtual_pointer_v1 *next=zwlr_virtual_pointer_manager_v1_create_virtual_pointer_with_output(pointer_manager,seat,outputs[target].handle);
if(!next) goto end;
if(sync_display()!=0) {zwlr_virtual_pointer_v1_destroy(next);goto end;}
for(unsigned i=0;i<2;i++) { frame_clear(&frames[i]); dma_clear(&frames[i]); shm_clear(&frames[i]); }
pending=0;
if(pointer) zwlr_virtual_pointer_v1_destroy(pointer);
pointer=next; selected=target; width=w; height=h;
if(power) { zwlr_output_power_v1_destroy(power); power=NULL; }
power_failed=0;
if(power_manager) {
power=zwlr_output_power_manager_v1_get_output_power(power_manager,outputs[selected].handle);
zwlr_output_power_v1_add_listener(power,&power_listener,NULL);
}
result=0;
end:
pthread_mutex_unlock(&lock); return result;
}
int uu_wl_wake(void) {
pthread_mutex_lock(&lock); int result=-1;
/* Output power management is optional; missing it must not block screencopy. */
if(initialized && !power) result=0;
if(initialized && (!power || power_failed)) {
/* No power manager, or the compositor refused the mode (outputs without DPMS,
headless outputs): streaming continues, the screen simply stays as it is. */
result=0;
}
if(initialized && power && !power_failed) {
zwlr_output_power_v1_set_mode(power,ZWLR_OUTPUT_POWER_V1_MODE_ON);
if(sync_display()==0 && !power_failed) result=0;
+1 -1
View File
@@ -1,7 +1,7 @@
# Unofficial UU Remote Linux host in a container, for NAS boxes (Synology DSM, etc.) without a desktop.
# Headless mode: file transfer, terminal and port mapping; no remote desktop. Uses the published release binary.
FROM ubuntu:24.04
ARG VERSION=v0.2.12
ARG VERSION=v0.2.20
LABEL org.opencontainers.image.source="https://github.com/VallierDev/uu-remote-linux" \
org.opencontainers.image.description="Unofficial UU Remote Linux host, headless (file transfer, terminal, port mapping)" \
org.opencontainers.image.licenses="GPL-3.0"
+25
View File
@@ -0,0 +1,25 @@
一个包支持所有桌面:Wayland 和 GNOME/KDE 不再需要源码编译。/ One package for every desktop: no source build needed for Wayland or GNOME/KDE.
### 新增 / Added
- **预编译包内置 Wayland 与 GNOME/KDE 支持**(#43、#54):Release 包新增 `libuu-wayland.so`(Hyprland / Sway / niri 等 wlroots)
和 `libuu-portal.so`(GNOME / KDE Wayland)。程序按当前会话自动选择后端,只在 Wayland 会话里加载对应插件,X11 用户不需要任何
Wayland 库。安装:
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
install -Dm644 libuu-wayland.so libuu-portal.so -t ~/.local/lib/uu-remote-linux/
```
系统要求:X11 与 wlroots 为 glibc ≥ 2.35;GNOME/KDE 插件为 glibc ≥ 2.39(Ubuntu 24.04、Fedora 40、Debian 13 及更新)及 libei ≥ 1.1。
缺库或版本过旧时日志会写明原因。**验证范围**:插件加载、回退与报错在 Hyprland 虚拟机(ARM)实测,wlroots 采集正常;
预编译的 GNOME/KDE 插件尚未在真机上完成画面/键鼠验收(引擎代码本身未改动)。Wayland 仍为实验性。
- The release now ships `libuu-wayland.so` and `libuu-portal.so`, loaded at runtime only on Wayland sessions; X11 hosts need no
Wayland libraries. The portal plugin requires glibc >= 2.39 and libei >= 1.1. Plugin loading was tested on a Hyprland VM;
the prebuilt GNOME/KDE plugin has not yet been accepted on real hardware.
### 改进 / Improved
- 在 GNOME/KDE Wayland 上缺少 portal 支持时,不再反复报看不懂的 `portal unavailable (code 2)`,而是直接说明原因和解决办法(#43)。
- README:支持表加入 niri(实验性,协议已按源码确认、未实机验收);systemd 单元名须为 `uuremote-native.service`;uinput 无人值守授权示例(#55)。
### 下载 / Download
`uu-remote-linux-v0.2.13-x86_64-linux.tar.gz`(`uuremote-server`、`uuremote-viewer`、`libuu-wayland.so`、`libuu-portal.so`、`contrib/`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.13`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+20
View File
@@ -0,0 +1,20 @@
Hyprland 双屏点击偏移修复,并可在手机端切换显示器(实验性)。/ Hyprland dual-monitor pointer fix and opt-in monitor switching.
### 修复 / Fixed
- **Hyprland 双屏点击偏移**(#57,感谢 @JuanZoran):原生 Wayland 后端的绝对鼠标定位改为绑定正在采集的输出
(此前 uinput 绝对坐标映射到整个桌面,双屏时点击位置偏移)。uinput 仍用于键盘、按键和相对移动。
**影响所有 Hyprland 用户的默认路径**;单屏下映射结果与之前等价。贡献者已在双屏真机(2560×1440@125% + 1920×1080@133%)
上验证落点误差 ≤ 2 像素;维护者未另行复测。
- Absolute pointer motion on the native Wayland backend is now bound to the captured output (it previously spanned the whole
desktop through uinput, offsetting clicks on multi-monitor setups). Verified by the contributor on real dual-monitor hardware.
### 新增 / Added
- **Hyprland 多显示器切换(实验性,默认关闭)**:设置 `UU_WAYLAND_MULTISCREEN=1` 后,手机端可以选择物理显示器,画面与
鼠标定位同步切换;`UU_WAYLAND_OUTPUT` 指定默认屏幕。通过 `hyprctl` 枚举未旋转的显示器,插拔或布局变化后需重启服务;
切换失败会恢复原屏。由贡献者用官方手机客户端在 Omarchy / Hyprland 双屏上实测。
- Opt-in Hyprland monitor switching (`UU_WAYLAND_MULTISCREEN=1`), accepted by the contributor with the official phone client.
### 下载 / Download
`uu-remote-linux-v0.2.14-x86_64-linux.tar.gz`(含 `libuu-wayland.so` / `libuu-portal.so`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.14`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
ARM64 预编译包;无硬件编码器时默认 H.264。/ aarch64 release package; CPU-only hosts default to H.264.
### 新增 / Added
- **aarch64 预编译包**(#59,感谢 @DeliciousBuding):新增 `uu-remote-linux-v0.2.15-aarch64-linux.tar.gz`,与 x86_64 包相同,
含 `uuremote-server`、`uuremote-viewer` 和两个桌面引擎插件;ARM64 主机不再需要源码编译。CI 新增 ARM64 原生构建与测试(#58)。
aarch64 包由 GitHub ARM runner 构建,尚未在真实 ARM 主机上运行验收。
- New aarch64 release package (same contents as x86_64), built on GitHub ARM runners; not yet run on real ARM hardware.
### 变更 / Changed
- **只有 CPU 编码时默认使用 H.264**(#59):libx265 比 libx264 慢约 10 倍(4 核 Ampere A1 上 1080p 约 15 帧对 155 帧),
原先 CPU 主机默认 H.265 会掉到十几帧。现在只有使用硬件编码器(NVENC / 显式 VAAPI)时才自动选 H.265;
`UU_VIDEO_CODEC=h265` 仍可强制 H.265。NVENC / VAAPI 主机行为不变。
- Without NVENC/VAAPI the host now picks H.264 even when both sides offer H.265; `UU_VIDEO_CODEC=h265` forces H.265.
### 下载 / Download
`uu-remote-linux-v0.2.15-x86_64-linux.tar.gz` / `uu-remote-linux-v0.2.15-aarch64-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.15`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
KDE 远程期间不再自动锁屏;锁屏和黑屏原因写进日志。/ No idle lock on KDE during remote sessions; lock and black-screen hints.
### 修复 / Fixed
- **KDE Wayland 远程操作中途自动锁屏**(#61,感谢 @coolxll):桌面连接期间通过 `org.freedesktop.ScreenSaver.Inhibit` 阻止空闲锁屏,
断开后释放(GNOME 沿用 SessionManager 的空闲抑制)。尚未在 KDE 真机上验证。
- **`inproc-av` 奇数尺寸桌面**(#60,感谢 @ferstar):进程内编码路径同样补齐为偶数尺寸(#53 只修了默认 FFmpeg 管线)。
`inproc-av` 不在预编译包里;未在奇数尺寸真机上验证。
### 改进 / Improved
- 桌面锁屏时日志提示「控制端在解锁前只会看到黑屏」,并给出解锁方式(控制端「自动解锁被控端」或本机 `loginctl unlock-session`)。
- 检测到 Wayland 会话却选中了 X11 后端时给出警告(此时采集 XWayland 只会得到全黑画面且没有报错)。
- KDE sessions hold a freedesktop ScreenSaver inhibitor while connected (not yet tested on real KDE); the log now explains lock-screen
black frames and warns when X11 capture is used inside a Wayland session; `inproc-av` pads odd sizes too.
### 下载 / Download
`uu-remote-linux-v0.2.16-x86_64-linux.tar.gz` / `uu-remote-linux-v0.2.16-aarch64-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.16`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
新增 `uuremote-server doctor` 一键诊断。/ New `uuremote-server doctor` diagnostic report.
### 新增 / Added
- **`uuremote-server doctor`**:一次输出提 issue 需要的状态——会话类型与桌面、最终选中的后端(含「Wayland 会话里用了 X11 后端会黑屏」的提醒)、
Wayland / portal 插件能否加载及缺什么库、`/dev/uinput` 与显卡 render 节点权限、FFmpeg 可用编码器和版本、默认编码(H.264 / H.265)、
是否已登录、服务状态和重复进程。只输出布尔值、名称和版本,主目录和用户名会被替换,不含账号 ID、令牌、IP、MAC 或文件内容,
可以直接贴到 issue。issue 模板已改为先运行它。
- `uuremote-server doctor` prints a paste-safe report (session, backend, plugins, permissions, encoders, default codec, sign-in and
service state) with no ids, tokens, addresses or file contents.
### 下载 / Download
`uu-remote-linux-v0.2.17-x86_64-linux.tar.gz` / `uu-remote-linux-v0.2.17-aarch64-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.17`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+25
View File
@@ -0,0 +1,25 @@
Ubuntu / Debian 安装包(.deb);实验性远程开机辅助。/ Debian packages; experimental Wake-on-LAN helper.
### 新增 / Added
- **`.deb` 安装包**(amd64 / arm64):`sudo apt install ./uu-remote-linux_0.2.18_amd64.deb` 一步装好程序、两个桌面插件、
用户级 systemd 服务和应用菜单图标,依赖由 apt 自动安装。之后以桌面用户运行:
```sh
uuremote-server login
systemctl --user enable --now uuremote-native.service
```
服务随图形会话启动(GNOME / KDE 会自动传入显示环境;Xfce 等需按 README 补 `DISPLAY`)。uinput 权限不会自动开启,规则文件放在
`/usr/share/doc/uu-remote-linux/`。安装流程在 CI 的 Ubuntu 22.04 上实测(apt 安装、`--help`、systemd 单元校验);尚未在真实桌面上完整验收。
- **远程开机辅助(实验性,默认关闭,`UU_WOL_HELPER=1`)**:仿照官方 Windows 被控端,登录后向网易上报本机局域网信息,
收到云端的唤醒请求时向同一局域网发送唤醒包,让这台常开的 Linux(例如 NAS)帮你唤醒同局域网的其他电脑。
字段名来自官方程序的日志字符串,**未经端到端验证**;不开启时不上报任何局域网信息,只记录唤醒推送的字段名(不含 MAC/IP)。
- Debian packages (amd64/arm64) with the binaries, plugins, a systemd user unit and menu entries; install-tested on Ubuntu 22.04 in CI.
Experimental, opt-in Wake-on-LAN helper (`UU_WOL_HELPER=1`) modelled on the official Windows host; not verified end to end.
### 修复 / Fixed
- `uuremote-server doctor` 不再输出带完整路径的插件加载日志(路径可能含用户名)。
### 下载 / Download
`uu-remote-linux_0.2.18_amd64.deb` / `uu-remote-linux_0.2.18_arm64.deb`,或 `uu-remote-linux-v0.2.18-<x86_64|aarch64>-linux.tar.gz`,
或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.18`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
无头 Wayland 出画面、自定义码率、`show` 与登录体验修复。/ Headless Wayland video, custom bitrate, `show` and login fixes.
### 修复 / Fixed
- **无头 Wayland 主机连上没有画面**(#64 / #65,感谢 @axlrose):输出不支持 DPMS 时电源握手失败不再中断视频;贡献者在 sway headless 上复现并验证。
- **自定义码率单位错误**(#67,感谢 @JuanZoran):手机端自定义码率按 bit/s 发送(1 Mbps = 1000000),此前被当成 kbit/s 而触发 100 Mbps 上限,
导致大量重传、画面滞留。贡献者在 Hyprland + NVENC 上用手机实测。另外对明显是 Mbps / kbps 的小数值做了兜底换算(维护者补充,未实测)。
- **`uuremote-server show` 静默卡 30 秒**(#62,感谢 @axlrose):服务被条件跳过、反复崩溃重启或启动失败时立即报出真实原因。贡献者已用真实 systemd 单元验证。
- **登录二维码反复立即失效**(#68,感谢 @axlrose):状态轮询在服务器立即应答时不再紧循环(2 秒退避);二维码连续在几秒内失效时指数退避,
并提示可备份删除 `~/.config/uuremote/config.json` 重新登录(注册新设备身份,#68 中以此恢复)。退避逻辑未在被标记的设备上实测。
### 改进 / Improved
- `doctor`:会话里没有 `DISPLAY` / `WAYLAND_DISPLAY` 时给出提示(#66,感谢 @axlrose)。
- 文档:`inproc-av` / `viewer-ffmpeg` 只支持 FFmpeg 6.x,FFmpeg 7+ 会在依赖里报 `avfft.h file not found`(#63)。
### 下载 / Download
`uu-remote-linux_0.2.19_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.19-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.19`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
扫码登录改为与官方客户端一致,修复二维码刚生成就失效。/ QR sign-in now matches the official client.
### 修复 / Fixed
- **登录二维码反复立即失效(1190)**(#68,感谢 @axlrose 的详细排查):逆向官方 Mac 客户端(4.42)后确认,新版服务端在生成二维码时
返回 `status_query_ticket`,官方客户端查询扫码状态和确认登录时都用它(放在 `token` 键下);我们此前优先发送旧的 `token` 字段。现在与官方一致:
- 生成二维码不带请求体;状态查询用 `status_query_ticket`(服务端没有时才用旧 `token`);
- 状态查询是长轮询,每次应答后立即再问,单次超时 60 秒(此前 12 秒);
- 状态 3 立即换新码、状态 0 在 0.35 秒后换新码、状态 4 登录(状态 3 不再去调确认登录);
- 出错(如 HTTP 400 / 1190)或超时时停止轮询,等用户点击登录窗口新增的「刷新二维码」按钮(终端里按回车;既无窗口也无终端时 60 秒后自动换码)。
取代 v0.2.19 的临时退避和「重新注册设备」提示。已用全新设备身份实测:状态查询正常挂起,60 秒后按官方行为停止并等待刷新;
未在 #68 那台被标记的设备上实测,「刷新二维码」按钮的界面尚未在桌面上目视验收。
- QR sign-in mirrors the official Mac client: `status_query_ticket` as the status ticket, 60 s long poll, regenerate on status 3/0,
stop on errors (e.g. code 1190) until the user clicks the new “refresh QR” button.
### 下载 / Download
`uu-remote-linux_0.2.20_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.20-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.20`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+67
View File
@@ -0,0 +1,67 @@
#!/bin/sh
# Build uu-remote-linux_<version>_<arch>.deb from release binaries.
# usage: packaging/deb/build-deb.sh VERSION BIN_DIR OUT_DIR (VERSION without the leading v)
set -eu
version=$1 bin=$2 out=$3
here=$(cd "$(dirname "$0")" && pwd) root=$(cd "$here/../.." && pwd)
case $(uname -m) in x86_64) arch=amd64 ;; aarch64) arch=arm64 ;; *) echo "unsupported arch" >&2; exit 1 ;; esac
pkg=$(mktemp -d)
trap 'rm -rf "$pkg"' EXIT
install -Dm755 "$bin/uuremote-server" "$pkg/usr/bin/uuremote-server"
[ -f "$bin/uuremote-viewer" ] && install -Dm755 "$bin/uuremote-viewer" "$pkg/usr/bin/uuremote-viewer"
for lib in libuu-wayland.so libuu-portal.so; do
[ -f "$bin/$lib" ] && install -Dm644 "$bin/$lib" "$pkg/usr/lib/uu-remote-linux/$lib"
done
install -Dm644 "$here/uuremote-native.service" "$pkg/usr/lib/systemd/user/uuremote-native.service"
install -Dm644 "$root/contrib/desktop/uu-remote-linux.desktop" "$pkg/usr/share/applications/uu-remote-linux.desktop"
[ -f "$pkg/usr/bin/uuremote-viewer" ] && install -Dm644 "$root/contrib/desktop/uu-remote-linux-viewer.desktop" "$pkg/usr/share/applications/uu-remote-linux-viewer.desktop"
install -Dm644 "$root/contrib/desktop/uu-remote-linux.svg" "$pkg/usr/share/icons/hicolor/scalable/apps/uu-remote-linux.svg"
install -Dm644 "$root/LICENSE" "$pkg/usr/share/doc/uu-remote-linux/copyright"
# uinput access is opt-in: it lets the service inject input into the whole seat.
printf '%s\n' 'KERNEL=="uinput", SUBSYSTEM=="misc", OPTIONS+="static_node=uinput", TAG+="uaccess"' \
> "$pkg/usr/share/doc/uu-remote-linux/60-uu-remote-linux-uinput.rules"
size=$(du -sk "$pkg/usr" | cut -f1)
# Library dependencies from the binaries themselves (the server hard, the viewer recommended).
shlibdeps() {
work=$(mktemp -d); mkdir "$work/debian"
printf 'Source: uu-remote-linux\n\nPackage: uu-remote-linux\nArchitecture: any\n' > "$work/debian/control"
(cd "$work" && dpkg-shlibdeps -O --ignore-missing-info "$1" 2>/dev/null) | sed -n 's/^shlibs:Depends=//p'
rm -rf "$work"
}
depends=$(shlibdeps "$pkg/usr/bin/uuremote-server")
recommends=""
[ -f "$pkg/usr/bin/uuremote-viewer" ] && recommends=$(shlibdeps "$pkg/usr/bin/uuremote-viewer")
[ -n "$depends" ] || { echo "dpkg-shlibdeps produced no dependencies" >&2; exit 1; }
mkdir -p "$pkg/DEBIAN"
cat > "$pkg/DEBIAN/control" <<CONTROL
Package: uu-remote-linux
Version: $version
Architecture: $arch
Maintainer: VallierDev <[email protected]>
Installed-Size: $size
Depends: $depends, ffmpeg
Recommends: ${recommends:+$recommends, }libwayland-client0, libxkbcommon0
Suggests: libpipewire-0.3-0, libei1, wl-clipboard
Section: net
Priority: optional
Homepage: https://github.com/VallierDev/uu-remote-linux
Description: Unofficial native Linux host for NetEase UU Remote
Lets the official NetEase UU Remote clients control this Linux desktop
(X11, wlroots Wayland and GNOME/KDE Wayland through runtime plugins).
Includes the experimental uuremote-viewer. Not affiliated with NetEase.
CONTROL
cat > "$pkg/DEBIAN/postinst" <<'POSTINST'
#!/bin/sh
set -e
if [ "$1" = configure ]; then
cat <<'MSG'
uu-remote-linux installed. As your desktop user (not root):
uuremote-server login # scan the QR code with the UU Remote app
systemctl --user enable --now uuremote-native.service # start with the graphical session
Optional uinput keyboard/mouse (Wayland): see /usr/share/doc/uu-remote-linux/60-uu-remote-linux-uinput.rules
MSG
fi
POSTINST
chmod 755 "$pkg/DEBIAN/postinst"
mkdir -p "$out"
dpkg-deb --build --root-owner-group "$pkg" "$out/uu-remote-linux_${version}_${arch}.deb"
+17
View File
@@ -0,0 +1,17 @@
# Installed by the uu-remote-linux .deb as a systemd *user* unit; enable it per user:
# systemctl --user enable --now uuremote-native.service
# GNOME and KDE import DISPLAY / WAYLAND_DISPLAY into the user manager when the graphical session
# starts. Desktops that do not (e.g. Xfce) can add a drop-in with Environment=DISPLAY=:0.
[Unit]
Description=UU Remote Linux host (unofficial)
After=graphical-session.target
PartOf=graphical-session.target
[Service]
Environment=RUST_LOG=info
ExecStart=/usr/bin/uuremote-server
Restart=always
RestartSec=5
[Install]
WantedBy=graphical-session.target
+21
View File
@@ -251,6 +251,27 @@ impl UUAuthClient {
Ok((status, value))
}
/// Signed POST with an optional JSON body (None = empty body, like Moya `requestPlain`) and an
/// explicit timeout. The official clients long-poll the QR status with a 60 s request timeout.
pub async fn post_with_timeout(&self, path: &str, body: Option<&serde_json::Value>, timeout: std::time::Duration) -> Result<(u16, serde_json::Value), String> {
let body_str = body.map(serde_json::to_string).transpose().map_err(|e| e.to_string())?.unwrap_or_default();
let resp = self.http.post(format!("{}{}", BASE_URL, path)).timeout(timeout)
.headers(self.build_headers("POST", path, &body_str)).body(body_str)
.send().await.map_err(|e| format!("HTTP post {path} failed: {}", transport_error(&e)))?;
let status = resp.status().as_u16();
Ok((status, resp.json().await.unwrap_or(serde_json::Value::Null)))
}
/// Signed JSON POST to another API host (the signature covers the path only).
pub async fn post_json_url(&self, base: &str, path: &str, body: &serde_json::Value) -> Result<(u16, serde_json::Value), String> {
let body_str = serde_json::to_string(body).map_err(|e| e.to_string())?;
let resp = self.http.post(format!("{base}{path}"))
.headers(self.build_headers("POST", path, &body_str)).body(body_str)
.send().await.map_err(|e| format!("HTTP post {path} failed: {}", transport_error(&e)))?;
let status = resp.status().as_u16();
Ok((status, resp.json().await.unwrap_or(serde_json::Value::Null)))
}
/// Guest APIs use requestPlain for empty requests; sign the actual empty body.
/// Errors intentionally exclude response text and URL (both can contain secrets).
pub async fn assist_post(&self, path: &str, body: Option<&serde_json::Value>) -> Result<(u16, serde_json::Value), String> {
+118 -13
View File
@@ -40,11 +40,13 @@ impl VideoCodec {
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct VideoSettings {
pub source_id: usize,
pub source_generation: u64,
pub fps: u32,
pub codec: VideoCodec,
pub quality: u64,
/// Viewer max_custom_bitrate (only used for QUALITY_CUSTOM): Mbit/s, or kbit/s above 1000.
pub custom_mbps: u32,
/// Viewer max_custom_bitrate in bits/s (only used for QUALITY_CUSTOM).
pub custom_bps: u32,
/// Scaled stream size (其他分辨率); None streams the native desktop size.
pub output: Option<(u32, u32)>,
/// CHROMA_420 or CHROMA_444 (真彩); 4:4:4 only when the encoder pipeline supports it.
@@ -52,7 +54,7 @@ pub struct VideoSettings {
}
impl Default for VideoSettings {
fn default() -> Self { Self { codec: VideoCodec::H264, fps: 60, quality: QUALITY_AUTO, custom_mbps: 0, output: None, chroma: CHROMA_420 } }
fn default() -> Self { let (source_id,source_generation)=crate::wayland::selection(); Self { source_id,source_generation, codec: VideoCodec::H264, fps: 60, quality: QUALITY_AUTO, custom_bps: 0, output: None, chroma: CHROMA_420 } }
}
/// Selectable smaller stream sizes with the desktop's aspect ratio (even dimensions).
@@ -84,8 +86,8 @@ impl VideoSettings {
QUALITY_GENERAL => Some(2_000),
QUALITY_HD => Some(8_000),
QUALITY_BLURAY => Some(20_000),
QUALITY_CUSTOM if self.custom_mbps > 0 =>
Some(if self.custom_mbps > 1_000 { self.custom_mbps } else { self.custom_mbps * 1_000 }.min(100_000)),
QUALITY_CUSTOM if self.custom_bps > 0 =>
Some((self.custom_bps / 1_000).clamp(1, 100_000)),
_ => None,
}
}
@@ -110,15 +112,29 @@ fn fps_from_option(value: u64) -> Option<u64> {
/// Applies a capture-setting RPC to `settings` and returns the RpcResponse payload (Message 22),
/// or None when the RPC is not a capture/fps/quality setting.
/// max_custom_bitrate (field 8) in bit/s: the mobile viewer sends 1_000_000 for 1 Mbps (#67). Values
/// that can only be a different unit stay usable instead of collapsing to a 1 kbit/s cap: below 1000
/// they are Mbit/s, below 200_000 kbit/s (no viewer offers custom rates under 200 kbit/s).
fn custom_bitrate_bps(value: u64) -> u32 {
let bps = if value < 1_000 { value * 1_000_000 } else if value < 200_000 { value * 1_000 } else { value };
bps.min(u64::from(u32::MAX)) as u32
}
pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32)) -> Option<Vec<u8>> {
handle_rpc_with_codecs(rpc, settings, native, true, false)
}
/// Initial codec once the m-line is negotiated: H.265 when both sides support it (the Mac viewer
/// lists H265 first in its offer), unless UU_VIDEO_CODEC=h264.
/// lists H265 first in its offer) and a hardware encoder is selected. Software libx265 is about ten
/// times slower than libx264 (measured 15 vs 155 fps at 1080p on a 4-core ARM host, #59), so CPU
/// hosts default to H.264. UU_VIDEO_CODEC=h264 / h265 overrides.
pub fn preferred_codec(h264: bool, h265: bool) -> VideoCodec {
let forced_h264 = std::env::var("UU_VIDEO_CODEC").is_ok_and(|v| v.eq_ignore_ascii_case("h264"));
if h265 && !(forced_h264 && h264) { VideoCodec::H265 } else { VideoCodec::H264 }
let forced = std::env::var("UU_VIDEO_CODEC").ok().map(|v| v.to_ascii_lowercase());
pick_codec(h264, h265, forced.as_deref(), crate::video::Encoder::requested() != crate::video::Encoder::Cpu)
}
fn pick_codec(h264: bool, h265: bool, forced: Option<&str>, hardware: bool) -> VideoCodec {
let wants_h265 = match forced { Some("h264") => false, Some("h265" | "hevc") => true, _ => hardware };
if h265 && (wants_h265 || !h264) { VideoCodec::H265 } else { VideoCodec::H264 }
}
pub fn handle_rpc_with_codecs(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool) -> Option<Vec<u8>> {
@@ -140,7 +156,7 @@ fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native:
// Field 1 is the viewer's fps option index (1 = 30, 2 = 60, ...); 18 fpsCount is the frame rate.
if let Some(fps) = number(&fields, 18).filter(|v| *v > 0).or_else(|| number(&fields, 1).and_then(fps_from_option)) { next.fps = fps as u32; }
if let Some(quality) = number(&fields, 2).filter(|v| *v > 0) { next.quality = quality; }
if let Some(bitrate) = number(&fields, 8).filter(|v| *v > 0) { next.custom_mbps = bitrate as u32; }
if let Some(bitrate) = number(&fields, 8).filter(|v| *v > 0) { next.custom_bps = custom_bitrate_bps(bitrate); }
// Field 7 chorma_format (sic): 3 = 4:4:4 when 真彩 is on, 1 = 4:2:0. The Sync reports what is encoded.
match number(&fields, 7) {
Some(CHROMA_444) if full_chroma => next.chroma = CHROMA_444,
@@ -180,9 +196,37 @@ fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native:
Some(out)
}
/// CaptureSettingResponse.errors (Error fields 1 code / 2 message, rpc_main.proto).
pub fn rejected_request(data:&[u8],reason:&str)->Option<Vec<u8>> {
let outer=decode_wire(data).ok()?;
let rpc=decode_wire(message(&outer,21)?).ok()?;
message(&rpc,2)?;
let mut error=Vec::new();
put_varint(1,(-1i64) as u64,&mut error);
put_bytes(2,reason.as_bytes(),&mut error);
let mut errors=Vec::new();put_bytes(1,&error,&mut errors);
let mut response=Vec::new();
put_bytes(1,message(&rpc,1).unwrap_or(&[]),&mut response);
put_bytes(2,&errors,&mut response);
Some(response)
}
/// Message 7 ScreenSources in pixels for capture-setting v4: native, choices, current size.
pub fn screen_sources(seq: u64, timestamp: u64, native: (u32, u32), output: Option<(u32, u32)>, name: &str) -> Result<Vec<u8>, String> {
use crate::initialization::{Screen, WinRect};
let outputs=crate::wayland::outputs();
if !outputs.is_empty() {
let current=crate::wayland::selected();
let choices:Vec<Vec<(i32,i32)>>=outputs.iter().map(|m|scaled_sizes((m.width,m.height)).into_iter().map(|(w,h)|(w as i32,h as i32)).collect()).collect();
let screens:Vec<Screen<'_>>=outputs.iter().enumerate().map(|(id,m)| Screen {
id:id as i32, fps:m.fps,
resolution:WinRect {left:0,top:0,width:m.width as i32,height:m.height as i32,pixel_width:m.width as i32,pixel_height:m.height as i32},
primary:id==0,dpr:1.0,display_name:&m.name,video_track_index:if id==current {0} else {-1},
screen_type:0,builtin_screen_type:if m.name.starts_with("eDP") {1} else {2},scaled:&choices[id],
current:if id==current {output.map(|(w,h)|(w as i32,h as i32))} else {None},
}).collect();
return crate::initialization::encode_screen_sources(seq,timestamp,&screens,current as i32);
}
let (w, h) = (native.0 as i32, native.1 as i32);
let scaled: Vec<(i32, i32)> = scaled_sizes(native).into_iter().map(|(w, h)| (w as i32, h as i32)).collect();
// DPI_SCALE starts at version 5; the observed v4 request uses fields 5/6 as pixels.
@@ -201,7 +245,7 @@ pub fn sync_payload(settings: &VideoSettings, native: (u32, u32)) -> Vec<u8> {
put_varint(1, u64::from(settings.fps), &mut out);
put_varint(2, settings.quality, &mut out);
put_varint(3, settings.chroma, &mut out);
if settings.custom_mbps > 0 { put_varint(4, u64::from(settings.custom_mbps), &mut out); }
if settings.custom_bps > 0 { put_varint(4, u64::from(settings.custom_bps), &mut out); }
put_varint(5, u64::from(size.0), &mut out);
put_varint(6, u64::from(size.1), &mut out);
put_varint(9, u64::from(size.0), &mut out);
@@ -248,7 +292,7 @@ mod tests {
put_varint(18, 30, &mut body);
let request = rpc(77, 2, &body);
let response = handle_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(*rx.borrow(), VideoSettings { codec: VideoCodec::H264, fps: 30, quality: QUALITY_GENERAL, custom_mbps: 0, output: None, chroma: CHROMA_420 });
assert_eq!(*rx.borrow(), VideoSettings { source_id:0,source_generation:0, codec: VideoCodec::H264, fps: 30, quality: QUALITY_GENERAL, custom_bps: 0, output: None, chroma: CHROMA_420 });
assert_eq!(rx.borrow().max_kbps(), Some(2_000));
let fields = decode_wire(&response).unwrap();
assert_eq!(message(&fields, 1), Some(&[8u8, 77][..]));
@@ -432,8 +476,40 @@ mod tests {
#[test]
fn auto_quality_keeps_constant_quality_encoding() {
assert_eq!(VideoSettings::default().max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_mbps: 0, ..Default::default() }.max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_mbps: 12, ..Default::default() }.max_kbps(), Some(12_000));
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_bps: 0, ..Default::default() }.max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_bps: 12_000_000, ..Default::default() }.max_kbps(), Some(12_000));
}
#[test]
fn mobile_custom_bitrate_is_bits_per_second_in_request_and_sync() {
// Mobile viewer sends field 8 = 1_000_000 for 1 Mbps (observed live, 2026-10-20).
for (bps, kbps) in [(1_000_000, 1_000), (30_000_000, 30_000), (500_000, 500), (100_000_000, 100_000), (200_000_000, 100_000)] {
let (tx, rx) = watch::channel(VideoSettings::default());
let mut body = Vec::new();
put_varint(2, QUALITY_CUSTOM, &mut body);
put_varint(8, bps, &mut body);
handle_rpc(&decode_wire(&rpc(7, 2, &body)).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().max_kbps(), Some(kbps));
let sync = sync_payload(&rx.borrow(), (1920, 1080));
assert_eq!(number(&decode_wire(&sync).unwrap(), 4), Some(bps));
}
}
#[test]
fn small_custom_bitrates_are_read_as_larger_units() {
assert_eq!(custom_bitrate_bps(20), 20_000_000);
assert_eq!(custom_bitrate_bps(8_000), 8_000_000);
assert_eq!(custom_bitrate_bps(1_000_000), 1_000_000);
}
#[test]
fn oversized_custom_bitrate_does_not_wrap_before_encoder_limit() {
let (tx, rx) = watch::channel(VideoSettings::default());
let mut body = Vec::new();
put_varint(2, QUALITY_CUSTOM, &mut body);
put_varint(8, u64::from(u32::MAX) + 1, &mut body);
handle_rpc(&decode_wire(&rpc(8, 2, &body)).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().max_kbps(), Some(100_000));
}
#[test]
@@ -469,4 +545,33 @@ mod codec_tests {
assert_eq!(rx.borrow().codec, VideoCodec::H265);
assert_eq!(preferred_codec(true, false), VideoCodec::H264);
}
#[test]
fn software_hosts_default_to_h264_unless_forced() {
assert_eq!(pick_codec(true, true, None, true), VideoCodec::H265);
assert_eq!(pick_codec(true, true, None, false), VideoCodec::H264);
assert_eq!(pick_codec(true, true, Some("h265"), false), VideoCodec::H265);
assert_eq!(pick_codec(true, true, Some("h264"), true), VideoCodec::H264);
// Only one codec bound in the SDP: use it whatever the preference.
assert_eq!(pick_codec(false, true, None, false), VideoCodec::H265);
assert_eq!(pick_codec(true, false, Some("h265"), true), VideoCodec::H264);
}
}
#[cfg(test)]
mod screen_error_tests {
use super::*;
#[test]
fn failed_switch_returns_correlated_error_not_success() {
let header=[10,4,b't',b'e',b's',b't'];
let mut rpc=Vec::new();put_bytes(1,&header,&mut rpc);put_bytes(2,&[32,99],&mut rpc);
let request=crate::initialization::envelope(1,2,21,&rpc);
let response=rejected_request(&request,"Unknown screen").unwrap();
let fields=decode_wire(&response).unwrap();
assert_eq!(message(&fields,1),Some(header.as_slice()));
let result=decode_wire(message(&fields,2).unwrap()).unwrap();
let error=decode_wire(message(&result,1).unwrap()).unwrap();
assert_eq!(number(&error,1),Some(u64::MAX));
assert_eq!(message(&error,2),Some(b"Unknown screen".as_slice()));
assert!(rejected_request(b"invalid","failure").is_none());
}
}
+10
View File
@@ -6,6 +6,16 @@ pub enum DesktopBackend { X11, Wayland, Portal, Kms }
/// port mapping stay available (servers without a monitor or logged-in session).
pub fn headless() -> bool { std::env::var("UU_DESKTOP_BACKEND").is_ok_and(|v| v == "none") }
/// A Wayland compositor socket exists for this user or the environment says so, even when this
/// process (e.g. a systemd unit with only DISPLAY set) would select X11.
pub fn wayland_session_running() -> bool {
std::env::var("XDG_SESSION_TYPE").is_ok_and(|v| v == "wayland")
|| std::env::var("WAYLAND_DISPLAY").is_ok_and(|v| !v.is_empty())
|| std::env::var_os("XDG_RUNTIME_DIR").and_then(|dir| std::fs::read_dir(dir).ok())
.is_some_and(|entries| entries.flatten().any(|e| e.file_name().to_str()
.is_some_and(|n| n.starts_with("wayland-") && !n.ends_with(".lock"))))
}
pub fn detect() -> Result<DesktopBackend, String> {
let backend=select(std::env::var("UU_DESKTOP_BACKEND").ok().as_deref(),
std::env::var("XDG_SESSION_TYPE").ok().as_deref(),
+16 -10
View File
@@ -4,10 +4,11 @@
mod native {
use std::{ffi::c_void, ptr::NonNull};
extern "C" {
crate::engine_ffi! { crate::engine_plugin::Engine::Portal;
fn uu_desktop_power_wake() -> i32;
fn uu_desktop_idle_inhibitor_acquire(error: *mut i32) -> *mut c_void;
fn uu_desktop_idle_inhibitor_release(inhibitor: *mut c_void);
fn uu_desktop_screensaver_inhibitor_acquire(error: *mut i32) -> *mut c_void;
}
pub struct Handle(NonNull<c_void>);
@@ -16,9 +17,9 @@ mod native {
unsafe impl Send for Handle {}
impl Handle {
pub fn acquire() -> Result<Self, String> {
pub fn acquire(gnome: bool) -> Result<Self, String> {
let mut error = 0;
let pointer = unsafe { uu_desktop_idle_inhibitor_acquire(&mut error) };
let pointer = unsafe { if gnome { uu_desktop_idle_inhibitor_acquire(&mut error) } else { uu_desktop_screensaver_inhibitor_acquire(&mut error) } };
NonNull::new(pointer).map(Self).ok_or_else(|| super::error("idle inhibition", error))
}
@@ -50,7 +51,9 @@ pub fn wake() -> Result<(), String> {
}
}
/// Holds a GNOME SessionManager idle-only inhibitor until dropped.
/// Holds an idle-only inhibitor until dropped: GNOME SessionManager on GNOME, the freedesktop
/// ScreenSaver interface on KDE (remote input through the portal does not count as activity
/// there, so the session locked mid-session, #61).
///
/// Acquire and drop perform blocking D-Bus work. Session-bus setup and each method call are
/// bounded to three seconds. Callers on an async runtime should move both operations to a
@@ -62,7 +65,8 @@ pub struct IdleInhibitor {
impl IdleInhibitor {
pub fn acquire() -> Result<Self, String> {
if !gnome_portal_active() {
let kde = portal_desktop_is("kde");
if !gnome_portal_active() && !kde {
return Ok(Self {
#[cfg(all(target_os = "linux", feature = "portal"))]
_handle: None,
@@ -70,7 +74,7 @@ impl IdleInhibitor {
}
#[cfg(all(target_os = "linux", feature = "portal"))]
{
native::Handle::acquire().map(|handle| Self { _handle: Some(handle) })
native::Handle::acquire(!kde).map(|handle| Self { _handle: Some(handle) })
}
#[cfg(not(all(target_os = "linux", feature = "portal")))]
{
@@ -79,10 +83,12 @@ impl IdleInhibitor {
}
}
fn gnome_portal_active() -> bool {
let gnome = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().split(':')
.any(|desktop| desktop.eq_ignore_ascii_case("gnome"));
gnome && crate::desktop_backend::detect().is_ok_and(|backend| backend == crate::desktop_backend::DesktopBackend::Portal)
fn gnome_portal_active() -> bool { portal_desktop_is("gnome") }
fn portal_desktop_is(name: &str) -> bool {
let matches = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().split(':')
.any(|desktop| desktop.eq_ignore_ascii_case(name));
matches && crate::desktop_backend::detect().is_ok_and(|backend| backend == crate::desktop_backend::DesktopBackend::Portal)
}
#[cfg(all(target_os = "linux", feature = "portal"))]
+165
View File
@@ -0,0 +1,165 @@
//! `uuremote-server doctor`: one report with what an issue needs (session, backend, plugins,
//! input permission, encoders, config and service state), safe to paste publicly. It prints only
//! booleans, names and versions: no account ids, tokens, addresses, MACs or file contents, and the
//! home directory is shown as `~`.
fn redact(text: &str) -> String {
let mut out = text.to_owned();
if let Some(home) = std::env::var_os("HOME").and_then(|h| h.into_string().ok()).filter(|h| h.len() > 1) { out = out.replace(&home, "~"); }
if let Ok(user) = std::env::var("USER") { if user.len() > 2 { out = out.replace(&user, "<user>"); } }
out
}
fn env_state(name: &str) -> String {
match std::env::var(name) { Ok(v) if v.is_empty() => "set (empty)".into(), Ok(_) => "set".into(), Err(_) => "unset".into() }
}
fn line(key: &str, value: impl std::fmt::Display) { println!("{key:<22} {}", redact(&value.to_string())); }
fn glibc() -> String {
#[cfg(all(target_os = "linux", target_env = "gnu"))]
{
extern "C" { fn gnu_get_libc_version() -> *const libc::c_char; }
return unsafe { std::ffi::CStr::from_ptr(gnu_get_libc_version()) }.to_string_lossy().into_owned();
}
#[allow(unreachable_code)]
"n/a".into()
}
fn writable(path: &str) -> &'static str {
let Ok(c_path) = std::ffi::CString::new(path) else { return "invalid" };
if !std::path::Path::new(path).exists() { "missing" }
else if unsafe { libc::access(c_path.as_ptr(), libc::W_OK) } == 0 { "writable" } else { "no permission" }
}
async fn command_output(program: &str, args: &[&str]) -> Option<String> {
let output = tokio::time::timeout(std::time::Duration::from_secs(5),
tokio::process::Command::new(program).args(args).kill_on_drop(true).output()).await.ok()?.ok()?;
Some(String::from_utf8_lossy(&output.stdout).trim().to_owned())
}
/// Whether the report must say that this session has no screen to capture: neither DISPLAY nor
/// WAYLAND_DISPLAY is set, and the backend is the X11 one that needs a display to open.
fn missing_display(backend: crate::desktop_backend::DesktopBackend, headless: bool,
display: Option<&std::ffi::OsStr>, wayland: Option<&std::ffi::OsStr>) -> bool {
!headless && backend == crate::desktop_backend::DesktopBackend::X11
&& display.is_none() && wayland.is_none()
}
pub async fn run() -> Result<(), String> {
use crate::desktop_backend as backend;
use crate::engine_plugin::{load, Engine};
// Info logs (e.g. plugin paths under the home directory) would bypass the redaction below.
log::set_max_level(log::LevelFilter::Warn);
println!("uu-remote-linux doctor (safe to paste: no ids, tokens, addresses or file contents)");
line("version", format!("v{} {}", env!("CARGO_PKG_VERSION"), std::env::consts::ARCH));
line("glibc", glibc());
let os = std::fs::read_to_string("/etc/os-release").ok()
.and_then(|t| t.lines().find_map(|l| l.strip_prefix("PRETTY_NAME=").map(|v| v.trim_matches('"').to_owned())));
line("os", os.unwrap_or_else(|| "unknown".into()));
let features: Vec<&str> = [("wayland", cfg!(feature = "wayland")), ("portal", cfg!(feature = "portal")),
("engine-plugins", cfg!(feature = "engine-plugins")), ("inproc-av", cfg!(feature = "inproc-av"))]
.into_iter().filter(|(_, on)| *on).map(|(name, _)| name).collect();
line("build features", if features.is_empty() { "default (X11 only)".to_owned() } else { features.join(", ") });
println!("-- session");
line("XDG_SESSION_TYPE", std::env::var("XDG_SESSION_TYPE").unwrap_or_else(|_| "unset".into()));
line("XDG_CURRENT_DESKTOP", std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_else(|_| "unset".into()));
line("DISPLAY", env_state("DISPLAY"));
line("WAYLAND_DISPLAY", env_state("WAYLAND_DISPLAY"));
line("wayland running", backend::wayland_session_running());
line("UU_DESKTOP_BACKEND", std::env::var("UU_DESKTOP_BACKEND").unwrap_or_else(|_| "auto".into()));
let selected = backend::detect();
line("selected backend", match &selected { Ok(b) if backend::headless() => format!("none (headless, {b:?} unused)"), Ok(b) => format!("{b:?}"), Err(e) => format!("error: {e}") });
if selected.as_ref().is_ok_and(|b| *b == backend::DesktopBackend::X11) && backend::wayland_session_running() && !backend::headless() {
println!(" ! X11 backend inside a Wayland session: the picture will be black");
}
// A session without any display cannot capture a screen; say so instead of naming a backend.
if let Ok(selected) = &selected {
if missing_display(*selected, backend::headless(), std::env::var_os("DISPLAY").as_deref(), std::env::var_os("WAYLAND_DISPLAY").as_deref()) {
println!(" ! DISPLAY and WAYLAND_DISPLAY are unset: the X11 engine will only try :0 and :1; without an X server there, no screen can be captured");
println!(" terminal, file transfer and port mapping still work; UU_DESKTOP_BACKEND=none marks the host as headless");
}
}
if cfg!(feature = "engine-plugins") {
for engine in [Engine::Wayland, Engine::Portal] {
line(engine.file(), match load(engine) { Ok(()) => "loaded".to_owned(), Err(e) => e });
}
}
println!("-- input");
line("/dev/uinput", writable("/dev/uinput"));
line("UU_INPUT_BACKEND", std::env::var("UU_INPUT_BACKEND").unwrap_or_else(|_| "auto".into()));
println!("-- video");
let encoder = crate::video::Encoder::requested();
line("encoder", format!("{encoder:?} (UU_VIDEO_ENCODER={})", std::env::var("UU_VIDEO_ENCODER").unwrap_or_else(|_| "auto".into())));
line("default codec", format!("{:?}", crate::capture_setting::preferred_codec(true, true)));
let mut ffmpeg = crate::video::ffmpeg_command();
ffmpeg.args(["-hide_banner", "-encoders"]).kill_on_drop(true);
match tokio::time::timeout(std::time::Duration::from_secs(5), ffmpeg.output()).await {
Ok(Ok(output)) => {
let text = String::from_utf8_lossy(&output.stdout);
let found: Vec<&str> = ["libx264", "libx265", "h264_nvenc", "hevc_nvenc", "h264_vaapi", "hevc_vaapi"].into_iter()
.filter(|name| text.split_whitespace().any(|word| word == *name)).collect();
line("ffmpeg encoders", if found.is_empty() { "none of libx264/libx265/nvenc/vaapi".to_owned() } else { found.join(", ") });
}
_ => line("ffmpeg encoders", "ffmpeg not runnable (install ffmpeg or set ffmpeg_root)"),
}
let mut version = crate::video::ffmpeg_command();
version.arg("-version").kill_on_drop(true);
if let Ok(Ok(output)) = tokio::time::timeout(std::time::Duration::from_secs(5), version.output()).await {
line("ffmpeg version", String::from_utf8_lossy(&output.stdout).lines().next().unwrap_or("").split_whitespace().nth(2).unwrap_or("unknown"));
}
line("nvidia driver", std::path::Path::new("/proc/driver/nvidia/version").exists());
line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
println!("-- audio");
for tool in ["pactl", "pw-cli"] {
line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into()));
}
println!("-- account and service");
let path = crate::config::path();
line("config", path.display());
match std::fs::metadata(&path) {
Ok(meta) => {
use std::os::unix::fs::PermissionsExt;
line("config mode", format!("{:o}", meta.permissions().mode() & 0o777));
// Presence only: never read values out of the file.
let fields: Option<serde_json::Value> = std::fs::read(&path).ok().and_then(|b| serde_json::from_slice(&b).ok());
let has = |key: &str| fields.as_ref().and_then(|v| v.get(key)).is_some_and(|v| !v.is_null() && v.as_str() != Some(""));
line("signed in", has("token") && has("user_id"));
line("device registered", has("device_id"));
}
Err(_) => line("config mode", "missing (run `uuremote-server login`)"),
}
line("service", command_output("systemctl", &["--user", "is-active", "uuremote-native.service"]).await.unwrap_or_else(|| "systemctl unavailable".into()));
let running = command_output("pgrep", &["-c", "-x", "uuremote-server"]).await.filter(|n| !n.is_empty()).unwrap_or_else(|| "unknown".into());
line("uuremote-server procs", format!("{running} (including this one; more than 2 means duplicates)"));
Ok(())
}
#[cfg(test)]
mod tests {
#[test]
fn redaction_hides_home_and_user() {
let home = std::env::var("HOME").unwrap_or_default();
if home.len() > 1 { assert_eq!(super::redact(&format!("{home}/.config/x")), "~/.config/x"); }
assert_eq!(super::env_state("UU_DOCTOR_TEST_SURELY_UNSET"), "unset");
}
#[test]
fn a_session_without_any_display_is_reported() {
use crate::desktop_backend::DesktopBackend;
let display = std::ffi::OsStr::new(":0");
let wayland = std::ffi::OsStr::new("wayland-1");
// No DISPLAY and no WAYLAND_DISPLAY: nothing can be captured.
assert!(super::missing_display(DesktopBackend::X11, false, None, None));
// One of them present: the backend has a screen to open.
assert!(!super::missing_display(DesktopBackend::X11, false, Some(display), None));
assert!(!super::missing_display(DesktopBackend::X11, false, None, Some(wayland)));
// Another backend, or a headless host: not this warning.
assert!(!super::missing_display(DesktopBackend::Wayland, false, None, None));
assert!(!super::missing_display(DesktopBackend::X11, true, None, None));
}
}
+121
View File
@@ -0,0 +1,121 @@
//! Optional desktop engines loaded at runtime (`--features engine-plugins`).
//!
//! The Wayland (wlroots) and GNOME/KDE portal engines link libwayland/libxkbcommon and
//! GIO/PipeWire/libei. Linking them into `uuremote-server` would stop it from starting on X11 hosts
//! without those libraries, and libei is missing on older distributions. With engine-plugins they
//! are built as `libuu-wayland.so` / `libuu-portal.so`, shipped next to the binary, and opened with
//! dlopen only when the session needs them, so one release package serves every backend.
//! Without the feature the engines are linked statically as before and nothing here is used.
#![cfg_attr(not(feature = "engine-plugins"), allow(dead_code))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Engine { Wayland, Portal }
impl Engine {
pub fn file(self) -> &'static str { match self { Self::Wayland => "libuu-wayland.so", Self::Portal => "libuu-portal.so" } }
fn index(self) -> usize { self as usize }
}
/// Directories searched for engine libraries, in order.
fn search_dirs() -> Vec<std::path::PathBuf> {
let mut dirs = Vec::new();
if let Some(dir) = std::env::var_os("UU_ENGINE_DIR").filter(|d| !d.is_empty()) { dirs.push(dir.into()); }
if let Some(exe_dir) = std::env::current_exe().ok().and_then(|exe| exe.parent().map(|d| d.to_path_buf())) {
dirs.push(exe_dir.join("../lib/uu-remote-linux"));
dirs.push(exe_dir.clone());
}
if let Some(home) = std::env::var_os("HOME") { dirs.push(std::path::Path::new(&home).join(".local/lib/uu-remote-linux")); }
dirs.extend(["/usr/local/lib/uu-remote-linux", "/usr/lib/uu-remote-linux"].map(std::path::PathBuf::from));
dirs
}
#[cfg(all(target_os = "linux", feature = "engine-plugins"))]
mod native {
use super::Engine;
use std::sync::OnceLock;
static HANDLES: [OnceLock<Result<usize, String>>; 2] = [OnceLock::new(), OnceLock::new()];
fn dlerror() -> String {
let message = unsafe { libc::dlerror() };
if message.is_null() { return "unknown dlopen error".into(); }
unsafe { std::ffi::CStr::from_ptr(message) }.to_string_lossy().into_owned()
}
fn open(engine: Engine) -> Result<usize, String> {
for dir in super::search_dirs() {
let path = dir.join(engine.file());
if !path.is_file() { continue; }
use std::os::unix::ffi::OsStrExt;
let Ok(c_path) = std::ffi::CString::new(path.as_os_str().as_bytes()) else { continue };
let handle = unsafe { libc::dlopen(c_path.as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL) };
if handle.is_null() {
// Usually a missing system library (e.g. libei.so.1) or a too old glibc.
return Err(format!("{} could not be loaded: {}", path.display(), dlerror()));
}
log::info!("Desktop engine loaded: {}", path.display());
return Ok(handle as usize);
}
Err(format!("{} not found (looked next to uuremote-server, in ../lib/uu-remote-linux, ~/.local/lib/uu-remote-linux, /usr/lib/uu-remote-linux; UU_ENGINE_DIR overrides)", engine.file()))
}
pub fn load(engine: Engine) -> Result<(), String> {
HANDLES[engine.index()].get_or_init(|| open(engine)).as_ref().map(|_| ()).map_err(Clone::clone)
}
/// Address of `name` (NUL-terminated) in the engine, or 0 when the engine or symbol is missing.
pub fn symbol(engine: Engine, name: &'static str) -> usize {
let Ok(handle) = HANDLES[engine.index()].get_or_init(|| open(engine)) else { return 0 };
let address = unsafe { libc::dlsym(*handle as *mut libc::c_void, name.as_ptr().cast()) };
if address.is_null() { log::warn!("Desktop engine {} lacks {}", engine.file(), name.trim_end_matches('\0')); }
address as usize
}
}
/// Loads `engine`, or explains why it is unavailable. Always Ok when the engines are linked in.
pub fn load(engine: Engine) -> Result<(), String> {
#[cfg(all(target_os = "linux", feature = "engine-plugins"))]
{ native::load(engine) }
#[cfg(not(all(target_os = "linux", feature = "engine-plugins")))]
{ let _ = engine; Ok(()) }
}
#[cfg(all(target_os = "linux", feature = "engine-plugins"))]
pub use native::symbol;
/// Value returned by an engine call whose library could not be loaded (callers check `load` first).
pub trait Missing { fn missing() -> Self; }
impl Missing for () { fn missing() -> Self {} }
impl Missing for i32 { fn missing() -> Self { -1 } }
impl<T> Missing for *mut T { fn missing() -> Self { std::ptr::null_mut() } }
/// Declares engine C functions: an `extern "C"` block when linked statically, or dlsym-resolved
/// wrappers with the same names and signatures with `engine-plugins`.
#[macro_export]
macro_rules! engine_ffi {
($engine:expr; $(fn $name:ident($($arg:ident: $ty:ty),* $(,)?) $(-> $ret:ty)?;)*) => {
#[cfg(not(feature = "engine-plugins"))]
extern "C" { $(fn $name($($arg: $ty),*) $(-> $ret)?;)* }
$(
#[cfg(feature = "engine-plugins")]
unsafe fn $name($($arg: $ty),*) $(-> $ret)? {
static ADDRESS: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
let address = *ADDRESS.get_or_init(|| $crate::engine_plugin::symbol($engine, concat!(stringify!($name), "\0")));
if address == 0 { return $crate::engine_plugin::Missing::missing(); }
let function: unsafe extern "C" fn($($ty),*) $(-> $ret)? = unsafe { std::mem::transmute(address) };
unsafe { function($($arg),*) }
}
)*
};
}
#[cfg(test)]
mod tests {
#[test]
fn search_prefers_override_then_package_layout() {
let dirs = super::search_dirs();
let exe_dir = std::env::current_exe().unwrap().parent().unwrap().to_path_buf();
assert!(dirs.iter().position(|d| *d == exe_dir.join("../lib/uu-remote-linux")) < dirs.iter().position(|d| *d == exe_dir));
assert_eq!(dirs.last().unwrap(), std::path::Path::new("/usr/lib/uu-remote-linux"));
}
}
+14 -3
View File
@@ -77,8 +77,8 @@ pub struct Screen<'a> {
}
impl Screen<'_> {
fn encode(&self) -> Result<Vec<u8>, String> {
if self.id < 0 || self.fps <= 0 || self.video_track_index < 0 {
return Err("Screen id/track must be nonnegative and fps positive".into());
if self.id < 0 || self.fps <= 0 || self.video_track_index < -1 {
return Err("Screen id must be nonnegative, track >= -1 and fps positive".into());
}
if !self.dpr.is_finite() || self.dpr <= 0.0 {
return Err("Screen dpr must be positive and finite".into());
@@ -118,7 +118,7 @@ pub fn encode_screen_sources(seq: u64, timestamp: u64, screens: &[Screen<'_>], c
let mut tracks = std::collections::HashSet::new();
let mut payload = Vec::new();
for screen in screens {
if !ids.insert(screen.id) || !tracks.insert(screen.video_track_index) {
if !ids.insert(screen.id) || (screen.video_track_index >= 0 && !tracks.insert(screen.video_track_index)) {
return Err("Screen ids and video track indices must be unique".into());
}
bytes(1, &screen.encode()?, &mut payload);
@@ -295,3 +295,14 @@ mod tests {
assert!(encode_capture_change(1, 2, 4, 1, "").is_err());
}
}
#[cfg(test)]
mod inactive_track_tests {
use super::*;
#[test]
fn multiple_inactive_screens_share_minus_one_but_active_track_is_unique() {
let screen=|id,track| Screen {id,fps:60,resolution:WinRect {left:0,top:0,width:1920,height:1080,pixel_width:1920,pixel_height:1080},primary:id==0,dpr:1.0,display_name:"test",video_track_index:track,screen_type:0,builtin_screen_type:0,scaled:&[],current:None};
assert!(encode_screen_sources(1,2,&[screen(0,0),screen(1,-1),screen(2,-1)],0).is_ok());
assert!(encode_screen_sources(1,2,&[screen(0,0),screen(1,0)],0).is_err());
}
}
+9 -3
View File
@@ -101,7 +101,9 @@ fn drain(encoder: &mut encoder::Video, packet: &mut Packet, units: &mpsc::Sender
/// Opens the selected video encoder for `config`. Returns the encoder, its input pixel format and output size.
fn open_encoder(config: &Config) -> Result<(encoder::Video, Pixel, u32, u32), String> {
// H.264/HEVC 4:2:0 and NVENC need even dimensions; an odd native capture is padded (see run_damage).
let (width, height) = config.output.unwrap_or(config.input);
let (width, height) = (width + width % 2, height + height % 2);
let codec = encoder::find_by_name(config.encoder.name_for(config.codec))
.ok_or_else(|| format!("{} is not available in this FFmpeg build", config.encoder.name_for(config.codec)))?;
// Allocate for this codec so FFmpeg fills its defaults; libx264 rejects a context allocated without one.
@@ -278,7 +280,11 @@ pub fn run(config: Config, units: mpsc::Sender<EncodedUnit>, stop: Arc<AtomicBoo
fn run_damage(config: Config, mut capture: DamageCapture, units: mpsc::Sender<EncodedUnit>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>) -> Result<(), String> {
let (mut encoder, pixel, width, height) = open_encoder(&config)?;
let (cap_width, cap_height) = capture.size();
let mut captured = frame::Video::new(Pixel::BGRZ, cap_width, cap_height);
// Native size uses the even encoder size. The extra row/column is never overwritten, so it stays black.
let native = config.output.is_none();
let (frame_width, frame_height) = if native { (width, height) } else { (cap_width, cap_height) };
let mut captured = frame::Video::new(Pixel::BGRZ, frame_width, frame_height);
if native { captured.data_mut(0).fill(0); }
let mut converted = frame::Video::empty();
let mut scaler = None;
let mut packet = Packet::empty();
@@ -324,11 +330,11 @@ fn run_damage(config: Config, mut capture: DamageCapture, units: mpsc::Sender<En
let slot = slot.max(last_slot + 1);
last_slot = slot;
let frame = if pixel == Pixel::BGRZ && width == cap_width && height == cap_height {
let frame = if pixel == Pixel::BGRZ && width == captured.width() && height == captured.height() {
&mut captured
} else {
if scaler.is_none() {
scaler = Some(scaling::Context::get(Pixel::BGRZ, cap_width, cap_height, pixel, width, height, scaling::Flags::BILINEAR).map_err(text)?);
scaler = Some(scaling::Context::get(Pixel::BGRZ, captured.width(), captured.height(), pixel, width, height, scaling::Flags::BILINEAR).map_err(text)?);
}
if dirty {
if let Some(context) = scaler.as_mut() { context.run(&captured, &mut converted).map_err(text)?; }
+58
View File
@@ -325,6 +325,12 @@ impl InputInjector {
}
}
fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 {
// uinput ABS axes span the compositor's whole desktop. A captured output
// uses its own pixel space; bind absolute motion to that Wayland output,
// including when uinput remains in use for keyboard/buttons/relative input.
if !relative && self.backend==crate::desktop_backend::DesktopBackend::Wayland {
return crate::wayland::move_pointer(x,y,false);
}
if let Some(uinput)=&self.uinput {
if relative { return Self::uinput_result(uinput.move_relative(x,y)); }
let (w,h)=*self.screen.lock().unwrap();
@@ -639,3 +645,55 @@ mod lifecycle_tests {
session.with_input(||panic!("late event after disconnect"));
}
}
#[cfg(all(test,target_os="linux",feature="wayland"))]
mod output_pointer_tests {
use super::*;
#[test]
#[ignore="requires unlocked Hyprland, UU_WAYLAND_MULTISCREEN=1 and accessible uinput; moves pointer only"]
fn absolute_pointer_stays_on_capture_output_with_uinput_enabled() {
fn cursor()->serde_json::Value {
let output=std::process::Command::new("hyprctl").args(["cursorpos","-j"]).output().unwrap();
assert!(output.status.success());serde_json::from_slice(&output.stdout).unwrap()
}
struct Restore(serde_json::Value);
impl Drop for Restore {
fn drop(&mut self) {
let _=std::process::Command::new("hyprctl").args(["dispatch","movecursor",&self.0["x"].to_string(),&self.0["y"].to_string()]).output();
}
}
let _restore=Restore(cursor());
crate::wayland::init().unwrap();
let input=InputInjector::new();
assert!(input.uinput.is_some(),"test must exercise the uinput/native hybrid path");
// libinput discovers the newly created virtual devices asynchronously.
std::thread::sleep(std::time::Duration::from_secs(1));
let output=std::process::Command::new("hyprctl").args(["monitors","-j"]).output().unwrap();
let monitors:Vec<serde_json::Value>=serde_json::from_slice(&output.stdout).unwrap();
let outputs=crate::wayland::outputs();assert!(outputs.len()>=2,"needs at least two outputs");
for (id,output) in outputs.iter().enumerate().chain(outputs.iter().enumerate().rev()) {
crate::wayland::select(id).unwrap();
let monitor=monitors.iter().find(|m|m["name"].as_str()==Some(output.name.as_str())).unwrap();
let scale=monitor["scale"].as_f64().unwrap();
for (x,y) in [(0.1,0.1),(0.5,0.5),(0.9,0.9),(0.1,0.9),(0.9,0.1)] {
let size=(output.width,output.height);
let pixels=crate::input_mapping::normalized_pointer(x,y,size.0,size.1).unwrap();
assert_eq!(input.backend,crate::desktop_backend::DesktopBackend::Wayland);
input.mouse_absolute_normalized(x,y,size);input.flush_pointer();
let expected=(monitor["x"].as_f64().unwrap()+f64::from(pixels.0)/scale,
monitor["y"].as_f64().unwrap()+f64::from(pixels.1)/scale);
// Motion is asynchronous; observe its first arrival instead of a
// later position potentially changed by another input device.
let deadline=std::time::Instant::now()+std::time::Duration::from_millis(250);
loop {
let actual=cursor();
let matched=(actual["x"].as_f64().unwrap()-expected.0).abs()<=2.0
&& (actual["y"].as_f64().unwrap()-expected.1).abs()<=2.0;
if matched {break;}
assert!(std::time::Instant::now()<deadline,"pointer offset: output={} normalized=({},{}) actual={} expected={:?}",output.name,x,y,actual,expected);
std::thread::sleep(std::time::Duration::from_millis(5));
}
}
}
}
}
+65 -33
View File
@@ -268,13 +268,22 @@ pub async fn prepare_device() -> Result<(Value, Credentials), String> {
pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
let (mut cfg, creds) = prepare_device().await?;
let client = UUAuthClient::new(creds.clone());
// Mirrors the official Mac client (LoginViewController / LoginManager, UURemote 4.42): gen/login has
// no body; the status long poll sends gen's `status_query_ticket` under `token` with the last
// status, re-asks as soon as an answer arrives (60 s request timeout), regenerates on status 3
// at once and on status 0 after 0.35 s, logs in on 4, and on any error (e.g. HTTP 400 code 1190)
// stops until the user asks for a new QR. Sending gen's older `token` field made the cloud reject
// every QR within seconds (#68).
let timeout = Duration::from_secs(60);
loop {
let (status, resp) = client.post_json("/api/v1/qrcode/gen/login", &json!({})).await?;
let d = data("qrcode gen", status, &resp)?;
let (status, resp) = client.post_with_timeout("/api/v1/qrcode/gen/login", None, timeout).await?;
let d = match data("qrcode gen", status, &resp) {
Ok(d) => d.clone(),
Err(e) => { println!("QR code could not be loaded ({e})"); wait_for_refresh(ui, "二维码加载失败").await; continue; }
};
let url = d.get("qrcode_jump_url").and_then(|v| v.as_str()).ok_or("qrcode gen returned no qrcode_jump_url")?.to_string();
let ticket = d.get("token").or_else(|| d.get("status_query_ticket")).and_then(|v| v.as_str())
.ok_or("qrcode gen returned no token")?.to_string();
let ticket = qr_ticket(&d).ok_or("qrcode gen returned no status ticket")?.to_string();
ui.offer_refresh(false);
if ui.shown() {
let modules = qrcode::QrCode::new(url.as_bytes()).map_err(|e| e.to_string())?.width() + 2;
let (rgba, edge) = qr_rgba(&url, (224 / modules).max(2), 1)?;
@@ -289,40 +298,31 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
file.write_all(&crate::cursor::encode_png(edge as u32,edge as u32,&rgba)).map_err(|e|e.to_string())?;
}
if !ui.quiet() { println!("\nScan with the UU Remote mobile app (网易UU远程 App 扫码登录):\n{}", render_qr(&url)?); }
// Status is a long poll: send the state already shown (server enum 1..4; observed:
// 1 waiting, 2 scanned, 4 after the phone confirmed); the server answers when it changes.
let mut login_status = 1i64;
let mut expired = false;
for _ in 0..150 {
let failure = loop {
let query = json!({"token": ticket, "qrcode_jump_url": url, "login_status": login_status});
let (status, resp) = match client.post_json("/api/v1/qrcode/login/status", &query).await {
let (status, resp) = match client.post_with_timeout("/api/v1/qrcode/login/status", Some(&query), timeout).await {
Ok(r) => r,
Err(_) => continue, // long-poll timeout: ask again
Err(_) => break "网络超时,二维码已停止刷新",
};
// Code 1190 (HTTP 400, "二维码已失效"): the QR expired; generate a new one.
if resp.get("code").and_then(|c| c.as_i64()) == Some(QR_EXPIRED) {
ui.status("二维码已过期,正在刷新…", Tone::Info);
expired = true; break;
}
let st = data("qrcode status", status, &resp)?.get("status").and_then(|v| v.as_i64()).unwrap_or(login_status);
if st == login_status { continue; }
login_status = st;
let code = resp.get("code").and_then(|c| c.as_i64());
if code == Some(QR_EXPIRED) { break "二维码已失效"; }
let Ok(d) = data("qrcode status", status, &resp) else { break "二维码状态查询失败"; };
let st = d.get("status").and_then(|v| v.as_i64()).unwrap_or(login_status);
match st {
2 => {
1 => {}
2 => if login_status != 2 {
println!("已扫码,请在手机上确认 (scanned, confirm on the phone)");
ui.status("已扫码,请在手机上确认登录", Tone::Ok);
}
3 | 4 => {
// A final state: confirmed logs in; cancelled/expired is refused and a new QR follows.
},
3 => { println!("QR code expired; generating a new one"); break ""; }
0 => { tokio::time::sleep(Duration::from_millis(350)).await; break ""; }
4 => {
let body = json!({"token": ticket, "qrcode_jump_url": url});
let (status, resp) = client.post_json("/api/v1/login/by_qrcode", &body).await?;
let (status, resp) = client.post_with_timeout("/api/v1/login/by_qrcode", Some(&body), timeout).await?;
let d = match data("qrcode login", status, &resp) {
Ok(d) => d,
Err(e) => {
println!("QR status {st}: login not granted ({e})");
ui.status("手机端未确认登录,正在刷新二维码…", Tone::Error);
expired = true; break;
}
Err(e) => { println!("QR login not granted ({e})"); break "登录失败"; }
};
let token = d.get("token").and_then(|v| v.as_str()).ok_or("login returned no token")?;
let user = d.get("user_id").and_then(|v| v.as_str()).ok_or("login returned no user_id")?;
@@ -339,17 +339,49 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
println!("Logged in as {} ({}); saved to {}", nickname, user, path.display());
return Ok(if nickname.is_empty() { user.to_string() } else { nickname.to_string() });
}
_ => { println!("QR status: {st}"); ui.status("二维码已失效,正在刷新…", Tone::Error); expired = true; break; }
other => { println!("QR status: {other}"); break "二维码已失效"; }
}
}
println!("{}", if expired { "QR code expired; generating a new one" } else { "QR code timed out; generating a new one" });
tokio::time::sleep(Duration::from_secs(1)).await; // never spin if the server keeps refusing
login_status = st;
};
if !failure.is_empty() { wait_for_refresh(ui, failure).await; }
}
}
/// gen/login's status ticket: `status_query_ticket` (current cloud and official clients), else the
/// older `token` field for servers that do not send it.
fn qr_ticket(gen: &Value) -> Option<&str> {
gen.get("status_query_ticket").or_else(|| gen.get("token")).and_then(|v| v.as_str()).filter(|t| !t.is_empty())
}
/// Stop like the official client and wait for the user: the 刷新二维码 button, Enter in a terminal,
/// or (no window and no terminal, e.g. a service) one minute.
async fn wait_for_refresh(ui: &LoginUi, reason: &str) {
use std::io::IsTerminal;
ui.status(&format!("{reason},请点击「刷新二维码」"), Tone::Error);
ui.offer_refresh(true);
let terminal = !ui.quiet() && std::io::stdin().is_terminal();
if terminal { println!("{reason}. Press Enter to show a new QR code (按回车刷新二维码)"); }
else { println!("{reason}; waiting for 刷新二维码{}", if ui.shown() { "" } else { " (a new QR code follows in 60 s)" }); }
let mut line = terminal.then(|| tokio::task::spawn_blocking(|| { let mut s = String::new(); let _ = std::io::stdin().read_line(&mut s); }));
let started = std::time::Instant::now();
loop {
if ui.take_refresh() || (ui.shown() && ui.closed()) { break; }
if let Some(handle) = line.as_mut() { if handle.is_finished() { break; } }
if !ui.shown() && !terminal && started.elapsed() >= Duration::from_secs(60) { break; }
tokio::time::sleep(Duration::from_millis(200)).await;
}
ui.offer_refresh(false);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn status_ticket_prefers_status_query_ticket() {
assert_eq!(qr_ticket(&json!({"token": "old", "status_query_ticket": "new"})), Some("new"));
assert_eq!(qr_ticket(&json!({"token": "old"})), Some("old"));
assert_eq!(qr_ticket(&json!({"status_query_ticket": ""})), None);
}
#[tokio::test]
async fn service_waits_until_a_new_token_is_saved() {
let dir = std::env::temp_dir().join(format!("uu-login-wait-{}", std::process::id()));
+15
View File
@@ -10,6 +10,8 @@ extern "C" {
fn uu_login_ui_set_done(text: *const libc::c_char);
fn uu_login_ui_closed() -> libc::c_int;
fn uu_login_ui_close();
fn uu_login_ui_offer_refresh(visible: libc::c_int);
fn uu_login_ui_take_refresh() -> libc::c_int;
}
#[derive(Clone, Copy)]
@@ -56,6 +58,19 @@ impl LoginUi {
}
#[allow(unused_variables)]
/// Show or hide the 刷新二维码 button (a failed QR waits for the user, like the official client).
pub fn offer_refresh(&self, visible: bool) {
#[cfg(uu_gtk)]
if self.shown { unsafe { uu_login_ui_offer_refresh(libc::c_int::from(visible)) } }
#[cfg(not(uu_gtk))]
let _ = visible;
}
/// The user clicked 刷新二维码 since the last call.
pub fn take_refresh(&self) -> bool {
#[cfg(uu_gtk)]
if self.shown { return unsafe { uu_login_ui_take_refresh() } != 0; }
false
}
pub fn status(&self, text: &str, tone: Tone) {
#[cfg(uu_gtk)]
if self.shown { let t = cstr(text); unsafe { uu_login_ui_set_status(t.as_ptr(), tone as libc::c_int) } }
+68 -4
View File
@@ -1,6 +1,9 @@
//! UU Remote Pure Native Linux Server (Rust Edition)
//! Zero-Wine, Zero-Python, Single-Binary, 5 Native Tools Integrated
mod engine_plugin;
mod doctor;
mod wol;
mod desktop_backend;
mod desktop_session;
mod desktop_power;
@@ -140,6 +143,35 @@ fn write_host_pid() {
let _ = write!(f, "{}", std::process::id());
}
}
/// Why `unit` is not (going to be) running, from `systemctl --user show`; None while it is active or starting.
fn unit_not_running(unit: &str, settled: bool) -> Option<String> {
let output = std::process::Command::new("systemctl").args(["--user", "show", unit, "-p", "ActiveState,SubState,ConditionResult"]).output().ok()?;
let text = String::from_utf8_lossy(&output.stdout);
let value = |key: &str| text.lines().find_map(|l| l.strip_prefix(key).and_then(|v| v.strip_prefix('='))).unwrap_or("").to_owned();
unit_state_problem(unit, &value("ActiveState"), &value("SubState"), &value("ConditionResult"), settled)
}
fn unit_state_problem(unit: &str, active: &str, sub: &str, condition: &str, settled: bool) -> Option<String> {
let hint = format!("see `systemctl --user status {unit}` and `journalctl --user -u {unit}`");
if condition == "no" { return Some(format!("{unit} was skipped: a Condition in the unit is not met (e.g. ConditionEnvironment outside the graphical session); {hint}")); }
if active == "failed" { return Some(format!("{unit} failed to start; {hint}")); }
if sub == "auto-restart" { return Some(format!("{unit} keeps exiting and being restarted; {hint}")); }
if settled && active == "inactive" { return Some(format!("{unit} is not running; {hint}")); }
None
}
#[cfg(test)]
mod show_unit_tests {
#[test]
fn skipped_crashing_and_failed_units_are_reported() {
let p = |a, s, c, settled| super::unit_state_problem("u.service", a, s, c, settled);
assert!(p("inactive", "dead", "no", false).unwrap().contains("skipped"));
assert!(p("activating", "auto-restart", "yes", false).unwrap().contains("restarted"));
assert!(p("failed", "failed", "yes", false).unwrap().contains("failed"));
assert!(p("inactive", "dead", "yes", false).is_none());
assert!(p("inactive", "dead", "yes", true).unwrap().contains("not running"));
assert!(p("active", "running", "yes", true).is_none());
assert!(p("activating", "start", "yes", true).is_none());
}
}
/// `uuremote-server show` (desktop launcher): open the running host's window, or start the host in the
/// foreground with its window when none runs (e.g. no systemd unit installed yet).
fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
@@ -159,7 +191,10 @@ fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null()).status().is_ok_and(|s| s.success());
if installed && std::process::Command::new("systemctl").args(["--user", "start", &unit]).status().is_ok_and(|s| s.success()) {
let before = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok();
for _ in 0..60 {
for attempt in 0..60 {
// `systemctl start` also returns 0 when the unit is skipped by a Condition or keeps
// crashing under Restart=; report that instead of waiting 30 s for a pid (#62).
if let Some(reason) = unit_not_running(&unit, attempt >= 2) { return Err(reason.into()); }
std::thread::sleep(std::time::Duration::from_millis(500));
let fresh = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok().is_some_and(|t| Some(t) != before);
let pid = std::fs::read_to_string(host_pid_path()).ok().and_then(|s| s.trim().parse::<i32>().ok());
@@ -168,7 +203,7 @@ fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
if unsafe { libc::kill(pid, libc::SIGUSR1) } == 0 { return Ok(()); }
}
}
return Err("the UU remote host service started but did not open its window".into());
return Err(format!("{unit} is running but did not open its window within 30 s; check `journalctl --user -u {unit}`").into());
}
use std::os::unix::process::CommandExt;
Err(Box::new(std::process::Command::new("/proc/self/exe").env("UU_SHOW_WINDOW", "1").exec()))
@@ -190,7 +225,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
.filter_module("uuremote_server", log::LevelFilter::Info).init();
} else { env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init(); }
// An unknown argument must never fall through to starting a second full host server.
const SUBCOMMANDS: [&str; 14] = ["show", "assist", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
const SUBCOMMANDS: [&str; 15] = ["doctor", "show", "assist", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
"wayland-input-probe", "wayland-text-probe", "clipboard-acceptance", "portal-acceptance"];
if let Some(arg) = std::env::args().nth(1).filter(|a| !SUBCOMMANDS.contains(&a.as_str())) {
let usage = format!("usage: uuremote-server [{}]\n (no argument: run the host)", SUBCOMMANDS.join(" | "));
@@ -356,6 +391,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if std::env::args().nth(1).as_deref() == Some("wayland-text-probe") {
return wayland::text_probe().map_err(|e|e.into());
}
if std::env::args().nth(1).as_deref() == Some("doctor") {
return doctor::run().await.map_err(|e| e.into());
}
if std::env::args().nth(1).as_deref() == Some("wayland-capture") {
return wayland::capture_stdout().map_err(|e| e.into());
}
@@ -409,10 +447,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let _audio_cleanup=virtual_audio::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
if !desktop_backend::headless() && desktop_backend::detect()? == desktop_backend::DesktopBackend::X11 && desktop_backend::wayland_session_running() {
// X11 capture inside a Wayland session reads XWayland's root window: all black, no error (#61).
log::warn!("A Wayland session is running but the X11 backend is selected: the picture will be black. Run inside the Wayland session (WAYLAND_DISPLAY set, UU_DESKTOP_BACKEND=auto) or log in to the Xorg session");
}
let capture = Arc::new((if desktop_backend::headless() {
Err("headless mode (UU_DESKTOP_BACKEND=none)".to_owned())
} else if desktop_backend::detect()?==desktop_backend::DesktopBackend::Portal {
Err("Portal capture waits for a desktop CONTROL connection".to_owned())
Err(if !cfg!(feature = "portal") { portal::NOT_BUILT.to_owned() }
else if let Err(reason) = engine_plugin::load(engine_plugin::Engine::Portal) { format!("GNOME/KDE Wayland (portal) engine unavailable: {reason}") }
else { "Portal capture waits for a desktop CONTROL connection".to_owned() })
} else { ScreenCapture::new() }).unwrap_or_else(|error| {
log::warn!("Desktop unavailable; terminal and file tools remain available: {error}");
ScreenCapture::unavailable(error)
@@ -638,6 +682,11 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
}
SignalingEvent::Connected => {
log::info!("Signaling handshake established.");
static WOL_REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
if wol::enabled() && assist.as_ref().is_none_or(|s| s.is_account()) && !WOL_REPORTED.swap(true, std::sync::atomic::Ordering::AcqRel) {
let client = auth.clone();
tokio::spawn(async move { wol::report(&client).await; });
}
}
SignalingEvent::RoomInfoAck(_) => { log::info!("RoomInfo acknowledged by NetEase server"); }
SignalingEvent::DeviceInfoChanged(val) => {
@@ -647,6 +696,21 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
log::debug!("Assist bmsg_push shape: type={:?} keys={:?} data_keys={:?}",
val.get("type").and_then(serde_json::Value::as_str), keys(Some(&val)), keys(val.get("data")));
}
if val.get("type").and_then(serde_json::Value::as_str) == Some("wake_on_lan") {
// Key names only: the target carries a MAC and LAN address.
let data = val.get("data").unwrap_or(&val);
log::info!("wake_on_lan push received: keys={:?} target_keys={:?} helper_enabled={}",
data.as_object().map(|o| o.keys().cloned().collect::<Vec<_>>()).unwrap_or_default(),
data.get("target_device").and_then(|t| t.as_object()).map(|o| o.keys().cloned().collect::<Vec<_>>()).unwrap_or_default(),
wol::enabled());
if wol::enabled() {
match wol::handle_push(data) {
Ok(sent) => log::info!("WOL helper: magic packet sent ({sent} datagrams)"),
Err(error) => log::warn!("WOL helper: {error}"),
}
}
continue;
}
if val.get("type").and_then(serde_json::Value::as_str) == Some("get_control_mode") {
if let Some(s) = assist.as_mut() {
match s.control_mode(val.get("data").unwrap_or(&serde_json::Value::Null)).await {
+20 -9
View File
@@ -22,7 +22,7 @@ mod permissions;
#[cfg(all(target_os = "linux", feature = "portal"))]
mod native {
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}};
extern "C" {
crate::engine_ffi! { crate::engine_plugin::Engine::Portal;
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
@@ -116,6 +116,8 @@ mod native {
if cancelled.is_some_and(|value| value.load(std::sync::atomic::Ordering::Acquire)) {
return Err(super::PortalError { code: 13 });
}
// engine-plugins: libuu-portal.so (or one of its libraries) may be missing on this host.
crate::engine_plugin::load(crate::engine_plugin::Engine::Portal).map_err(|_| super::PortalError { code: 15 })?;
let (mut error, mut width, mut height) = (0, 0, 0);
let directory = super::permissions::directory();
let key = super::permissions::desktop_key();
@@ -584,12 +586,20 @@ fn error(code: i32) -> String {
8 => "unsupported frame format or size", 9 => "session closed or stream lost",
10 => "frame unavailable", 11 => "invalid input or frame buffer",
13 => "operation cancelled", 14 => "dimensions changed; reconnect required",
15 => return match crate::engine_plugin::load(crate::engine_plugin::Engine::Portal) {
Err(reason) if cfg!(feature = "portal") => format!("GNOME/KDE Wayland (portal) engine unavailable: {reason}"),
_ => NOT_BUILT.into(),
},
_ => "operation failed",
};
format!("Portal {reason} (code {code})")
}
fn check(code: i32) -> Result<(), String> { if code == 0 { Ok(()) } else { Err(error(code)) } }
/// GNOME/KDE Wayland selected the portal backend, but this binary was built without it (the release
/// package is X11 only): say how to get a picture instead of an opaque "portal unavailable".
pub const NOT_BUILT: &str = "this build has no GNOME/KDE Wayland (portal) support: choose the Xorg session \
(\"GNOME on Xorg\" / \"Plasma (X11)\") at the login screen, or build with --features wayland,portal";
#[cfg(all(target_os = "linux", feature = "portal"))]
pub use native::Session as PortalSession;
#[cfg(not(all(target_os = "linux", feature = "portal")))]
@@ -598,24 +608,24 @@ pub struct PortalSession { pub width: u32, pub height: u32 }
impl PortalSession {
pub fn clipboard_supported(&self) -> bool { false }
pub fn clipboard_ready(&self) -> bool { false }
pub fn clipboard_set(&self, _: &str) -> Result<(), String> { Err(error(2)) }
pub fn clipboard_set(&self, _: &str) -> Result<(), String> { Err(error(15)) }
pub fn clipboard_poll(&self) -> Option<String> { None }
pub fn is_alive(&self) -> bool { false }
pub fn open() -> Result<Self, String> { Err("Portal backend requires Linux and --features portal".into()) }
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, PortalError> {
if cancelled.load(std::sync::atomic::Ordering::Acquire) { Err(PortalError { code: 13 }) }
else { Err(PortalError { code: 2 }) }
else { Err(PortalError { code: 15 }) }
}
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, PortalError> {
if cancelled.load(std::sync::atomic::Ordering::Acquire) { Err(PortalError { code: 13 }) }
else { Err(PortalError { code: 2 }) }
else { Err(PortalError { code: 15 }) }
}
pub fn pause(&self) {}
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(2)) }
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(2)) }
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(2)) }
pub fn button(&self, _: i32, _: bool) -> Result<(), String> { Err(error(2)) }
pub fn key(&self, _: u64, _: bool) -> Result<(), String> { Err(error(2)) }
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(15)) }
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(15)) }
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn button(&self, _: i32, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn key(&self, _: u64, _: bool) -> Result<(), String> { Err(error(15)) }
}
/// Forward frames in-process into encoder stdin. Cancellation drops the Arc;
@@ -641,6 +651,7 @@ mod tests {
fn errors_never_include_remote_messages_or_identifiers() {
assert!(super::check(4).unwrap_err().contains("cancelled or denied"));
assert!(super::check(9).unwrap_err().contains("closed or stream lost"));
assert!(super::check(15).unwrap_err().contains("--features wayland,portal"));
}
#[test]
fn portal_error_display_is_fixed_and_sanitized() {
+2
View File
@@ -92,6 +92,8 @@ pub fn watch_locked() -> watch::Receiver<Option<bool>> {
if locked.is_none() { session = None; } // session ended or changed: look it up again
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
// The viewer only sees black frames while locked and gives no hint (#61).
if locked == Some(true) { log::info!("Desktop is locked: viewers see a black screen until it is unlocked (viewer 自动解锁被控端, or `loginctl unlock-session` on the host)"); }
*current = locked; true
} else { false });
std::thread::sleep(Duration::from_secs(1));
+52 -9
View File
@@ -160,6 +160,8 @@ fn is_independent_frame(bytes: &[u8]) -> bool { is_independent_frame_for(bytes,
#[derive(Debug)]
struct CompleteFrame {
source_id: usize,
source_generation: u64,
codec: VideoCodec,
sequence: u64,
completed_at: Instant,
@@ -167,6 +169,12 @@ struct CompleteFrame {
_permit: Option<OwnedSemaphorePermit>,
}
impl CompleteFrame {
fn matches(&self,settings:&VideoSettings)->bool {
self.codec==settings.codec && self.source_id==settings.source_id && self.source_generation==settings.source_generation
}
}
const RTP_CLOCK: u64 = 90_000;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -527,7 +535,7 @@ async fn read_inprocess(
let mut gate = DependencyGate::default();
while let Some(unit) = units.recv().await {
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
gate.submit(&latest, Arc::new(CompleteFrame { codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) }));
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: 0, source_id: 0, codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) }));
if latest.is_closed() { break; }
}
// Dropping the receiver also unblocks the encoder if it is waiting to send.
@@ -574,6 +582,8 @@ async fn read_encoder_with(
size: (u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,latest:mpsc::Sender<Arc<CompleteFrame>>,encoder:Encoder,sequence:Arc<std::sync::atomic::AtomicU64>,
settings: VideoSettings, #[cfg_attr(not(feature = "inproc-av"), allow(unused_variables))] idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
)->Result<(),String>{
let selected_output=if display.starts_with("wayland:") {crate::wayland::source(settings.source_id)} else {None};
let size=selected_output.map_or(size,|s|(s.width,s.height));
let kms=display.starts_with("kms:");
let wayland=kms || display.starts_with("wayland:");
let (permits_tx,mut permits_rx)=mpsc::channel::<OwnedSemaphorePermit>(4);
@@ -637,7 +647,9 @@ async fn read_encoder_with(
let executable=std::path::PathBuf::from("/proc/self/exe");
#[cfg(not(target_os="linux"))]
let executable=std::env::current_exe().map_err(|e|format!("Capture executable: {e}"))?;
let mut capture=wayland_capture_command(&executable,settings.fps)
let mut capture_command=wayland_capture_command(&executable,settings.fps);
if let Some(output)=selected_output {capture_command.env("UU_WAYLAND_OUTPUT",&output.name);}
let mut capture=capture_command
.env("UU_WAYLAND_DEMAND","1")
.kill_on_drop(true).stdin(std::process::Stdio::piped()).stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::inherit())
.spawn().map_err(|e|format!("Start Wayland capture: {e}"))?;
@@ -735,7 +747,7 @@ async fn read_encoder_with(
let frame: Vec<u8> = pending.drain(..next).collect();
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
let permit=if wayland {Some(permits_rx.recv().await.ok_or("Capture producer stopped")?)} else {None};
gate.submit(&latest, Arc::new(CompleteFrame {
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: settings.source_generation, source_id: settings.source_id,
codec: settings.codec, sequence, completed_at: Instant::now(), data: frame, _permit: permit,
}));
if latest.is_closed() { return Ok(()); }
@@ -921,7 +933,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
'stream: loop {
let next = *settings.borrow_and_update();
if next != current || send_interrupted {
let discard = next.codec != current.codec || send_interrupted;
let discard = next.codec != current.codec || next.source_generation != current.source_generation || next.source_id != current.source_id || send_interrupted;
current = next;
timeline.fps = u64::from(next.fps);
if discard {
@@ -945,6 +957,19 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone()));
continue;
}
if result.is_err() && !crate::wayland::outputs().is_empty() && !crate::wayland::input_ready() {
// Leave the stream task alive so the request worker can roll back
// a failed capture/encoder and restart the previous source.
crate::wayland::failed(current.source_id,current.source_generation);
loop {
tokio::select! {
changed=settings.changed()=>{if changed.is_err(){return result;}break;},
_=health.tick()=>{if transport_closed(&pc){return Ok(());}},
}
}
send_interrupted=true;
continue;
}
return result;
},
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
@@ -955,7 +980,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
frame = receiver.recv() => {
// A closed queue means the reader ended; its JoinHandle carries the reason.
let Some(frame) = frame else { return (&mut reader.0).await.map_err(|e| format!("Encoder reader task: {e}"))?; };
if frame.codec != current.codec { continue; }
if !frame.matches(&current) { continue; }
let duration = timeline.duration_after(frame.completed_at);
if let Some(last) = previous { skipped += frame.sequence.saturating_sub(last + 1); }
max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis());
@@ -964,6 +989,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
data: frame.data.clone().into(), duration, ..Default::default()
};
let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()];
let sent_before=track.revision();
let send = track.write_sample_with_extensions(frame.codec, &sample, &extensions);
let send_started=Instant::now();
tokio::pin!(send);
@@ -977,6 +1003,9 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
},
}
}
if !crate::wayland::outputs().is_empty() && track.revision()>sent_before {
crate::wayland::presented(current.source_id,current.source_generation);
}
previous = Some(frame.sequence);
max_send_ms=max_send_ms.max(send_started.elapsed().as_millis());
frames += 1;
@@ -1082,7 +1111,7 @@ mod tests {
let mut gate=DependencyGate::default();
for sequence in 1..=2 {
let permit=budget.clone().acquire_owned().await.unwrap();
gate.submit(&tx,Arc::new(CompleteFrame {codec:VideoCodec::H264,sequence,completed_at:Instant::now(),
gate.submit(&tx,Arc::new(CompleteFrame { source_generation: 0, source_id: 0,codec:VideoCodec::H264,sequence,completed_at:Instant::now(),
data:vec![0,0,1,5,42],_permit:Some(permit)}));
}
let sending=rx.recv().await.unwrap();
@@ -1216,7 +1245,7 @@ mod tests {
let (tx, mut rx) = mpsc::channel(4);
let old_tx = tx.clone();
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
let frame = |sequence, idr| Arc::new(CompleteFrame { _permit: None,
let frame = |sequence, idr| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None,
sequence, codec: VideoCodec::H264, completed_at: Instant::now(),
data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42],
});
@@ -1311,7 +1340,7 @@ mod tests {
async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){
let(tx,mut rx)=mpsc::channel(1);
let mut gate=DependencyGate::default();
let frame=|sequence,idr|Arc::new(CompleteFrame{_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
let frame=|sequence,idr|Arc::new(CompleteFrame{source_generation:0,source_id:0,_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet
gate.submit(&tx,frame(2,true));
gate.submit(&tx,frame(3,false)); // queue full: P3 lost
@@ -1365,7 +1394,7 @@ mod tests {
async fn hevc_dependency_gate_recovers_only_at_irap_after_overflow() {
let (tx, mut rx) = mpsc::channel(1);
let mut gate = DependencyGate::default();
let frame = |sequence, irap| Arc::new(CompleteFrame { _permit: None, codec: VideoCodec::H265,
let frame = |sequence, irap| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, codec: VideoCodec::H265,
sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42] });
gate.submit(&tx, frame(1, false));
assert!(rx.try_recv().is_err());
@@ -1407,3 +1436,17 @@ mod tests {
}
}
#[cfg(test)]
mod screen_frame_tests {
use super::*;
#[test]
fn source_restart_rejects_queued_frames_even_with_same_screen_and_codec() {
let frame=CompleteFrame {source_id:0,source_generation:7,codec:VideoCodec::H264,sequence:1,completed_at:Instant::now(),data:vec![],_permit:None};
let mut settings=VideoSettings {source_id:0,source_generation:7,..Default::default()};
assert!(frame.matches(&settings));
settings.source_generation=9;assert!(!frame.matches(&settings));
settings.source_generation=7;settings.source_id=1;assert!(!frame.matches(&settings));
settings.source_id=0;settings.codec=VideoCodec::H265;assert!(!frame.matches(&settings));
}
}
+161 -1
View File
@@ -1,6 +1,7 @@
//! Hyprland/wlroots native backend. No XWayland fallback and no input logging.
#[cfg(all(target_os="linux", feature="wayland"))]
extern "C" {
crate::engine_ffi! { crate::engine_plugin::Engine::Wayland;
fn uu_wl_select_output(name: *const libc::c_char, width: u32, height: u32) -> i32;
fn uu_wl_init(out_w: *mut i32, out_h: *mut i32) -> i32;
fn uu_wl_capture(buffer: *mut u8, length: usize) -> i32;
fn uu_wl_move(x: i32, y: i32, relative: i32) -> i32;
@@ -38,11 +39,19 @@ pub fn release_all()->i32 {
pub fn init() -> Result<(u32,u32),String> {
#[cfg(all(target_os="linux", feature="wayland"))]
{
crate::engine_plugin::load(crate::engine_plugin::Engine::Wayland).map_err(|reason| format!("Wayland engine unavailable: {reason}"))?;
let (mut w,mut h)=(0,0);
let result=unsafe { uu_wl_init(&mut w,&mut h) };
if result != 0 || w <= 0 || h <= 0 {
return Err(format!("Wayland initialization failed ({result}); requires screencopy, virtual keyboard and virtual pointer. Check UU_WAYLAND_OUTPUT and session environment."));
}
// The compositor registry and hyprctl need not enumerate outputs in the
// same order. Bind the initial engine to the inventory's selected output.
static BINDING: std::sync::OnceLock<Result<(),String>>=std::sync::OnceLock::new();
if !outputs().is_empty() {
BINDING.get_or_init(||select(0)).as_ref().map_err(Clone::clone)?;
return Ok(input_size((w as u32,h as u32)));
}
return Ok((w as u32,h as u32));
}
#[cfg(not(all(target_os="linux", feature="wayland")))]
@@ -194,3 +203,154 @@ pub fn text_probe()->Result<(),String> {
sequence.chars().filter(|character|*character!='|').count(),sequence.split('|').count());
Ok(())
}
// Opt-in single-track monitor switching for Hyprland. The existing native engine owns
// capture/pointer binding; no compositor layout or user credentials are modified.
#[derive(Clone, Debug)]
pub struct Output { pub name:String, pub width:u32, pub height:u32, pub fps:i32 }
static OUTPUTS: std::sync::OnceLock<Vec<Output>> = std::sync::OnceLock::new();
#[derive(Default)]
struct Selection { id:usize, generation:u64, presented:Option<u64>, failed:bool }
impl Selection {
fn begin(&mut self,id:usize) {
self.id=id; self.generation+=1; self.presented=None; self.failed=false;
}
fn sent(&mut self,id:usize,generation:u64) {
if (self.id,self.generation)==(id,generation) {self.presented=Some(generation);}
}
fn ready(&self)->bool {self.presented==Some(self.generation)}
}
static SELECTION:std::sync::Mutex<Selection>=std::sync::Mutex::new(Selection {id:0,generation:0,presented:None,failed:false});
pub fn outputs() -> &'static [Output] {
OUTPUTS.get_or_init(|| {
if !cfg!(all(target_os="linux",feature="wayland"))
|| std::env::var("UU_WAYLAND_MULTISCREEN").ok().as_deref()!=Some("1")
|| crate::desktop_backend::detect().ok()!=Some(crate::desktop_backend::DesktopBackend::Wayland) {return Vec::new();}
let output=std::process::Command::new("hyprctl").args(["monitors","-j"]).output();
let result=output.map_err(|_|"hyprctl unavailable").and_then(|output| {
if !output.status.success() {return Err("hyprctl failed");}
parse_outputs(&output.stdout,&std::env::var("UU_WAYLAND_OUTPUT").unwrap_or_default())
});
match result {Ok(outputs)=>outputs,Err(reason)=>{log::warn!("Wayland multi-screen disabled: {}",reason);Vec::new()}}
})
}
fn parse_outputs(json:&[u8],preferred:&str)->Result<Vec<Output>,&'static str> {
let monitors=serde_json::from_slice::<Vec<serde_json::Value>>(json).map_err(|_|"Invalid monitor inventory")?;
let mut seen=std::collections::HashSet::new();
let mut outputs:Vec<Output>=monitors.into_iter().filter_map(|m| {
if m["disabled"].as_bool()==Some(true) || m["transform"].as_u64()!=Some(0) {return None;}
let name=m["name"].as_str()?;
let width=u32::try_from(m["width"].as_u64()?).ok()?;
let height=u32::try_from(m["height"].as_u64()?).ok()?;
if name.is_empty() || name.len()>127 || name.contains('\0') || !seen.insert(name.to_owned())
|| width<2 || height<2 || width>16384 || height>16384 || u64::from(width)*u64::from(height)*4>256*1024*1024 {return None;}
Some(Output {name:name.into(),width,height,fps:m["refreshRate"].as_f64()?.round().clamp(1.0,240.0) as i32})
}).collect();
outputs.sort_by_key(|m| (m.name!=preferred,m.name.clone()));
outputs.truncate(16);
if outputs.is_empty() || (!preferred.is_empty() && outputs[0].name!=preferred) {return Err("No capturable preferred output");}
Ok(outputs)
}
pub fn selection()->(usize,u64) {let s=SELECTION.lock().unwrap();(s.id,s.generation)}
pub fn selected()->usize {selection().0}
pub fn source(id:usize)->Option<&'static Output> {outputs().get(id)}
pub fn input_size(fallback:(u32,u32))->(u32,u32) {source(selected()).map_or(fallback,|s|(s.width,s.height))}
pub fn input_ready()->bool {outputs().is_empty() || SELECTION.lock().unwrap().ready()}
pub fn switch_failed()->bool {SELECTION.lock().unwrap().failed}
pub fn presented(id:usize,generation:u64) {SELECTION.lock().unwrap().sent(id,generation);}
pub fn failed(id:usize,generation:u64) {
let mut state=SELECTION.lock().unwrap();
if (state.id,state.generation)==(id,generation) {state.failed=true;}
}
pub fn select(id:usize)->Result<(),String> {
let output=source(id).ok_or("Unknown Wayland screen")?;
#[cfg(all(target_os="linux",feature="wayland"))]
{
let name=std::ffi::CString::new(output.name.as_str()).map_err(|_|"Invalid output name")?;
let mut state=SELECTION.lock().unwrap();
if unsafe {uu_wl_select_output(name.as_ptr(),output.width,output.height)}!=0 {return Err("Wayland output switch failed".into());}
state.begin(id);
log::info!("Wayland screen selected: id={} source={}x{}",id,output.width,output.height);
Ok(())
}
#[cfg(not(all(target_os="linux",feature="wayland")))]
{let _=output;Err("Wayland output switching unavailable".into())}
}
/// CaptureSettingRequest.screen_id is field 4 (rpc_main.proto); official desktop
/// activation also uses SimpleAction 8 {"screen_id":id}. Reference: openuuyc main
/// a87b8e7, stream_control/wire.rs and publisher/displays.rs (Windows S456070).
/// https://github.com/djkcyl/openuuyc/tree/a87b8e772c238e542215ab039f1b1d2ca4a9ef46/src/features/stream_control
/// Official phone acceptance on Hyprland: field 4 selected each advertised id;
/// current-source settings used the signed value -1.
pub fn requested_output(data:&[u8]) -> Option<usize> {
use crate::protocol::{decode_wire,WireValue};
let outer=decode_wire(data).ok()?;
fn bytes<'a>(fields:&[crate::protocol::WireField<'a>],n:u32)->Option<&'a [u8]> {fields.iter().find_map(|f|match f.value {WireValue::Bytes(b) if f.number==n=>Some(b),_=>None})}
if let Some(rpc)=bytes(&outer,21) {
let rpc=decode_wire(rpc).ok()?;
let request=decode_wire(bytes(&rpc,2)?).ok()?;
let id=request.iter().find_map(|f|match f.value {WireValue::Varint(v) if f.number==4=>Some(v as i64),_=>None}).unwrap_or(0);
return usize::try_from(id).ok();
}
let action=decode_wire(bytes(&outer,3)?).ok()?;
let kind=action.iter().find_map(|f|match f.value {WireValue::Varint(v) if f.number==1=>Some(v),_=>None})?;
if kind!=8 {return None;}
let args:serde_json::Value=serde_json::from_slice(bytes(&action,2)?).ok()?;
usize::try_from(args["screen_id"].as_i64()?).ok()
}
#[cfg(test)]
mod monitor_switch_tests {
use super::*;
#[test]
fn capture_setting_screen_zero_and_signed_current_target() {
// Message.rpc_request(21), RpcRequest.capture_setting(2), screen_id(4).
let request=|payload:&[u8]| {let mut rpc=vec![18,payload.len() as u8];rpc.extend(payload);crate::initialization::envelope(1,2,21,&rpc)};
assert_eq!(requested_output(&request(&[32,1])),Some(1));
assert_eq!(requested_output(&request(&[])),Some(0));
assert_eq!(requested_output(&request(&[32,255,255,255,255,255,255,255,255,255,1])),None);
assert_eq!(requested_output(b"not protobuf"),None);
}
#[test]
fn only_explicit_desktop_restart_selects_an_output() {
let request=|action:u8,args:&str| {let mut sa=vec![8,action,18,args.len() as u8];sa.extend(args.bytes());crate::initialization::envelope(1,2,3,&sa)};
assert_eq!(requested_output(&request(8,r#"{"screen_id":1}"#)),Some(1));
assert_eq!(requested_output(&request(8,r#"{"screen_id":-1}"#)),None);
assert_eq!(requested_output(&request(7,r#"{"screen_id":1}"#)),None);
}
}
#[cfg(test)]
mod selection_regressions {
use super::*;
#[test]
fn old_frames_cannot_unlock_a_return_to_the_same_screen() {
let mut s=Selection::default();
s.begin(0);let old=s.generation;s.sent(0,old);assert!(s.ready());
s.begin(1);assert!(!s.ready());s.sent(0,old);assert!(!s.ready());
s.begin(0);let current=s.generation;
s.sent(0,old);assert!(!s.ready());
s.sent(1,current);assert!(!s.ready());
s.sent(0,current);assert!(s.ready());
}
#[test]
fn mixed_scale_inventory_preserves_pixel_sizes_and_preferred_output() {
let json=br#"[{"name":"eDP-1","width":1920,"height":1080,"scale":1.3333334,"transform":0,"refreshRate":144},
{"name":"HDMI-A-1","width":2560,"height":1440,"scale":1.25,"transform":0,"refreshRate":75}]"#;
let outputs=parse_outputs(json,"HDMI-A-1").unwrap();
assert_eq!(outputs.iter().map(|m|(m.name.as_str(),m.width,m.height)).collect::<Vec<_>>(),
vec![("HDMI-A-1",2560,1440),("eDP-1",1920,1080)]);
assert!(parse_outputs(json,"missing-output").is_err());
}
#[test]
fn unusable_outputs_are_not_advertised() {
let json=br#"[{"name":"rotated","width":1920,"height":1080,"transform":1,"refreshRate":60},
{"name":"too-large","width":16000,"height":16000,"transform":0,"refreshRate":60},
{"name":"off","width":1920,"height":1080,"disabled":true,"transform":0,"refreshRate":60},
{"name":"normal","width":1920,"height":1080,"transform":0,"refreshRate":60}]"#;
let outputs=parse_outputs(json,"").unwrap();
assert_eq!(outputs.len(),1);assert_eq!(outputs[0].name,"normal");
assert!(parse_outputs(b"not JSON","").is_err());
}
}
+79 -10
View File
@@ -391,11 +391,14 @@ impl WebRtcSession {
});
}
// Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
let settings_serial=Arc::new(Mutex::new(()));
// 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string();
log::info!("New DataChannel received: {}", label);
let peer_settings_serial=settings_serial.clone();
let input_inst = input_clone.clone();
let channel_input_session=input_session.clone();
let screen = control_capture.clone();
@@ -445,7 +448,7 @@ impl WebRtcSession {
});
}
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
if label == "CONTROL_DATA_CHANNEL" {
if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") {
let settings = channel_video_settings.clone();
let track = peer_video_track.clone();
let response_tx = outbound.clone();
@@ -453,6 +456,8 @@ impl WebRtcSession {
let manager = portal_desktop.clone();
let channel = Arc::downgrade(&d);
let initial_screen = screen.clone();
let switch_owner=channel_input_session.clone();
let settings_serial=peer_settings_serial.clone();
tokio::spawn(async move {
let mut health = tokio::time::interval(std::time::Duration::from_millis(100));
loop {
@@ -467,6 +472,36 @@ impl WebRtcSession {
continue;
}
};
let _serial=settings_serial.lock().await;
if desktop && switch_owner.as_ref().is_none_or(|owner|!owner.is_current()) {continue;}
let reject=|reason:&str| {
if let Some(response)=crate::capture_setting::rejected_request(&request,reason) {
let ts=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _=response_tx.send(crate::initialization::envelope(sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),ts,22,&response));
}
};
let source_before=crate::wayland::selected();
let settings_before=*settings.borrow();
if desktop && !crate::wayland::outputs().is_empty() {
if let Some(id)=crate::wayland::requested_output(&request) {
if crate::wayland::source(id).is_none() {reject("Unknown screen");continue;}
if id!=source_before {
let mut changed=false;
if let Some(owner)=&switch_owner {owner.with_current(|| {
owner.release_input();
match crate::wayland::select(id) {
Ok(())=>{
let (source_id,source_generation)=crate::wayland::selection();
settings.send_modify(|s|{s.source_id=source_id;s.source_generation=source_generation;s.output=None;});
changed=true;
},
Err(error)=>{log::warn!("Screen switch rejected: {}",error);reject(&error);},
}
});}
if !changed {continue;}
}
}
}
let active_screen = if desktop {
if let Some(manager) = &manager {
loop {
@@ -492,6 +527,33 @@ impl WebRtcSession {
let input_size = if active_screen.init_error.is_none() {
(active_screen.width, active_screen.height)
} else { (1920, 1080) };
let input_size=crate::wayland::input_size(input_size);
let source_changed=source_before!=crate::wayland::selected();
if source_changed {
let target=crate::wayland::selection();
let deadline=tokio::time::Instant::now()+std::time::Duration::from_secs(10);
while crate::wayland::selection()==target && !crate::wayland::input_ready()
&& !crate::wayland::switch_failed() && tokio::time::Instant::now()<deadline {
if channel.upgrade().is_none_or(|c|c.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open)
|| switch_owner.as_ref().is_none_or(|owner|!owner.is_current()) {return;}
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
}
if switch_owner.as_ref().is_none_or(|owner|!owner.is_current()) || crate::wayland::selection()!=target {continue;}
if !crate::wayland::input_ready() {
if let Some(owner)=&switch_owner {owner.with_current(|| {
if crate::wayland::selection()==target && crate::wayland::select(source_before).is_ok() {
let (source_id,source_generation)=crate::wayland::selection();
settings.send_replace(crate::capture_setting::VideoSettings {source_id,source_generation,..settings_before});
}
});}
log::warn!("Screen switch failed; previous source requested");
reject("Screen switch failed; restoring previous screen");
continue;
}
let ts=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
if let Ok(message)=crate::capture_setting::screen_sources(sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),ts,input_size,None,"Linux desktop") {let _=response_tx.send(message);}
if let Ok(message)=crate::initialization::encode_capture_change(sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),ts,0,crate::wayland::selected() as i32,"Linux desktop") {let _=response_tx.send(message);}
}
let Ok(fields) = crate::protocol::decode_wire(&request) else { continue; };
use crate::protocol::WireValue;
let Some(rpc) = fields.iter().find_map(|f| match (f.number, &f.value) {
@@ -501,10 +563,14 @@ impl WebRtcSession {
let before = *settings.borrow();
let output_before = before.output;
let revision = track.revision();
let Some(response) = crate::capture_setting::handle_rpc_with_codecs(
let apply=|| crate::capture_setting::handle_rpc_with_codecs(
&rpc_fields, &settings, input_size,
track.supports(crate::capture_setting::VideoCodec::H264),
track.supports(crate::capture_setting::VideoCodec::H265)) else { continue; };
track.supports(crate::capture_setting::VideoCodec::H265));
let response=if let Some(owner)=&switch_owner {
let mut response=None;owner.with_current(||response=apply());response
} else {apply()};
let Some(response)=response else {continue;};
let codec_changed = settings.borrow().codec != before.codec;
if desktop && codec_changed && !track.wait_for_applied(revision, &settings).await {
log::warn!("Codec switch did not produce a transmitted frame; success reply withheld");
@@ -645,7 +711,7 @@ impl WebRtcSession {
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::initialization::encode_capture_change(
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
timestamp, 0, 0, "Linux desktop").expect("desktop capture type");
timestamp, 0, crate::wayland::selected() as i32, "Linux desktop").expect("desktop capture type");
if let Err(error) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL desktop selection failed: {error}");
return;
@@ -733,9 +799,9 @@ impl WebRtcSession {
} else { crate::system_metrics::Permission::Reject };
// Without a desktop (headless/portal before consent) the port-mapping tool still waits
// for ScreenSources/CaptureChange and aborts otherwise: tool peers get a nominal screen.
let screen_size=if screen.init_error.is_none() { (screen.width, screen.height) } else { (1920, 1080) };
let screen_size=crate::wayland::input_size(if screen.init_error.is_none() { (screen.width, screen.height) } else { (1920, 1080) });
let messages = [
(8, crate::initialization::encode_capture_change(next_seq(), timestamp, 0, 0, "Linux desktop")),
(8, crate::initialization::encode_capture_change(next_seq(), timestamp, 0, crate::wayland::selected() as i32, "Linux desktop")),
(13, Ok(crate::initialization::envelope(next_seq(), timestamp, 13, &init_actions.metrics_payload(desktop_sound, desktop_permission)))),
(26, Ok(crate::initialization::envelope(next_seq(), timestamp, 26,
&crate::system_metrics::remote_download_path(&home)))),
@@ -822,11 +888,12 @@ impl WebRtcSession {
let capture_requests = capture_tx.clone();
Box::pin(async move {
let input_size = (screen.width, screen.height);
let input_size = crate::wayland::input_size((screen.width, screen.height));
if let Some(term) = &terminal_worker {
if crate::terminal::is_frame(&msg.data) { term.handle(&msg.data); return; }
}
if channel_name == "CONTROL_DATA_CHANNEL" && is_capture_setting_message(&msg.data) {
if matches!(channel_name.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL")
&& (is_capture_setting_message(&msg.data) || (!crate::wayland::outputs().is_empty() && crate::wayland::requested_output(&msg.data).is_some())) {
// Back-pressure like the old inline handler instead of dropping the latest setting.
if capture_requests.send(msg.data.to_vec()).await.is_err() {
log::warn!("Capture setting queue closed; request dropped");
@@ -1070,7 +1137,7 @@ impl WebRtcSession {
}
}
if let Ok(crate::control_protocol::ControlMessage::Input(crate::control_protocol::ControlInput::TextInput {text})) = crate::control_protocol::decode_control(&msg.data) {
if let Some(session)=message_input_session.as_ref() { session.with_input(|| input_worker.text_input(&text)); }
if let Some(session)=message_input_session.as_ref() { session.with_input(|| {if crate::wayland::input_ready() {input_worker.text_input(&text);}}); }
}
}
if channel_name.contains("CONTROL") {
@@ -1078,6 +1145,7 @@ impl WebRtcSession {
Ok(crate::control_protocol::ControlMessage::Input(event)) => {
if screen.backend == crate::desktop_backend::DesktopBackend::Portal
&& (screen.init_error.is_some() || !desktop_ready || *lock_for_message.borrow() != Some(false)) { return; }
if !crate::wayland::input_ready() {return;}
use crate::control_protocol::ControlInput;
// Separate receipt budgets keep motion floods from hiding clicks.
static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
@@ -1090,8 +1158,9 @@ impl WebRtcSession {
log::info!("CONTROL input received: kind={}", kind);
}
if let Some(session)=message_input_session.as_ref() {session.with_input(|| {
if !crate::wayland::input_ready() {return;}
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,input_size),
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(input_size)),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
+123
View File
@@ -0,0 +1,123 @@
//! Experimental Wake-on-LAN helper (`UU_WOL_HELPER=1`, off by default).
//!
//! The official Windows host (GameViewerServer: LoginManager::reportLanInfo, PushMessageHandler::wakeOnLan,
//! wake_on_lan.cpp host::send_wol) reports its LAN address to `api-ipv4…/api/v1/device/wake_on_lan/info`
//! after sign-in (logged as "mac / ip / subnet_mask", response carries `turn_on_wol`), and on a
//! `wake_on_lan` cloud push with a `target_device` {mac, ip, subnet_mask} it sends a magic packet to that
//! subnet's broadcast address, waking another PC of the account on the same LAN. The exact request and
//! push field names come from the official log strings only; nothing here is verified end to end yet.
//! Addresses are sent to NetEase only when the helper is enabled and are never logged.
use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket};
pub fn enabled() -> bool { std::env::var("UU_WOL_HELPER").is_ok_and(|v| v == "1") }
/// `aa:bb:cc:dd:ee:ff` / `aa-bb-…` / `aabbcc…` → 6 bytes.
pub fn parse_mac(text: &str) -> Option<[u8; 6]> {
let hex: String = text.chars().filter(|c| c.is_ascii_hexdigit()).collect();
if hex.len() != 12 || text.chars().any(|c| !(c.is_ascii_hexdigit() || matches!(c, ':' | '-' | '.'))) { return None; }
let mut mac = [0u8; 6];
for (i, byte) in mac.iter_mut().enumerate() { *byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).ok()?; }
(mac != [0; 6] && mac != [0xff; 6]).then_some(mac)
}
/// Six 0xFF bytes followed by the MAC sixteen times.
pub fn magic_packet(mac: [u8; 6]) -> Vec<u8> {
let mut packet = vec![0xff; 6];
for _ in 0..16 { packet.extend_from_slice(&mac); }
packet
}
/// Directed broadcast of `ip`/`mask`, or None when either is missing or invalid.
pub fn subnet_broadcast(ip: &str, mask: &str) -> Option<Ipv4Addr> {
let (ip, mask): (Ipv4Addr, Ipv4Addr) = (ip.parse().ok()?, mask.parse().ok()?);
let mask = u32::from(mask);
if mask == 0 || mask.leading_ones() + mask.trailing_zeros() != 32 { return None; }
Some(Ipv4Addr::from(u32::from(ip) | !mask))
}
/// Handles a `wake_on_lan` push payload; returns how many datagrams were sent.
pub fn handle_push(data: &serde_json::Value) -> Result<usize, String> {
let target = data.get("target_device").or_else(|| data.get("data").and_then(|d| d.get("target_device")))
.ok_or("wake_on_lan push without target_device")?;
let text = |key: &str| target.get(key).and_then(serde_json::Value::as_str).unwrap_or("");
let mac = parse_mac(text("mac")).ok_or("wake_on_lan target has no valid mac")?;
let packet = magic_packet(mac);
let socket = UdpSocket::bind("0.0.0.0:0").map_err(|e| format!("WOL socket: {}", e.kind()))?;
socket.set_broadcast(true).map_err(|e| format!("WOL broadcast: {}", e.kind()))?;
let mut targets = vec![Ipv4Addr::BROADCAST];
if let Some(directed) = subnet_broadcast(text("ip"), text("subnet_mask")) { targets.insert(0, directed); }
let mut sent = 0;
for address in targets { for port in [9, 7] {
if socket.send_to(&packet, SocketAddrV4::new(address, port)).is_ok() { sent += 1; }
} }
if sent == 0 { return Err("WOL packet could not be sent".into()); }
Ok(sent)
}
/// This host's LAN identity on the default IPv4 route: (mac, ip, subnet mask).
#[cfg(target_os = "linux")]
pub fn lan_info() -> Option<(String, String, String)> {
let routes = std::fs::read_to_string("/proc/net/route").ok()?;
let iface = routes.lines().skip(1).map(|l| l.split_whitespace().collect::<Vec<_>>())
.find(|f| f.len() > 2 && f[1] == "00000000")?.first()?.to_string();
let mac = std::fs::read_to_string(format!("/sys/class/net/{iface}/address")).ok()?.trim().to_owned();
parse_mac(&mac)?;
let mut addrs: *mut libc::ifaddrs = std::ptr::null_mut();
if unsafe { libc::getifaddrs(&mut addrs) } != 0 { return None; }
let mut result = None;
let mut cursor = addrs;
while !cursor.is_null() {
let entry = unsafe { &*cursor };
cursor = entry.ifa_next;
if entry.ifa_addr.is_null() || entry.ifa_netmask.is_null() { continue; }
let name = unsafe { std::ffi::CStr::from_ptr(entry.ifa_name) }.to_string_lossy();
if name != iface.as_str() || i32::from(unsafe { (*entry.ifa_addr).sa_family }) != libc::AF_INET { continue; }
let v4 = |p: *mut libc::sockaddr| Ipv4Addr::from(u32::from_be(unsafe { (*(p as *const libc::sockaddr_in)).sin_addr.s_addr }));
result = Some((mac.clone(), v4(entry.ifa_addr).to_string(), v4(entry.ifa_netmask).to_string()));
break;
}
unsafe { libc::freeifaddrs(addrs) };
result
}
#[cfg(not(target_os = "linux"))]
pub fn lan_info() -> Option<(String, String, String)> { None }
/// Report this host's LAN identity like the official host after sign-in.
pub async fn report(auth: &crate::auth::UUAuthClient) {
let Some((mac, ip, subnet_mask)) = lan_info() else { log::warn!("WOL helper: no IPv4 default-route interface"); return; };
let body = serde_json::json!({ "mac": mac, "ip": ip, "subnet_mask": subnet_mask });
match auth.post_json_url("https://api-ipv4.nrd.nie.163.com", "/api/v1/device/wake_on_lan/info", &body).await {
Ok((status, value)) => log::info!("WOL helper: LAN info reported: status={status} code={:?} turn_on_wol={:?}",
value.get("code").and_then(serde_json::Value::as_i64),
value.get("data").and_then(|d| d.get("turn_on_wol")).or_else(|| value.get("turn_on_wol"))),
Err(error) => log::warn!("WOL helper: LAN info report failed: {error}"),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn mac_parsing_and_packet() {
assert_eq!(parse_mac("AA:bb:cc:dd:ee:01"), Some([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 1]));
assert_eq!(parse_mac("aa-bb-cc-dd-ee-01"), parse_mac("aabbccddee01"));
assert!(parse_mac("aa:bb:cc").is_none() && parse_mac("zz:bb:cc:dd:ee:01").is_none() && parse_mac("00:00:00:00:00:00").is_none());
let packet = magic_packet([1, 2, 3, 4, 5, 6]);
assert_eq!(packet.len(), 102);
assert_eq!(&packet[..6], &[0xff; 6]);
assert_eq!(&packet[96..], &[1, 2, 3, 4, 5, 6]);
}
#[test]
fn directed_broadcast() {
assert_eq!(subnet_broadcast("192.168.2.29", "255.255.255.0"), Some(Ipv4Addr::new(192, 168, 2, 255)));
assert_eq!(subnet_broadcast("10.1.2.3", "255.255.0.0"), Some(Ipv4Addr::new(10, 1, 255, 255)));
assert_eq!(subnet_broadcast("10.1.2.3", "255.0.255.0"), None);
assert_eq!(subnet_broadcast("", "255.255.255.0"), None);
}
#[test]
fn push_without_target_is_rejected() {
assert!(handle_push(&serde_json::json!({})).is_err());
assert!(handle_push(&serde_json::json!({"target_device": {"mac": "nope"}})).is_err());
}
}