Compare commits

..
60 Commits
Author SHA1 Message Date
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
VallierDevandClaude Opus 5.5 22fb6783a0 Release v0.2.12: pad odd capture sizes (#53)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-19 14:57:29 +08:00
wen0531andwen0531 10166c66e0 video: pad odd captured frame dimensions to even (#53)
The portal backend reports the compositor's logical desktop size, which is
odd when a scaled monitor's logical extent is odd: two stacked monitors at
150% scale capture 2560x2507. H.264/HEVC 4:2:0 encoders (and NVENC's surface
allocation) reject odd dimensions, so with such a desktop every encoder
failed to open:

  [libx264] height not divisible by 2 (2560x2507)
  [h264_nvenc] InitializeEncoder failed: out of memory (10)
  ERROR Live desktop stream stopped: Encoder output ended

and the official viewer stayed on 正在传输画面 while input still worked.

Pad the odd row/column in the filter chain when the native capture size is
known and no output scaling was requested (a no-op case omitted for even
sizes). The host display mode, the reported capture size and the explicit
分辨率 scaling path are unchanged; the fixed-input probe keeps its chain.

Co-authored-by: wen0531 <[email protected]>
2026-10-19 14:57:02 +08:00
VallierDevandClaude Opus 5.5 b7f9f2aa68 Release v0.2.11: wlroots text_input (#51), proxy bypass by default (#52)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-19 10:26:55 +08:00
aresbit 6416f75b7f auth: bypass ambient proxies by default; UU_USE_PROXY=1 opts in (#52)
A local HTTP/SOCKS proxy that intercepts TLS caused login to fail with
"tls handshake eof". Build all cloud API clients with no_proxy() unless
UU_USE_PROXY is explicitly truthy, so direct connections are the default
and environments that genuinely need a proxy can still enable it.
2026-10-19 10:25:58 +08:00
70cb5ad57e Wayland/wlroots: type mobile IME text through the virtual keyboard's spare keycodes (#51)
The mobile clients' input method sends `text_input {content}` over CONTROL. Upstream only
implements it for X11, so a Wayland host (Hyprland here) dropped the characters with a
warning. Wire it up: characters the session keymap already produces are pressed as
ordinary keycodes, and characters it cannot produce are carried by spare keycodes (the
keymap has ~33 named but unmapped ones) declared for the duration of one batch, in text
order, then removed again.

The focused client translates keycodes with the keymap the compositor last handed it, and
a keymap uploaded to a keyboard the seat already has is never handed on again: measured on
Hyprland 0.56.2, pressing the remapped keycodes then reproduces the previous message's
text (a space came out as the previous message's first character, and every message
repeated the one before it). Re-attaching the virtual keyboard is what makes the
compositor send the keymap to the client, so each batch does that, waits for the
compositor to install the keymap, and releases held keys first because the new keyboard
starts with none. No timing sleep is needed once the keyboard is re-attached, so there is
none. Plain latin text and spaces never touch the keymap at all. The pristine keymap is
restored after every call, so uu_wl_key keeps its own symbol map and the compositor is
never left with spare keys bound.

`wayland-text-probe` reports how many characters one upload can carry and types a sample;
UU_PROBE_SEQUENCE types one message per |-separated field, the way the phone's input
method sends them, which is what reproduced this locally.

Co-authored-by: Hey Claw <[email protected]>
Co-authored-by: Claude Code <[email protected]>
2026-10-18 21:07:23 +08:00
VallierDevandClaude Opus 5.5 7fcc674440 Release v0.2.10: official device_capability shape and sender_para_info (#49)
The iPhone client ignored our flat forward_setting device_capability and kept
quality and chroma locked. Send it nested under data.device_capability with
type beside it, list the formats the encoder really produces (4:4:4 when
available), and add sender_para_info, as the official Windows host does.
Verified with the UU iPhone app 4.42.0.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 20:54:34 +08:00
VallierDevandClaude Opus 5.5 19d0563781 desktop: viewer launcher entry and window icon; explicit StartupWMClass (#13)
The viewer's GTK windows had no icon and no desktop entry, so docks showed a
generic icon next to the host's. Add uu-remote-linux-viewer.desktop and use the
host icon for viewer windows.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 17:25:14 +08:00
VallierDevandClaude Opus 5.5 edd4c9250c Release v0.2.9: HEVC picture-boundary AUs (#48), VAAPI buffer (#47)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 16:33:33 +08:00
ca49232674 HEVC: split access units by picture boundaries; no -aud for hevc_vaapi (#48)
* HEVC: split access units by picture boundaries, and stop passing -aud to hevc_vaapi

hevc_vaapi with `-aud 1` writes an AUD only at IRAPs and drops every other picture from
the bitstream: a 90-frame 640x360 clip came out as 3 IDRs and no P-frames. The reader
splits access units on AUDs, so each "frame" became one IDR plus a whole GOP, and the
IRAP gate then rejected all of them - the H.265 path sent no video at all (measured
~12 kbit/s outbound against 4-6 Mbit/s for H.264).

HEVC now leaves AUD off and hevc_au_offsets() splits on RFC 7798 picture boundaries (an
AUD, or the first NAL after a VCL NAL that is non-VCL or starts a picture), which also
keeps multi-slice pictures in one unit and covers the libx265/NVENC shapes. Parameter
sets still repeat in-band ahead of every IDR, so no out-of-band sprop is needed.

The fixed-input probe hardcoded H.264 in three places (settings, output muxer, first-unit
check), which is why this path was never measurable; it now follows UU_VIDEO_CODEC.

Verified with desktop-video-probe (90-frame fixed input): hevc_vaapi and libx265 both
emit 90 frames, first unit an IRAP with its parameter sets.

Assisted-by: DeepSeek V4.1 Flash-1017

* HEVC: keep suffix SEI, filler and end markers with the preceding picture

RFC 7798 / H.265 7.4.2.4.4 lets only AUD, VPS/SPS/PPS, prefix SEI and types
41-44/48-55 open an access unit; trailing NALs stay with the picture. Verified on
an RTX 3090 with the fixed-input probe: hevc_nvenc and libx265 both yield 90/90
decodable units with an IRAP first.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-18 16:32:35 +08:00
NuoFang cb8253febf VAAPI: opt-in UU_VAAPI_BUFFER_MS for the VBV buffer (#47)
The 100-500 kbit default keeps NVENC keyframes inside the buffer, but VAAPI quantizes a
whole desktop keyframe when the buffer is that small: on a 2560x1440 H.264 VAAPI stream
capped at 30 Mbit/s the first IDR measured 59,910 bytes and the picture blurred once per
GOP before sharpening back.

UU_VAAPI_BUFFER_MS (10-1000 ms, VAAPI only) sizes the buffer as bitrate x ms/1000. With
250 ms on the same input the first IDR measured 142,397 bytes and the worst-frame Y-SSIM
over 180 static frames went from 0.9492 to 0.9933, with no rise in average bitrate.

Opt-in: unset, out of range or unparsable keeps the old buffer.

Assisted-by: DeepSeek V4.1 Flash-1017
2026-10-18 15:31:00 +08:00
VallierDevandClaude Opus 5.5 696cf10e33 docs: NAS Docker deployment guide; link it and the ghcr image from the READMEs
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 11:52:36 +08:00
VallierDevandClaude Opus 5.5 a9433b73be Release v0.2.8: NAS Docker image
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 11:44:44 +08:00
VallierDevandClaude Opus 5.5 c9e5fec175 docker: headless NAS container (Synology); publish ghcr image on release
docker/Dockerfile installs the release binary on Ubuntu 24.04 with the X11/GTK runtime
libs, headless (UU_DESKTOP_BACKEND=none), config in /config, data in /data. Verified
on Synology DSM 7.3: file transfer (sha256 round trip), terminal and port mapping
to the DSM web UI. Release workflow now pushes ghcr.io/vallierdev/uu-remote-linux.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 11:43:58 +08:00
VallierDevandClaude Opus 5.5 380a08e293 docs: v0.2.7 notes — mobile text_input verified with a phone
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 09:54:53 +08:00
VallierDevandClaude Opus 5.5 63ebb3e78a Release v0.2.7: mobile text_input (#13, #46); platform-aware viewer clipboard
Host: accept the official text_input {content} action on any channel and type it on
X11 via spare-keycode Unicode keysyms (verified with xev); log non-CONTROL JSON
action names. Viewer: Windows-type hosts get only the case-10 text change (a rich
format list overwrote it and was never rendered), Mac gets only the rich offer.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 09:41:56 +08:00
jo32 e4a2cc4698 contrib: macOS SSH companion for Finder file paste uploads (#45)
* Add macOS SSH companion for Finder file paste uploads

* Show measured upload progress in Ghostty title and progress bar
2026-10-18 08:50:45 +08:00
VallierDevandClaude Opus 5.5 8fb57b421d Release v0.2.6: input diagnostics (#46), Mac terminal fix
Log unsupported CONTROL input actions (names only) and the server NumLock
state for numpad keys; skip the SDL window test on macOS (main-thread SDL).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 07:26:26 +08:00
VallierDevandClaude Opus 5.5 72c1e6101f docs: introduce the experimental viewer in the README title and intro (#44)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 01:23:46 +08:00
VallierDevandClaude Opus 5.5 a67731052f docs: show the viewer screenshot first; fix the host screenshot caption
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 00:04:58 +08:00
VallierDevandClaude Opus 5.5 e6089bfb46 docs: add the viewer launcher screenshot (device names redacted)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 00:02:25 +08:00
VallierDevandClaude Opus 5.5 aa2a341d15 docs: refresh the host main window screenshot
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 23:50:44 +08:00
VallierDevandClaude Opus 5.5 9622bf4c1e fix(viewer): accept terminal RPC answers on the terminal channel
The official Mac host answers check_env on the BINARY terminal channel next
to TERM frames; the viewer parsed it as a TERM frame and closed. Verified
live: Mac host terminal opens and echoes input.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 23:30:13 +08:00
VallierDevandClaude Opus 5.5 d7e52a098b Release v0.2.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 23:15:28 +08:00
VallierDevandClaude Opus 5.5 94ff1f1c02 fix(viewer): exchange text clipboard with the official Mac host
The Mac host offers pasteboard text as format 0 "public.utf8-plain-text"
(UTF-8), not CF_UNICODETEXT, so the viewer never requested it. Accept and
request that format, and offer it next to CF_UNICODETEXT from the viewer.
Host-side offers to official clients are unchanged. Mac -> viewer verified
live; viewer -> Mac not yet. Adds format-name/echo diagnostics (no data).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 23:14:13 +08:00
VallierDevandClaude Opus 5.5 aafc17e626 fix(ui): keep GTK windows on the light Adwaita theme (#43)
The CSS hard-codes a light palette; under a dark system theme unstyled
labels became white on white.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 22:45:34 +08:00
VallierDevandClaude Opus 5.5 cd6df7f03f fix(viewer): pick -fps_mode or -vsync by probing ffmpeg; Release v0.2.4
FFmpeg 9 removed -vsync, so v0.2.2/v0.2.3 decoders exited at start and every
frame failed. Verified against the official Mac host on FFmpeg 9.0.2.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 22:38:33 +08:00
VallierDevandClaude Opus 5.5 2815a01569 feat(viewer): remove a device from the account (unbind)
POST /api/v1/device/{id}/unbind, the path the official Windows host and Mac
viewer use for 「删除设备」. Verified live on a disposable test device; the
shared-device path (/api/v1/device/share/{id}/unbind) comes from strings only.
CLI: uuremote-viewer unbind DEVICE [--shared]; launcher: 更多工具 → 删除设备
with a confirmation dialog.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 22:26:14 +08:00
VallierDevandClaude Opus 5.5 664c96941c Release v0.2.3
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 20:25:25 +08:00
wanglz111 8967dfdd4b fix(viewer): reuse the SDL window for clipboard to stop GNOME Dock churn (#41)
* Fix viewer Dock churn by reusing SDL clipboard window

* Handle clipboard text boundaries and read only after changes

* Keep SDL clipboard scoped to the focused desktop and validate CI call sites
2026-10-17 20:24:07 +08:00
VallierDevandClaude Opus 5.5 c38b41b543 docs: v0.2.2 notes include #40 (Mac keycodes, FFmpeg 4.4 decoding)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 18:59:18 +08:00
wanglz111 3d4d8d1d64 fix(viewer): use native keycodes for Mac targets; ffmpeg 4.4 compatible decoding (#40)
* fix(viewer): send native keycodes to Mac targets

* fix(viewer): reject unknown keyboard target platforms

* fix(viewer): support FFmpeg 4.4 passthrough decoding
2026-10-17 18:58:57 +08:00
VallierDevandClaude Opus 5.5 843e4aa342 Release v0.2.2
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 18:57:22 +08:00
VallierDevandClaude Opus 5.5 73c1d9b54d viewer: also send ClipboardTextChangeRequest for official Windows hosts
The official Windows host only acknowledges the rich format-list offer
and never asks for the data. Each local change now also sends RpcRequest
case 10 ClipboardTextChangeRequest with the text (its
handle_text_change_request -> notifyReceiveText path); the host answers
case 6 err=1 (CB_SUCCEEDED), logged as a status only. This project's
host ignores case 10 and keeps using the rich offer. Note: on the tested
Windows host the acknowledged text still did not reach the desktop
clipboard; under investigation.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 18:56:26 +08:00
VallierDevandClaude Opus 5.5 432593083e viewer: terminal on the official Windows host
Live against an official Windows host (PowerShell via ConPTY):
- Its rpc_main.proto has no check_env (requests end at 25), so a missing
  answer within 3 s no longer aborts; a negative answer still does.
- OPEN carries "option":"none"; the host rejects an OPEN without it
  ("terminal open: missing 'option' field", kError 1004). This
  project's host ignores the key.
- The host answers OPEN with {code,message}, header session 0, and keeps
  one terminal per connection as session 0; a nonzero header still
  overrides the body for this project's host.
- Echo requests whose SimpleAction omits the default action 0 are
  answered too.
Create/reattach on this project's host unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 18:36:45 +08:00
VallierDevandClaude Opus 5.5 e5e6a04b5d viewer: port mapping through the official Windows host
The official Windows host answers every PortMappingFrame with session_id
1 regardless of the viewer's value, so the random 64-bit session never
matched and every stream ended with a SYN timeout. One port-mapping peer
carries one session; use 1 (this project's host echoes it). Stream
failures and unmatched frames are now logged with reasons and wire types
only. Verified: HTTP through the official Windows host and this
project's host.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 17:52:05 +08:00
VallierDevandClaude Opus 5.5 23aec299bb viewer: upload to and download from the official Windows host
Live against an official Windows host:
- Uploads split Windows targets (C:\dir\name) on either separator and
  keep the host's separator for the directory; '/x' keeps the root.
- The upload request carries FileInfo.modified_time, the zlib FileList in
  list_data (field 6) and a task_unique_id, as official viewers with the
  list-compress feature do; the Windows host rejected the inline-only
  request with code 2. The inline copy stays for older hosts.
- Downloads accept blocks up to 256 KiB: the Windows host sent a 64 KiB
  file as one block, which the old 32 KiB limit rejected with code 3.
64 KiB and 1 MiB round trips matched by sha256 on the Windows host and
on this project's host.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 17:33:34 +08:00
VallierDevandClaude Opus 5.5 9a91000e0a docs: H.265 and 4:4:4 tested live against this project's host
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 17:17:19 +08:00
VallierDevandClaude Opus 5.5 693660ed85 viewer: decode H.265 and request 4:4:4
Offer H.265 (RFC 7798) next to H.264 and list H.265 and 4:4:4 decoder
caps; the host picks the codec. Depacketize single NAL, AP and FU units
with the existing reorder/loss handling and decode with the ffmpeg CLI
(-f hevc). UU_VIEWER_CHROMA=444 requests true color via
CaptureSettingRequest field 7 and follows CaptureSettingSync;
UU_VIEWER_CODEC=h264 keeps H.264 only.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 17:11:45 +08:00
VallierDevandClaude Opus 5.5 5c5958115a viewer: keep the open device page usable across list refreshes
The device list refresh (startup and every 30 s) reset the selected
device to none while its page stayed open, so every button on that page
silently did nothing. Re-select the same device by id after a refresh.
The replace-session confirmation now uses Chinese button labels like the
other dialogs instead of locale-dependent OK/Cancel.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 17:08:46 +08:00
VallierDevandClaude Opus 5.5 1054af0950 Release v0.2.1
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 16:31:41 +08:00
VallierDevandClaude Opus 5.5 94fd3c2fa7 fix(actions): never wait for a polkit prompt on remote reboot/shutdown
Without polkit permission (for example no active local session)
systemctl reboot/poweroff waited for an authentication dialog on the
controlled screen. Pass --no-ask-password so the action fails and is
logged instead. README: the viewer's terminal session list, reboot and
shutdown, and its Wayland window/clipboard were tested in a VM.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 16:31:41 +08:00
VallierDevandClaude Opus 5.5 1b10a22c8c Release v0.2.0
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 15:41:51 +08:00
809ce1697d Add the experimental native viewer (uuremote-viewer) (#36)
* Add the experimental native viewer (uuremote-viewer)

A Linux viewer/controller for UU Remote hosts, built separately with
--features native-viewer,viewer-sdl; the host build and behaviour are
unchanged.

- Cloud join by device and remote assistance by share ID + code (code
  via stdin only), WebRTC offer side, SDL desktop window with ffmpeg CLI
  H.264 decoding, Opus sound, keyboard/mouse, view-only mode, text
  clipboard on TEXT_DATA_CHANNEL.
- Tools: file browser/transfer (zero- and one-based download blocks),
  terminal and terminal session list, port mapping (127.0.0.1 only),
  reboot/shutdown; tools reuse the desktop peer while one is open.
- GTK launcher with device list and tool windows.
- CI builds and tests the viewer; release tarballs include it.

Logs carry field numbers, sizes and states only.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

* ci: install the ffmpeg CLI for the viewer audio tests

Co-Authored-By: Claude Opus 5.5 <[email protected]>

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-17 15:41:20 +08:00
105 changed files with 10161 additions and 167 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
+71 -1
View File
@@ -6,6 +6,16 @@ on:
pull_request:
jobs:
test-macos-ssh-paste:
runs-on: macos-latest
steps:
- uses: actions/checkout@v4
- run: python3 -m unittest discover -s contrib/macos-ssh -p 'test_*.py' -v
- name: Test file-URL clipboard reader on a private pasteboard
run: |
swiftc -O contrib/macos-ssh/clipboard-files.swift -o "$RUNNER_TEMP/clipboard-files"
"$RUNNER_TEMP/clipboard-files" --self-test
test:
runs-on: ubuntu-22.04
steps:
@@ -14,10 +24,39 @@ 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
steps:
- uses: actions/checkout@v4
- name: Install build dependencies (X11 + GTK + SDL2 + ffmpeg CLI for the viewer)
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 ffmpeg
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- run: cargo test --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
- run: cargo build --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
test-wayland:
runs-on: ubuntu-24.04
@@ -32,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
@@ -58,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
+94 -7
View File
@@ -6,32 +6,119 @@ on:
permissions:
contents: write
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
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
# 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 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:
needs: release
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v4
- uses: docker/login-action@v3
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- uses: docker/build-push-action@v6
with:
context: docker
build-args: VERSION=${{ github.ref_name }}
push: true
tags: |
ghcr.io/vallierdev/uu-remote-linux:${{ github.ref_name }}
ghcr.io/vallierdev/uu-remote-linux:latest
+12 -3
View File
@@ -7,8 +7,9 @@ This file is written for large language model agents (Claude Code, Codex, Cursor
## 1. What this project is
- An **unofficial Linux host** for NetEase UU Remote (网易 UU 远程). The official Mac / Windows / mobile
clients connect to it and control the Linux desktop. There is no viewer/controller side here.
- One Rust binary, `uuremote-server` (Cargo package `uu-remote-linux`), plus small C engines in `c_engine/`
clients connect to it and control the Linux desktop. An experimental Linux viewer/controller, `uuremote-viewer`
(`src/viewer_main.rs`, `src/viewer/`, feature `native-viewer`), connects to other hosts with the same protocol.
- One host binary, `uuremote-server` (Cargo package `uu-remote-linux`), plus small C engines in `c_engine/`
compiled by `build.rs`. No Wine, no NetEase binaries.
- The host registers with the UU cloud as a **Windows PC** (`x-param-plat=1`) so the official clients accept it.
- License GPL-3.0. Not affiliated with NetEase.
@@ -50,6 +51,7 @@ cargo test # unit tests (macOS builds use C st
cargo build --release # X11 host
cargo build --release --features wayland # + Hyprland/wlroots
cargo build --release --features wayland,portal # + GNOME/KDE Wayland via xdg-desktop-portal
cargo build --release --features native-viewer,viewer-sdl --bin uuremote-viewer # viewer (needs libsdl2-dev)
```
- `build.rs` links X11/Xext/Xtst/Xfixes and `dl` (PAM is loaded at runtime with `dlopen`), and builds the GTK3
@@ -114,6 +116,9 @@ 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 |
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. The config is re-read
@@ -140,12 +145,16 @@ 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 |
| `src/assist.rs`, `c_engine/assist_window.c` | remote assistance (guest + account) and the unified GTK main window (assist + account/QR card) |
| `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
+32 -1
View File
@@ -2050,6 +2050,30 @@ dependencies = [
"untrusted 0.9.0",
]
[[package]]
name = "sdl2"
version = "0.37.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b498da7d14d1ad6c839729bd4ad6fc11d90a57583605f3b4df2cd709a9cd380"
dependencies = [
"bitflags 1.3.2",
"lazy_static",
"libc",
"sdl2-sys",
]
[[package]]
name = "sdl2-sys"
version = "0.37.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "951deab27af08ed9c6068b7b0d05a93c91f0a8eb16b6b816a5e73452a43521d3"
dependencies = [
"cfg-if",
"libc",
"pkg-config",
"version-compare",
]
[[package]]
name = "sdp"
version = "0.6.2"
@@ -2717,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.1.31"
version = "0.2.18"
dependencies = [
"async-trait",
"base64 0.22.1",
@@ -2735,6 +2759,7 @@ dependencies = [
"qrcode",
"rand 0.8.8",
"reqwest",
"sdl2",
"serde",
"serde_json",
"sha2",
@@ -2761,6 +2786,12 @@ version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "version-compare"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29"
[[package]]
name = "version_check"
version = "0.9.5"
+14 -1
View File
@@ -1,7 +1,8 @@
[package]
name = "uu-remote-linux"
version = "0.1.31"
version = "0.2.18"
edition = "2021"
default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"]
description = "Unofficial Linux host for NetEase UU Remote: control a Linux desktop from the official clients"
readme = "README.md"
@@ -13,12 +14,22 @@ repository = "https://github.com/VallierDev/uu-remote-linux"
name = "uuremote-server"
path = "src/main.rs"
[[bin]]
name = "uuremote-viewer"
path = "src/viewer_main.rs"
required-features = ["native-viewer"]
[features]
default = []
native-viewer = []
viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"]
viewer-sdl = ["native-viewer", "dep:sdl2"]
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"]
@@ -47,6 +58,8 @@ env_logger = "0.11"
ffmpeg-next = { version = "6.1", optional = true, default-features = false, features = ["codec", "format", "device", "software-scaling", "software-resampling"] }
x11rb = { version = "0.13", features = ["damage", "shm", "allow-unsafe-code"], optional = true }
sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] }
[build-dependencies]
cc = "1.0"
+155 -11
View File
@@ -1,4 +1,4 @@
# uu-remote-linux · Unofficial Linux host for NetEase UU Remote
# uu-remote-linux · Unofficial Linux host and viewer for NetEase UU Remote
[简体中文](README.md) | **English**
@@ -7,13 +7,21 @@
> NetEase UU Remote (网易 UU 远程) is a great remote-desktop tool, but there is no Linux version on its
> official website. So, with the help of Claude and Codex, I wrote this open-source Linux host: install it,
> and you can control your Linux machine from the official Mac / Windows / mobile UU Remote clients.
> It now also ships an **experimental Linux viewer**, `uuremote-viewer`, that controls official Windows / Mac hosts or this
> project's host from Linux (desktop, file transfer, terminal, port mapping, remote assistance; see
> [below](#experimental-native-viewer-uuremote-viewer)).
> Desktop-less **Synology / NAS** boxes can run it in Docker: [deployment guide](docs/deploy-nas-docker.md#english), image
> [`ghcr.io/vallierdev/uu-remote-linux`](https://github.com/VallierDev/uu-remote-linux/pkgs/container/uu-remote-linux).
>
> This is a personal hobby project. **It is not affiliated with NetEase and is not an official client.**
> If NetEase considers this project infringing or inappropriate, please DM me on X
> **[@ai_fengshou](https://x.com/ai_fengshou)** and I will take it down right away.
<p align="center"><img src="docs/images/viewer-window.png" width="720" alt="Linux viewer launcher: device list (device names redacted)"></p>
<p align="center"><sub>Linux viewer: device list (device names redacted)</sub></p>
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Host main window: remote assistance and account"></p>
<p align="center"><sub>The QR login window shown on first run (QR code blurred). The UI is in Chinese, like the official app.</sub></p>
<p align="center"><sub>Linux host main window: remote assistance and account (device ID, code and account redacted). The UI is in Chinese, like the official app.</sub></p>
<!-- Screenshot placeholder: the Linux desktop controlled from the official client. Take your own
screenshot, remove account/device details and NetEase logos, save it as docs/images/remote-desktop.png
@@ -45,7 +53,7 @@
| Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked |
| Lock after remote session | Stored on the host, so it still applies after reconnecting |
| Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards |
| System actions | Lock, show desktop, task manager (system monitor), reboot, shut down |
| System actions | Lock, show desktop, task manager (system monitor), reboot, shut down (via `systemctl`; needs polkit permission for the user, usually an active local graphical session; without it the action fails and is logged, no password dialog appears on the host) |
| Port mapping | The official "port mapping" tool: forwards a local port on the viewer to an address reachable from the Linux host (e.g. 127.0.0.1:22); `UU_PORT_MAPPING=0` disables it |
| Reconnects | Every tool window has its own connection; they do not disturb each other |
| Headless servers | Goes online without a monitor with terminal, file transfer and port mapping; an Xvfb virtual desktop gives a full remote desktop (see below) |
@@ -65,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.
@@ -94,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 |
@@ -107,10 +125,43 @@ mapping and hardware acceleration remain unverified. This is not zero-copy VAAPI
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist |
| Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
| Acting as a viewer (controlling other machines from Linux) | Out of scope |
| Acting as a viewer (controlling other machines from Linux) | 🧪 Experimental `uuremote-viewer`, see [below](#experimental-native-viewer-uuremote-viewer) |
## 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
@@ -217,6 +268,7 @@ Optional launcher icon:
```sh
install -Dm644 contrib/desktop/uu-remote-linux.svg ~/.local/share/icons/hicolor/scalable/apps/uu-remote-linux.svg
install -Dm644 contrib/desktop/uu-remote-linux.desktop ~/.local/share/applications/uu-remote-linux.desktop
install -Dm644 contrib/desktop/uu-remote-linux-viewer.desktop ~/.local/share/applications/uu-remote-linux-viewer.desktop
```
Verified with the official Mac viewer: guest connections, wrong-code rejection, code rotation, switching assistance off,
@@ -230,6 +282,17 @@ service and run `loginctl enable-linger $USER`, so the systemd user manager (wit
starts at boot without a login. The viewer's remote desktop keeps showing "connecting" in this mode; that is expected.
Log in once with `uuremote-server login --no-gui` (QR in the terminal).
**Synology / NAS (Docker)**: run headless mode in a container on a desktop-less NAS (file transfer, terminal, port
mapping): image [`ghcr.io/vallierdev/uu-remote-linux`](https://github.com/VallierDev/uu-remote-linux/pkgs/container/uu-remote-linux),
see the [NAS deployment guide](docs/deploy-nas-docker.md#english). Verified on Synology DSM 7.3 (x86_64).
**Paste files from a Mac terminal**: when using Ghostty over UU's SSH port mapping,
the optional [Mac SSH paste companion](contrib/macos-ssh/README.md) uploads files
copied in Finder before inserting their remote paths. Text and mouse reports pass
through. Ghostty's title and progress bar show upload progress, transferred size,
speed and elapsed time. It does not change the official UU terminal; folders, drag-and-drop and
raw screenshot clipboard data are not supported.
**Virtual desktop**: for a full remote desktop, run a desktop session (Xfce recommended) on an Xvfb screen:
```sh
@@ -258,15 +321,20 @@ 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 |
| `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution |
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
| `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`.
@@ -328,13 +396,22 @@ 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.
`UU_VIDEO_CODEC=h264` forces H.264. 8-bit; true color 4:4:4 uses hevc_nvenc `rext` / libx265 `main444-8`.
Verified with the official Mac viewer on an RTX 3090 (hevc_nvenc, including 4:4:4); libx265, hevc_vaapi and
other viewers are not hardware-verified.
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
one "frame" and the IRAP gate then rejects all of them: the connection stalls at "transferring" while the host
sends about 12 kbit/s. `UU_VIDEO_CODEC=h265` selects H.265 explicitly for A/B diagnosis.
### VAAPI (opt-in / 显式启用)
@@ -347,6 +424,13 @@ with a warning. Accepted on Intel UHD 770 (iHD) with the default FFmpeg process
viewer (presets, fps, scaling, reconnect; no fallback, ~40% less CPU than libx264). AMD and the `inproc-av`
VAAPI path are not hardware-verified.
The default VAAPI VBV buffer (100-500 kbit) squeezes keyframes hard at high resolution: on a 2560x1440
H.264 VAAPI stream capped at 30 Mbit/s the first IDR measured 59,910 bytes and the picture blurred at
every GOP before sharpening back. `UU_VAAPI_BUFFER_MS=250` (buffer = bitrate cap x ms/1000) restored that
first IDR to 142,397 bytes and raised the worst-frame Y-SSIM from 0.9492 to 0.9933 without raising the
average bitrate. Off by default; unset or out of the 10-1000 ms range keeps the old buffer. Larger
keyframes can queue briefly on a weak link, so start at 250 ms.
### Virtual audio / 虚拟声卡
The viewer's 静音运行 switch creates the null sink `uu-remote-sink`,
@@ -380,13 +464,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`.
@@ -403,3 +491,59 @@ This capability is broad: it applies to the whole network-facing process and can
The VM GDM greeter capture was solid black (failed visual acceptance); lock/greeter support and Intel/AMD hardware remain unverified. Use uinput for input; clipboard
is unavailable without a desktop session. No default release behavior changes.
No official "no desktop" error code was found for headless desktop offers, so the existing offer behavior is retained.
## Experimental native viewer (uuremote-viewer)
`uuremote-viewer` is a Linux **viewer/controller**: it connects to and controls other devices on your UU account (official Windows / Mac
hosts or this project's Linux host), and can start remote assistance with someone's device ID and code. It is experimental and
separate from the host `uuremote-server`; the default host build and behaviour are unchanged.
**Get it**: release tarballs include `uuremote-viewer` (x86_64) from this version on. Runtime needs GTK3, SDL2 (Ubuntu/Debian:
`libsdl2-2.0-0`) and the `ffmpeg` command; SDL desktop windows synchronize text clipboard directly on Wayland/X11 without extra clipboard tools; the terminal needs a local
terminal emulator (`TERMINAL` selects one). From source: `sudo apt install libsdl2-dev`, then
`cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`.
SDL clipboard access reuses the desktop window to avoid temporary-window Dock churn on GNOME Wayland (#37).
Synchronization runs only while that window is focused and keeps the 30 KiB text limit. Selections without a supported
text format are skipped; empty-text detection depends on the SDL2 backend. Builds without SDL retain the command backend.
SDL2 reads selections synchronously, so a slow selection owner can temporarily block the window; the bridge timeout cannot interrupt it.
GNOME-to-official-Mac bidirectional clipboard synchronization is still unverified; this change does not resolve host compatibility.
**Use**:
- `uuremote-viewer login`: QR login (reuses the sibling `uuremote-server` login window; `--no-gui` prints a terminal QR). The viewer
shares `~/.config/uuremote/config.json` with the host (`UU_CONFIG` selects another), so it **cannot connect to a host on the same
machine with the same identity**; other devices are fine.
- `uuremote-viewer ui`: launcher listing your devices: desktop, view-only, files, terminal, port mapping, reboot/shutdown, assistance.
- CLI: `connect DEVICE false - echo legacy [--view-only]` (desktop), `files DEVICE ls|get|put …`, `terminal DEVICE [SESSION]`,
`terminal-ui DEVICE NAME`, `portmap DEVICE LOCAL_PORT HOST PORT` (listens on 127.0.0.1 only), `power DEVICE reboot|shutdown`, `unbind DEVICE` (remove a device from the account; also under "More tools" in the launcher),
`assist CONNECT_ID` (the code is read from one stdin line, never an argument). See `uuremote-viewer --help`.
- Ctrl+Alt+F in the desktop window opens the files window on the same connection. `UU_VIEWER_AUDIO=0` disables sound,
`UU_VIEWER_CLIPBOARD=0` the clipboard, `UU_VIEWER_VIEW_ONLY=1` input; `UU_VIEWER_FFMPEG` selects the ffmpeg binary.
- Desktop offers H.264 / H.265; the host chooses the codec. `UU_VIEWER_CODEC=h264` limits both SDP and decoder capabilities to H.264.
The default request stays 4:2:0; `UU_VIEWER_CHROMA=444` requests true color (4:4:4) after CONTROL opens. The host may fall back to
4:2:0, as reported by CaptureSettingSync. FFmpeg converts either chroma format to RGB24 for display.
Mac targets use native macOS keycodes; Windows / Linux targets retain Windows VK. Keys follow physical positions, without
automatically translating Ctrl to Command; on a Mac target the PC Super / Windows key acts as Command. Only verified target
platform values 1 (Windows / this project's Linux host) and 4 (Mac) are accepted; unknown values fail explicitly. Account
connections look up the selected device only when the platform is absent; assistance requires it in the join response.
View-only sessions skip this lookup. Media keys and some JIS-specific keys are not mapped; Mac platform detection for remote
assistance and ISO / JIS keyboards have not been tested live.
**Tested live** (author's setup, not full acceptance):
| Feature | Official Windows host | Official Mac host | This project's Linux host |
|---|---|---|---|
| Desktop video (H.264) | ✅ | ✅ | ✅ |
| H.265, 4:4:4 true color | — | — | ✅ (VM, libx265) |
| Keyboard, mouse | ✅ | — | ✅ |
| File list / download / upload | ✅ | — | ✅ |
| Port mapping, terminal | ✅ (PowerShell terminal) | — | ✅ |
| Clipboard (text) | host → viewer only; viewer → Windows not applied yet | — | ✅ both ways (VM) |
| Sound | unconfirmed (no audio packets while the host is silent) | — | ✅ (VM) |
| Remote assistance (ID + code) | — | — | ✅ (VM, guest host) |
| Terminal session list (create, double-click reattach, end) | — | — | ✅ (VM) |
| Reboot, shutdown | — | — | ✅ (VM) |
| Wayland desktop window and clipboard | — | — | ✅ Hyprland, KDE; GNOME window works; clipboard switched to SDL in v0.2.3 (#37, final revision not re-verified live) |
"—" = not tested yet. Only use reboot/shutdown on machines you can restart. **Not tested live**: H.265 / 4:4:4 with official hosts, multiple monitors. Logs carry field
numbers, sizes and states only, never keystrokes, clipboard or file contents, codes or credentials.
+143 -12
View File
@@ -1,4 +1,4 @@
# uu-remote-linux · UU 远程 Linux 被控端(非官方)
# uu-remote-linux · UU 远程 Linux 被控端 + 控制端(非官方)
**简体中文** | [English](README.en.md)
@@ -6,12 +6,18 @@
>
> 网易 UU 远程非常好用,但官网一直没有 Linux 版本。于是我借助 Claude 和 Codex,写了这个开源的 Linux 被控端:
> 装上之后,就能用官方的 Mac / Windows / 手机客户端远程控制你的 Linux 电脑。
> 现在还附带一个**实验性 Linux 控制端** `uuremote-viewer`:在 Linux 上用 UU 账号远控官方 Windows / Mac 被控端或本项目主机
> (桌面、文件传输、终端、端口映射、远程协助,详见[下文](#实验性原生控制端uuremote-viewer))。
> 没有桌面的**群晖 / NAS** 也能用 Docker 部署:[部署指南](docs/deploy-nas-docker.md),镜像 [`ghcr.io/vallierdev/uu-remote-linux`](https://github.com/VallierDev/uu-remote-linux/pkgs/container/uu-remote-linux)。
>
> 这是个人兴趣项目,**与网易无关,也不是官方客户端**。如果网易认为本项目侵权或有不妥,
> 请在推特私信我 **[@ai_fengshou](https://x.com/ai_fengshou)**,我会第一时间自行下架。
<p align="center"><img src="docs/images/viewer-window.png" width="720" alt="Linux 控制端启动窗口:设备列表(设备名已打码)"></p>
<p align="center"><sub>Linux 控制端:设备列表(设备名已打码)</sub></p>
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Linux 主机主窗口:远程协助与账号"></p>
<p align="center"><sub>首次运行时弹出的扫码登录窗口(二维码已打码)</sub></p>
<p align="center"><sub>Linux 被控端主窗口:远程协助与账号(设备 ID、验证码和账号已打码)</sub></p>
<!-- 截图占位:在官方客户端里远控 Linux 桌面的效果图。请自行截图并去掉账号、设备名等信息后放到
docs/images/remote-desktop.png,再取消下面这行的注释。注意不要截入网易的图标和品牌素材。 -->
@@ -41,7 +47,7 @@
| 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 |
| 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 |
| 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 |
| 系统操作 | 锁屏、显示桌面、任务管理器(系统监视器)、重启、关机 |
| 系统操作 | 锁屏、显示桌面、任务管理器(系统监视器)、重启、关机(通过 `systemctl`,需要当前用户有 polkit 权限:通常本机有活动的图形会话即可;没有权限时直接失败并记日志,不会在被控端弹出密码框) |
| 端口映射 | 官方「端口映射」工具:把控制端本地端口转发到 Linux 能访问到的地址(如 127.0.0.1:22);`UU_PORT_MAPPING=0` 可关闭 |
| 多次重连 | 每个工具窗口独立连接,互不影响 |
| 无头服务器 | 没有显示器也能上线,提供终端、文件传输和端口映射;也可以用 Xvfb 虚拟桌面提供完整远程桌面(见下文) |
@@ -59,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 逻辑尺寸仅用于本地输入映射。
@@ -81,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 | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 |
@@ -94,10 +111,42 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
| 作为控制端(在 Linux 上控制别的电脑) | 不在本项目范围 |
| 作为控制端(在 Linux 上控制别的电脑) | 🧪 实验性 `uuremote-viewer`,见[下文](#实验性原生控制端uuremote-viewer) |
## 安装
### 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
@@ -193,6 +242,7 @@ X11 默认继续用 XTest,因为它能正确处理网络延迟下按住不放
```sh
install -Dm644 contrib/desktop/uu-remote-linux.svg ~/.local/share/icons/hicolor/scalable/apps/uu-remote-linux.svg
install -Dm644 contrib/desktop/uu-remote-linux.desktop ~/.local/share/applications/uu-remote-linux.desktop
install -Dm644 contrib/desktop/uu-remote-linux-viewer.desktop ~/.local/share/applications/uu-remote-linux-viewer.desktop
```
验证情况:访客身份下的连接、错误验证码拒绝、用完换码、关闭后不可连接、登录与退出登录的切换,已用官方 Mac 客户端实测通过。
@@ -204,6 +254,16 @@ install -Dm644 contrib/desktop/uu-remote-linux.desktop ~/.local/share/applicatio
再执行 `loginctl enable-linger $USER`,这样开机后不用登录,systemd 用户服务(以及 `XDG_RUNTIME_DIR`、用户 D-Bus)也会自动启动。
无头模式下控制端点「远程桌面」会一直显示正在连接,这是正常的。首次登录用 `uuremote-server login --no-gui` 在终端里扫码。
**群晖 / NAS(Docker)**:没有桌面的 NAS 可以用容器运行无头模式(文件传输、终端、端口映射)。
镜像 [`ghcr.io/vallierdev/uu-remote-linux`](https://github.com/VallierDev/uu-remote-linux/pkgs/container/uu-remote-linux),
**部署步骤见 [群晖 / NAS 部署指南](docs/deploy-nas-docker.md)**。已在群晖 DSM 7.3(x86_64)上实测三项功能。
**Mac 终端粘贴文件**:使用 Ghostty 通过 UU 端口映射连接 SSH 时,可安装
[Mac SSH 粘贴助手](contrib/macos-ssh/README.md)。在 Finder 复制文件后按 Command-V,
助手先通过同一个 SSH 别名上传文件,再插入服务器路径;普通文本和鼠标报告正常透传。
Ghostty 标题栏和进度条显示上传进度、已传大小、速度和耗时。
这是可选的 Mac 端工具,不会改变官方 UU 内置终端;暂不支持文件夹、拖放或原始截图剪贴板。
**虚拟桌面**:需要完整的远程桌面时,用 Xvfb 创建一块虚拟屏幕,再在上面跑一个桌面环境(推荐 Xfce):
```sh
@@ -231,15 +291,20 @@ 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 |
| `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 |
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
| `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`。
@@ -293,11 +358,17 @@ 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)实机验收;libx265、hevc_vaapi 及其他客户端尚未实机验证。
已用官方 Mac 客户端在 RTX 3090(hevc_nvenc,含 4:4:4)实机验收;`hevc_vaapi` 配官方 Android 客户端也已实机验收
(Intel Alder Lake-P / iHD,2560×1440 全程硬件编码,客户端 58 fps 解码、约 10 ms 延迟);`libx265` 仍未经控制端验收。
HEVC 的访问单元按 RFC 7798 的图片边界切分,不依赖 AUD:`hevc_vaapi` 带 `-aud 1` 时只在 IRAP 处写 AUD,并把其余
画面从码流里丢掉,读取端按 AUD 切分就会把整个 GOP 当成一帧,再被 IRAP 门控全部拒绝——对外表现为连接停在
「正在传输画面」,而主机侧只有约 12 kbit/s。`UU_VIDEO_CODEC=h265` 可显式选中 H.265,便于对照排查。
### VAAPI 硬件编码(显式启用)
@@ -307,6 +378,12 @@ flowchart LR
VBR 使用控制端码率预设及 CQ 对应的最小 QP,无 B 帧、async depth=1,并保留现有 GOP/VFR 规则。
Intel 核显(UHD 770,iHD 驱动)已实机验收:默认的外部 FFmpeg 管线用官方 Mac 控制端测试了各档画质、帧率、缩放和重连,全程硬件编码、无回退,CPU 占用比 libx264 低约 40%。**AMD 显卡和 `--features inproc-av` 管线的 VAAPI 尚未实机验证。**
高分辨率下 VAAPI 的默认 VBV 缓冲(100–500 kbit)会把关键帧压得过狠:2560×1440 H.264 VAAPI、30M
上限、静止画面上实测首个 IDR 只有 59,910 字节,画面每隔一个 GOP 糊一下再慢慢恢复。设
`UU_VAAPI_BUFFER_MS=250`(按 `码率上限 × 毫秒 / 1000` 放大 VBV)后首个 IDR 为 142,397 字节,
最低帧 Y-SSIM 从 0.9492 升到 0.9933,平均码率没有上升。默认不启用,未设置或超出 10–1000 ms
仍用原缓冲;代价是关键帧变大,弱网下可能出现瞬时排队,建议从 250 ms 试起。
### 静音运行与虚拟声卡
控制端开启「静音运行」后,程序创建虚拟输出 `uu-remote-sink`,保存原默认输出,
@@ -335,7 +412,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。
@@ -356,6 +434,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`。
@@ -370,3 +452,52 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
当前仅为线性帧缓冲原型:VM 的 GDM 截图仍是黑屏,**没有通过登录界面视觉验收**,不承诺锁屏可用。
键鼠需 uinput;没有桌面会话时不提供剪贴板。
无头模式下桌面连接没有找到官方的「无桌面」错误码,因此保持原有 offer 行为。
## 实验性原生控制端(uuremote-viewer)
`uuremote-viewer` 是 Linux 上的**控制端**:用你的 UU 账号连接并控制其他设备(官方 Windows / Mac 被控端,或本项目的 Linux 主机),
也可以凭对方的设备 ID 和验证码发起远程协助。它是实验性功能,与主机 `uuremote-server` 相互独立,默认主机构建和行为不变。
**获取**:Release 包从本版本起附带 `uuremote-viewer`(x86_64)。运行时需要 GTK3、SDL2(Ubuntu/Debian:`libsdl2-2.0-0`)和
`ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。
从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。仅在桌面窗口获得焦点时同步,
保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。
SDL2 同步读取选择内容,慢速的剪贴板提供者可能暂时阻塞窗口,桥接超时无法中断该原生调用。
GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不解决被控端兼容问题。
**使用**:
- `uuremote-viewer login`:扫码登录(复用同目录下 `uuremote-server` 的登录窗口;`--no-gui` 为终端二维码)。控制端与主机共用
`~/.config/uuremote/config.json`(可用 `UU_CONFIG` 另指定),因此**不能用同一身份连接本机上的主机**;控制其他设备不受影响。
- `uuremote-viewer ui`:启动窗口,列出账号下的设备,可进入桌面、只看模式、文件传输、终端、端口映射、重启/关机、远程协助。
- 命令行:`connect DEVICE false - echo legacy [--view-only]`(桌面)、`files DEVICE ls|get|put …`、`terminal DEVICE [SESSION]`、
`terminal-ui DEVICE NAME`、`portmap DEVICE LOCAL_PORT HOST PORT`(只监听 127.0.0.1)、`power DEVICE reboot|shutdown`、`unbind DEVICE`(从账号删除设备,启动窗口「更多工具」里也有)、
`assist CONNECT_ID`(验证码从 stdin 读取一行,不能作为参数传入)。`uuremote-viewer --help` 查看全部参数。
- 桌面窗口中按 Ctrl+Alt+F 打开文件窗口(复用同一连接)。`UU_VIEWER_AUDIO=0` 关闭声音,`UU_VIEWER_CLIPBOARD=0` 关闭剪贴板,
`UU_VIEWER_VIEW_ONLY=1` 只看不控,`UU_VIEWER_FFMPEG` 指定 ffmpeg 路径。
- 桌面同时提供 H.264 / H.265,由主机协商选择;`UU_VIEWER_CODEC=h264` 将 SDP 和解码能力限制为 H.264。
默认请求 4:2:0;`UU_VIEWER_CHROMA=444` 在 CONTROL 打开后请求真彩(4:4:4)。主机可能回落到 4:2:0,
以 CaptureSettingSync 回报为准。两种色度均由 FFmpeg 转为 RGB24 显示。
Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。键盘按物理键位置转发,不自动把 Ctrl 改成 Command;
控制 Mac 时,PC 键盘的 Super / Win 键对应 Command。仅接受已验证的目标平台值 1(Windows / 本项目 Linux 主机)和 4(Mac),
未知值会报错,不猜测键码。账号连接缺少平台字段时查询目标设备;远程协助必须由连接响应提供平台。只看模式不需要此识别。
媒体键和部分 JIS 专用键尚未映射;远程协助的 Mac 平台识别及 ISO / JIS 键盘尚未实机验收。
**已实测**(作者环境,非全面验收):
| 功能 | 官方 Windows 被控端 | 官方 Mac 被控端 | 本项目 Linux 主机 |
|---|---|---|---|
| 桌面画面(H.264) | ✅ | ✅ | ✅ |
| H.265、4:4:4 真彩 | — | — | ✅(虚拟机,libx265) |
| 键盘、鼠标 | ✅ | — | ✅ |
| 文件列表 / 下载 / 上传 | ✅ | — | ✅ |
| 端口映射、终端 | ✅(终端为 PowerShell) | — | ✅ |
| 剪贴板(文本) | 仅被控端 → 控制端;控制端 → Windows 未生效 | — | ✅ 双向(虚拟机) |
| 声音 | 未确认(被控端未播放声音时没有音频包) | — | ✅(虚拟机) |
| 远程协助(ID + 验证码) | — | — | ✅(虚拟机,访客主机) |
| 终端会话列表(新建、双击接回、结束) | — | — | ✅(虚拟机) |
| 重启、关机 | — | — | ✅(虚拟机) |
| Wayland 下的桌面窗口与剪贴板 | — | — | ✅ Hyprland、KDE;GNOME 窗口正常,剪贴板已于 v0.2.3 改为 SDL 直连(#37,最终版本未重新实机验收) |
「—」表示尚未测试。重启/关机只应在可以重启的机器上使用。**未实测**:官方被控端的 H.265 / 4:4:4、多显示器。日志只记录字段号、大小和状态,不记录键盘、剪贴板、文件内容、验证码或凭据。
+47 -6
View File
@@ -3,6 +3,8 @@ fn main() {
println!("cargo:rerun-if-changed=c_engine/x11_engine.c");
println!("cargo:rerun-if-changed=c_engine/clipboard.c");
println!("cargo:rerun-if-changed=c_engine/assist_window.c");
println!("cargo:rerun-if-changed=c_engine/viewer_window.c");
println!("cargo:rerun-if-changed=c_engine/viewer_tools.c");
println!("cargo:rerun-if-changed=c_engine/pam_check.c");
println!("cargo:rerun-if-env-changed=UU_NO_GTK");
println!("cargo:rustc-check-cfg=cfg(uu_gtk)");
@@ -36,7 +38,7 @@ fn main() {
match (std::env::var_os("UU_NO_GTK").is_none()).then(|| gtk("--cflags").zip(gtk("--libs"))).flatten() {
Some((cflags, libs)) => {
let mut build = cc::Build::new();
build.file("c_engine/assist_window.c").flag_if_supported("-Wno-deprecated-declarations");
build.file("c_engine/assist_window.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").flag_if_supported("-Wno-deprecated-declarations");
for flag in cflags.split_whitespace() { build.flag(flag); }
build.compile("uu_login_window");
for flag in libs.split_whitespace() {
@@ -48,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");
@@ -74,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}");
@@ -82,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"); }
}
+2
View File
@@ -475,6 +475,8 @@ static void build_window(void) {
static void *ui_main(void *arg) {
(void)arg;
int ok = gtk_init_check(NULL, NULL);
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
if (ok) build_window();
pthread_mutex_lock(&init_lock);
init_state = ok ? 1 : -1;
+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);
+497
View File
@@ -0,0 +1,497 @@
// GTK3 tool windows for the native viewer: file transfer (`files-ui`) and port mapping (`portmap-ui`).
// One tool window per process; desktop files reuse the desktop peer. GTK runs on its own thread; Rust pushes state with g_idle_add and polls commands. Paths and
// names stay inside this window; nothing here logs.
#include <gtk/gtk.h>
#include <pthread.h>
#include <stdatomic.h>
#include <string.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#define QSIZE 64
static char queue[QSIZE][4096];
static int q_head, q_len;
static pthread_mutex_t q_lock = PTHREAD_MUTEX_INITIALIZER;
static atomic_int closed;
static int init_state;
static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
static GtkWidget *window, *toast;
static char remote_name[256];
static void push(const char *cmd) {
pthread_mutex_lock(&q_lock);
if (q_len < QSIZE) { snprintf(queue[(q_head + q_len) % QSIZE], sizeof queue[0], "%s", cmd); q_len++; }
pthread_mutex_unlock(&q_lock);
}
int uu_tools_ui_take(char *out, size_t len) {
pthread_mutex_lock(&q_lock);
int got = q_len > 0;
if (got) { snprintf(out, len, "%s", queue[q_head]); q_head = (q_head + 1) % QSIZE; q_len--; }
pthread_mutex_unlock(&q_lock);
return got;
}
int uu_tools_ui_closed(void) { return atomic_load(&closed); }
static void add_class(GtkWidget *w, const char *cls) { gtk_style_context_add_class(gtk_widget_get_style_context(w), cls); }
static GtkWidget *hbox(int s) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, s); }
static GtkWidget *vbox(int s) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, s); }
static GtkWidget *label(const char *text, const char *cls) { GtkWidget *l = gtk_label_new(text); if (cls) add_class(l, cls); gtk_label_set_xalign(GTK_LABEL(l), 0); return l; }
static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; }
static gboolean hide_toast(gpointer d) { (void)d; gtk_widget_hide(toast); return G_SOURCE_REMOVE; }
static void show_toast(const char *text) { gtk_label_set_text(GTK_LABEL(toast), text); gtk_widget_show(toast); g_timeout_add(3500, hide_toast, NULL); }
static gboolean toast_idle(gpointer d) { show_toast(d); g_free(d); return G_SOURCE_REMOVE; }
void uu_tools_ui_toast(const char *text) { g_idle_add(toast_idle, g_strdup(text)); }
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); atomic_store(&closed, 1); return TRUE; }
static const char *css =
"window { background: #f5f6f8; }\n"
".title { font-size: 22px; font-weight: bold; color: #111827; }\n"
".tag { background: #e5e7eb; color: #4b5563; border-radius: 6px; padding: 2px 8px; }\n"
".tag.remote { background: #d1fae5; color: #047857; }\n"
".card { background: white; border: 1px solid #e5e7eb; border-radius: 10px; padding: 8px; }\n"
".section { font-size: 17px; font-weight: bold; }\n"
".toast { background: rgba(17,24,39,0.88); color: white; border-radius: 8px; padding: 10px 18px; }\n"
".primary { background-image: none; background-color: #10b981; color: white; border: none; }\n"
".empty { color: #6b7280; font-size: 15px; }\n"
".online { color: #10b981; }\n";
static GtkWidget *frame(const char *title, GtkWidget **content) {
GtkCssProvider *p = gtk_css_provider_new(); gtk_css_provider_load_from_data(p, css, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(p), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), title);
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
GtkWidget *overlay = gtk_overlay_new(); *content = vbox(14);
gtk_container_set_border_width(GTK_CONTAINER(*content), 22);
gtk_container_add(GTK_CONTAINER(overlay), *content);
toast = label("", "toast"); gtk_widget_set_halign(toast, GTK_ALIGN_CENTER); gtk_widget_set_valign(toast, GTK_ALIGN_END);
gtk_widget_set_margin_bottom(toast, 30); gtk_widget_set_no_show_all(toast, TRUE);
gtk_overlay_add_overlay(GTK_OVERLAY(overlay), toast);
gtk_container_add(GTK_CONTAINER(window), overlay);
return overlay;
}
static GtkWidget *add_column(GtkWidget *view, const char *title, int col, int expand) {
GtkCellRenderer *r = gtk_cell_renderer_text_new();
if (expand) g_object_set(r, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
GtkTreeViewColumn *c = gtk_tree_view_column_new_with_attributes(title, r, "text", col, NULL);
gtk_tree_view_column_set_resizable(c, TRUE); gtk_tree_view_column_set_expand(c, expand);
if (expand) gtk_tree_view_column_set_min_width(c, 160);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), c);
return view;
}
static GtkWidget *scrolled(GtkWidget *child, int height) {
GtkWidget *s = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(s), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(s, -1, height); gtk_container_add(GTK_CONTAINER(s), child);
return s;
}
static void format_size(guint64 size, int kind, char *out, size_t len) {
if (kind != 4) { snprintf(out, len, "--"); return; }
if (size < 1024) snprintf(out, len, "%llu B", (unsigned long long)size);
else if (size < 1024 * 1024) snprintf(out, len, "%.2f KB", size / 1024.0);
else if (size < 1024ull * 1024 * 1024) snprintf(out, len, "%.2f MB", size / 1048576.0);
else snprintf(out, len, "%.2f GB", size / 1073741824.0);
}
static void format_time(guint64 secs, char *out, size_t len) {
if (!secs) { snprintf(out, len, "--"); return; }
time_t t = (time_t)secs; struct tm tm; localtime_r(&t, &tm);
strftime(out, len, "%Y年%m月%d日", &tm);
}
static const char *kind_name(int kind) { return kind == 4 ? "文件" : kind == 3 ? "磁盘" : "文件夹"; }
/* ---------------- file transfer ---------------- */
enum { C_NAME, C_TIME, C_TYPE, C_SIZE, C_PATH, C_KIND, C_N };
enum { T_ID, T_NAME, T_STATUS, T_SIZE, T_FROM, T_TO, T_DONE, T_N };
static GtkListStore *local_store, *remote_store, *task_store;
static GtkWidget *local_view, *remote_view, *local_path, *remote_path;
static char local_dir[2048] = "", remote_dir[2048] = ":/";
static void load_local(const char *path) {
char *dir = g_strdup(path); /* path may alias local_dir */
GDir *d = g_dir_open(dir, 0, NULL);
if (!d) { show_toast("无法打开本机目录"); g_free(dir); return; }
snprintf(local_dir, sizeof local_dir, "%s", dir); g_free(dir);
gtk_entry_set_text(GTK_ENTRY(local_path), local_dir);
gtk_list_store_clear(local_store);
const char *name;
GPtrArray *names = g_ptr_array_new_with_free_func(g_free);
while ((name = g_dir_read_name(d))) if (name[0] != '.') g_ptr_array_add(names, g_strdup(name));
g_dir_close(d);
for (int pass = 0; pass < 2; pass++) for (guint i = 0; i < names->len; i++) {
char *full = g_build_filename(local_dir, names->pdata[i], NULL); struct stat st;
if (stat(full, &st) == 0 && (S_ISDIR(st.st_mode) ? pass == 0 : pass == 1)) {
int kind = S_ISDIR(st.st_mode) ? 0 : 4; char size[32], when[64];
format_size(st.st_size, kind, size, sizeof size); format_time(st.st_mtime, when, sizeof when);
GtkTreeIter it; gtk_list_store_append(local_store, &it);
gtk_list_store_set(local_store, &it, C_NAME, names->pdata[i], C_TIME, when, C_TYPE, kind_name(kind), C_SIZE, size, C_PATH, full, C_KIND, kind, -1);
}
g_free(full);
}
g_ptr_array_free(names, TRUE);
}
static void request_remote(const char *path) { char cmd[2100]; snprintf(cmd, sizeof cmd, "ls\t%s", path); push(cmd); }
static void on_local_up(GtkButton *b, gpointer d) { (void)b; (void)d; char *p = g_path_get_dirname(local_dir); load_local(p); g_free(p); }
static void on_local_refresh(GtkButton *b, gpointer d) { (void)b; (void)d; load_local(local_dir); }
static void on_local_path(GtkEntry *e, gpointer d) { (void)d; load_local(gtk_entry_get_text(e)); }
static void on_remote_up(GtkButton *b, gpointer d) {
(void)b; (void)d;
if (!strcmp(remote_dir, ":/") || !strcmp(remote_dir, "/")) { request_remote(":/"); return; }
char *p = g_path_get_dirname(remote_dir); request_remote(p); g_free(p);
}
static void on_remote_refresh(GtkButton *b, gpointer d) { (void)b; (void)d; request_remote(remote_dir); }
static void on_remote_path(GtkEntry *e, gpointer d) { (void)d; request_remote(gtk_entry_get_text(e)); }
static void on_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer remote) {
(void)col; GtkTreeModel *m = gtk_tree_view_get_model(view); GtkTreeIter it; char *full; int kind;
if (!gtk_tree_model_get_iter(m, &it, path)) return;
gtk_tree_model_get(m, &it, C_PATH, &full, C_KIND, &kind, -1);
if (kind != 4) { if (remote) request_remote(full); else load_local(full); }
g_free(full);
}
static char *ask_name(const char *title) {
GtkWidget *dlg = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "确定", GTK_RESPONSE_OK, NULL);
GtkWidget *entry = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dlg)); gtk_container_set_border_width(GTK_CONTAINER(area), 16);
gtk_box_pack_start(GTK_BOX(area), entry, FALSE, FALSE, 0); gtk_widget_show_all(dlg);
char *name = NULL;
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
const char *t = gtk_entry_get_text(GTK_ENTRY(entry));
if (*t && !strchr(t, '/') && strcmp(t, ".") && strcmp(t, "..")) name = g_strdup(t); else if (*t) show_toast("名称无效");
}
gtk_widget_destroy(dlg);
return name;
}
static void on_local_mkdir(GtkButton *b, gpointer d) {
(void)b; (void)d; char *name = ask_name("新建文件夹"); if (!name) return;
char *full = g_build_filename(local_dir, name, NULL);
if (mkdir(full, 0755) != 0) show_toast("无法创建文件夹"); else load_local(local_dir);
g_free(full); g_free(name);
}
static void on_remote_mkdir(GtkButton *b, gpointer d) {
(void)b; (void)d;
if (!strcmp(remote_dir, ":/")) { show_toast("请先进入一个文件夹"); return; }
char *name = ask_name("新建文件夹"); if (!name) return;
char *full = g_build_filename(remote_dir, name, NULL); char cmd[2200];
snprintf(cmd, sizeof cmd, "mkdir\t%s", full); push(cmd); g_free(full); g_free(name);
}
/* Each selected row becomes one queued transfer. Remote folders download recursively; local folders
* are not supported by the upload RPC sequence implemented here. */
static void on_send(GtkButton *b, gpointer upload) {
(void)b; GtkTreeView *view = GTK_TREE_VIEW(upload ? local_view : remote_view);
GtkTreeModel *m; GList *rows = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(view), &m);
if (!rows) { show_toast("请先选择要发送的文件"); return; }
if (upload && !strcmp(remote_dir, ":/")) { show_toast("请先在远端进入目标文件夹"); g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free); return; }
int skipped = 0;
for (GList *r = rows; r; r = r->next) {
GtkTreeIter it; char *full, *name; int kind;
if (!gtk_tree_model_get_iter(m, &it, r->data)) continue;
gtk_tree_model_get(m, &it, C_PATH, &full, C_NAME, &name, C_KIND, &kind, -1);
char cmd[4096];
if (upload && kind != 4) skipped++;
else if (!upload && kind == 3) skipped++;
else {
if (upload) snprintf(cmd, sizeof cmd, "put\t%s\t%s", full, remote_dir);
else snprintf(cmd, sizeof cmd, "get\t%s\t%s", full, local_dir);
push(cmd);
}
g_free(full); g_free(name);
}
g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free);
if (skipped) show_toast(upload ? "暂不支持上传文件夹,已跳过" : "不能下载整个磁盘,已跳过");
}
static void on_cancel_all(GtkButton *b, gpointer d) { (void)b; (void)d; push("cancel"); }
static void on_clear_done(GtkButton *b, gpointer d) {
(void)b; (void)d; GtkTreeIter it; gboolean ok = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(task_store), &it);
while (ok) { int done; gtk_tree_model_get(GTK_TREE_MODEL(task_store), &it, T_DONE, &done, -1);
ok = done ? gtk_list_store_remove(task_store, &it) : gtk_tree_model_iter_next(GTK_TREE_MODEL(task_store), &it); }
}
static GtkWidget *pane(int remote) {
GtkWidget *card = vbox(6); add_class(card, "card");
GtkWidget *bar = hbox(6), *up = button("↑", NULL), *refresh = button("刷新", NULL), *mk = button("新建文件夹", NULL), *path = gtk_entry_new();
gtk_widget_set_tooltip_text(up, "上一级"); gtk_widget_set_tooltip_text(refresh, "刷新");
gtk_box_pack_start(GTK_BOX(bar), up, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), refresh, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bar), mk, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), path, TRUE, TRUE, 0);
GtkListStore *store = gtk_list_store_new(C_N, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
add_column(view, "名称", C_NAME, 1); add_column(view, "修改日期", C_TIME, 0); add_column(view, "类型", C_TYPE, 0); add_column(view, "大小", C_SIZE, 0);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE);
g_signal_connect(view, "row-activated", G_CALLBACK(on_row_activated), GINT_TO_POINTER(remote));
g_signal_connect(up, "clicked", G_CALLBACK(remote ? on_remote_up : on_local_up), NULL);
g_signal_connect(refresh, "clicked", G_CALLBACK(remote ? on_remote_refresh : on_local_refresh), NULL);
g_signal_connect(mk, "clicked", G_CALLBACK(remote ? on_remote_mkdir : on_local_mkdir), NULL);
g_signal_connect(path, "activate", G_CALLBACK(remote ? on_remote_path : on_local_path), NULL);
gtk_box_pack_start(GTK_BOX(card), bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), scrolled(view, 300), TRUE, TRUE, 0);
if (remote) { remote_store = store; remote_view = view; remote_path = path; }
else { local_store = store; local_view = view; local_path = path; }
return card;
}
static void build_files(void) {
GtkWidget *content; frame("文件传输", &content);
gtk_window_set_default_size(GTK_WINDOW(window), 1100, 760);
GtkWidget *head = gtk_grid_new(); gtk_grid_set_column_homogeneous(GTK_GRID(head), TRUE); gtk_grid_set_column_spacing(GTK_GRID(head), 24);
GtkWidget *left = hbox(10), *right = hbox(10);
char host[256]; if (gethostname(host, sizeof host) != 0) snprintf(host, sizeof host, "本机"); host[sizeof host - 1] = 0;
GtkWidget *tag_l = label("本机", "tag"), *tag_r = label("远端", "tag"); add_class(tag_r, "remote");
GtkWidget *send_r = button("发送 →", NULL), *send_l = button("← 发送", NULL);
g_signal_connect(send_r, "clicked", G_CALLBACK(on_send), GINT_TO_POINTER(1));
g_signal_connect(send_l, "clicked", G_CALLBACK(on_send), NULL);
gtk_box_pack_start(GTK_BOX(left), label(host, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(left), tag_l, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(left), send_r, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(right), send_l, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(right), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(right), tag_r, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(head), left, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(head), right, 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(head), pane(0), 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(head), pane(1), 1, 1, 1, 1);
gtk_grid_set_row_spacing(GTK_GRID(head), 14);
gtk_box_pack_start(GTK_BOX(content), head, TRUE, TRUE, 0);
GtkWidget *tasks = vbox(8); add_class(tasks, "card");
GtkWidget *tbar = hbox(8), *cancel = button("全部取消", NULL), *clear = button("清除完结任务", NULL);
g_signal_connect(cancel, "clicked", G_CALLBACK(on_cancel_all), NULL); g_signal_connect(clear, "clicked", G_CALLBACK(on_clear_done), NULL);
gtk_box_pack_start(GTK_BOX(tbar), label("传输列表", "section"), FALSE, FALSE, 4);
gtk_box_pack_end(GTK_BOX(tbar), clear, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(tbar), cancel, FALSE, FALSE, 0);
task_store = gtk_list_store_new(T_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkWidget *tview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(task_store));
add_column(tview, "名称", T_NAME, 1); add_column(tview, "状态", T_STATUS, 0); add_column(tview, "大小", T_SIZE, 0);
add_column(tview, "发送路径", T_FROM, 1); add_column(tview, "接收路径", T_TO, 1);
gtk_box_pack_start(GTK_BOX(tasks), tbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(tasks), scrolled(tview, 180), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), tasks, TRUE, TRUE, 0);
const char *home = g_get_home_dir(); load_local(home ? home : "/");
gtk_entry_set_text(GTK_ENTRY(remote_path), "此电脑");
}
struct listing { char *path; char *rows; };
static gboolean remote_idle(gpointer d) {
struct listing *l = d;
snprintf(remote_dir, sizeof remote_dir, "%s", l->path);
gtk_entry_set_text(GTK_ENTRY(remote_path), strcmp(remote_dir, ":/") ? remote_dir : "此电脑");
gtk_list_store_clear(remote_store);
char **lines = g_strsplit(l->rows, "\n", -1);
for (char **line = lines; *line; line++) {
char **f = g_strsplit(*line, "\t", 5);
if (g_strv_length(f) == 5) {
int kind = atoi(f[0]); char size[32], when[64];
format_size(g_ascii_strtoull(f[2], NULL, 10), kind, size, sizeof size); format_time(g_ascii_strtoull(f[3], NULL, 10), when, sizeof when);
GtkTreeIter it; gtk_list_store_append(remote_store, &it);
gtk_list_store_set(remote_store, &it, C_NAME, f[1], C_TIME, when, C_TYPE, kind_name(kind), C_SIZE, size, C_PATH, f[4], C_KIND, kind, -1);
}
g_strfreev(f);
}
g_strfreev(lines); g_free(l->path); g_free(l->rows); g_free(l);
return G_SOURCE_REMOVE;
}
/* rows: "kind\tname\tsize\tmodified\tpath\n" */
void uu_files_ui_set_remote(const char *path, const char *rows) {
struct listing *l = g_new0(struct listing, 1); l->path = g_strdup(path); l->rows = g_strdup(rows); g_idle_add(remote_idle, l);
}
struct task { int id, done; char *name, *status, *size, *from, *to; };
static gboolean task_idle(gpointer d) {
struct task *t = d; GtkTreeIter it; gboolean ok = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(task_store), &it), found = FALSE;
while (ok) { int id; gtk_tree_model_get(GTK_TREE_MODEL(task_store), &it, T_ID, &id, -1); if (id == t->id) { found = TRUE; break; } ok = gtk_tree_model_iter_next(GTK_TREE_MODEL(task_store), &it); }
if (!found) { gtk_list_store_append(task_store, &it); gtk_list_store_set(task_store, &it, T_ID, t->id, T_NAME, t->name, -1); }
gtk_list_store_set(task_store, &it, T_STATUS, t->status, T_SIZE, t->size, T_FROM, t->from, T_TO, t->to, T_DONE, t->done, -1);
g_free(t->name); g_free(t->status); g_free(t->size); g_free(t->from); g_free(t->to); g_free(t);
return G_SOURCE_REMOVE;
}
/* total == 0 means unknown size; done: 0 running/queued, 1 finished (success), 2 finished (failed/canceled). */
void uu_files_ui_task(int id, const char *name, const char *status, unsigned long long transferred, unsigned long long total, const char *from, const char *to, int done) {
struct task *t = g_new0(struct task, 1); char a[32], b[32];
t->id = id; t->done = done;
format_size(transferred, 4, a, sizeof a); format_size(total, 4, b, sizeof b);
t->name = g_strdup(name); t->status = g_strdup(status); t->from = g_strdup(from); t->to = g_strdup(to);
t->size = total ? g_strdup_printf("%s / %s", a, b) : g_strdup(transferred ? a : "--");
g_idle_add(task_idle, t);
}
static gboolean refresh_local_idle(gpointer d) { (void)d; load_local(local_dir); return G_SOURCE_REMOVE; }
void uu_files_ui_refresh_local(void) { g_idle_add(refresh_local_idle, NULL); }
/* ---------------- port mapping ---------------- */
enum { P_ID, P_NAME, P_LOCAL, P_TARGET, P_STATUS, P_N };
static GtkListStore *rule_store;
static GtkWidget *rule_stack;
static void on_add_rule(GtkButton *b, gpointer d) {
(void)b; (void)d;
GtkWidget *dlg = gtk_dialog_new_with_buttons("添加映射规则", GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "保存后立即启用", GTK_RESPONSE_OK, NULL);
GtkWidget *grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 12); gtk_grid_set_column_spacing(GTK_GRID(grid), 24);
gtk_container_set_border_width(GTK_CONTAINER(grid), 20);
const char *labels[] = {"名称", "本地端口", "目标地址", "目标端口"}, *hints[] = {"名称", "请输入端口", "", "请输入端口"};
GtkWidget *entries[4];
for (int i = 0; i < 4; i++) {
entries[i] = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entries[i]), hints[i]); gtk_widget_set_hexpand(entries[i], TRUE);
gtk_grid_attach(GTK_GRID(grid), label(labels[i], NULL), 0, i, 1, 1); gtk_grid_attach(GTK_GRID(grid), entries[i], 1, i, 1, 1);
}
gtk_entry_set_text(GTK_ENTRY(entries[2]), "127.0.0.1");
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))), grid, TRUE, TRUE, 0);
gtk_window_set_default_size(GTK_WINDOW(dlg), 480, -1); gtk_widget_show_all(dlg);
while (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
const char *name = gtk_entry_get_text(GTK_ENTRY(entries[0])), *host = gtk_entry_get_text(GTK_ENTRY(entries[2]));
char *end; long local = strtol(gtk_entry_get_text(GTK_ENTRY(entries[1])), &end, 10); int bad_local = *end || local < 0 || local > 65535;
long port = strtol(gtk_entry_get_text(GTK_ENTRY(entries[3])), &end, 10); int bad_port = *end || port < 1 || port > 65535;
if (!*name || strchr(name, '\t') || !*host || strchr(host, '\t') || bad_local || bad_port) { show_toast("请填写名称、有效端口和目标地址"); continue; }
char cmd[1024]; snprintf(cmd, sizeof cmd, "add\t%s\t%ld\t%s\t%ld", name, local, host, port); push(cmd);
break;
}
gtk_widget_destroy(dlg);
}
static void on_remove_rule(GtkButton *b, gpointer view) {
(void)b; GtkTreeModel *m; GtkTreeIter it;
if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(view), &m, &it)) { show_toast("请先选择一条规则"); return; }
int id; gtk_tree_model_get(m, &it, P_ID, &id, -1); char cmd[64]; snprintf(cmd, sizeof cmd, "remove\t%d", id); push(cmd);
}
static void build_portmap(void) {
GtkWidget *content; frame("端口映射", &content);
gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
GtkWidget *head = hbox(12), *add = button("添加规则", "primary"), *del = button("删除", NULL);
GtkWidget *dot = label("● 已连接", "online");
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), dot, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(head), add, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), del, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
rule_store = gtk_list_store_new(P_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(rule_store));
add_column(view, "名称", P_NAME, 1); add_column(view, "本地地址", P_LOCAL, 0); add_column(view, "目标地址", P_TARGET, 1); add_column(view, "状态", P_STATUS, 0);
rule_stack = gtk_stack_new();
GtkWidget *empty = label("当前没有端口映射规则,点击「添加规则」把远端端口映射到本机", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
gtk_stack_add_named(GTK_STACK(rule_stack), empty, "empty");
gtk_stack_add_named(GTK_STACK(rule_stack), scrolled(view, 360), "list");
GtkWidget *card = vbox(0); add_class(card, "card"); gtk_box_pack_start(GTK_BOX(card), rule_stack, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), card, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), label("本地端口只监听 127.0.0.1;本地端口填 0 时自动分配。", "empty"), FALSE, FALSE, 0);
g_signal_connect(add, "clicked", G_CALLBACK(on_add_rule), NULL);
g_signal_connect(del, "clicked", G_CALLBACK(on_remove_rule), view);
}
static gboolean rules_idle(gpointer d) {
char *rows = d; gtk_list_store_clear(rule_store); int n = 0;
char **lines = g_strsplit(rows, "\n", -1);
for (char **line = lines; *line; line++) {
char **f = g_strsplit(*line, "\t", 5);
if (g_strv_length(f) == 5) { GtkTreeIter it; gtk_list_store_append(rule_store, &it);
gtk_list_store_set(rule_store, &it, P_ID, atoi(f[0]), P_NAME, f[1], P_LOCAL, f[2], P_TARGET, f[3], P_STATUS, f[4], -1); n++; }
g_strfreev(f);
}
g_strfreev(lines); g_free(rows);
gtk_stack_set_visible_child_name(GTK_STACK(rule_stack), n ? "list" : "empty");
return G_SOURCE_REMOVE;
}
/* rows: "id\tname\tlocal\ttarget\tstatus\n" */
void uu_portmap_ui_set_rules(const char *rows) { g_idle_add(rules_idle, g_strdup(rows)); }
/* ---------------- terminal sessions ---------------- */
enum { S_ID, S_SHELL, S_TIME, S_STATE, S_N };
static GtkListStore *session_store;
static GtkWidget *session_view, *session_stack, *session_dot, *session_create, *session_kill;
static guint selected_session(void) {
GtkTreeModel *m; GtkTreeIter it; guint id = 0;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(session_view)), &m, &it)) gtk_tree_model_get(m, &it, S_ID, &id, -1);
return id;
}
static void on_create_session(GtkButton *b, gpointer d) { (void)b; (void)d; push("create"); }
static void on_open_session(GtkTreeView *v, GtkTreePath *path, GtkTreeViewColumn *col, gpointer d) {
(void)col; (void)d; GtkTreeIter it; guint id;
if (!gtk_widget_get_sensitive(GTK_WIDGET(v)) || !gtk_tree_model_get_iter(GTK_TREE_MODEL(session_store), &it, path)) return;
gtk_tree_model_get(GTK_TREE_MODEL(session_store), &it, S_ID, &id, -1);
char cmd[64]; snprintf(cmd, sizeof cmd, "open\t%u", id); push(cmd);
}
static void on_kill_session(GtkButton *b, gpointer d) {
(void)b; (void)d; guint id = selected_session();
if (!id) { show_toast("请先选择一个会话"); return; }
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "确定结束会话 %u?", id);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dlg), "会话内正在运行的程序将被终止。");
gtk_dialog_add_buttons(GTK_DIALOG(dlg), "取消", GTK_RESPONSE_CANCEL, "结束会话", GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_CANCEL);
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { char cmd[64]; snprintf(cmd, sizeof cmd, "kill\t%u", id); push(cmd); }
gtk_widget_destroy(dlg);
}
static void build_terminal(void) {
GtkWidget *content; frame("终端远控", &content); gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
GtkWidget *head = hbox(12); session_dot = label("● 正在读取会话", "online");
session_create = button("创建会话", "primary"); session_kill = button("结束会话", NULL);
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(head), session_dot, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(head), session_create, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), session_kill, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
session_store = gtk_list_store_new(S_N, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
session_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(session_store));
add_column(session_view, "会话 ID", S_ID, 0); add_column(session_view, "Shell", S_SHELL, 1);
add_column(session_view, "创建时间", S_TIME, 0); add_column(session_view, "状态", S_STATE, 0);
session_stack = gtk_stack_new();
GtkWidget *empty = label("当前无正在运行的终端会话", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
gtk_stack_add_named(GTK_STACK(session_stack), empty, "empty");
gtk_stack_add_named(GTK_STACK(session_stack), label("正在读取会话…", "empty"), "loading");
gtk_stack_add_named(GTK_STACK(session_stack), label("连接已断开,请关闭窗口后重试", "empty"), "offline");
gtk_stack_add_named(GTK_STACK(session_stack), scrolled(session_view, 360), "list");
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), "loading");
gtk_box_pack_start(GTK_BOX(content), session_stack, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), label("双击接回会话;创建会话将在本机终端程序中打开。", "empty"), FALSE, FALSE, 0);
gtk_widget_set_sensitive(session_create, FALSE); gtk_widget_set_sensitive(session_kill, FALSE);
g_signal_connect(session_create, "clicked", G_CALLBACK(on_create_session), NULL);
g_signal_connect(session_kill, "clicked", G_CALLBACK(on_kill_session), NULL);
g_signal_connect(session_view, "row-activated", G_CALLBACK(on_open_session), NULL);
}
struct sessions { char *rows; int connected; };
static gboolean sessions_idle(gpointer d) {
struct sessions *s = d;
if (atomic_load(&closed)) { g_free(s->rows); g_free(s); return G_SOURCE_REMOVE; }
guint selected = selected_session(); gtk_list_store_clear(session_store); int n = 0;
char **lines = g_strsplit(s->rows, "\n", -1);
for (char **line = lines; *line; line++) {
char **f = g_strsplit(*line, "\t", 4);
if (g_strv_length(f) == 4) {
guint id = (guint)g_ascii_strtoull(f[0], NULL, 10); GtkTreeIter it; char date[64] = "--";
gint64 ms = g_ascii_strtoll(f[2], NULL, 10);
GDateTime *time = ms > 0 ? g_date_time_new_from_unix_local(ms / 1000) : NULL;
if (time) { char *text = g_date_time_format(time, "%Y-%m-%d %H:%M:%S"); g_strlcpy(date, text, sizeof date); g_free(text); g_date_time_unref(time); }
gtk_list_store_append(session_store, &it);
gtk_list_store_set(session_store, &it, S_ID, id, S_SHELL, f[1], S_TIME, date, S_STATE, f[3], -1); n++;
if (id == selected) gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(session_view)), &it);
}
g_strfreev(f);
}
g_strfreev(lines);
gtk_label_set_text(GTK_LABEL(session_dot), s->connected ? "● 已连接" : "● 已断开");
gtk_widget_set_sensitive(session_create, s->connected); gtk_widget_set_sensitive(session_kill, s->connected);
gtk_widget_set_sensitive(session_view, s->connected);
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), s->connected ? (n ? "list" : "empty") : "offline");
g_free(s->rows); g_free(s); return G_SOURCE_REMOVE;
}
/* rows: "id\tshell\tcreated_at_ms\tstate\n"; copied before returning to Rust. */
void uu_terminal_ui_set(const char *rows, int connected) {
struct sessions *s = g_new0(struct sessions, 1); s->rows = g_strdup(rows); s->connected = connected; g_idle_add(sessions_idle, s);
}
/* ---------------- startup ---------------- */
static char tool_kind[16];
static gboolean show_window(gpointer d) {
(void)d;
if (!window) {
if (!strcmp(tool_kind, "files")) build_files(); else if (!strcmp(tool_kind, "terminal")) build_terminal(); else build_portmap();
}
atomic_store(&closed, 0); gtk_widget_show_all(window); gtk_window_present(GTK_WINDOW(window));
pthread_mutex_lock(&init_lock); init_state = 1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
return G_SOURCE_REMOVE;
}
static void *ui_thread(void *d) {
(void)d;
if (!gtk_init_check(NULL, NULL)) { pthread_mutex_lock(&init_lock); init_state = -1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); return NULL; }
gtk_window_set_default_icon_name("uu-remote-linux"); // same taskbar icon as the host (#13)
// Light palette in CSS; keep a dark system theme from making unstyled text white on white (#43).
g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
show_window(NULL); gtk_main(); return NULL;
}
/* Hidden windows retain their widgets so queued idle callbacks stay valid. */
int uu_tools_ui_start(const char *kind, const char *name) {
static int started;
pthread_mutex_lock(&init_lock); if (init_state < 0) { pthread_mutex_unlock(&init_lock); return -1; } init_state = 0;
snprintf(tool_kind, sizeof tool_kind, "%s", kind); snprintf(remote_name, sizeof remote_name, "%s", name);
pthread_mutex_lock(&q_lock); q_head = q_len = 0; pthread_mutex_unlock(&q_lock);
if (!started) {
pthread_t t; if (pthread_create(&t, NULL, ui_thread, NULL) != 0) { pthread_mutex_unlock(&init_lock); return -1; }
pthread_detach(t); started = 1;
} else g_idle_add(show_window, NULL);
while (!init_state) pthread_cond_wait(&init_cond, &init_lock);
int s = init_state; pthread_mutex_unlock(&init_lock); return s == 1 ? 0 : -1;
}
static gboolean hide_window(gpointer d) { (void)d; if (window) gtk_widget_hide(window); atomic_store(&closed, 1); return G_SOURCE_REMOVE; }
void uu_tools_ui_hide(void) { g_idle_add(hide_window, NULL); }
void uu_tools_ui_present(void) { pthread_mutex_lock(&init_lock); if (init_state == 1) g_idle_add(show_window, NULL); pthread_mutex_unlock(&init_lock); }
+732
View File
@@ -0,0 +1,732 @@
// GTK3 launcher window for the experimental native viewer (`uuremote-viewer ui`). Layout follows the
// official client's screens (see analysis notes: sidebar, device page, all devices, assistance,
// favorites, settings, QR sign-in, sign-out confirmation) without any NetEase assets. GTK runs on
// its own thread; Rust pushes state through g_idle_add and polls user commands. Account data is
// shown only in this local window and never logged.
#include <gtk/gtk.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
static const char *CSS =
"window { background-color: #ffffff; }\n"
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
".sidebar { background-color: #e9e9ec; }\n"
".section { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
".sidebar list, .sidebar row { background-color: transparent; }\n"
".sidebar row { border-radius: 8px; margin: 1px 10px; padding: 8px 10px; }\n"
".sidebar row:selected { background-color: #d4d4d9; color: #1d1d1f; }\n"
".devname { font-size: 15px; color: #1d1d1f; }\n"
".offline { color: #9ca3af; }\n"
".dot { color: #22c55e; font-size: 10px; }\n"
".dot.off { color: transparent; }\n"
".icon { background-color: #2f7bff; color: #ffffff; border-radius: 6px; font-size: 11px; font-weight: 700; padding: 2px 5px; }\n"
".icon.off { background-color: #c4c7cf; }\n"
".tag { background-color: #e8f0ff; color: #2f6bff; border-radius: 4px; font-size: 12px; padding: 1px 6px; }\n"
".title { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n"
".header { border-bottom: 1px solid #e5e7eb; padding: 12px 22px; background-color: #f7f7f8; }\n"
".badge { background-color: #1d1d1f; color: #ffffff; border-radius: 12px; padding: 3px 12px; font-size: 13px; }\n"
".badge.off { background-color: #9ca3af; }\n"
".hbtn { background-image: none; background-color: transparent; border: none; font-size: 17px; color: #4b5563; padding: 4px 10px; }\n"
".preview { background-image: linear-gradient(135deg, #a8c0ff 0%, #e2c2f2 50%, #f6c8a8 100%); border-radius: 12px 12px 0 0; }\n"
".enter { background-image: none; background-color: rgba(0,0,0,0.18); color: #ffffff; border: none; font-size: 19px; padding: 8px 20px; border-radius: 8px; }\n"
".toolbar { border: 1px solid #e5e7eb; border-top: none; border-radius: 0 0 12px 12px; padding: 4px; }\n"
".tool { background-image: none; background-color: transparent; border: none; font-size: 15px; color: #374151; padding: 10px; }\n"
".dashed { border: 1px dashed #d1d5db; border-radius: 12px; padding: 36px; }\n"
".round { background-image: none; background-color: #f3f4f6; border: none; border-radius: 40px; font-size: 26px; min-width: 64px; min-height: 64px; }\n"
".card { background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
".cardbtn { background-image: none; background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 12px 16px; }\n"
".banner { background-color: #f7f8fa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
".group { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
".h2 { font-size: 19px; font-weight: 700; color: #1d1d1f; }\n"
".big { font-size: 30px; font-weight: 800; color: #111111; }\n"
".hint { font-size: 14px; color: #6b7280; }\n"
".primary { background-image: none; background-color: #3b82f6; color: #ffffff; border: none; border-radius: 8px; font-size: 16px; padding: 8px 26px; }\n"
".secondary { background-image: none; background-color: #ffffff; border: 1px solid #d1d5db; border-radius: 8px; padding: 6px 16px; }\n"
".qrbox { background-color: #ffffff; border-radius: 12px; border: 1px solid #e5e7eb; padding: 14px; }\n"
".status { font-size: 13px; color: #2f6bff; }\n"
".toast { background-color: #ffffff; border: 1px solid #e5e7eb; border-radius: 10px; padding: 10px 18px; font-size: 15px; }\n";
typedef struct { char id[64]; char name[128]; int platform, online, current; } Device;
static Device devices[64];
static int device_count;
static char queue[16][200];
static int q_head, q_len;
static pthread_mutex_t q_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t d_lock = PTHREAD_MUTEX_INITIALIZER;
static atomic_int closed;
static pthread_t ui_thread;
static int ui_started, init_state;
static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
static GtkWidget *assist_list;
static GtkWidget *window, *stack, *title_label, *badge, *more_button, *device_list, *my_section, *all_box,
*qr_image, *status_label, *toast, *banner, *fav_stack, *settings_window;
static int logged_in, selected = -1, banner_closed;
static char qr_path[512], status_text[256], user_text[128];
static int push(const char *cmd) {
pthread_mutex_lock(&q_lock);
int accepted = q_len < 16;
if (accepted) { snprintf(queue[(q_head + q_len) % 16], sizeof queue[0], "%s", cmd); q_len++; }
pthread_mutex_unlock(&q_lock);
return accepted;
}
static void add_class(GtkWidget *w, const char *cls) { gtk_style_context_add_class(gtk_widget_get_style_context(w), cls); }
static GtkWidget *label(const char *text, const char *cls) {
GtkWidget *l = gtk_label_new(text);
if (cls) add_class(l, cls);
gtk_label_set_xalign(GTK_LABEL(l), 0);
gtk_label_set_line_wrap(GTK_LABEL(l), TRUE);
return l;
}
static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; }
static GtkWidget *hbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, spacing); }
static GtkWidget *vbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, spacing); }
static GtkWidget *platform_icon(int platform, int online) {
GtkWidget *i = gtk_label_new(platform == 4 ? "Mac" : platform == 1 ? "Win" : "PC");
add_class(i, "icon"); if (!online) add_class(i, "off");
return i;
}
static gboolean hide_toast(gpointer d) { (void)d; gtk_widget_hide(toast); return G_SOURCE_REMOVE; }
static void show_toast(const char *text) { gtk_label_set_text(GTK_LABEL(toast), text); gtk_widget_show(toast); g_timeout_add(3500, hide_toast, NULL); }
static void unsupported(GtkButton *b, gpointer what) { (void)b; char t[128]; snprintf(t, sizeof t, "%s:暂未支持", (const char *)what); show_toast(t); }
static void connect_kind(const char *kind) {
if (selected < 0) return;
char cmd[200];
pthread_mutex_lock(&d_lock);
snprintf(cmd, sizeof cmd, "connect\t%s\t%s", devices[selected].id, kind);
pthread_mutex_unlock(&d_lock);
push(cmd);
if (!strcmp(kind, "desktop") || !strcmp(kind, "watch")) show_toast("正在连接…");
}
static void on_tool(GtkButton *b, gpointer kind);
static void more_item(GtkButton *b, gpointer kind) {
GtkWidget *dialog = gtk_widget_get_toplevel(GTK_WIDGET(b));
const char *k = kind;
if (!strcmp(k, "reboot") || !strcmp(k, "shutdown")) {
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
!strcmp(k, "reboot") ? "确定要重启被控电脑吗?" : "确定要关闭被控电脑吗?");
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "远程会话会断开。");
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "确认", GTK_RESPONSE_OK, NULL);
int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d);
if (ok) { connect_kind(k); show_toast("正在发送电源指令…"); }
return;
}
if (!strcmp(k, "unbind")) {
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
"确定要从账号中删除该设备吗?");
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "删除后需要在该设备上重新登录才能再次远控。");
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "删除", GTK_RESPONSE_OK, NULL);
int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d);
if (ok) { gtk_widget_destroy(dialog); connect_kind(k); show_toast("正在删除设备…"); }
return;
}
gtk_widget_destroy(dialog);
on_tool(NULL, kind);
}
static void open_more(void) {
GtkWidget *dialog = gtk_dialog_new_with_buttons("更多工具", GTK_WINDOW(window), GTK_DIALOG_MODAL, NULL, NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog), 520, -1);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(10);
gtk_container_set_border_width(GTK_CONTAINER(box), 22);
gtk_box_pack_start(GTK_BOX(box), label("更多工具", "h2"), FALSE, FALSE, 6);
const char *names[] = {"🗂 文件传输", "▶ 观看模式", "⌨ 终端", "⇄ 端口映射", "⏻ 远程开机", "↻ 重启", "⏻ 关机", "🗑 删除设备"};
const char *kinds[] = {"file", "watch", "terminal", "portmap", "wol", "reboot", "shutdown", "unbind"};
for (int i = 0; i < 8; i++) {
GtkWidget *b = gtk_button_new(), *line = hbox(10); add_class(b, "cardbtn");
gtk_box_pack_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(line), label("›", "hint"), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(b), line);
if (i == 4) gtk_widget_set_sensitive(b, FALSE); // 远程开机 is greyed for devices without Wake-on-LAN
else g_signal_connect(b, "clicked", G_CALLBACK(more_item), (gpointer)kinds[i]);
gtk_box_pack_start(GTK_BOX(box), b, FALSE, FALSE, 0);
}
GtkWidget *foot = hbox(10), *order = button("调整顺序", "secondary"), *close = button("关闭", "secondary");
g_signal_connect(order, "clicked", G_CALLBACK(unsupported), "调整顺序");
g_signal_connect_swapped(close, "clicked", G_CALLBACK(gtk_widget_destroy), dialog);
gtk_box_pack_start(GTK_BOX(foot), order, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(foot), close, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 8);
gtk_box_pack_start(GTK_BOX(box), foot, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(area), box);
gtk_widget_show_all(dialog);
}
static void on_tool(GtkButton *b, gpointer kind) {
(void)b;
if (!strcmp(kind, "more")) open_more();
else if (!strcmp(kind, "wol") || !strcmp(kind, "reboot") || !strcmp(kind, "shutdown"))
unsupported(NULL, (gpointer)(!strcmp(kind, "wol") ? "远程开机" : !strcmp(kind, "reboot") ? "重启" : "关机"));
else connect_kind(kind);
}
static void on_login(GtkButton *b, gpointer d) { (void)b; (void)d; push("login"); gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); gtk_label_set_text(GTK_LABEL(title_label), "登录"); }
static void set_header(const char *title, int device_page) {
gtk_label_set_text(GTK_LABEL(title_label), title);
gtk_widget_set_visible(badge, device_page); gtk_widget_set_visible(more_button, device_page);
}
static void show_page(const char *name, const char *title) {
int need_login = strcmp(name, "assist") && strcmp(name, "login");
if (!logged_in && need_login) { set_header("全部设备", 0); gtk_stack_set_visible_child_name(GTK_STACK(stack), "welcome"); return; }
set_header(title, 0);
gtk_stack_set_visible_child_name(GTK_STACK(stack), name);
}
static void show_device(int index) {
pthread_mutex_lock(&d_lock);
if (index < 0 || index >= device_count) { pthread_mutex_unlock(&d_lock); return; }
selected = index;
char name[128]; snprintf(name, sizeof name, "%s", devices[index].name);
int online = devices[index].online;
pthread_mutex_unlock(&d_lock);
set_header(name, 1);
gtk_label_set_markup(GTK_LABEL(badge), online ? "<span foreground='#22c55e'>●</span> 在线" : "离线");
GtkStyleContext *ctx = gtk_widget_get_style_context(badge);
if (online) gtk_style_context_remove_class(ctx, "off"); else gtk_style_context_add_class(ctx, "off");
gtk_stack_set_visible_child_name(GTK_STACK(stack), "device");
}
static void on_row(GtkListBox *box, GtkListBoxRow *row, gpointer d) {
(void)d;
if (!row) return;
// The two sidebar lists act as one selection.
gtk_list_box_unselect_all(GTK_LIST_BOX(box == GTK_LIST_BOX(device_list) ? assist_list : device_list));
const char *kind = g_object_get_data(G_OBJECT(row), "kind");
if (!kind) { show_device(GPOINTER_TO_INT(g_object_get_data(G_OBJECT(row), "index"))); return; }
if (!strcmp(kind, "all")) show_page("all", "全部设备");
else if (!strcmp(kind, "assist")) show_page("assist", "远程协助");
else if (!strcmp(kind, "favorite")) show_page("favorite", "收藏设备");
}
static void on_card(GtkButton *b, gpointer index) { (void)b; show_device(GPOINTER_TO_INT(index)); }
static GtkWidget *nav_row(const char *icon, const char *text, const char *kind) {
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(10);
gtk_box_pack_start(GTK_BOX(line), label(icon, "devname"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(line), label(text, "devname"), TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(row), line);
g_object_set_data_full(G_OBJECT(row), "kind", g_strdup(kind), g_free);
return row;
}
static void clear(GtkWidget *container) {
GList *children = gtk_container_get_children(GTK_CONTAINER(container));
for (GList *c = children; c; c = c->next) gtk_widget_destroy(c->data);
g_list_free(children);
}
// ---- device info dialog (设备信息) ----
static void on_info(GtkButton *b, gpointer index) {
(void)b;
int i = GPOINTER_TO_INT(index);
char name[128] = "";
pthread_mutex_lock(&d_lock); if (i >= 0 && i < device_count) snprintf(name, sizeof name, "%s", devices[i].name); pthread_mutex_unlock(&d_lock);
GtkWidget *dialog = gtk_dialog_new_with_buttons("设备信息", GTK_WINDOW(window), GTK_DIALOG_MODAL, "完成", GTK_RESPONSE_OK, NULL);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(12);
gtk_container_set_border_width(GTK_CONTAINER(box), 20);
GtkWidget *c1 = vbox(8); add_class(c1, "card");
GtkWidget *r = hbox(8); gtk_box_pack_start(GTK_BOX(r), label("名称", "devname"), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(r), label(name, "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c1), r, FALSE, FALSE, 0);
GtkWidget *rename = button("重命名", "secondary"); gtk_widget_set_halign(rename, GTK_ALIGN_END);
g_signal_connect(rename, "clicked", G_CALLBACK(unsupported), "重命名");
gtk_box_pack_start(GTK_BOX(c1), rename, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), c1, FALSE, FALSE, 0);
GtkWidget *c2 = vbox(10); add_class(c2, "card");
const char *rows[] = {"处理器", "网卡", "总内存", "系统版本", "显卡"};
for (int k = 0; k < 5; k++) {
GtkWidget *line = hbox(8);
gtk_box_pack_start(GTK_BOX(line), label(rows[k], "devname"), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(line), label("—", "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c2), line, FALSE, FALSE, 0);
}
gtk_box_pack_start(GTK_BOX(box), c2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), label("硬件信息暂未获取。", "hint"), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(area), box);
gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog);
}
static void on_more(GtkButton *b, gpointer d) { (void)b; (void)d; on_info(NULL, GINT_TO_POINTER(selected)); }
static gboolean apply_devices(gpointer d) {
(void)d;
clear(device_list); clear(all_box);
pthread_mutex_lock(&d_lock);
if (!banner_closed) gtk_widget_show_all(banner);
char group[64]; snprintf(group, sizeof group, "⌄ 电脑 %d", device_count);
gtk_box_pack_start(GTK_BOX(all_box), label(group, "group"), FALSE, FALSE, 8);
for (int i = 0; i < device_count; i++) {
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(8);
GtkWidget *dot = gtk_label_new("●"); add_class(dot, "dot"); if (!devices[i].online) add_class(dot, "off");
GtkWidget *name = label(devices[i].name, "devname"); if (!devices[i].online) add_class(name, "offline");
gtk_label_set_line_wrap(GTK_LABEL(name), FALSE); gtk_label_set_ellipsize(GTK_LABEL(name), PANGO_ELLIPSIZE_END);
gtk_box_pack_start(GTK_BOX(line), dot, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(line), platform_icon(devices[i].platform, devices[i].online), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(line), name, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(row), line);
g_object_set_data(G_OBJECT(row), "index", GINT_TO_POINTER(i));
if (!devices[i].current) gtk_list_box_insert(GTK_LIST_BOX(device_list), row, -1); else gtk_widget_destroy(row);
GtkWidget *card = hbox(12); add_class(card, "card");
gtk_box_pack_start(GTK_BOX(card), platform_icon(devices[i].platform, 1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), label(devices[i].name, "devname"), FALSE, FALSE, 0);
if (devices[i].current) gtk_box_pack_start(GTK_BOX(card), label("本机", "tag"), FALSE, FALSE, 0);
GtkWidget *open = button("›", "hbtn"), *info = button("ⓘ", "hbtn");
g_signal_connect(info, "clicked", G_CALLBACK(on_info), GINT_TO_POINTER(i));
if (!devices[i].current) { g_signal_connect(open, "clicked", G_CALLBACK(on_card), GINT_TO_POINTER(i)); gtk_box_pack_end(GTK_BOX(card), open, FALSE, FALSE, 0); }
else gtk_widget_destroy(open);
gtk_box_pack_end(GTK_BOX(card), info, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(all_box), card, FALSE, FALSE, 4);
}
pthread_mutex_unlock(&d_lock);
gtk_list_box_insert(GTK_LIST_BOX(device_list), nav_row("◼", "全部设备", "all"), -1);
gtk_widget_show_all(device_list); gtk_widget_show_all(all_box);
return G_SOURCE_REMOVE;
}
static gboolean apply_login(gpointer d) {
(void)d;
gtk_label_set_text(GTK_LABEL(status_label), status_text);
if (qr_path[0]) {
GdkPixbuf *pix = gdk_pixbuf_new_from_file_at_size(qr_path, 240, 240, NULL);
if (pix) { gtk_image_set_from_pixbuf(GTK_IMAGE(qr_image), pix); g_object_unref(pix); }
} else gtk_image_clear(GTK_IMAGE(qr_image));
gtk_widget_set_visible(my_section, logged_in);
const char *page = gtk_stack_get_visible_child_name(GTK_STACK(stack));
if (logged_in && (!strcmp(page, "login") || !strcmp(page, "welcome"))) show_page("all", "全部设备");
if (!logged_in && strcmp(page, "login") && strcmp(page, "assist")) show_page("welcome", "全部设备");
if (!logged_in && qr_path[0]) { gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); set_header("登录", 0); }
return G_SOURCE_REMOVE;
}
// ---- pages ----
static GtkWidget *build_welcome(void) {
GtkWidget *page = vbox(22); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER);
GtkWidget *art = gtk_event_box_new(); add_class(art, "preview"); gtk_widget_set_size_request(art, 520, 300);
gtk_box_pack_start(GTK_BOX(page), art, FALSE, FALSE, 0);
GtkWidget *t = label("随时访问个人设备,可用于办公、游戏、文件传输。", "h2"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0);
GtkWidget *b = button("立即登录", "primary"); gtk_widget_set_halign(b, GTK_ALIGN_CENTER);
g_signal_connect(b, "clicked", G_CALLBACK(on_login), NULL);
gtk_box_pack_start(GTK_BOX(page), b, FALSE, FALSE, 0);
return page;
}
static GtkWidget *build_login(void) {
GtkWidget *page = vbox(16); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER);
GtkWidget *brand = label("UU 远程 Linux 控制端(非官方)", "h2"); gtk_widget_set_halign(brand, GTK_ALIGN_CENTER);
GtkWidget *t = label("扫码登录", "group"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), brand, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0);
GtkWidget *box = vbox(0); add_class(box, "qrbox"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER);
qr_image = gtk_image_new(); gtk_widget_set_size_request(qr_image, 240, 240);
gtk_container_add(GTK_CONTAINER(box), qr_image);
gtk_box_pack_start(GTK_BOX(page), box, FALSE, FALSE, 0);
GtkWidget *h = label("请使用网易 UU 远程 App 扫一扫\n可快速登录", "hint"); gtk_label_set_justify(GTK_LABEL(h), GTK_JUSTIFY_CENTER); gtk_widget_set_halign(h, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), h, FALSE, FALSE, 0);
status_label = label("", "status"); gtk_widget_set_halign(status_label, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), status_label, FALSE, FALSE, 0);
GtkWidget *again = button("刷新二维码", "secondary"); gtk_widget_set_halign(again, GTK_ALIGN_CENTER);
g_signal_connect(again, "clicked", G_CALLBACK(on_login), NULL);
gtk_box_pack_start(GTK_BOX(page), again, FALSE, FALSE, 0);
return page;
}
static GtkWidget *build_device(void) {
GtkWidget *page = vbox(0); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
GtkWidget *preview = gtk_overlay_new(), *bg = gtk_event_box_new(); add_class(bg, "preview"); gtk_widget_set_size_request(bg, -1, 320);
gtk_container_add(GTK_CONTAINER(preview), bg);
GtkWidget *enter = button("进入桌面 →", "enter");
gtk_widget_set_halign(enter, GTK_ALIGN_CENTER); gtk_widget_set_valign(enter, GTK_ALIGN_END); gtk_widget_set_margin_bottom(enter, 26);
g_signal_connect(enter, "clicked", G_CALLBACK(on_tool), "desktop");
gtk_overlay_add_overlay(GTK_OVERLAY(preview), enter);
gtk_box_pack_start(GTK_BOX(page), preview, FALSE, FALSE, 0);
GtkWidget *tools = hbox(0); add_class(tools, "toolbar");
const char *names[] = {"🗂 文件传输", "▶ 观看模式", "⌨ 终端", "⇄ 端口映射", "▦"}, *kinds[] = {"file", "watch", "terminal", "portmap", "more"};
for (int i = 0; i < 5; i++) {
GtkWidget *b = button(names[i], "tool");
g_signal_connect(b, "clicked", G_CALLBACK(on_tool), (gpointer)kinds[i]);
gtk_box_pack_start(GTK_BOX(tools), b, i < 4, TRUE, 0);
if (i < 4) gtk_box_pack_start(GTK_BOX(tools), gtk_separator_new(GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
}
gtk_box_pack_start(GTK_BOX(page), tools, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), label("快速启动", "h2"), FALSE, FALSE, 22);
GtkWidget *quick = vbox(10); add_class(quick, "dashed");
GtkWidget *add = button("+", "round"); gtk_widget_set_halign(add, GTK_ALIGN_CENTER);
g_signal_connect(add, "clicked", G_CALLBACK(unsupported), "快速启动");
GtkWidget *al = label("添加", "hint"); gtk_widget_set_halign(al, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(quick), add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(quick), al, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), quick, FALSE, FALSE, 0);
return page;
}
static void close_banner(GtkButton *b, gpointer d) { (void)b; (void)d; banner_closed = 1; gtk_widget_hide(banner); }
static GtkWidget *build_all(void) {
GtkWidget *page = vbox(8); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
banner = hbox(10); add_class(banner, "banner");
GtkWidget *text = vbox(4);
gtk_box_pack_start(GTK_BOX(text), label("ⓘ 添加你的其他设备", "group"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(text), label("在其他电脑上安装 UU 远程官方客户端或本项目主机端,登录同一账号后即可在这里远程访问。", "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(banner), text, TRUE, TRUE, 0);
GtkWidget *x = button("×", "hbtn"); gtk_widget_set_valign(x, GTK_ALIGN_START);
g_signal_connect(x, "clicked", G_CALLBACK(close_banner), NULL);
gtk_box_pack_end(GTK_BOX(banner), x, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), banner, FALSE, FALSE, 0);
all_box = vbox(4);
gtk_box_pack_start(GTK_BOX(page), all_box, FALSE, FALSE, 8);
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(scroll), page);
return scroll;
}
static void on_assist_connect(GtkButton *b, gpointer entry) {
(void)b;
const char *id = gtk_entry_get_text(GTK_ENTRY(entry));
if (!id[0]) { show_toast("请输入伙伴的设备 ID"); return; }
GtkWidget *code_entry = g_object_get_data(G_OBJECT(entry), "assist-code");
const char *code = gtk_entry_get_text(GTK_ENTRY(code_entry));
if (!code[0]) { show_toast("请输入伙伴的设备验证码"); return; }
if (strpbrk(id, "\t\r\n") || strpbrk(code, "\t\r\n")) { show_toast("设备 ID 和验证码不能包含换行或制表符"); return; }
char cmd[200];
int n = snprintf(cmd, sizeof cmd, "assist\t%s\t%s", id, code);
if (n < 0 || (size_t)n >= sizeof cmd) { show_toast("设备 ID 或验证码过长"); return; }
int accepted = push(cmd);
memset(cmd, 0, sizeof cmd);
if (!accepted) { show_toast("连接请求过多,请稍后重试"); return; }
gtk_entry_set_text(GTK_ENTRY(code_entry), "");
show_toast("正在连接…");
}
static GtkWidget *build_assist(void) {
GtkWidget *page = vbox(20); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
GtkWidget *mine = vbox(14); add_class(mine, "card");
GtkWidget *top = hbox(10); gtk_box_pack_start(GTK_BOX(top), label("本设备", "h2"), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(top), label("允许他人远程协助", "devname"), FALSE, FALSE, 0);
GtkWidget *sw = gtk_switch_new(); gtk_widget_set_sensitive(sw, FALSE); gtk_box_pack_start(GTK_BOX(top), sw, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), top, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
GtkWidget *grid = hbox(40), *c1 = vbox(6), *c2 = vbox(6);
gtk_box_pack_start(GTK_BOX(c1), label("本设备 ID", "devname"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c1), label("— — —", "big"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c2), label("验证方式:仅使用临时验证码", "devname"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c2), label("—", "big"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c2), label("每次远控结束刷新", "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(grid), c1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(grid), c2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), grid, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), label("本机被协助由 uuremote-server 主机端提供(uuremote-server assist)。", "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), mine, FALSE, FALSE, 0);
GtkWidget *peer = vbox(12); add_class(peer, "card");
gtk_box_pack_start(GTK_BOX(peer), label("远控伙伴设备", "h2"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), label("通过其他设备的【设备 ID】及【设备验证码】启动远程控制", "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), label("伙伴的设备 ID", "devname"), FALSE, FALSE, 0);
GtkWidget *row = hbox(20), *entry = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entry), "请输入设备 ID"); gtk_widget_set_size_request(entry, 320, -1);
GtkWidget *code = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(code), "请输入设备验证码");
gtk_entry_set_visibility(GTK_ENTRY(code), FALSE);
gtk_entry_set_input_purpose(GTK_ENTRY(code), GTK_INPUT_PURPOSE_PASSWORD);
gtk_entry_set_max_length(GTK_ENTRY(entry), 64); gtk_entry_set_max_length(GTK_ENTRY(code), 64);
g_object_set_data(G_OBJECT(entry), "assist-code", code);
g_signal_connect(code, "activate", G_CALLBACK(on_assist_connect), entry);
GtkWidget *go = button("连接", "primary"); g_signal_connect(go, "clicked", G_CALLBACK(on_assist_connect), entry);
gtk_box_pack_start(GTK_BOX(row), entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), code, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), go, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), row, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), peer, FALSE, FALSE, 0);
return page;
}
static void on_add_favorite(GtkButton *b, gpointer d) {
(void)b; (void)d;
GtkWidget *dialog = gtk_dialog_new_with_buttons("添加收藏设备", GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "添加", GTK_RESPONSE_OK, NULL);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *card = vbox(12); add_class(card, "card");
gtk_container_set_border_width(GTK_CONTAINER(area), 16);
const char *names[] = {"伙伴的设备 ID", "设备验证码(可选)", "备注名称(可选)"}, *hints[] = {"请输入设备 ID", "请输入设备验证码", "请输入名称"};
GtkWidget *first = NULL;
for (int i = 0; i < 3; i++) {
GtkWidget *line = hbox(20), *e = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(e), hints[i]); gtk_widget_set_size_request(e, 280, -1);
if (!first) first = e;
gtk_box_pack_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(line), e, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), line, FALSE, FALSE, 0);
}
gtk_container_add(GTK_CONTAINER(area), card);
gtk_widget_show_all(dialog);
int response = gtk_dialog_run(GTK_DIALOG(dialog));
int has_id = first && gtk_entry_get_text(GTK_ENTRY(first))[0];
gtk_widget_destroy(dialog);
if (response == GTK_RESPONSE_OK) show_toast(has_id ? "收藏设备:暂未支持" : "请输入伙伴的设备 ID");
}
static GtkWidget *build_favorite(void) {
GtkWidget *page = vbox(10); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
GtkWidget *add = button("添加收藏设备", "secondary"); gtk_widget_set_halign(add, GTK_ALIGN_END);
g_signal_connect(add, "clicked", G_CALLBACK(on_add_favorite), NULL);
gtk_box_pack_start(GTK_BOX(page), add, FALSE, FALSE, 0);
fav_stack = gtk_stack_new();
GtkWidget *empty = vbox(10); gtk_widget_set_valign(empty, GTK_ALIGN_CENTER);
GtkWidget *box = label("📦", "big"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER);
GtkWidget *t = label("暂无收藏", "devname"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(empty), box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(empty), t, FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(fav_stack), empty, "empty");
gtk_box_pack_start(GTK_BOX(page), fav_stack, TRUE, TRUE, 0);
return page;
}
// ---- settings window (常规 / 安全 / 键盘 / 网络) ----
static GtkWidget *setting_row(const char *title, const char *detail, GtkWidget *control) {
GtkWidget *row = hbox(12), *text = vbox(2);
gtk_box_pack_start(GTK_BOX(text), label(title, "devname"), FALSE, FALSE, 0);
if (detail) gtk_box_pack_start(GTK_BOX(text), label(detail, "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(row), text, TRUE, TRUE, 0);
if (control) { gtk_widget_set_valign(control, GTK_ALIGN_CENTER); gtk_box_pack_end(GTK_BOX(row), control, FALSE, FALSE, 0); }
return row;
}
static GtkWidget *combo(const char *const *items, int n) {
GtkWidget *c = gtk_combo_box_text_new();
for (int i = 0; i < n; i++) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(c), items[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(c), 0);
return c;
}
static GtkWidget *settings_card(GtkWidget **rows, int n) {
GtkWidget *card = vbox(10); add_class(card, "card");
for (int i = 0; i < n; i++) { if (i) gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), rows[i], FALSE, FALSE, 0); }
return card;
}
static GtkWidget *settings_page(void) { GtkWidget *p = vbox(14); gtk_container_set_border_width(GTK_CONTAINER(p), 22); return p; }
static GtkWidget *edit_button(const char *what) { GtkWidget *b = button("编辑", "secondary"); g_signal_connect(b, "clicked", G_CALLBACK(unsupported), (gpointer)what); return b; }
static gboolean settings_hidden(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); return TRUE; }
static gboolean settings_key(GtkWidget *w, GdkEventKey *e, gpointer d) { (void)d; if (e->keyval == GDK_KEY_Escape) { gtk_widget_hide(w); return TRUE; } return FALSE; }
// Compositors such as Hyprland draw no title bar, so windows carry their own (with a close button).
static void own_titlebar(GtkWidget *w, const char *title) {
GtkWidget *bar = gtk_header_bar_new();
gtk_header_bar_set_title(GTK_HEADER_BAR(bar), title);
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(w), bar);
}
static void open_settings(void) {
if (settings_window) { gtk_window_present(GTK_WINDOW(settings_window)); return; }
settings_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(settings_window), "设置");
gtk_window_set_transient_for(GTK_WINDOW(settings_window), GTK_WINDOW(window));
gtk_window_set_default_size(GTK_WINDOW(settings_window), 680, 600);
g_signal_connect(settings_window, "delete-event", G_CALLBACK(settings_hidden), NULL);
g_signal_connect(settings_window, "key-press-event", G_CALLBACK(settings_key), NULL);
own_titlebar(settings_window, "设置");
GtkWidget *root = vbox(0), *tabs = gtk_stack_new(), *switcher = gtk_stack_switcher_new();
gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(switcher), GTK_STACK(tabs));
gtk_widget_set_halign(switcher, GTK_ALIGN_CENTER); gtk_widget_set_margin_top(switcher, 10); gtk_widget_set_margin_bottom(switcher, 6);
gtk_box_pack_start(GTK_BOX(root), switcher, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(root), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
// 常规
GtkWidget *general = settings_page();
const char *wake[] = {"永不", "接通电源时", "始终"}, *close_opts[] = {"最小化", "退出程序"};
GtkWidget *g1[] = { setting_row("开机自启动", NULL, gtk_switch_new()),
setting_row("保持唤醒状态", "防止电脑进入睡眠状态,导致无法远程访问。", combo(wake, 3)),
setting_row("关闭窗口时", NULL, combo(close_opts, 2)) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g1, 3), FALSE, FALSE, 0);
GtkWidget *path = hbox(8); GtkWidget *change = button("修改路径", "secondary"), *open = button("打开文件夹", "secondary");
g_signal_connect(change, "clicked", G_CALLBACK(unsupported), "修改路径"); g_signal_connect(open, "clicked", G_CALLBACK(unsupported), "打开文件夹");
gtk_box_pack_end(GTK_BOX(path), open, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(path), change, FALSE, FALSE, 0);
GtkWidget *g2[] = { setting_row("传输文件存储路径", "~/Downloads", path) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g2, 1), FALSE, FALSE, 0);
GtkWidget *real = button("在手机 App 中查看", "secondary"); gtk_widget_set_sensitive(real, FALSE);
GtkWidget *g3[] = { setting_row("实名认证", NULL, real) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g3, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), general, "general", "⚙ 常规");
// 安全
GtkWidget *security = settings_page();
const char *verify[] = {"仅使用临时验证码", "仅使用自定义验证码", "临时与自定义验证码"};
GtkWidget *s1[] = { setting_row("允许同账号控制本设备", NULL, gtk_switch_new()), setting_row("允许他人远程协助", NULL, gtk_switch_new()) };
GtkWidget *s2[] = { setting_row("远程协助连接本设备的验证方式", NULL, combo(verify, 3)) };
GtkWidget *s3[] = { setting_row("客户端锁定", "防止客户端设置被修改,保障数据与使用安全。", gtk_switch_new()) };
gtk_box_pack_start(GTK_BOX(security), settings_card(s1, 2), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(security), settings_card(s2, 1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(security), settings_card(s3, 1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(security), label("本机被控相关设置由 uuremote-server 主机端提供。", "hint"), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), security, "security", "🔒 安全");
// 键盘
GtkWidget *keys = settings_page();
gtk_box_pack_start(GTK_BOX(keys), label("仅控制端响应的快捷键", "h2"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(keys), label("远控时按下以下快捷键,仅在控制端本地响应,不会发送到被控端。", "hint"), FALSE, FALSE, 0);
GtkWidget *addk = button("添加控制端快捷键", "secondary"); g_signal_connect(addk, "clicked", G_CALLBACK(unsupported), "添加快捷键");
GtkWidget *k1[] = { setting_row("当前暂无设置", NULL, NULL), setting_row("", NULL, addk) };
gtk_box_pack_start(GTK_BOX(keys), settings_card(k1, 2), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(keys), label("功能快捷键", "h2"), FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(keys), label("按下以下快捷键时,仅在本地触发对应功能,不会发送到被控端。", "hint"), FALSE, FALSE, 0);
const char *fns[] = {"使用被控端鼠标/解锁鼠标", "被控时解除防窥模式", "切换上一个屏幕", "切换下一个屏幕", "显示/隐藏悬浮球", "静音/取消静音", "老板键(隐藏/显示所有客户端窗口)", "发送 Ctrl+Alt+Delete 组合键"};
GtkWidget *k2[8];
for (int i = 0; i < 8; i++) k2[i] = setting_row(fns[i], NULL, edit_button(fns[i]));
gtk_box_pack_start(GTK_BOX(keys), settings_card(k2, 8), FALSE, FALSE, 0);
GtkWidget *kscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(kscroll), keys);
gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", "⌨ 键盘");
// 网络
GtkWidget *network = settings_page();
const char *proxy[] = {"使用系统环境代理", "不使用代理"};
GtkWidget *n1[] = { setting_row("代理设置", NULL, combo(proxy, 2)) };
gtk_box_pack_start(GTK_BOX(network), settings_card(n1, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), network, "network", "🌐 网络");
gtk_box_pack_start(GTK_BOX(root), tabs, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(settings_window), root);
gtk_widget_show_all(settings_window);
}
static void confirm_logout(void) {
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "确定要退出登录吗?");
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "退出登录会中断正在进行中的连接,你的设备也将从本账户删除。请谨慎操作!");
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "确认", GTK_RESPONSE_OK, NULL);
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) push("logout");
gtk_widget_destroy(d);
}
static void on_menu(GtkMenuItem *item, gpointer what) {
(void)item;
if (!strcmp(what, "settings")) open_settings();
else if (!strcmp(what, "logout")) { if (logged_in) confirm_logout(); }
else if (!strcmp(what, "refresh")) push("refresh");
else if (!strcmp(what, "quit")) { atomic_store(&closed, 1); push("quit"); gtk_main_quit(); }
}
static void popup(GtkButton *b, gpointer kind) {
GtkWidget *menu = gtk_menu_new();
if (!strcmp(kind, "account")) {
GtkWidget *who = gtk_menu_item_new_with_label(logged_in ? (user_text[0] ? user_text : "已登录") : "未登录"); gtk_widget_set_sensitive(who, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), who);
GtkWidget *out = gtk_menu_item_new_with_label("退出登录"); g_signal_connect(out, "activate", G_CALLBACK(on_menu), "logout");
gtk_widget_set_sensitive(out, logged_in); gtk_menu_shell_append(GTK_MENU_SHELL(menu), out);
} else if (!strcmp(kind, "notice")) {
GtkWidget *none = gtk_menu_item_new_with_label("暂无通知"); gtk_widget_set_sensitive(none, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), none);
} else {
const char *labels[] = {"刷新设备列表", "设置", "退出程序"}, *whats[] = {"refresh", "settings", "quit"};
for (int i = 0; i < 3; i++) { GtkWidget *it = gtk_menu_item_new_with_label(labels[i]); g_signal_connect(it, "activate", G_CALLBACK(on_menu), (gpointer)whats[i]); gtk_menu_shell_append(GTK_MENU_SHELL(menu), it); }
}
gtk_widget_show_all(menu);
gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(b), GDK_GRAVITY_SOUTH_EAST, GDK_GRAVITY_NORTH_EAST, NULL);
}
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) { (void)w; (void)e; (void)d; atomic_store(&closed, 1); push("quit"); gtk_main_quit(); return FALSE; }
static void *run(void *arg) {
(void)arg;
int ok = gtk_init_check(NULL, NULL);
if (ok) { gtk_window_set_default_icon_name("uu-remote-linux"); } // same taskbar icon as the host (#13)
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
if (ok) {
GtkCssProvider *css = gtk_css_provider_new();
gtk_css_provider_load_from_data(css, CSS, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "UU 远程 Linux 控制端(非官方)");
gtk_window_set_default_size(GTK_WINDOW(window), 1180, 780);
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
own_titlebar(window, "UU 远程 Linux 控制端(非官方)");
GtkWidget *root = hbox(0);
// Sidebar
GtkWidget *side = vbox(0); add_class(side, "sidebar"); gtk_widget_set_size_request(side, 270, -1);
my_section = vbox(0);
GtkWidget *mh = hbox(8); gtk_widget_set_margin_start(mh, 18); gtk_widget_set_margin_top(mh, 22); gtk_widget_set_margin_bottom(mh, 6);
gtk_box_pack_start(GTK_BOX(mh), label("⧉ 我的设备", "section"), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(my_section), mh, FALSE, FALSE, 0);
device_list = gtk_list_box_new(); g_signal_connect(device_list, "row-activated", G_CALLBACK(on_row), NULL);
gtk_box_pack_start(GTK_BOX(my_section), device_list, FALSE, FALSE, 0);
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
GtkWidget *side_inner = vbox(0); gtk_box_pack_start(GTK_BOX(side_inner), my_section, FALSE, FALSE, 0);
GtkWidget *welcome_nav = gtk_list_box_new(); g_signal_connect(welcome_nav, "row-activated", G_CALLBACK(on_row), NULL);
GtkWidget *ah = label("⧉ 远程协助", "section"); gtk_widget_set_margin_start(ah, 18); gtk_widget_set_margin_top(ah, 16); gtk_widget_set_margin_bottom(ah, 6);
gtk_box_pack_start(GTK_BOX(side_inner), ah, FALSE, FALSE, 0);
GtkWidget *assist = assist_list = gtk_list_box_new(); g_signal_connect(assist, "row-activated", G_CALLBACK(on_row), NULL);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("◧", "开始协助", "assist"), -1);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("★", "收藏设备", "favorite"), -1);
gtk_box_pack_start(GTK_BOX(side_inner), assist, FALSE, FALSE, 0);
gtk_list_box_unselect_all(GTK_LIST_BOX(assist));
(void)welcome_nav;
gtk_container_add(GTK_CONTAINER(scroll), side_inner);
gtk_box_pack_start(GTK_BOX(side), scroll, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(root), side, FALSE, FALSE, 0);
// Main area
GtkWidget *main = vbox(0), *header = hbox(10); add_class(header, "header");
badge = gtk_label_new(""); add_class(badge, "badge");
title_label = label("全部设备", "title");
more_button = button("⋮", "hbtn"); g_signal_connect(more_button, "clicked", G_CALLBACK(on_more), NULL);
gtk_box_pack_start(GTK_BOX(header), badge, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), title_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), more_button, FALSE, FALSE, 0);
const char *icons[] = {"☰", "◉", "🔔"}, *kinds[] = {"menu", "account", "notice"};
for (int i = 0; i < 3; i++) { GtkWidget *b = button(icons[i], "hbtn"); g_signal_connect(b, "clicked", G_CALLBACK(popup), (gpointer)kinds[i]); gtk_box_pack_end(GTK_BOX(header), b, FALSE, FALSE, 0); }
gtk_box_pack_start(GTK_BOX(main), header, FALSE, FALSE, 0);
GtkWidget *overlay = gtk_overlay_new();
stack = gtk_stack_new();
gtk_stack_add_named(GTK_STACK(stack), build_welcome(), "welcome");
gtk_stack_add_named(GTK_STACK(stack), build_login(), "login");
gtk_stack_add_named(GTK_STACK(stack), build_device(), "device");
gtk_stack_add_named(GTK_STACK(stack), build_all(), "all");
gtk_stack_add_named(GTK_STACK(stack), build_assist(), "assist");
gtk_stack_add_named(GTK_STACK(stack), build_favorite(), "favorite");
gtk_container_add(GTK_CONTAINER(overlay), stack);
toast = gtk_label_new(""); add_class(toast, "toast"); gtk_widget_set_halign(toast, GTK_ALIGN_CENTER); gtk_widget_set_valign(toast, GTK_ALIGN_START); gtk_widget_set_margin_top(toast, 30);
gtk_overlay_add_overlay(GTK_OVERLAY(overlay), toast);
gtk_box_pack_start(GTK_BOX(main), overlay, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(root), main, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(window), root);
gtk_widget_show_all(window);
gtk_widget_hide(badge); gtk_widget_hide(more_button); gtk_widget_hide(toast); gtk_widget_hide(my_section);
gtk_stack_set_visible_child_name(GTK_STACK(stack), "welcome");
}
pthread_mutex_lock(&init_lock); init_state = ok ? 1 : -1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
if (ok) gtk_main();
atomic_store(&closed, 1);
return NULL;
}
int uu_viewer_ui_start(void) {
if (ui_started) return init_state == 1 ? 0 : -1;
ui_started = 1;
if (pthread_create(&ui_thread, NULL, run, NULL)) return -1;
pthread_mutex_lock(&init_lock); while (!init_state) pthread_cond_wait(&init_cond, &init_lock); pthread_mutex_unlock(&init_lock);
return init_state == 1 ? 0 : -1;
}
/// Lines of "id\tname\tplatform\tonline\tcurrent".
void uu_viewer_ui_set_devices(const char *tsv) {
pthread_mutex_lock(&d_lock);
/* A refresh (every 30 s) must keep the open device page usable: re-select by id, not reset. */
char keep[sizeof devices[0].id] = "";
if (selected >= 0 && selected < device_count) snprintf(keep, sizeof keep, "%s", devices[selected].id);
device_count = 0;
char *copy = strdup(tsv ? tsv : ""), *save = NULL;
for (char *line = strtok_r(copy, "\n", &save); line && device_count < 64; line = strtok_r(NULL, "\n", &save)) {
char *f[5] = {0}, *s2 = NULL; int n = 0;
for (char *p = strtok_r(line, "\t", &s2); p && n < 5; p = strtok_r(NULL, "\t", &s2)) f[n++] = p;
if (n < 5) continue;
Device *d = &devices[device_count++];
snprintf(d->id, sizeof d->id, "%s", f[0]); snprintf(d->name, sizeof d->name, "%s", f[1]);
d->platform = atoi(f[2]); d->online = atoi(f[3]); d->current = atoi(f[4]);
}
free(copy);
selected = -1;
for (int i = 0; keep[0] && i < device_count; i++) if (!strcmp(devices[i].id, keep)) { selected = i; break; }
pthread_mutex_unlock(&d_lock);
if (init_state == 1) g_idle_add(apply_devices, NULL);
}
void uu_viewer_ui_set_login(int signed_in, const char *qr_png, const char *status, const char *user) {
logged_in = signed_in;
snprintf(qr_path, sizeof qr_path, "%s", qr_png ? qr_png : "");
snprintf(status_text, sizeof status_text, "%s", status ? status : "");
snprintf(user_text, sizeof user_text, "%s", user ? user : "");
if (init_state == 1) g_idle_add(apply_login, NULL);
}
int uu_viewer_ui_take_command(char *out, size_t len) {
pthread_mutex_lock(&q_lock);
int has = q_len > 0;
if (has) { snprintf(out, len, "%s", queue[q_head]); memset(queue[q_head], 0, sizeof queue[q_head]); q_head = (q_head + 1) % 16; q_len--; }
pthread_mutex_unlock(&q_lock);
return has;
}
int uu_viewer_ui_closed(void) { return atomic_load(&closed); }
static char toast_text[256];
static gboolean apply_toast(gpointer d) { (void)d; show_toast(toast_text); return G_SOURCE_REMOVE; }
void uu_viewer_ui_toast(const char *text) {
snprintf(toast_text, sizeof toast_text, "%s", text ? text : "");
if (init_state == 1) g_idle_add(apply_toast, NULL);
}
static int replace_result;
static gboolean confirm_replace(gpointer d) {
(void)d;
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "打开后将断开当前与该设备的连接,继续吗?");
gtk_dialog_add_buttons(GTK_DIALOG(dialog), "取消", GTK_RESPONSE_CANCEL, "继续", GTK_RESPONSE_OK, NULL);
int accepted = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK;
gtk_widget_destroy(dialog);
pthread_mutex_lock(&init_lock); replace_result = accepted; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
return G_SOURCE_REMOVE;
}
int uu_viewer_ui_confirm_replace(void) {
pthread_mutex_lock(&init_lock); replace_result = -1; g_idle_add(confirm_replace, NULL);
while (replace_result < 0 && !atomic_load(&closed)) {
struct timespec until; clock_gettime(CLOCK_REALTIME, &until); until.tv_sec++;
pthread_cond_timedwait(&init_cond, &init_lock, &until);
}
int result = replace_result; pthread_mutex_unlock(&init_lock); return result;
}
+202 -8
View File
@@ -58,6 +58,14 @@ static struct xkb_context *xkb;
static struct xkb_keymap *keymap;
static struct xkb_state *key_state;
static unsigned char held_keys[768];
/* Mobile input-method text (#13/#46). The protocol has no per-key remap request, but
zwp_virtual_keyboard_v1_keymap may be re-sent at any time, so the pristine keymap text is kept
and a spare keycode is pointed at one character's keysym at a time. Never logs the text. */
#define UU_TEXT_SPARE 32
static char *keymap_text;
static size_t keymap_text_len, keymap_insert;
static xkb_keycode_t spare_codes[UU_TEXT_SPARE];
static unsigned spare_count;
struct output { struct wl_output *handle; char name[128]; int transform,scale; uint32_t width,height; };
static struct output outputs[32];
static unsigned output_count, selected;
@@ -116,6 +124,164 @@ static int sync_display(void) {
if (!ready) wl_callback_destroy(cb);
return result;
}
/* Hand a keymap to the virtual keyboard. The compositor dups the fd, so it is closed here. */
static int upload_keymap(const char *text,size_t length) {
int fd=memfd_create("uuremote-keymap",MFD_CLOEXEC);
if(fd<0) return -1;
if(ftruncate(fd,(off_t)length)!=0 || write(fd,text,length)!=(ssize_t)length) { close(fd); return -1; }
zwp_virtual_keyboard_v1_keymap(keyboard,WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,fd,(uint32_t)length);
close(fd);
return 0;
}
/* A keymap uploaded to a keyboard the seat already has is never handed to the focused client again,
so pressing the remapped keycodes would still be translated with the keymap it has - which is how
every message came out as the one before it. Re-attaching the keyboard is what makes the
compositor send the keymap to the client (measured 2026-10-18 on Hyprland 0.56.2). */
static int rekey_keyboard(void) {
if(!keyboard_manager || !seat) return -1;
if(keyboard) zwp_virtual_keyboard_v1_destroy(keyboard);
keyboard=zwp_virtual_keyboard_manager_v1_create_virtual_keyboard(keyboard_manager,seat);
return keyboard?0:-1;
}
/* Offset of the '}' that closes the xkb_symbols section, so extra keys can be declared there.
Pairing the braces is enough because the bodies are balanced; looking for the last "};" is not,
the keymap's own brace follows, and an optional xkb_geometry section may too. */
static size_t symbols_close(const char *text) {
const char *section=strstr(text,"xkb_symbols");
if(!section) return 0;
const char *open=strchr(section,'{');
if(!open) return 0;
int depth=0;
for(const char *p=open;*p;p++) {
if(*p=='{') depth++;
else if(*p=='}' && --depth==0) return (size_t)(p-text);
}
return 0;
}
/* Named keycodes the keymap gives no symbol to. Reading the compositor's own list is the only
portable way: pressing an unmapped keycode types nothing, and uu_wl_key never matches one
because it searches by keysym. Highest first, since uu_wl_key takes the lowest match. */
static unsigned find_spare_codes(xkb_keycode_t *out,unsigned limit) {
unsigned count=0;
xkb_keycode_t min=xkb_keymap_min_keycode(keymap);
for(xkb_keycode_t code=xkb_keymap_max_keycode(keymap);code>min && count<limit;code--) {
if(code<8 || code>=sizeof(held_keys) || !xkb_keymap_key_get_name(keymap,code)) continue;
int mapped=0;
for(xkb_level_index_t level=0;level<xkb_keymap_num_levels_for_key(keymap,code,0) && !mapped;level++) {
const xkb_keysym_t *syms;
if(xkb_keymap_key_get_syms_by_level(keymap,code,0,level,&syms)>0) mapped=1;
}
if(!mapped) out[count++]=code;
}
return count;
}
/* A keycode the session keymap already produces this symbol with, unshifted. Typing through it
needs no upload, so no client can mistranslate it - and it is how plain latin text and spaces
arrive without touching the keymap at all. Spares never match: the pristine keymap leaves them
unmapped. */
static xkb_keycode_t existing_keycode(xkb_keysym_t symbol) {
for(xkb_keycode_t code=xkb_keymap_min_keycode(keymap);code<=xkb_keymap_max_keycode(keymap);code++) {
if(code<8 || code>=sizeof(held_keys)) continue;
const xkb_keysym_t *syms;
if(xkb_keymap_key_get_syms_by_level(keymap,code,0,0,&syms)==1 && syms[0]==symbol) return code;
}
return 0;
}
static void press_keycode(xkb_keycode_t code) {
zwp_virtual_keyboard_v1_key(keyboard,timestamp(),code-8,WL_KEYBOARD_KEY_STATE_PRESSED);
zwp_virtual_keyboard_v1_key(keyboard,timestamp(),code-8,WL_KEYBOARD_KEY_STATE_RELEASED);
held_keys[code]=0;
}
/* The replaced keyboard starts with nothing held, and a keycode held_keys still calls held would be
skipped by uu_wl_key's next press of it. */
static void release_held_keys_locked(void) {
for(xkb_keycode_t code=xkb_keymap_min_keycode(keymap);code<=xkb_keymap_max_keycode(keymap);code++) {
if(code<8 || code>=sizeof(held_keys) || !held_keys[code]) continue;
zwp_virtual_keyboard_v1_key(keyboard,timestamp(),code-8,WL_KEYBOARD_KEY_STATE_RELEASED);
xkb_state_update_key(key_state,code,XKB_KEY_UP);
}
memset(held_keys,0,sizeof(held_keys));
}
/* Upload one batch: re-attach the keyboard so the client takes the keymap, point spare keycodes at
these symbols, wait for the compositor to install it, then press them. Spares are left out of
key_state and held_keys: pressed and released here. */
static int flush_batch(char *buffer,size_t capacity,const char names[][64],const xkb_keycode_t *codes,unsigned count,int *typed) {
release_held_keys_locked();
if(rekey_keyboard()!=0) return -1;
size_t at=keymap_insert;
memcpy(buffer,keymap_text,at);
for(unsigned i=0;i<count;i++) {
int wrote=snprintf(buffer+at,capacity-at,"\tkey <%s> { [ %s ] };\n",xkb_keymap_key_get_name(keymap,codes[i]),names[i]);
if(wrote<0 || (size_t)wrote>=capacity-at) return -1;
at+=(size_t)wrote;
}
memcpy(buffer+at,keymap_text+keymap_insert,keymap_text_len-keymap_insert);
if(upload_keymap(buffer,at+(keymap_text_len-keymap_insert))!=0) return -1;
if(sync_display()!=0) return -1;
for(unsigned i=0;i<count;i++) { press_keycode(codes[i]); (*typed)++; }
return 0;
}
/* Type UTF-8 like xdotool type does on X11, but on Wayland: characters the session keymap already
has go out as ordinary keycodes, the rest share the spares of one keymap upload (~70 KB, so one
batch per upload), in text order. Never logs the text. */
static int type_utf8_locked(const char *text) {
size_t capacity=keymap_text_len+(size_t)UU_TEXT_SPARE*96+64;
char *buffer=malloc(capacity);
if(!buffer) return -1;
char names[UU_TEXT_SPARE][64];
xkb_keycode_t codes[UU_TEXT_SPARE];
unsigned count=0;
int typed=0, failed=0;
const unsigned char *p=(const unsigned char *)text;
while(*p && !failed) {
unsigned cp=0; int n=0;
if(*p<0x80) { cp=*p; n=1; }
else if((*p&0xE0)==0xC0 && (p[1]&0xC0)==0x80) { cp=((p[0]&0x1F)<<6)|(p[1]&0x3F); n=2; }
else if((*p&0xF0)==0xE0 && (p[1]&0xC0)==0x80 && (p[2]&0xC0)==0x80) { cp=((p[0]&0x0F)<<12)|((p[1]&0x3F)<<6)|(p[2]&0x3F); n=3; }
else if((*p&0xF8)==0xF0 && (p[1]&0xC0)==0x80 && (p[2]&0xC0)==0x80 && (p[3]&0xC0)==0x80) { cp=((p[0]&0x07)<<18)|((p[1]&0x3F)<<12)|((p[2]&0x3F)<<6)|(p[3]&0x3F); n=4; }
else { p++; continue; }
p+=n;
xkb_keysym_t sym;
if(cp=='\n') sym=0xff0d; /* Return */
else if(cp=='\t') sym=0xff09; /* Tab */
else if(cp<0x20 || cp==0x7f || (cp>=0x80 && cp<0xa0)) continue; /* controls carry no text */
else if(cp<0x100) sym=cp; /* Latin-1 keysyms equal the code point */
else sym=(xkb_keysym_t)(0x1000000|cp); /* Unicode keysym */
xkb_keycode_t existing=existing_keycode(sym);
if(existing) {
if(count && flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; }
count=0;
press_keycode(existing); typed++;
continue;
}
if(count==UU_TEXT_SPARE) {
if(flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; }
count=0;
}
/* The name is what the keymap parser reads back; an unnamed keysym cannot be spelled. */
if(xkb_keysym_get_name(sym,names[count],sizeof(names[count]))<=0) continue;
codes[count]=spare_codes[count];
count++;
}
if(!failed && count) failed=flush_batch(buffer,capacity,names,codes,count,&typed)!=0;
free(buffer);
/* Restore the pristine keymap whatever happened above, so uu_wl_key keeps its own symbol map. */
if(upload_keymap(keymap_text,keymap_text_len)!=0) return -1;
return failed && !typed?-1:typed;
}
int uu_wl_type_utf8(const char *text) {
pthread_mutex_lock(&lock);
int typed=-1;
if(initialized && text && keymap_text && keymap_insert && spare_count) typed=type_utf8_locked(text);
if(typed>=0 && wl_display_flush(display)<0) typed=-1;
pthread_mutex_unlock(&lock); return typed;
}
/* Diagnostic: how many characters one keymap upload can carry, 0 when this keymap has no spare. */
int uu_wl_text_ready(void) {
pthread_mutex_lock(&lock);
int ready=initialized && keymap_text && keymap_insert ? (int)spare_count : 0;
pthread_mutex_unlock(&lock); return ready;
}
static void output_geometry(void*d,struct wl_output*o,int32_t x,int32_t y,int32_t w,int32_t h,int32_t sub,const char*m,const char*model,int32_t transform) { ((struct output*)d)->transform=transform; }
static void output_mode(void*d,struct wl_output*o,uint32_t f,int32_t w,int32_t h,int32_t rate) {
if(f&WL_OUTPUT_MODE_CURRENT) { ((struct output*)d)->width=w; ((struct output*)d)->height=h; }
@@ -357,6 +523,7 @@ static void reset(void) {
dmabuf=NULL; dmabuf_requested=dmabuf_disabled=dmabuf_reported=0; dmabuf_linear_formats=0;
pending=0; output_count=0; initialized=0; memset(outputs,0,sizeof(outputs));
memset(held_keys,0,sizeof(held_keys));
free(keymap_text); keymap_text=NULL; keymap_text_len=keymap_insert=0; spare_count=0;
}
int uu_wl_init(int32_t *w,int32_t *h) {
pthread_mutex_lock(&lock);
@@ -390,20 +557,47 @@ int uu_wl_init(int32_t *w,int32_t *h) {
keymap=xkb_keymap_new_from_names(xkb,&names,XKB_KEYMAP_COMPILE_NO_FLAGS);
if(!keymap) goto end;
key_state=xkb_state_new(keymap); if(!key_state) goto end;
char *map=xkb_keymap_get_as_string(keymap,XKB_KEYMAP_FORMAT_TEXT_V1);
if(!map) goto end;
size_t length=strlen(map)+1;
int fd=memfd_create("uuremote-keymap",MFD_CLOEXEC);
if(fd<0) { free(map); goto end; }
if(ftruncate(fd,(off_t)length)!=0 || write(fd,map,length)!=(ssize_t)length) { free(map); close(fd); goto end; }
free(map);
zwp_virtual_keyboard_v1_keymap(keyboard,WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,fd,length); close(fd);
keymap_text=xkb_keymap_get_as_string(keymap,XKB_KEYMAP_FORMAT_TEXT_V1);
if(!keymap_text) goto end;
keymap_text_len=strlen(keymap_text)+1;
if(upload_keymap(keymap_text,keymap_text_len)!=0) goto end;
if(sync_display()!=0) goto end;
/* Text typing needs unmapped keycodes and a place to declare them. A keymap without either
only costs that path - uu_wl_type_utf8 refuses and the caller keeps its own fallback. */
keymap_insert=symbols_close(keymap_text);
spare_count=find_spare_codes(spare_codes,sizeof(spare_codes)/sizeof(spare_codes[0]));
initialized=1; *w=width; *h=height; result=0;
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. */
+49
View File
@@ -3,6 +3,7 @@
* Zero-Wine dependency, zero-overhead, thread-safe.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/shm.h>
@@ -218,6 +219,54 @@ int x11_key_symbol(unsigned long symbol, int is_press) {
return 0;
}
/* Type UTF-8 text the way xdotool does: bind each character's keysym to a spare (unmapped) keycode, press it,
* then restore the keycode. Works for CJK text from mobile input methods. Never logs the text. */
int x11_type_utf8(const char *text) {
if (!g_display || !text) return -1;
int min_kc = 0, max_kc = 0, per = 0;
XDisplayKeycodes(g_display, &min_kc, &max_kc);
KeySym *map = XGetKeyboardMapping(g_display, (KeyCode)min_kc, max_kc - min_kc + 1, &per);
if (!map) return -2;
int spare = 0;
for (int kc = max_kc; kc >= min_kc && !spare; kc--) {
int empty = 1;
for (int i = 0; i < per; i++) if (map[(kc - min_kc) * per + i] != NoSymbol) { empty = 0; break; }
if (empty) spare = kc;
}
XFree(map);
if (!spare) return -3;
int typed = 0;
const unsigned char *p = (const unsigned char *)text;
while (*p) {
unsigned cp; int n;
if (*p < 0x80) { cp = *p; n = 1; }
else if ((*p & 0xE0) == 0xC0 && (p[1] & 0xC0) == 0x80) { cp = ((p[0] & 0x1F) << 6) | (p[1] & 0x3F); n = 2; }
else if ((*p & 0xF0) == 0xE0 && (p[1] & 0xC0) == 0x80 && (p[2] & 0xC0) == 0x80) { cp = ((p[0] & 0x0F) << 12) | ((p[1] & 0x3F) << 6) | (p[2] & 0x3F); n = 3; }
else if ((*p & 0xF8) == 0xF0 && (p[1] & 0xC0) == 0x80 && (p[2] & 0xC0) == 0x80 && (p[3] & 0xC0) == 0x80) { cp = ((p[0] & 0x07) << 18) | ((p[1] & 0x3F) << 12) | ((p[2] & 0x3F) << 6) | (p[3] & 0x3F); n = 4; }
else { p++; continue; }
p += n;
KeySym sym;
if (cp == '\n') sym = 0xff0d; /* Return */
else if (cp == '\t') sym = 0xff09; /* Tab */
else if (cp < 0x20 || cp == 0x7f || (cp >= 0x80 && cp < 0xa0)) continue;
else if (cp < 0x100) sym = cp; /* Latin-1 keysyms equal the code point */
else sym = 0x1000000 | cp; /* Unicode keysym */
KeySym syms[2] = { sym, sym };
XChangeKeyboardMapping(g_display, spare, 2, syms, 1);
XSync(g_display, False);
usleep(8000); /* let clients see the MappingNotify before the key */
XTestFakeKeyEvent(g_display, spare, True, CurrentTime);
XTestFakeKeyEvent(g_display, spare, False, CurrentTime);
XSync(g_display, False);
usleep(8000);
typed++;
}
KeySym none[2] = { NoSymbol, NoSymbol };
XChangeKeyboardMapping(g_display, spare, 2, none, 1);
XSync(g_display, False);
return typed;
}
int x11_key_event(int keycode, int is_press) {
if (!g_display) return -1;
if (is_press) track_injected_key(keycode, 1);
@@ -0,0 +1,14 @@
[Desktop Entry]
Type=Application
Name=UU 远程 Linux 控制端
Name[en]=UU Remote Linux Viewer
GenericName=Remote desktop viewer
Comment=非官方 UU 远程控制端(实验性):远控你的 Windows / Mac / Linux 设备
Comment[en]=Unofficial NetEase UU Remote viewer (experimental)
Exec=uuremote-viewer ui
Icon=uu-remote-linux
Terminal=false
Categories=Network;RemoteAccess;
Keywords=remote;desktop;viewer;UU;远程;控制;
StartupNotify=false
StartupWMClass=uuremote-viewer
+2
View File
@@ -11,3 +11,5 @@ Terminal=false
Categories=Network;RemoteAccess;
Keywords=remote;assist;UU;远程;协助;
StartupNotify=false
# Matches the GTK window class so docks/taskbars show this icon for the host window (#13).
StartupWMClass=uu-remote-linux
+1
View File
@@ -0,0 +1 @@
__pycache__/
+103
View File
@@ -0,0 +1,103 @@
# Paste copied files into a UU-mapped SSH terminal on macOS
This optional Mac companion uploads files copied in Finder when you paste them
into Ghostty, then inserts shell-quoted **remote** paths into the terminal.
For example, copy an image in Finder, connect with `uu-ssh-paste`, and press
Command-V at a remote shell prompt or in a terminal application's text field.
The file is available on the server before its path is inserted. No Enter is sent.
The connection is Ghostty → OpenSSH → your existing UU TCP mapping → the Linux
host's SSH server. Both terminal traffic and uploads use the same SSH alias.
The companion does not create a mapping or fall back to a public network route.
The official Mac UU application's built-in terminal is unaffected.
## Install and connect
On the controlling Mac, install Python 3 and Apple's command-line developer
tools (for `swiftc`), then run from this repository:
```sh
sh contrib/macos-ssh/install.sh
```
Enable port mapping on your Linux UU host (`UU_PORT_MAPPING=1`); in the official
Mac UU app, map a **local loopback** port to `127.0.0.1:22` on that host. Keep
the mapping connected. Configure an SSH alias for that local port, using your
existing key and the server's verified host key. For example:
```sshconfig
Host uu-server
HostName 127.0.0.1
Port 22243
User your-linux-user
IdentityFile ~/.ssh/id_ed25519
IdentitiesOnly yes
HostKeyAlias your-existing-server-host-key-name
StrictHostKeyChecking yes
ProxyCommand none
ProxyJump none
```
In Ghostty, connect using that alias:
```sh
uu-ssh-paste uu-server
# Or use a separate SSH config:
uu-ssh-paste -F ~/.config/your-uu-ssh.conf uu-server
```
Copy one or several files in Finder with Command-C, switch to the connected
terminal, and press Command-V. Each paste creates a unique mode-0700 directory
under `~/.local/share/uuremote/uploads/` on the server. Files remain there until
you remove them. Filenames with spaces, Unicode and shell metacharacters are
supported. Existing files are never overwritten by another paste batch.
Text paste, SSH exit statuses, terminal resizing and mouse reports pass through.
The remote application still controls whether it receives bracketed paste and
mouse movement. Ctrl-C during a transfer cancels that paste. Input typed while
the upload is running is queued, so Enter cannot overtake the uploaded path.
Ghostty's title bar shows the connection phase, upload percentage, transferred
size, transfer speed and elapsed time. Its progress indicator tracks the upload
too. Progress is derived from OpenSSH's transfer meter, aggregated across copied
files; it is not a simulated timer. The original terminal title is restored when
the upload finishes, fails or is cancelled, and no terminal cells are overwritten.
Filename and error output from SCP stays private; only numeric progress is shown.
## Scope and failure behavior
- Only file-URL clipboard entries copied in Finder are uploaded, and only when
they match the complete pasted path list. Pasting a textual local path or a
command does not upload anything. The clipboard is never modified or polled
in the background; file URLs are read only during a potential file paste.
- Folder paste, drag-and-drop and raw screenshot/image clipboard data are not
supported. Save an image as a file and copy that file in Finder first.
- The SSH server must support SFTP. Upload authentication is noninteractive
(`BatchMode=yes`); the alias must already work with a key or SSH agent.
- Missing files, duplicate basenames in a batch, control characters in filenames,
failed uploads and clipboard-reader failures do not insert a misleading path.
Failed transfer directories are removed on a best-effort basis. No file names,
clipboard contents, file contents, terminal input or SSH error text are logged.
- A paste is limited to 256 files and 8 MiB of pasted path/text data. Transfers
time out after five minutes. File sizes themselves are not limited to 8 MiB.
- The companion keeps local bracketed-paste framing enabled while the session
runs and removes framing for remote applications that have not requested it.
No global Ghostty configuration, remote desktop or Wine component is needed.
## Tests
```sh
python3 -m unittest discover -s contrib/macos-ssh -p 'test_*.py' -v
swiftc -O contrib/macos-ssh/clipboard-files.swift -o /tmp/clipboard-files
/tmp/clipboard-files --self-test
# Optional real SSH/SFTP acceptance test over an already connected UU mapping:
UU_PASTE_TEST_HOST=uu-server UU_PASTE_TEST_CONFIG="$HOME/.config/your-uu-ssh.conf" \
python3 -m unittest discover -s contrib/macos-ssh -p 'test_*.py' -v
```
The Swift test uses a private pasteboard and never touches the user's clipboard.
Python tests exercise fragmented paste framing, shell quoting, plain text,
mouse reports, failed uploads, queued Enter, PTY restoration and exit status.
The optional live tests transfer synthetic binary files and verify hashes,
including a throttled upload that must report intermediate byte progress.
Physical Command-C/Command-V behavior in Finder/Ghostty remains a manual check.
+29
View File
@@ -0,0 +1,29 @@
import AppKit
import Foundation
// Only file URLs are read. Text, images and the general pasteboard are never
// written, and the result is consumed privately by the SSH companion.
func filePaths(_ board: NSPasteboard) -> [String] {
let options: [NSPasteboard.ReadingOptionKey: Any] = [.urlReadingFileURLsOnly: true]
return (board.readObjects(forClasses: [NSURL.self], options: options) as? [URL] ?? [])
.filter { $0.isFileURL }.map { $0.path }
}
if CommandLine.arguments.dropFirst().first == "--self-test" {
// An isolated pasteboard: tests never read or overwrite the user's clipboard.
let board = NSPasteboard.withUniqueName()
defer { board.releaseGlobally() }
let paths = ["/tmp/space and 中文.png", "/tmp/quote'$(literal).txt"]
board.writeObjects(paths.map { NSURL(fileURLWithPath: $0) })
precondition(filePaths(board) == paths)
board.clearContents()
board.setString("/tmp/text-is-not-a-file", forType: .string)
precondition(filePaths(board).isEmpty)
board.clearContents()
board.writeObjects([NSURL(string: "https://example.invalid/file")!])
precondition(filePaths(board).isEmpty)
print("Private pasteboard tests passed")
} else {
let data = try JSONSerialization.data(withJSONObject: filePaths(.general))
FileHandle.standardOutput.write(data)
}
+27
View File
@@ -0,0 +1,27 @@
#!/bin/sh
set -eu
if [ "$(uname -s)" != Darwin ]; then
echo 'Install this companion on the controlling Mac.' >&2
exit 1
fi
command -v python3 >/dev/null
source_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
data_dir="$HOME/.local/share/uuremote/macos-ssh"
bin_dir="$HOME/.local/bin"
mkdir -p "$data_dir" "$bin_dir"
scratch=$(mktemp -d)
trap 'rm -rf "$scratch"' EXIT HUP INT TERM
swiftc -O "$source_dir/clipboard-files.swift" -o "$scratch/clipboard-files"
"$scratch/clipboard-files" --self-test
install -m 755 "$scratch/clipboard-files" "$data_dir/clipboard-files"
install -m 755 "$source_dir/uu-ssh-paste" "$data_dir/uu-ssh-paste"
if [ -e "$bin_dir/uu-ssh-paste" ] && [ ! -L "$bin_dir/uu-ssh-paste" ]; then
echo 'An existing uu-ssh-paste file was preserved; inspect it before replacing it.' >&2
exit 1
fi
if [ -L "$bin_dir/uu-ssh-paste" ] && [ "$(readlink "$bin_dir/uu-ssh-paste")" != "$data_dir/uu-ssh-paste" ]; then
echo 'An unrelated uu-ssh-paste symlink was preserved; inspect it before replacing it.' >&2
exit 1
fi
ln -sfn "$data_dir/uu-ssh-paste" "$bin_dir/uu-ssh-paste"
echo 'Installed uu-ssh-paste. Connect using your existing UU SSH alias.'
+472
View File
@@ -0,0 +1,472 @@
"""Synthetic fixtures only; never inspect or change the general pasteboard."""
import base64
import errno
import hashlib
import importlib.machinery
import importlib.util
import json
import os
from pathlib import Path
import pty
import select
import shlex
import signal
import struct
import subprocess
import sys
import tempfile
import termios
import threading
import time
import unittest
from unittest import mock
SCRIPT = Path(__file__).with_name("uu-ssh-paste")
loader = importlib.machinery.SourceFileLoader("uu_paste", str(SCRIPT))
spec = importlib.util.spec_from_loader(loader.name, loader)
paste = importlib.util.module_from_spec(spec)
loader.exec_module(paste)
class FramingTests(unittest.TestCase):
def test_paste_at_every_fragment_boundary_and_multiple_pastes(self):
wire = b"key" + paste.START + b"hello\nworld" + paste.END + b"\r"
expected = [("data", b"key"), ("paste", b"hello\nworld"), ("data", b"\r")]
for split in range(len(wire) + 1):
frames = paste.InputFrames()
events = frames.feed(wire[:split]) + frames.feed(wire[split:])
merged = []
for kind, data in events:
if kind == "data" and merged and merged[-1][0] == "data":
merged[-1] = (kind, merged[-1][1] + data)
else:
merged.append((kind, data))
self.assertEqual(merged, expected)
frames = paste.InputFrames()
self.assertEqual(frames.feed(paste.START + b"a" + paste.END + paste.START + b"b" + paste.END),
[("paste", b"a"), ("paste", b"b")])
def test_mouse_and_arrow_bytes_and_standalone_escape(self):
raw = b"\x1b[<2;12;4M\x1b[<2;12;4m\x1b[<35;13;5M\x1b[A\x1b"
frames = paste.InputFrames()
output = b"".join(data for kind, data in frames.feed(raw) if kind == "data")
self.assertEqual(output + frames.flush_key(), raw)
def test_oversized_paste_is_discarded_and_parser_recovers(self):
frames = paste.InputFrames()
with mock.patch.object(paste, "MAX_PASTE", 16):
self.assertEqual(frames.feed(paste.START + b"x" * 40), [])
self.assertEqual(frames.feed(paste.END + b"next")[-1], ("data", b"next"))
self.assertFalse(frames.pasting)
self.assertLess(len(frames.buffer), 16)
def test_remote_modes_track_split_sequences_without_disabling_local_framing(self):
for split in range(len(paste.DISABLE) + 1):
modes = paste.OutputModes()
modes.bracketed = True
result = modes.feed(paste.DISABLE[:split]) + modes.feed(paste.DISABLE[split:])
self.assertEqual(result, paste.ENABLE)
self.assertFalse(modes.bracketed)
modes = paste.OutputModes()
self.assertEqual(modes.feed(b"\x1b[?1;2004h"), b"\x1b[?1h" + paste.ENABLE)
self.assertTrue(modes.bracketed)
self.assertEqual(modes.feed(b"\x1b[?2004;25l"), b"\x1b[?25l" + paste.ENABLE)
self.assertFalse(modes.bracketed)
self.assertEqual(modes.feed(b"\x1bc"), b"\x1bc" + paste.ENABLE)
raw = b"\x1b[31mhello\x1b[0m\x1b]0;title\x07"
self.assertEqual(modes.feed(raw), raw)
class FileTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.files = [self.root / "space 中文.png", self.root / "quote'$(literal);.txt"]
for path in self.files:
path.write_bytes(os.urandom(1025))
self.paths = [str(p) for p in self.files]
# Ghostty uses backslash escaping rather than POSIX single quotes.
escape = "\\ ()[]{}<>\"'`!#$&;|*?\t"
self.payload = " ".join("".join("\\" + c if c in escape else c for c in p)
for p in self.paths).encode()
def test_finder_files_match_ghostty_escaping(self):
self.assertEqual(paste.copied_files(self.payload, lambda: self.paths), self.paths)
def test_plain_text_and_pasted_commands_do_not_upload(self):
clipboard = mock.Mock(return_value=[])
for value in (b"hello\nworld", b"cat /tmp/file", b"\xff", b"'unterminated"):
self.assertIsNone(paste.copied_files(value, clipboard))
clipboard.assert_not_called()
self.assertIsNone(paste.copied_files(self.payload, lambda: []))
self.assertIsNone(paste.copied_files(self.payload, lambda: self.paths[::-1]))
def test_missing_files_folders_duplicate_names_and_control_characters_rejected(self):
cases = [[str(self.root)], [str(self.root / "missing")]]
newline = self.root / "bad\nname"
newline.write_text("synthetic")
cases.append([str(newline)])
folder = self.root / "another"
folder.mkdir()
duplicate = folder / self.files[0].name
duplicate.write_text("synthetic")
cases.append([self.paths[0], str(duplicate)])
for paths in cases:
with self.assertRaises(paste.PasteError):
paste.copied_files(shlex.join(paths).encode(), lambda: paths)
def test_upload_paths_are_quoted_and_failed_batch_is_cleaned(self):
uploader = paste.Uploader(self.root / "config with spaces", "uu-test")
directory = b"/home/test user/.local/share/uuremote/uploads/paste.ABCD1234\n"
with mock.patch.object(paste, "run_private", side_effect=[directory, b""]) as run:
result = uploader.upload(self.paths, threading.Event())
self.assertEqual(shlex.split(result.decode()),
[directory.decode().strip() + "/" + p.name for p in self.files])
self.assertEqual(run.call_args_list[1].args[0][-3:-1], self.paths)
self.assertNotIn("-O", run.call_args_list[1].args[0])
self.assertIn("BatchMode=yes", run.call_args_list[1].args[0])
with mock.patch.object(paste, "run_private", side_effect=[directory, paste.PasteError("failed"), b""]) as run:
with self.assertRaises(paste.PasteError):
uploader.upload(self.paths, threading.Event())
cleanup = run.call_args_list[2].args[0][-1]
self.assertEqual(shlex.split(cleanup), ["rm", "-rf", "--", directory.decode().strip()])
def test_bad_destination_and_bad_clipboard_fail_without_content_in_error(self):
uploader = paste.Uploader(None, "uu-test")
for output in (b"relative", b"/tmp/invalid", b"/tmp/paste.abc\nextra", b"\xff"):
with mock.patch.object(paste, "run_private", return_value=output):
with self.assertRaises(paste.PasteError):
uploader.upload(self.paths, threading.Event())
with mock.patch.object(paste.subprocess, "run", return_value=subprocess.CompletedProcess([], 0, b"{}")):
with self.assertRaises(paste.PasteError):
paste.clipboard_paths("helper")
def test_cancellation_stops_transfer(self):
cancel = threading.Event()
cancel.set()
with self.assertRaisesRegex(paste.PasteError, "cancelled"):
paste.run_private([sys.executable, "-c", "import time;time.sleep(30)"], cancel, 3)
class ProgressTests(unittest.TestCase):
def test_numeric_meter_handles_fragments_multiple_files_and_rounding(self):
for fragment in (1, 7, 9999):
reports = []
meter = paste.SCPMeter([1048576, 1025], lambda *args: reports.append(args))
wire = (b"\rprivate-file 0% 0 0.0KB/s --:-- ETA"
b"\rprivate-file 50% 512KB 128.0KB/s 00:04 ETA"
b"\rprivate-file 100% 1024KB 128.0KB/s 00:08\r\n"
b"\rsecret-other 0% 0 0.0KB/s --:-- ETA"
b"\rsecret-other 100% 1025 64.0KB/s 00:00\r\n")
for offset in range(0, len(wire), fragment):
meter.feed(wire[offset:offset + fragment])
self.assertIn(("uploading", 524288, 1049601, 131072), reports)
self.assertEqual(reports[-1], ("uploading", 1049601, 1049601, 65536))
self.assertEqual(meter.index, 2)
self.assertEqual([p[1] for p in reports], sorted(p[1] for p in reports))
self.assertNotIn("private-file", repr(reports))
self.assertNotIn("secret-other", repr(reports))
def test_unrecognized_output_is_not_displayed_and_buffer_is_bounded(self):
reports = []
meter = paste.SCPMeter([10], lambda *args: reports.append(args))
meter.feed(b"private error " * 10000 + b" 999% 5 1.0KB/s 00:00\n")
self.assertEqual(reports, [])
self.assertLessEqual(len(meter.buffer), 512)
def test_metered_process_captures_progress_privately_and_preserves_failure_cancellation(self):
reports = []
code = ("import os;assert os.isatty(1);assert os.tcgetpgrp(1)==os.getpgrp();"
"os.write(1,b'\\rprivate-file 100% 1025 64.0KB/s 00:00\\n')")
paste.run_metered([sys.executable, "-c", code], threading.Event(), 5,
paste.SCPMeter([1025], lambda *args: reports.append(args)))
self.assertEqual(reports[-1], ("uploading", 1025, 1025, 65536))
with self.assertRaises(paste.PasteError):
paste.run_metered([sys.executable, "-c", "raise SystemExit(2)"], threading.Event(), 5,
paste.SCPMeter([1], lambda *_: None))
cancel = threading.Event()
cancel.set()
with self.assertRaises(paste.PasteError):
paste.run_metered([sys.executable, "-c", "import time;time.sleep(30)"], cancel, 5,
paste.SCPMeter([1], lambda *_: None))
def test_display_restores_split_remote_title_and_never_changes_terminal_cells(self):
output = []
display = paste.UploadDisplay(output.append)
for byte in b"\x1b]2;remote app title\x1b\\":
display.observe(bytes([byte]))
with mock.patch.object(paste.time, "monotonic", return_value=10):
display.start(1048576)
with mock.patch.object(paste.time, "monotonic", return_value=13):
display.update("uploading", 524288, 1048576, 131072)
display.render()
display.render() # Throttled, not a second display update.
self.assertEqual(len(output), 2)
self.assertIn(b"Connecting", output[0])
self.assertIn(b"Uploading 50% | 512.0 KiB/1.0 MiB | 128.0 KiB/s | 3s", output[1])
self.assertIn(b"\x1b]9;4;1;50\x1b\\", output[1])
display.observe(b"\x1b]0;new remote title\x07")
display.finish()
self.assertEqual(output[-1], b"\x1b]9;4;0\x1b\\\x1b]2;new remote title\x1b\\")
display.finish()
self.assertEqual(len(output), 3)
self.assertTrue(all(b"\n" not in item and b"\r" not in item for item in output))
HARNESS = r'''
import os, runpy, sys, time, json
h = runpy.run_path(sys.argv[1])
paths, remote, mode, fail = json.loads(sys.argv[2])
class Upload:
def upload(self, files, cancel, progress):
assert files == paths
progress('uploading',512,1024,256)
time.sleep(0.1)
if fail == 'cancel':
assert cancel.wait(5)
if fail:
raise h['PasteError']('synthetic failure')
return remote.encode()
child = """import os,tty,base64
tty.setraw(0)
os.write(1, %r + b'CHILD_READY')
data=b''
while not data.endswith(b'\\r'):
part=os.read(0,65536)
if not part: break
data+=part
os.write(1,b'RECEIVED:' + base64.b64encode(data) + b':DONE')
raise SystemExit(7)
""" % (h['ENABLE'] if mode else h['DISABLE'])
raise SystemExit(h['relay']([sys.executable,'-c',child], lambda: paths, Upload()))
'''
class RelayTests(unittest.TestCase):
def test_resize_and_signal_shutdown_restore_terminal(self):
child = r'''
import fcntl,os,signal,struct,termios,tty
tty.setraw(0)
def resized(*_):
rows,cols,_,_=struct.unpack('HHHH',fcntl.ioctl(0,termios.TIOCGWINSZ,bytes(8)))
os.write(1,('SIZE:%d,%d;'%(rows,cols)).encode())
signal.signal(signal.SIGWINCH,resized)
resized()
while True: signal.pause()
'''
harness = "import runpy,sys;h=runpy.run_path(sys.argv[1]);h['relay']([sys.executable,'-c',sys.argv[2]],lambda:[],None)"
master, slave = pty.openpty()
original = termios.tcgetattr(slave)
import fcntl
fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 24, 80, 0, 0))
proc = subprocess.Popen([sys.executable, "-c", harness, str(SCRIPT), child],
stdin=slave, stdout=slave, stderr=slave)
output = bytearray()
def until(marker):
deadline = time.monotonic() + 5
while marker not in output:
self.assertLess(time.monotonic(), deadline, "Resize was not forwarded")
if select.select([master], [], [], 0.1)[0]:
output.extend(os.read(master, 65536))
try:
until(b"SIZE:24,80;")
fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 31, 110, 0, 0))
proc.send_signal(signal.SIGWINCH)
until(b"SIZE:31,110;")
proc.send_signal(signal.SIGTERM)
self.assertEqual(proc.wait(timeout=5), 128 + signal.SIGTERM)
restored = termios.tcgetattr(slave)
restored[3] &= ~getattr(termios, "PENDIN", 0)
original[3] &= ~getattr(termios, "PENDIN", 0)
self.assertEqual(restored, original)
finally:
if proc.poll() is None:
proc.kill()
proc.wait()
os.close(master)
os.close(slave)
def test_real_pty_upload_order_mouse_text_failure_exit_status_and_restoration(self):
with tempfile.TemporaryDirectory() as tmp:
file = Path(tmp) / "paste space 中文.txt"
file.write_text("synthetic fixture")
mouse = b"\x1b[<2;2;3M\x1b[<2;2;3m\x1b[<35;3;4M"
for mode, fail, ordinary in ((False, False, False), (True, False, False),
(True, True, False), (False, False, True),
(True, False, True), (True, 'cancel', False)):
with self.subTest(mode=mode, fail=fail, ordinary=ordinary):
master, slave = pty.openpty()
original = termios.tcgetattr(slave)
remote = shlex.quote("/home/test/.local/share/uuremote/uploads/paste.test/space 中文.txt")
config = json.dumps([[str(file)], remote, mode, fail])
proc = subprocess.Popen([sys.executable, "-c", HARNESS, str(SCRIPT), config],
stdin=slave, stdout=slave, stderr=slave)
output = bytearray()
try:
deadline = time.monotonic() + 10
while b"CHILD_READY" not in output:
self.assertLess(time.monotonic(), deadline, "PTY harness did not start")
if select.select([master], [], [], 0.1)[0]:
output.extend(os.read(master, 65536))
payload = b"ordinary\ntext" if ordinary else shlex.quote(str(file)).encode()
wire = mouse + paste.START + payload + paste.END
wire += b"\x03\r" if fail == 'cancel' else b"\r"
for byte in wire:
os.write(master, bytes([byte]))
while proc.poll() is None or select.select([master], [], [], 0)[0]:
self.assertLess(time.monotonic(), deadline, "PTY relay did not exit")
if select.select([master], [], [], 0.1)[0]:
try:
chunk = os.read(master, 65536)
except OSError as error:
if error.errno == errno.EIO:
break
raise
if not chunk:
break
output.extend(chunk)
self.assertEqual(proc.wait(timeout=2), 7)
encoded = bytes(output).split(b"RECEIVED:", 1)[1].split(b":DONE", 1)[0]
expected = b"" if fail else paste.paste_bytes(payload if ordinary else remote.encode(), mode)
interrupt = b"\x03" if fail == 'cancel' else b""
self.assertEqual(base64.b64decode(encoded), mouse + expected + interrupt + b"\r")
restored = termios.tcgetattr(slave)
# macOS sets PENDIN when restoring canonical input. It
# is kernel bookkeeping, not an unrestored user mode.
restored[3] &= ~getattr(termios, "PENDIN", 0)
original[3] &= ~getattr(termios, "PENDIN", 0)
self.assertEqual(restored, original)
if fail:
self.assertNotIn(str(file).encode(), output)
if not ordinary:
self.assertIn(b"UU upload: Connecting", output)
self.assertIn(b"\x1b]9;4;0\x1b\\", output)
if fail == 'cancel':
self.assertIn(b"UU upload: Cancelling", output)
finally:
if proc.poll() is None:
proc.kill()
proc.wait()
os.close(master)
os.close(slave)
@unittest.skipUnless(os.environ.get("UU_PASTE_TEST_HOST"), "set UU_PASTE_TEST_HOST for a real mapped SSH test")
class MappedSSHTests(unittest.TestCase):
def test_live_upload_reports_intermediate_progress_and_verified_completion(self):
host = os.environ["UU_PASTE_TEST_HOST"]
uploader = paste.Uploader(os.environ.get("UU_PASTE_TEST_CONFIG"), host)
uploader.scp.extend(["-l", "1024"]) # Deliberately slow a synthetic transfer.
reports = []
with tempfile.TemporaryDirectory() as tmp:
source = Path(tmp) / "private progress 中文.bin"
source.write_bytes(os.urandom(1024 * 1024))
paths = shlex.split(uploader.upload([str(source)], threading.Event(),
lambda *args: reports.append(args)).decode())
try:
total = source.stat().st_size
self.assertEqual(reports[0], ("connecting", 0, total, 0))
self.assertTrue(any(0 < done < total and speed > 0
for stage, done, size, speed in reports if stage == "uploading"))
self.assertEqual(reports[-1], ("finishing", total, total, 0))
self.assertNotIn(source.name, repr(reports))
remote = paste.run_private([*uploader.ssh, "sha256sum -- " + shlex.quote(paths[0])],
threading.Event(), 30)
self.assertEqual(remote.split()[0].decode(), hashlib.sha256(source.read_bytes()).hexdigest())
finally:
paste.run_private([*uploader.ssh, "rm -rf -- " + shlex.quote(str(Path(paths[0]).parent))],
threading.Event(), 30)
def test_paste_through_real_pty_and_uu_ssh_opens_uploaded_files(self):
host = os.environ["UU_PASTE_TEST_HOST"]
config = os.environ.get("UU_PASTE_TEST_CONFIG")
with tempfile.TemporaryDirectory() as tmp:
files = [Path(tmp) / "copied file 中文.bin", Path(tmp) / "literal'$(echo nope);.bin"]
for file in files:
file.write_bytes(os.urandom(65569))
hashes = [hashlib.sha256(f.read_bytes()).hexdigest() for f in files]
mouse = b"\x1b[<2;2;3M\x1b[<2;2;3m\x1b[<35;3;4M"
remote = r'''
import os,tty,shlex,hashlib,json,shutil
from pathlib import Path
tty.setraw(0)
os.write(1,b'\x1b[?2004hLIVE_READY')
data=b''
while not data.endswith(b'\r'):
data+=os.read(0,65536)
mouse=b'\x1b[<2;2;3M\x1b[<2;2;3m\x1b[<35;3;4M'
assert data.startswith(mouse+b'\x1b[200~') and data.endswith(b'\x1b[201~\r')
paths=shlex.split(data[len(mouse)+6:-7].decode())
assert len(paths)==2
hashes=[hashlib.sha256(Path(p).read_bytes()).hexdigest() for p in paths]
for directory in {Path(p).parent for p in paths}:
assert directory.parent==Path.home()/'.local/share/uuremote/uploads'
assert directory.name.startswith('paste.')
shutil.rmtree(directory)
os.write(1,b'LIVE_HASHES:'+json.dumps(hashes).encode()+b':DONE')
'''
harness = r'''
import runpy,sys,json
h=runpy.run_path(sys.argv[1])
host,config,paths,remote=json.loads(sys.argv[2])
uploader=h['Uploader'](config,host)
common=['-F',config] if config else []
raise SystemExit(h['relay'](['/usr/bin/ssh',*common,'-tt',host,remote],lambda:paths,uploader))
'''
args = json.dumps([host, config, [str(p) for p in files], "python3 -c " + shlex.quote(remote)])
master, slave = pty.openpty()
process = subprocess.Popen([sys.executable, "-c", harness, str(SCRIPT), args],
stdin=slave, stdout=slave, stderr=slave)
output = bytearray()
try:
deadline = time.monotonic() + 60
sent = False
while process.poll() is None or select.select([master], [], [], 0)[0]:
self.assertLess(time.monotonic(), deadline, "Live paste timed out")
if select.select([master], [], [], 0.1)[0]:
output.extend(os.read(master, 65536))
if b"LIVE_READY" in output and not sent:
payload = shlex.join([str(p) for p in files]).encode()
os.write(master, mouse + paste.START + payload + paste.END + b"\r")
sent = True
self.assertEqual(process.wait(timeout=2), 0)
received = bytes(output).split(b"LIVE_HASHES:", 1)[1].split(b":DONE", 1)[0]
self.assertEqual(json.loads(received), hashes)
finally:
if process.poll() is None:
process.kill()
process.wait()
os.close(master)
os.close(slave)
def test_real_upload_roundtrip_binary_unicode_and_shell_metacharacters(self):
host = os.environ["UU_PASTE_TEST_HOST"]
config = os.environ.get("UU_PASTE_TEST_CONFIG")
uploader = paste.Uploader(config, host)
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
files = [root / "space 中文.bin", root / "literal'$(echo nope);.bin"]
for file in files:
file.write_bytes(os.urandom(65569))
paths = shlex.split(uploader.upload([str(f) for f in files], threading.Event()).decode())
try:
for index, (source, remote) in enumerate(zip(files, paths)):
dest = root / ("download-" + str(index))
paste.run_private([*uploader.scp, f"{host}:{remote}", str(dest)], threading.Event(), 60)
self.assertEqual(hashlib.sha256(source.read_bytes()).digest(),
hashlib.sha256(dest.read_bytes()).digest())
directory = str(Path(paths[0]).parent)
mode = paste.run_private([*uploader.ssh, "stat -c %a -- " + shlex.quote(directory)],
threading.Event(), 30)
self.assertEqual(mode.strip(), b"700")
finally:
paste.run_private([*uploader.ssh, "rm -rf -- " + shlex.quote(str(Path(paths[0]).parent))],
threading.Event(), 30)
if __name__ == "__main__":
unittest.main()
+594
View File
@@ -0,0 +1,594 @@
#!/usr/bin/env python3
"""Paste Finder files into an SSH terminal through an existing UU TCP mapping."""
import argparse
import collections
import errno
import fcntl
import json
import os
from pathlib import Path
import pty
import queue
import re
import select
import shlex
import signal
import stat
import struct
import subprocess
import sys
import termios
import threading
import time
import tty
START, END = b"\x1b[200~", b"\x1b[201~"
ENABLE, DISABLE = b"\x1b[?2004h", b"\x1b[?2004l"
MAX_PASTE = 8 * 1024 * 1024
class PasteError(Exception):
"""Messages must not include clipboard contents, paths or subprocess output."""
def prefix_tail(data, marker):
for length in range(min(len(data), len(marker) - 1), 0, -1):
if data.endswith(marker[:length]):
return length
return 0
class InputFrames:
"""Recognize bracketed pastes across arbitrary PTY read boundaries."""
def __init__(self):
self.buffer = b""
self.pasting = False
self.overflow = False
def feed(self, data):
self.buffer += data
events = []
while self.buffer:
if self.pasting:
end = self.buffer.find(END)
if end < 0:
if len(self.buffer) > MAX_PASTE:
self.overflow = True
tail = prefix_tail(self.buffer, END)
self.buffer = self.buffer[-tail:] if tail else b""
break
payload, self.buffer = self.buffer[:end], self.buffer[end + len(END):]
events.append(("error" if self.overflow or len(payload) > MAX_PASTE else "paste", payload))
self.pasting = self.overflow = False
else:
start = self.buffer.find(START)
if start >= 0:
if start:
events.append(("data", self.buffer[:start]))
self.buffer = self.buffer[start + len(START):]
self.pasting = True
else:
tail = prefix_tail(self.buffer, START)
size = len(self.buffer) - tail
if size:
events.append(("data", self.buffer[:size]))
self.buffer = self.buffer[size:]
break
return events
def flush_key(self):
# A standalone Escape must not wait indefinitely for another key.
if not self.pasting:
result, self.buffer = self.buffer, b""
return result
return b""
class OutputModes:
"""Keep local paste framing on; retain the remote app's requested mode."""
def __init__(self):
self.buffer = b""
self.bracketed = False
def feed(self, data):
self.buffer += data
output = bytearray()
while self.buffer:
index = self.buffer.find(b"\x1b")
if index < 0:
output.extend(self.buffer)
self.buffer = b""
break
output.extend(self.buffer[:index])
self.buffer = self.buffer[index:]
if self.buffer.startswith(b"\x1bc"):
output.extend(b"\x1bc" + ENABLE)
self.bracketed = False
self.buffer = self.buffer[2:]
continue
match = re.match(rb"\x1b\[\?([0-9;]+)([hl])", self.buffer)
if match:
params = match[1].split(b";")
if b"2004" in params:
self.bracketed = match[2] == b"h"
others = [p for p in params if p != b"2004"]
if others:
output.extend(b"\x1b[?" + b";".join(others) + match[2])
output.extend(ENABLE)
else:
output.extend(match[0])
self.buffer = self.buffer[match.end():]
elif len(self.buffer) < 128 and re.fullmatch(rb"\x1b(?:\[(?:\?[0-9;]*)?)?", self.buffer):
break
else:
output.extend(self.buffer[:1])
self.buffer = self.buffer[1:]
return bytes(output)
def paste_bytes(data, bracketed):
return START + data + END if bracketed else data
def clipboard_paths(helper):
try:
result = subprocess.run([str(helper)], capture_output=True, timeout=3, check=True)
paths = json.loads(result.stdout)
if not isinstance(paths, list) or not all(isinstance(p, str) for p in paths):
raise ValueError()
return paths
except (OSError, ValueError, subprocess.SubprocessError):
raise PasteError("Cannot check copied files; paste was not sent.") from None
def copied_files(data, read_clipboard):
try:
text = data.decode("utf-8")
paths = shlex.split(text)
except (UnicodeError, ValueError):
return None
if not paths or not all(p.startswith("/") for p in paths):
return None
# Ordinary text that happens to name a local file must never upload it.
# Ghostty 1.3.1 getOpinionatedStringContents escapes Finder file paths;
# require the entire pasted path list to match actual file-URL clipboard data.
if paths != read_clipboard():
return None
if len(paths) > 256:
raise PasteError("Too many copied files (maximum 256).")
for path in paths:
if any(ord(c) < 32 or ord(c) == 127 for c in path):
raise PasteError("A copied filename contains unsupported control characters.")
try:
if not stat.S_ISREG(os.stat(path).st_mode):
raise PasteError("Copy files individually; folder pasting is not supported.")
except OSError:
raise PasteError("A copied file is no longer readable.") from None
if len({Path(p).name for p in paths}) != len(paths):
raise PasteError("Copied files must have distinct filenames; paste them separately.")
return paths
class SCPMeter:
"""Reduce OpenSSH's private progress output to numeric batch counters."""
# OpenSSH progressmeter.c writes: filename percent size rate time [ETA].
# Anchor at the numeric suffix; filenames and errors are never displayed.
record = re.compile(rb" (\d{1,3})%\s+(\d{1,20}(?:[KMGT]B)?)\s+"
rb"(\d{1,20}(?:\.\d{1,10})?[KMGT]B)/s\s+"
rb"(?:\d+:\d\d(?::\d\d)?(?: ETA)?|--:-- ETA|- stalled -)\s*$")
def __init__(self, sizes, report):
self.sizes, self.report = sizes, report
self.buffer, self.index, self.finished = b"", 0, 0
self.current, self.percent = 0, 0
@staticmethod
def amount(token):
match = re.fullmatch(rb"(\d+(?:\.\d+)?)([KMGT])?B?", token)
return int(float(match[1]) * 1024 ** (b" KMGT".index(match[2]) if match[2] else 0))
def parse(self, line):
match = self.record.search(line)
if not match or self.index >= len(self.sizes):
return
percent = int(match[1])
if percent > 100:
return
self.percent = max(self.percent, percent)
size = self.sizes[self.index]
self.current = max(self.current, min(size, self.amount(match[2])))
if percent == 100:
self.current = size
self.report("uploading", self.finished + self.current, sum(self.sizes), self.amount(match[3]))
def feed(self, data):
for piece in re.split(rb"([\r\n])", data):
if piece in (b"\r", b"\n"):
self.parse(self.buffer)
self.buffer = b""
if piece == b"\n" and self.percent == 100:
self.finished += self.sizes[self.index]
self.index += 1
self.current = self.percent = 0
else:
# Keep only enough for a numeric suffix, not unlimited errors.
self.buffer = (self.buffer + piece)[-512:]
self.parse(self.buffer)
def run_metered(args, cancel, timeout, meter):
master, slave = pty.openpty()
fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 24, 120, 0, 0))
try:
# The upload runs on a worker thread, so avoid Python preexec_fn after
# fork. Acquire the private controlling TTY in a fresh interpreter.
launch = ("import fcntl,os,sys,termios;fcntl.ioctl(1,termios.TIOCSCTTY,0);"
"os.execv(sys.argv[1],sys.argv[1:])")
with subprocess.Popen([sys.executable, "-c", launch, *args],
stdin=subprocess.DEVNULL, stdout=slave, stderr=slave,
start_new_session=True) as process:
os.close(slave)
slave = None
deadline = time.monotonic() + timeout
try:
while True:
if cancel.is_set() or time.monotonic() > deadline:
raise PasteError("Upload cancelled or timed out; paste was not sent.")
if select.select([master], [], [], 0.1)[0]:
try:
data = os.read(master, 65536)
except OSError as error:
if error.errno != errno.EIO:
raise
data = b""
if not data:
break
meter.feed(data)
elif process.poll() is not None:
break
try:
status = process.wait(timeout=max(0.1, deadline - time.monotonic()))
except subprocess.TimeoutExpired:
raise PasteError("Upload timed out; paste was not sent.") from None
if status:
raise PasteError("Upload failed; paste was not sent.")
finally:
if process.poll() is None:
os.killpg(process.pid, signal.SIGKILL)
process.wait()
finally:
os.close(master)
if slave is not None:
os.close(slave)
return b""
def run_private(args, cancel, timeout, meter=None):
# Neither SSH errors nor SCP output may disclose paths, clipboard/file data,
# or credentials. Authentication never reads from the interactive terminal.
if meter is not None:
return run_metered(args, cancel, timeout, meter)
with subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL, start_new_session=True) as process:
deadline = time.monotonic() + timeout
while True:
if cancel.is_set() or time.monotonic() > deadline:
os.killpg(process.pid, signal.SIGKILL)
process.communicate()
raise PasteError("Upload cancelled." if cancel.is_set() else "Upload timed out; paste was not sent.")
try:
stdout, _ = process.communicate(timeout=0.1)
if process.returncode:
raise PasteError("Upload failed; check the UU mapping and SSH access. Paste was not sent.")
return stdout
except subprocess.TimeoutExpired:
pass
class Uploader:
def __init__(self, config, host):
common = ["-F", str(config)] if config else []
common += ["-o", "BatchMode=yes", "-o", "ConnectTimeout=15"]
self.ssh = ["/usr/bin/ssh", *common, host]
self.scp = ["/usr/bin/scp", "-q", *common]
self.host = host
def upload(self, paths, cancel, progress=None):
sizes = [os.stat(path).st_size for path in paths] if progress else []
if progress:
progress("connecting", 0, sum(sizes), 0)
script = ('umask 077; d="$HOME/.local/share/uuremote/uploads"; '
'mkdir -p "$d" && mktemp -d "$d/paste.XXXXXXXX"')
try:
directory = run_private([*self.ssh, script], cancel, 30).decode("utf-8").strip()
except UnicodeError:
raise PasteError("Invalid upload destination; paste was not sent.") from None
if (not directory.startswith("/") or len(directory) > 4096 or
any(ord(c) < 32 or ord(c) == 127 for c in directory) or
not re.fullmatch(r"paste\.[A-Za-z0-9]+", directory.rsplit("/", 1)[-1])):
raise PasteError("Invalid upload destination; paste was not sent.")
try:
# Use modern SCP's SFTP mode, never legacy SCP (-O). Unique batch
# directories prevent overwrites; all local paths are absolute.
if progress:
progress("uploading", 0, sum(sizes), 0)
scp = self.scp[:1] + self.scp[2:] # Remove only our own -q.
run_private([*scp, *paths, f"{self.host}:{directory}/"], cancel, 300,
SCPMeter(sizes, progress))
progress("finishing", sum(sizes), sum(sizes), 0)
else:
run_private([*self.scp, *paths, f"{self.host}:{directory}/"], cancel, 300)
except (PasteError, OSError):
# Clean only this batch, with quoted remote shell syntax. Cancellation
# of one upload must not stop another SSH/UU session.
try:
run_private([*self.ssh, "rm -rf -- " + shlex.quote(directory)], threading.Event(), 10)
except (PasteError, OSError):
pass
raise
return " ".join(shlex.quote(directory + "/" + Path(p).name) for p in paths).encode("utf-8")
def write_all(fd, data):
view = memoryview(data)
while view:
view = view[os.write(fd, view):]
def display_size(size):
for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
if size < 1024 or unit == "TiB":
return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
size /= 1024
class UploadDisplay:
"""Session-local title and OSC 9;4 progress; terminal cells stay untouched."""
# https://ghostty.org/docs/vt/osc/conemu: states 0=clear, 1=percent, 3=busy.
def __init__(self, emit):
self.emit, self.active = emit, False
self.title, self.pending = b"UU SSH", b""
self.state = ("connecting", 0, 0, 0)
self.started = self.rendered = 0
def observe(self, data):
self.pending = (self.pending + data)[-8192:]
for match in re.finditer(rb"\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)", self.pending):
self.title = match[1]
# Retain only an incomplete OSC title across output reads.
index = self.pending.rfind(b"\x1b]")
if index < 0:
self.pending = b"\x1b" if self.pending.endswith(b"\x1b") else b""
else:
tail = self.pending[index:]
self.pending = tail if b"\x07" not in tail and b"\x1b\\" not in tail else b""
def start(self, total):
self.active = True
self.started = time.monotonic()
self.state = ("connecting", 0, total, 0)
self.render(force=True)
def update(self, stage, done, total, speed):
self.state = stage, done, total, speed
def render(self, force=False):
now = time.monotonic()
if not self.active or (not force and now - self.rendered < 0.2):
return
self.rendered = now
stage, done, total, speed = self.state
elapsed = int(now - self.started)
if stage in ("connecting", "cancelling"):
label = "Connecting" if stage == "connecting" else "Cancelling"
text = f"UU upload: {label} | {display_size(total)} | {elapsed}s"
indicator = b"\x1b]9;4;3\x1b\\"
else:
percent = min(100, int(done * 100 / total)) if total else 100
label = "Finishing" if stage == "finishing" else "Uploading"
text = (f"UU upload: {label} {percent}% | {display_size(done)}/{display_size(total)}"
f" | {display_size(speed)}/s | {elapsed}s")
indicator = f"\x1b]9;4;1;{percent}\x1b\\".encode()
self.emit(b"\x1b]2;" + text.encode() + b"\x1b\\" + indicator)
def finish(self):
if self.active:
self.active = False
self.emit(b"\x1b]9;4;0\x1b\\\x1b]2;" + self.title + b"\x1b\\")
def relay(command, read_clipboard, uploader):
original = termios.tcgetattr(0)
master, slave = pty.openpty()
def resize(*_):
try:
size = fcntl.ioctl(0, termios.TIOCGWINSZ, bytes(8))
fcntl.ioctl(master, termios.TIOCSWINSZ, size)
except OSError:
pass
resize()
def child_tty():
os.setsid()
fcntl.ioctl(0, termios.TIOCSCTTY, 0)
child = subprocess.Popen(command, stdin=slave, stdout=slave, stderr=slave, preexec_fn=child_tty)
os.close(slave)
previous_resize = signal.signal(signal.SIGWINCH, resize)
def shutdown(signum, _frame):
raise SystemExit(128 + signum)
previous_signals = {sig: signal.signal(sig, shutdown)
for sig in (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)}
frames, modes = InputFrames(), OutputModes()
events, completed = collections.deque(), queue.Queue()
updates = queue.Queue()
display = UploadDisplay(lambda data: write_all(1, data))
cancel, uploading, interrupted = threading.Event(), False, False
worker = None
last_input = time.monotonic()
def upload_worker(paths):
try:
completed.put((uploader.upload(paths, cancel, lambda *args: updates.put(args)), None))
except (OSError, PasteError):
completed.put((None, "Upload failed or cancelled; paste was not sent."))
def notice(message):
write_all(2, ("\r\n[UU paste] " + message + "\r\n").encode())
def interrupt_upload():
nonlocal interrupted, frames
if not uploading:
return
pending = list(events)
positions = [(i, payload.rfind(b"\x03")) for i, (kind, payload) in enumerate(pending)
if kind == "data" and b"\x03" in payload]
if positions:
index, offset = positions[-1]
cancel.set()
interrupted = True
_, done, total, _ = display.state
display.update("cancelling", done, total, 0)
display.render(force=True)
frames = InputFrames()
events.clear()
events.extend(frames.feed(pending[index][1][offset + 1:]))
events.extend(pending[index + 1:])
write_all(master, b"\x03")
try:
tty.setraw(0)
write_all(1, ENABLE)
while True:
interrupt_upload()
while not updates.empty():
update = updates.get_nowait()
if not interrupted:
display.update(*update)
if uploading:
display.render()
try:
data, error = completed.get_nowait()
except queue.Empty:
pass
else:
uploading = False
display.finish()
if error:
notice(error)
elif not interrupted:
write_all(master, paste_bytes(data, modes.bracketed))
while events and not uploading:
kind, data = events.popleft()
if kind == "error":
notice("Paste exceeds 8 MiB; paste was not sent.")
continue
if kind == "data":
write_all(master, data)
continue
try:
files = copied_files(data, read_clipboard)
except PasteError as error:
notice(str(error))
continue
if files is None:
write_all(master, paste_bytes(data, modes.bracketed))
else:
try:
total = sum(os.stat(path).st_size for path in files)
except OSError:
notice("A copied file is no longer readable; paste was not sent.")
continue
cancel.clear()
uploading, interrupted = True, False
display.start(total)
worker = threading.Thread(target=upload_worker, args=(files,), daemon=True)
worker.start()
interrupt_upload()
readable, _, _ = select.select([0, master], [], [], 0.025)
if master in readable:
try:
data = os.read(master, 65536)
except OSError as error:
if error.errno != errno.EIO:
raise
data = b""
if not data:
break
display.observe(data)
write_all(1, modes.feed(data))
if 0 in readable:
data = os.read(0, 65536)
if not data:
break
last_input = time.monotonic()
events.extend(frames.feed(data))
if sum(len(payload) for _, payload in events) > MAX_PASTE:
events.clear()
notice("Input queue is full; queued input was discarded.")
elif time.monotonic() - last_input > 0.025:
data = frames.flush_key()
if data:
events.append(("data", data))
if modes.buffer:
write_all(1, modes.buffer)
finally:
cancel.set()
signal.signal(signal.SIGWINCH, previous_resize)
for sig, previous in previous_signals.items():
signal.signal(sig, previous)
termios.tcsetattr(0, termios.TCSADRAIN, original)
display.finish()
write_all(1, DISABLE)
os.close(master)
if child.poll() is None:
try:
child.wait(timeout=2)
except subprocess.TimeoutExpired:
os.killpg(child.pid, signal.SIGTERM)
try:
child.wait(timeout=2)
except subprocess.TimeoutExpired:
os.killpg(child.pid, signal.SIGKILL)
status = child.wait()
if worker is not None:
worker.join(timeout=12)
return status if status >= 0 else 128 - status
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("-F", "--ssh-config", type=Path)
parser.add_argument("host", help="SSH alias for an existing UU loopback port mapping")
parser.add_argument("command", nargs=argparse.REMAINDER)
args = parser.parse_args()
if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.@-]*", args.host):
parser.error("use an SSH host alias, without options or a port")
common = ["-F", str(args.ssh_config)] if args.ssh_config else []
command = ["/usr/bin/ssh", *common]
if not (os.isatty(0) and os.isatty(1)):
os.execv(command[0], [*command, args.host, *args.command])
helper = Path(__file__).resolve().with_name("clipboard-files")
if not helper.is_file():
parser.error("run contrib/macos-ssh/install.sh on your Mac first")
return relay([*command, "-tt", args.host, *args.command],
lambda: clipboard_paths(helper), Uploader(args.ssh_config, args.host))
if __name__ == "__main__":
try:
sys.exit(main())
except (OSError, PasteError):
print("UU SSH companion failed; check the UU mapping and SSH configuration.", file=sys.stderr)
sys.exit(1)
+21
View File
@@ -0,0 +1,21 @@
# 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.18
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"
RUN apt-get update \
&& DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
ca-certificates curl bash libx11-6 libxext6 libxtst6 libxfixes3 libgtk-3-0 \
&& cd /tmp \
&& base="https://github.com/VallierDev/uu-remote-linux/releases/download/${VERSION}/uu-remote-linux-${VERSION}-x86_64-linux.tar.gz" \
&& curl -fsSLO "$base" && curl -fsSLO "$base.sha256" && sha256sum -c "uu-remote-linux-${VERSION}-x86_64-linux.tar.gz.sha256" \
&& tar xzf "uu-remote-linux-${VERSION}-x86_64-linux.tar.gz" \
&& install -m755 "$(find /tmp -name uuremote-server -type f | head -1)" /usr/local/bin/uuremote-server \
&& rm -rf /tmp/* /var/lib/apt/lists/*
# Credentials live in /config (keep it private); /data is what file transfer and the terminal see as home.
ENV UU_CONFIG=/config/config.json UU_DESKTOP_BACKEND=none UU_LOGIN_WINDOW=0 UU_AUDIO=0 RUST_LOG=info HOME=/data
VOLUME ["/config", "/data"]
WORKDIR /data
ENTRYPOINT ["uuremote-server"]
+9
View File
@@ -0,0 +1,9 @@
# Docker(群晖 / NAS,无桌面)
本目录是 [`ghcr.io/vallierdev/uu-remote-linux`](https://github.com/VallierDev/uu-remote-linux/pkgs/container/uu-remote-linux) 镜像的构建文件。
**部署和使用步骤见 [docs/deploy-nas-docker.md](../docs/deploy-nas-docker.md)。**
This directory builds the `ghcr.io/vallierdev/uu-remote-linux` image; see
[docs/deploy-nas-docker.md](../docs/deploy-nas-docker.md#english) for deployment.
自行构建 / build locally: `docker compose build`(`Dockerfile` 从 GitHub 发布包安装 `uuremote-server`,可用 `--build-arg VERSION=vX.Y.Z` 指定版本)。
+13
View File
@@ -0,0 +1,13 @@
# docker compose up -d (first run: log in once, see README.md in this directory)
services:
uu-remote:
image: ghcr.io/vallierdev/uu-remote-linux:latest
build: .
container_name: uu-remote
# Host networking gives WebRTC direct UDP paths; bridge mode also works but falls back to relays more often.
network_mode: host
restart: unless-stopped
volumes:
- ./config:/config
# Folder offered to file transfer and the terminal (change to your share, e.g. /volume1/homes/you).
- ./data:/data
+133
View File
@@ -0,0 +1,133 @@
# 群晖 / NAS 部署指南(Docker,无桌面)
**简体中文** | [English](#english)
镜像:[`ghcr.io/vallierdev/uu-remote-linux`](https://github.com/VallierDev/uu-remote-linux/pkgs/container/uu-remote-linux)
(标签 `latest` 或具体版本如 `v0.2.8`)
把本项目主机跑在没有桌面的 NAS 上之后,就能在外面用官方 UU 远程客户端(手机 / Mac / Windows):
| 功能 | 说明 |
|---|---|
| 文件传输 | 收发 NAS 上的文件(只开放你挂进容器的文件夹) |
| 终端 | 打开容器里的命令行(bash) |
| 端口映射 | 经 UU 访问家里局域网的服务:NAS 管理页、路由器、其他电脑的 SSH / 远程桌面等 |
**不提供远程桌面**(NAS 没有图形界面,点「远程桌面」会一直显示正在连接,属正常)。
## 准备
- x86_64 的 NAS(群晖 DSM 7.2 及以上已安装「Container Manager」,或任意装了 Docker 的 Linux NAS)。ARM 机型暂不支持。
- 能 SSH 登录 NAS(群晖:控制面板 → 终端机和 SNMP → 启用 SSH),并有管理员权限(`sudo`)。
- 手机上的 UU 远程 App,用于扫码登录。
## 第一步:建目录和配置
SSH 登录 NAS,新建一个目录(下面以 `/volume1/docker/uu-remote` 为例):
```sh
sudo mkdir -p /volume1/docker/uu-remote/config
sudo chmod 700 /volume1/docker/uu-remote/config
cd /volume1/docker/uu-remote
```
新建 `compose.yaml`,内容如下。把 `/volume1/共享文件夹` 改成你想远程访问的文件夹(可以写多行挂多个):
```yaml
services:
uu-remote:
image: ghcr.io/vallierdev/uu-remote-linux:latest
container_name: uu-remote
network_mode: host # 让远程连接尽量走直连,速度更快
restart: unless-stopped
volumes:
- ./config:/config # 登录信息,请勿外传
- /volume1/共享文件夹:/data # 文件传输和终端看到的目录
```
## 第二步:扫码登录(只需一次)
```sh
sudo docker compose pull
sudo docker compose run --rm uu-remote login --no-gui
```
终端里会显示一个二维码:用手机 UU 远程扫码并确认。看到登录成功的提示后,按 `Ctrl+C` 退出(如果没有自动退出)。
> 二维码等同于你的登录凭据,**不要截图或发给别人**。登录信息保存在 `config/config.json`。
> 一定要用上面的 `docker compose run`(主机网络),这样设备在列表里显示的是 NAS 的名字;
> 若用普通 `docker run` 登录,设备名会是一串随机字符。
## 第三步:启动
```sh
sudo docker compose up -d
sudo docker compose logs -f
```
日志里出现 `availability=Some("ready")` 就说明上线了,按 `Ctrl+C` 退出日志查看(容器继续在后台运行)。
之后 NAS 开机会自动启动它。
**用群晖界面管理**:Container Manager → 项目 → 新增,路径选 `/volume1/docker/uu-remote`,会自动读取 `compose.yaml`。
首次登录仍需在 SSH 里执行第二步。
## 使用
打开官方 UU 远程客户端,在「我的设备」里找到你的 NAS(显示为 Windows 设备,这是正常的):
- **文件传输**:浏览、上传、下载 `/data` 里的文件。
- **终端**:进入容器的命令行,当前目录是 `/data`。注意这是容器而不是 NAS 系统本身。
- **端口映射**:例如目标填 `127.0.0.1`、端口 `5000`,就能在本地浏览器打开 NAS 的 DSM 管理页;
填局域网里其他设备的地址和端口(如 `192.168.1.10:22`)即可访问那台设备的服务。
## 更新
```sh
cd /volume1/docker/uu-remote
sudo docker compose pull && sudo docker compose up -d
```
`config` 目录保留即可,不用重新登录。
## 停用与移除
```sh
sudo docker compose down # 停止并删除容器
```
再在官方客户端的设备列表里删除这台设备;如需彻底清除登录信息,删除 `config` 目录。
## 常见问题
- **设备名是一串随机字符**:登录时没有用主机网络。删除 `config/config.json`,按第二步用 `docker compose run` 重新登录。
- **一直不上线**:`sudo docker compose logs --tail 100` 查看日志;确认 NAS 能访问外网。
- **连接慢、经常卡**:确认 `network_mode: host` 没有被去掉。
- **想要远程桌面**:NAS 上不支持;请在有桌面的 Linux 电脑上安装主机端(见主 README)。
安全提示:只挂需要远程访问的文件夹;端口映射可以访问 NAS 所在局域网,请保管好 UU 账号。
---
## English
Image: [`ghcr.io/vallierdev/uu-remote-linux`](https://github.com/VallierDev/uu-remote-linux/pkgs/container/uu-remote-linux)
Runs this project's host headless on a desktop-less NAS (x86_64, e.g. Synology DSM 7.2+ with Container Manager) for the
official UU Remote clients: **file transfer** (folders you mount at `/data`), **terminal** (bash inside the container) and
**port mapping** into your LAN. No remote desktop.
```sh
sudo mkdir -p /volume1/docker/uu-remote/config && sudo chmod 700 /volume1/docker/uu-remote/config
cd /volume1/docker/uu-remote
# compose.yaml: image ghcr.io/vallierdev/uu-remote-linux:latest, network_mode: host,
# volumes ./config:/config and /volume1/your-share:/data (see the Chinese section above)
sudo docker compose pull
sudo docker compose run --rm uu-remote login --no-gui # scan the QR with the UU mobile app; the QR is a credential
sudo docker compose up -d
sudo docker compose logs -f # wait for availability=Some("ready")
```
Update with `docker compose pull && docker compose up -d` (keep `config/`). Remove with `docker compose down`, then delete
the device in the official client.
**Unofficial project, not affiliated with NetEase.**
Binary file not shown.

Before

Width:  |  Height:  |  Size: 51 KiB

After

Width:  |  Height:  |  Size: 161 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 255 KiB

+20
View File
@@ -0,0 +1,20 @@
新增实验性 Linux 控制端 `uuremote-viewer`。/ Experimental Linux viewer `uuremote-viewer`.
### 新增 / Added
- **🧪 原生控制端 `uuremote-viewer`**(#36):在 Linux 上用 UU 账号连接并控制其他设备——官方 Windows / Mac 被控端或本项目的 Linux 主机,
也可凭对方的设备 ID 和验证码发起远程协助。包含启动窗口(设备列表)、桌面窗口(H.264 画面、键鼠、声音、文本剪贴板、只看模式)、
文件传输、终端与终端会话列表、端口映射(只监听 127.0.0.1)、重启/关机。与主机 `uuremote-server` 相互独立,**主机行为不变**。
- 使用:`uuremote-viewer login` 扫码登录,`uuremote-viewer ui` 打开启动窗口;命令行用法见 `uuremote-viewer --help` 和 README。
- 运行依赖:GTK3、SDL2(Ubuntu/Debian `libsdl2-2.0-0`)、`ffmpeg` 命令;剪贴板需 `xclip`/`xsel` 或 `wl-clipboard`。
- 与主机共用 `~/.config/uuremote/config.json`(`UU_CONFIG` 可另指定),因此不能用同一身份连接本机上的主机。
- **已实测**:官方 Windows 被控端(画面、键鼠、文件列表与下载)、官方 Mac 被控端(画面)、本项目主机(画面、键鼠、文件、
端口映射、终端;剪贴板、声音和远程协助在虚拟机中)。
- ⚠️ **未实测**:重启/关机、终端会话列表的新建与接回、Wayland 下的窗口与剪贴板、多显示器;只解码 H.264 4:2:0。
这是实验性功能,欢迎反馈问题。
An experimental viewer/controller for UU Remote hosts; the host build and behaviour are unchanged. See the README for usage,
dependencies and the tested scope (reboot/shutdown, terminal session list and Wayland are not tested live).
### 下载 / Download
`uu-remote-linux-v0.2.0-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+20
View File
@@ -0,0 +1,20 @@
控制端补测:重启/关机、终端会话列表、Wayland;主机远程关机不再等待授权弹窗。/ Viewer power, terminal list and Wayland tested; host power actions never wait for a polkit prompt.
### 修复 / Fixed
- **远程重启/关机不再卡在授权弹窗**:被控端用户没有 polkit 权限时(例如本机没有活动的图形会话),`systemctl reboot/poweroff`
会一直等待,并可能在被控端屏幕上弹出密码框。现在加了 `--no-ask-password`,没有权限时直接失败并在日志记录 `ok=false`。
正常情况下(本机有活动的图形会话)行为不变。
Reboot/shutdown no longer wait for a polkit authentication dialog on the host; without permission they fail and are logged.
### 控制端实测补充 / Viewer testing
在虚拟机中用第二个主机身份实测通过(`uuremote-viewer` 连接本项目主机):
- 远程**重启**、**关机**,以及关机后重新开机上线。
- 终端会话列表:新建、双击接回(重放历史输出、原 shell 环境保留)、确认后结束会话。
- Wayland(Hyprland)下的桌面窗口与剪贴板(`wl-copy`/`wl-paste`,双向)。
⚠️ 仍未实测:GNOME/KDE Wayland 下的窗口与剪贴板、H.265 与 4:4:4(只解码 H.264 4:2:0)、多显示器。
Tested in a VM: reboot, shutdown and power-on, terminal session list, Wayland (Hyprland) window and clipboard.
### 下载 / Download
`uu-remote-linux-v0.2.1-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
修复 iPhone 上「超清 / 原画」「常规 / 真彩」点不动。/ Fix iPhone quality and chroma choices being locked.
### 修复 / Fixed
- **iPhone 无法切换画质与真彩**(#49,感谢 @RiverOnVenus 的细致排查):连接本项目主机时,iPhone 的「超清」「原画」
以及「常规 / 真彩」按钮点了没反应,只有帧率能改。原因是主机发出的设备能力消息(`forward_setting` 的 `device_capability`)
格式与官方 Windows 被控端不一致,iPhone 无法识别,于是锁定在默认值。现在按官方格式发送设备能力(含 4:4:4 等真实支持的格式),
并补发发送参数 `sender_para_info`。
已实测:iPhone(UU 远程 4.42.0)连接修复后的主机,可以切换画质(主机收到新的画质请求)。Mac 客户端不依赖这条消息,此前即正常。
- Device capability is now sent in the official nested shape (and `sender_para_info` is added), so the iPhone client unlocks
quality and chroma choices. Verified with the UU iPhone app 4.42.0.
### 其他 / Other
- 控制端窗口与主机使用同一图标,并新增控制端启动项 `contrib/desktop/uu-remote-linux-viewer.desktop`(#13)。
### 下载 / Download
`uu-remote-linux-v0.2.10-x86_64-linux.tar.gz`(主机 `uuremote-server` + 控制端 `uuremote-viewer`,附带 `contrib/`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.10`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+20
View File
@@ -0,0 +1,20 @@
Wayland(wlroots)手机输入法上屏;登录默认直连,不走环境代理。/ Mobile IME text on wlroots Wayland; cloud API ignores ambient proxies by default.
### 新增 / Added
- **wlroots Wayland 支持手机输入法 `text_input`**(#51,感谢 @hiclaw):手机端输入法提交的文字,
在 Hyprland / Sway 等 wlroots 合成器上通过虚拟键盘的备用键码上屏。仅在 Hyprland 0.56.2 上实测;
KWin / GNOME(门户后端)仍不支持,见 #50。
- Mobile IME `text_input` now types through the virtual keyboard's spare keycodes on wlroots compositors.
Tested on Hyprland 0.56.2 only; KWin/GNOME (portal backend) are not covered yet.
### 变更 / Changed
- **云端接口默认忽略代理环境变量**(#52,感谢 @aresbit):本地有拦截 TLS 的 HTTP/SOCKS 代理时,登录会报
`tls handshake eof`。现在主机和控制端访问网易服务器默认直连,忽略 `http_proxy` / `https_proxy` / `all_proxy`;
确实需要经代理上网的环境请设置 `UU_USE_PROXY=1`。未在拦截代理环境中实机验证,CI 测试通过。
- Cloud API clients now bypass `http_proxy` / `https_proxy` / `all_proxy` by default; set `UU_USE_PROXY=1` if your
network requires a proxy. Not verified against an intercepting proxy; CI passes.
### 下载 / Download
`uu-remote-linux-v0.2.11-x86_64-linux.tar.gz`(主机 `uuremote-server` + 控制端 `uuremote-viewer`,附带 `contrib/`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.11`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
修复缩放桌面尺寸为奇数时画面一直「正在传输」。/ Fix the stream never starting when the captured desktop has an odd size.
### 修复 / Fixed
- **奇数尺寸桌面无法出画面**(#53,感谢 @wen0531):KDE Plasma(Wayland,门户后端)150% 缩放、两块屏上下排列时,
逻辑桌面为 2560x2507,H.264/HEVC 编码器要求偶数宽高,全部启动失败,客户端一直停在「正在传输画面」。
现在原生分辨率采集遇到奇数宽高时,在右/下补齐 1 像素黑边再编码;偶数尺寸、「其他分辨率」缩放不受影响。
贡献者已在 KDE Plasma 6.7 / Wayland / NVENC + 官方安卓客户端上实测。进程内编码(`inproc-av`)路径未覆盖。
- When the native capture size is odd (e.g. scaled stacked monitors), the encoder input is padded by one black
row/column so every H.264/HEVC encoder can open. Verified by the contributor on KDE Plasma 6.7 (Wayland, NVENC).
The optional `inproc-av` path is not covered.
### 下载 / Download
`uu-remote-linux-v0.2.12-x86_64-linux.tar.gz`(主机 `uuremote-server` + 控制端 `uuremote-viewer`,附带 `contrib/`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.12`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+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.**
+30
View File
@@ -0,0 +1,30 @@
控制端:支持 H.265 / 4:4:4,可对官方 Windows 被控端上传、端口映射和终端。/ Viewer: H.265 / 4:4:4, and upload, port mapping and terminal with the official Windows host.
### 控制端新增 / Viewer — added
- **H.265 与 4:4:4 真彩**:桌面同时提供 H.264 / H.265,由被控端选择;`UU_VIEWER_CHROMA=444` 请求真彩,`UU_VIEWER_CODEC=h264` 只用 H.264。
已在虚拟机中对本项目主机实测(libx265 4:2:0 与 4:4:4、强制 H.264 均 0 解码错误);⚠️ 官方被控端的 H.265 / 4:4:4 未实测。
H.265 and 4:4:4 true color (tested against this project's host in a VM; not yet with official hosts).
### 控制端修复 / Viewer — fixed(均为实测发现并验证 / found and verified live)
- **官方 Windows 被控端上传文件**:之前上传会被拒绝(错误码 2)。现在按官方客户端的格式发送(Windows 路径、修改时间、压缩文件列表),
64 KiB 与 1 MiB 文件上传后再下载回来 sha256 一致。下载也不再拒绝大于 32 KiB 的数据块(错误码 3)。
- **官方 Windows 被控端端口映射**:之前每个连接都超时;现在可正常转发(经被控端访问 HTTP 返回 200)。
- **官方 Windows 被控端终端**:之前连上后没有任何输出;现在可打开 PowerShell 并交互。
- **启动窗口**:设备列表每 30 秒刷新后,已打开的设备页按钮全部失效的问题;「断开当前连接」确认框改为中文按钮。
- **连接官方 Mac 被控端时键盘错位**(#39,感谢 @wanglz111,#40):按 1 出空格、Backspace 出 c。Mac 目标改用 macOS 原生键码
(按物理位置转发,PC 的 Win 键对应 Command),Windows 与本项目主机仍用 Windows VK;无法确定目标平台时拒绝控制而不是乱发键码。
贡献者已在官方 Mac 被控端实机确认;⚠️ ISO/JIS 键盘、媒体键与 Mac 远程协助未验收。
- **FFmpeg 4.4 下没有画面**(#40):v0.2.0 / v0.2.1 的控制端解码参数 `-fps_mode` 不被 FFmpeg 4.4(如 Ubuntu 22.04 自带版本)识别,
解码进程直接退出。现改用新旧版本都支持的参数。
- 对本项目主机的上传、端口映射、终端新建/接回均已回归验证。
- Upload, port mapping and terminal now work with the official Windows host; launcher device page stays usable after list refreshes.
### 已知问题 / Known issues
- 控制端 → 官方 Windows 被控端的剪贴板:被控端确认收到文本,但未出现在其桌面剪贴板中,仍在排查(被控端 → 控制端正常)。
- GNOME Wayland 下控制端剪贴板不可用,且轮询会让 Dock 图标跳动(#37,修复中);窗口本身正常。KDE、Hyprland 正常。
- Viewer → Windows host clipboard is acknowledged but not applied yet; GNOME clipboard (#37).
### 下载 / Download
`uu-remote-linux-v0.2.2-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+20
View File
@@ -0,0 +1,20 @@
控制端:GNOME Wayland 下剪贴板不再让 Dock 图标跳动。/ Viewer: clipboard no longer makes GNOME Wayland Dock icons jump.
### 控制端修复 / Viewer — fixed
- **GNOME Wayland 剪贴板与 Dock 跳动**(#37,感谢 @wanglz111,#41):之前每 500 ms 调用一次 `wl-paste`,在缺少 data-control 的 GNOME 上
每次都会创建临时窗口,导致 Dock 图标持续跳动。现在桌面窗口直接通过 SDL 读写文本剪贴板,不再需要 `wl-clipboard` / `xclip`。
只在桌面窗口获得焦点时同步,仍保留 30 KiB 上限、`UU_VIEWER_CLIPBOARD=0` 关闭开关和原有协议。
早期版本已由报告者在 GNOME Wayland 实机确认 Dock 不再跳动;⚠️ 最终的焦点门控版本只有自动化测试,尚未重新实机验收。
Clipboard now goes through the existing SDL window (focused only). An earlier revision was confirmed live by the reporter;
the final focus-gated revision is covered by automated tests only.
### 已知问题 / Known issues
- 剪贴板只在控制端窗口获得焦点时同步;窗口在后台时收到的被控端剪贴板变化不会写入本机。
- 剪贴板内容提供方响应很慢时,可能短暂卡住控制端窗口(SDL2 同步读取)。
- 控制端 → 官方 Windows 被控端的剪贴板:被控端确认收到文本,但未出现在其桌面剪贴板中,仍在排查;与官方 Mac 被控端的双向剪贴板未验证。
- Clipboard syncs only while the viewer window is focused; viewer → official Windows host clipboard is still unresolved.
### 下载 / Download
`uu-remote-linux-v0.2.3-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。主机端与 v0.2.2 相同。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+22
View File
@@ -0,0 +1,22 @@
控制端:修复 FFmpeg 9 下没有画面;新增「删除设备」。/ Viewer: fix no video with FFmpeg 9; add device removal.
### 控制端修复 / Viewer — fixed
- **FFmpeg 9 下桌面没有画面**(v0.2.2、v0.2.3 的回归):为兼容 FFmpeg 4.4 改用的 `-vsync 0` 已被 FFmpeg 9 删除,解码进程一启动就退出,
所有帧都解码失败。现在启动时探测当前 ffmpeg 支持的参数:新版本用 `-fps_mode passthrough`,旧版本(如 Ubuntu 22.04 的 4.4)用 `-vsync 0`。
已在 FFmpeg 9.0.2 上连接官方 Mac 被控端实测:0 解码错误。
Fixed: with FFmpeg 9 every frame failed to decode (`-vsync` was removed). Verified against the official Mac host on FFmpeg 9.0.2.
### 控制端新增 / Viewer — added
- **删除设备**:启动窗口「更多工具 → 删除设备」(带确认),或命令行 `uuremote-viewer unbind DEVICE`,把设备从账号中移除,
与官方客户端的「删除设备」相同。命令行方式已对一台测试设备实测删除成功;⚠️ 启动窗口里的按钮尚未实机点击验收;
分享给你的设备(`--shared`)只有字符串依据,未实测。
Remove a device from the account (CLI verified live on a test device; launcher button and `--shared` not yet verified).
### 已知问题 / Known issues
- 剪贴板只在控制端窗口获得焦点时同步;控制端 → 官方 Windows 被控端的剪贴板仍在排查。
- Clipboard syncs only while the viewer window is focused; viewer → official Windows host clipboard is still unresolved.
### 下载 / Download
`uu-remote-linux-v0.2.4-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。主机端与 v0.2.3 相同。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+21
View File
@@ -0,0 +1,21 @@
窗口颜色修复;控制端可接收官方 Mac 被控端的剪贴板。/ Window colors fixed; viewer receives the official Mac host's clipboard.
### 修复 / Fixed
- **深色系统主题下窗口文字看不见**(#43):协助窗口、控制端启动窗口和工具窗口使用固定浅色背景,但部分文字跟随系统深色主题变成了白色。
现在这些窗口固定使用浅色主题。已在虚拟机中设置深色偏好后截图确认。
GTK windows now stay on the light theme, so text is readable under dark system themes.
- **控制端 ↔ 官方 Mac 被控端剪贴板**:Mac 被控端以 `public.utf8-plain-text`(UTF-8)提供文本,而不是 Windows 的 `CF_UNICODETEXT`,
之前控制端不会请求,剪贴板始终不同步。现在两种格式都支持;主机端发给官方客户端的格式不变。
Mac → 控制端已实机验证;⚠️ 控制端 → Mac 尚未验证。
The viewer now handles the Mac host's UTF-8 text format (Mac → viewer verified live; viewer → Mac not yet verified).
### 已验证 / Verified with the official Mac host(FFmpeg 9.0.2)
- 画面 0 解码错误,键盘输入正确,文件上传/下载/列目录 sha256 一致。
### 已知问题 / Known issues
- 剪贴板只在控制端窗口获得焦点时同步;控制端 → 官方 Windows 被控端的剪贴板仍在排查。
### 下载 / Download
`uu-remote-linux-v0.2.5-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
控制端可打开官方 Mac 被控端的终端;输入问题诊断日志。/ Viewer terminal works with the official Mac host; input diagnostics.
### 控制端修复 / Viewer — fixed
- **连接官方 Mac 被控端的终端**:之前一连上就断开(「Terminal channel closed」)。Mac 被控端把终端的应答发在终端通道上,
控制端现在能识别。已实机验证:可打开终端并正常回显。Mac 被控端的端口映射也已实测可用。
Terminal sessions with the official Mac host now open (verified live); port mapping with it was verified too.
### 主机端诊断 / Host diagnostics(#46)
- 收到不认识的输入事件时记一条日志(只有动作名和字段名,**不含输入内容**),用于排查手机输入法打字无反应。
- 小键盘按键记录被控端当前的 NumLock 状态(只记开/关,不记按键),用于排查小键盘不出数字。
- Logs unsupported input actions (names only, never typed text) and the server's NumLock state for numpad keys.
### 其他 / Other
- README 标题与开头加入控制端介绍并放上截图(#44)。
### 下载 / Download
`uu-remote-linux-v0.2.6-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+25
View File
@@ -0,0 +1,25 @@
手机输入法打字(实验);控制端 → 官方 Windows 被控端剪贴板修复。/ Mobile input-method text (experimental); viewer → Windows host clipboard fixed.
### 主机端 / Host
- **手机自带输入法打字**(#13、#46):官方 Windows 被控端用 `text_input` 动作接收手机输入法的文字。本版主机端支持这个动作,
在 X11 上把文字(含中文)直接输入到当前窗口;不论它从哪个数据通道到达都会处理。
已用手机 UU 远程实测:手机自带键盘输入的英文正确打出(手机在 CONTROL 通道发送 `text_input`);中文注入已在 X11 上
单独实测正确,但尚未用手机中文输入法实测。Wayland / 门户后端暂不支持,会记录一次警告。
诊断:非 CONTROL 通道收到的输入动作会记录动作名(不含内容)。
- Mobile input-method text via the official `text_input {content}` action, typed on X11. Verified with the UU mobile app
(English); Chinese injection verified on X11 separately, not yet with a phone IME.
### 控制端修复 / Viewer — fixed
- **控制端 → 官方 Windows 被控端剪贴板**:之前被控端确认收到,但粘贴为空。原因是控制端同时发送的「富剪贴板格式通告」
会覆盖刚写入的文本,而 Windows 被控端之后从不请求数据。现在按被控端平台发送:Windows 及本项目主机只发文本变更,
Mac 只发格式通告,平台未知时两者都发。已实测:Windows 被控端「运行」框可粘贴,官方 Mac 被控端正常。
Viewer → official Windows host clipboard now works (verified live); Mac unchanged and verified.
### 社区贡献 / Community
- **Mac SSH 粘贴助手**(#45,感谢 @jo32):`contrib/macos-ssh/`,在 Ghostty 里经 UU 端口映射用 SSH 时粘贴 Finder 文件会先上传再插入路径。
可选工具,维护者尚未实机验收。Optional contrib tool, not verified by the maintainer.
### 下载 / Download
`uu-remote-linux-v0.2.7-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
群晖 / NAS 容器镜像。/ Docker image for Synology and other NAS boxes.
### 新增 / Added
- **群晖 / NAS(Docker,无桌面)**:`ghcr.io/vallierdev/uu-remote-linux`,在没有图形界面的 NAS 上运行本项目主机,
供官方客户端使用文件传输、终端(容器内 bash)和端口映射(经 UU 访问家里局域网的服务)。不提供远程桌面。
已在群晖 DSM 7.3.2(x86_64)上实测:文件上传下载 sha256 一致、终端回显正常、端口映射访问 DSM 管理页返回 200。
安装与首次扫码登录见 [docker/README.md](https://github.com/VallierDev/uu-remote-linux/blob/main/docker/README.md)。
- Headless NAS container image (file transfer, terminal, port mapping), verified on Synology DSM 7.3.2 (x86_64).
主机端与控制端程序与 v0.2.7 相同。/ Host and viewer binaries are unchanged from v0.2.7.
### 下载 / Download
`uu-remote-linux-v0.2.8-x86_64-linux.tar.gz`(主机 `uuremote-server` + 控制端 `uuremote-viewer`,附带 `contrib/`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.8`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
修复 H.265 + VAAPI 时手机卡在「正在传输」;VAAPI 可选加大编码缓冲。/ Fix H.265 + VAAPI stalling at "transferring"; optional VAAPI VBV buffer.
### 修复 / Fixed
- **H.265 用 VAAPI 硬件编码时没有画面**(#48,感谢 @NuoFang6):`hevc_vaapi` 只在关键帧处写帧分隔符,主机按分隔符切帧,
把整组画面当成一帧后全部被拦下,被控端几乎不发画面,手机停在「正在传输」。现在按图像边界切分 H.265 访问单元,
不再依赖帧分隔符;维护者补充了后缀 SEI 等尾随单元的处理。
已实测:作者在 Intel 核显 + 官方安卓客户端上(2560×1440,约 58 fps);维护者在 RTX 3090 上用固定输入探针验证
`hevc_nvenc` 与 `libx265` 均 90/90 帧可解码、首帧为关键帧。
- H.265 access units are now split on picture boundaries (RFC 7798), fixing hevc_vaapi sessions that sent almost nothing.
### 新增 / Added
- **`UU_VAAPI_BUFFER_MS`**(#47,感谢 @NuoFang6,源自 #42):可选加大 VAAPI 的编码缓冲(10–1000 ms),缓解高分辨率下
关键帧被压糊、画面周期性模糊。默认不启用。⚠️ 仅在一台机器上实测,代价是关键帧变大,建议从 250 ms 试起。
- Optional VAAPI VBV buffer `UU_VAAPI_BUFFER_MS` (off by default; verified on one machine only).
### 下载 / Download
`uu-remote-linux-v0.2.9-x86_64-linux.tar.gz`(主机 `uuremote-server` + 控制端 `uuremote-viewer`,附带 `contrib/`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.9`。
**非官方项目,与网易无关。** / **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
+32 -1
View File
@@ -121,9 +121,24 @@ fn redact_urls(text: &str) -> String {
out
}
/// Cloud API clients ignore ambient HTTP/SOCKS proxy settings by default: a local
/// proxy that intercepts TLS breaks login and signaling. `UU_USE_PROXY=1` opts back
/// into reqwest's standard proxy environment handling.
pub fn http_client_builder() -> reqwest::ClientBuilder {
let builder = reqwest::Client::builder();
if std::env::var("UU_USE_PROXY").ok().as_deref().is_some_and(proxy_requested) {
builder
} else {
builder.no_proxy()
}
}
fn proxy_requested(value: &str) -> bool {
matches!(value.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on")
}
impl UUAuthClient {
pub fn new(creds: Credentials) -> Self {
let http = reqwest::Client::builder()
let http = http_client_builder()
.timeout(std::time::Duration::from_secs(12))
.build()
.unwrap();
@@ -236,6 +251,16 @@ impl UUAuthClient {
Ok((status, value))
}
/// 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> {
@@ -346,4 +371,10 @@ mod guest_tests {
let text = super::redact_urls("proxy http://user:[email protected]:3128 failed for (https://api.example/p?token=abc)");
assert_eq!(text, "proxy http://proxy.example:3128 failed for (https://api.example/p)");
}
#[test]
fn proxy_opt_in_accepts_only_explicit_truthy_values() {
for value in ["1", "true", "TRUE", " yes ", "On"] { assert!(super::proxy_requested(value)); }
for value in ["", "0", "false", "no", "off", "2"] { assert!(!super::proxy_requested(value)); }
}
}
+58 -22
View File
@@ -27,21 +27,49 @@ pub fn h264_device_capability(
fps: i32,
codec_impl: i32,
) -> Value {
device_capability(client_id, ice_id, display_id, fps, codec_impl, false)
device_capability(client_id, ice_id, display_id, fps, codec_impl, false, false)
}
pub fn device_capability(client_id: &str, ice_id: &str, display_id: i32, fps: i32, codec_impl: i32, hevc: bool) -> Value {
let mut codecs = vec![json!({"video_codec": VIDEO_CODEC_H264, "chroma_sampling": 1,
"codec_impl": codec_impl, "bit_depth": 8})];
// Official VideoCodecCapability::SerializeJson uses the same fields for CodecType H265=2.
if hevc { codecs.push(json!({"video_codec": 2, "chroma_sampling": 1, "codec_impl": codec_impl, "bit_depth": 8})); }
/// Shape of the official Windows host's `forward_setting` (observed from a live 4.37 host):
/// `{client_id, data: {device_capability: {display_info, ice_id, video_codec_capability}, type}}`.
/// The payload sits under `data.device_capability` with `type` beside it. The earlier flat shape
/// (`type` at the top, fields directly in `data`) was not recognised by the iPhone client, which
/// then kept quality and chroma locked at their defaults (#49). Only 8-bit and the chroma formats
/// the encoder really produces are listed; the first entry carries the maximum size as officially.
pub fn device_capability(client_id: &str, ice_id: &str, display_id: i32, fps: i32, codec_impl: i32, hevc: bool, full_chroma: bool) -> Value {
let mut codecs = Vec::new();
for codec in [VIDEO_CODEC_H264].into_iter().chain(hevc.then_some(2)) {
for chroma in [1].into_iter().chain(full_chroma.then_some(3)) {
let (width, height) = if codecs.is_empty() { (3840, 2160) } else { (0, 0) };
codecs.push(json!({"video_codec": codec, "chroma_sampling": chroma, "codec_impl": codec_impl,
"bit_depth": 8, "width": width, "height": height}));
}
}
json!({
"client_id": client_id,
"type": "device_capability",
"data": {
"display_info": [{"id": display_id, "fps": fps, "type": 0, "hdr": 0}],
"video_codec_capability": codecs,
"ice_id": ice_id
"device_capability": {
"display_info": [{"id": display_id, "fps": fps, "type": 0, "hdr": -1}],
"video_codec_capability": codecs,
"ice_id": ice_id
},
"type": "device_capability"
}
})
}
/// Official `sender_para_info` (capture and encoder names; the Windows host sends "DXGI" /
/// "NVIDIA NVENC") for the single video track.
pub fn sender_para_info(client_id: &str, ice_id: &str, capture_impl: &str, encoder_impl: &str) -> Value {
json!({
"client_id": client_id,
"data": {
"sender_para_info": {
"capture_impl": capture_impl, "encoder_impl": encoder_impl, "ice_id": ice_id,
"sender_media_infos": [{"capture_impl": capture_impl, "encoder_impl": encoder_impl, "video_track_index": 0}],
"video_track_index": 0
},
"type": "sender_para_info"
}
})
}
@@ -51,12 +79,20 @@ mod tests {
use super::*;
#[test]
fn hevc_capability_uses_official_codec_enum_and_420_only() {
let payload = device_capability("client-example", "ice-example", 0, 60, 5, true);
assert_eq!(payload["data"]["video_codec_capability"], json!([
{"video_codec":1,"chroma_sampling":1,"codec_impl":5,"bit_depth":8},
{"video_codec":2,"chroma_sampling":1,"codec_impl":5,"bit_depth":8}]));
assert_eq!(device_capability("c", "i", 0, 60, 5, false)["data"]["video_codec_capability"].as_array().unwrap().len(), 1);
fn capability_uses_the_official_nested_shape_and_real_formats() {
let payload = device_capability("client-example", "ice-example", 0, 60, 5, true, true);
assert_eq!(payload["data"]["type"], "device_capability");
assert!(payload.get("type").is_none());
let caps = &payload["data"]["device_capability"]["video_codec_capability"];
assert_eq!(caps.as_array().unwrap().len(), 4);
assert_eq!(caps[0], json!({"video_codec":1,"chroma_sampling":1,"codec_impl":5,"bit_depth":8,"width":3840,"height":2160}));
assert_eq!(caps[3], json!({"video_codec":2,"chroma_sampling":3,"codec_impl":5,"bit_depth":8,"width":0,"height":0}));
assert_eq!(payload["data"]["device_capability"]["display_info"][0]["hdr"], -1);
let h264_420 = device_capability("c", "i", 0, 60, 5, false, false);
assert_eq!(h264_420["data"]["device_capability"]["video_codec_capability"].as_array().unwrap().len(), 1);
let sender = sender_para_info("c", "i", "X11", "NVIDIA NVENC");
assert_eq!(sender["data"]["type"], "sender_para_info");
assert_eq!(sender["data"]["sender_para_info"]["sender_media_infos"][0]["encoder_impl"], "NVIDIA NVENC");
}
#[test]
@@ -71,15 +107,15 @@ mod tests {
#[test]
fn device_capability_uses_object_data_and_string_ice_id() {
let payload = h264_device_capability("client-example", "ice-example", 11, 60, 0);
assert_eq!(payload["type"], "device_capability");
assert!(payload["data"].is_object());
assert_eq!(payload["data"]["ice_id"], "ice-example");
let display = &payload["data"]["display_info"][0];
let capability = &payload["data"]["device_capability"];
assert!(capability.is_object());
assert_eq!(capability["ice_id"], "ice-example");
let display = &capability["display_info"][0];
assert_eq!(display.as_object().unwrap().len(), 4);
assert_eq!(display["id"], 11);
assert_eq!(display["fps"], 60);
let codec = &payload["data"]["video_codec_capability"][0];
assert_eq!(codec.as_object().unwrap().len(), 4);
let codec = &capability["video_codec_capability"][0];
assert_eq!(codec.as_object().unwrap().len(), 6);
assert_eq!(codec["video_codec"], 1);
assert_eq!(codec["codec_impl"], 0);
assert_eq!(codec["bit_depth"], 8);
+70 -5
View File
@@ -40,6 +40,8 @@ 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,
@@ -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_mbps: 0, output: None, chroma: CHROMA_420 } }
}
/// Selectable smaller stream sizes with the desktop's aspect ratio (even dimensions).
@@ -115,10 +117,16 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
}
/// 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>> {
@@ -180,9 +188,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.
@@ -248,7 +284,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_mbps: 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][..]));
@@ -469,4 +505,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());
}
}
+73 -12
View File
@@ -5,11 +5,37 @@ use crate::protocol::{decode_wire,WireValue};
use std::collections::BTreeMap;
const UNICODE_TEXT:u64=13;
/// The official Mac host offers its pasteboard text as format id 0 named `public.utf8-plain-text` (observed live).
const MAC_TEXT:&str="public.utf8-plain-text";
#[derive(Clone,Copy,PartialEq,Eq,Debug)]
enum TextFormat {Windows,Mac}
impl TextFormat {
fn of(format:&[u8])->Option<Self>{
if number(format,1)==Ok(UNICODE_TEXT){return Some(Self::Windows)}
let named=|n|text_field(format,n).is_ok_and(|s|s==MAC_TEXT);
(named(2)||named(3)).then_some(Self::Mac)
}
fn id(self)->u64{match self{Self::Windows=>UNICODE_TEXT,Self::Mac=>0}}
fn name(self)->&'static str{match self{Self::Windows=>"CF_UNICODETEXT",Self::Mac=>MAC_TEXT}}
fn encode(self,text:&str)->Vec<u8>{match self{Self::Windows=>encode_windows(text),Self::Mac=>text.as_bytes().to_vec()}}
fn decode(self,data:&[u8])->Result<String,&'static str>{
match self{
Self::Windows=>decode_windows(data),
Self::Mac=>{
let data=data.strip_suffix(&[0]).unwrap_or(data);
if data.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}
let text=std::str::from_utf8(data).map_err(|_|"invalid UTF-8 clipboard text")?;
if text.contains('\0'){return Err("embedded NUL in clipboard text");}
Ok(text.to_owned())
}
}
}
}
const BLOCK_BYTES:usize=0x20000;
const MAX_BYTES:usize=MAX_TEXT*2+2;
pub struct ResultMessages {pub messages:Vec<(u32,Vec<u8>)>,pub text:Option<String>}
impl Default for ResultMessages {fn default()->Self{Self{messages:Vec::new(),text:None}}}
struct Pending {key:String, count:Option<usize>, blocks:BTreeMap<usize,Vec<u8>>}
struct Pending {key:String, format:TextFormat, count:Option<usize>, blocks:BTreeMap<usize,Vec<u8>>}
#[derive(Default)]
pub struct State {local:Option<String>, pending:Option<Pending>}
pub fn format_ids(rpc:&[u8])->Vec<u64>{
@@ -62,12 +88,15 @@ fn decode_windows(data:&[u8])->Result<String,&'static str>{
if text.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}Ok(text)
}
impl State{
pub fn offer(&mut self,id:u64,text:String)->Result<Vec<u8>,&'static str>{
pub fn offer(&mut self,id:u64,text:String)->Result<Vec<u8>,&'static str>{self.offer_formats(id,text,&[TextFormat::Windows])}
/// Viewer offers: Windows hosts pick CF_UNICODETEXT, the official Mac host its UTF-8 type.
pub fn offer_any_host(&mut self,id:u64,text:String)->Result<Vec<u8>,&'static str>{self.offer_formats(id,text,&[TextFormat::Windows,TextFormat::Mac])}
fn offer_formats(&mut self,id:u64,text:String,formats:&[TextFormat])->Result<Vec<u8>,&'static str>{
if text.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}
if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");}
self.local=Some(text);
let mut format=Vec::new();int(1,UNICODE_TEXT,&mut format);string(2,"CF_UNICODETEXT",&mut format);
let mut list=Vec::new();nested(1,&format,&mut list);
let mut list=Vec::new();
for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);string(2,kind.name(),&mut format);nested(1,&format,&mut list);}
Ok(request(id,1,&list))
}
pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{
@@ -78,22 +107,30 @@ impl State{
if let Some(list)=bytes(clip,1)?{
out.messages.push((22,response(h,1,&[])));
let fields=decode_wire(list).map_err(|_|"invalid clipboard format list")?;
let supports_text=fields.iter().filter(|f|f.number==1).any(|f|match f.value{WireValue::Bytes(format)=>number(format,1)==Ok(UNICODE_TEXT),_=>false});
let offered:Vec<TextFormat>=fields.iter().filter(|f|f.number==1).filter_map(|f|match f.value{WireValue::Bytes(format)=>TextFormat::of(format),_=>None}).collect();
let chosen=if offered.contains(&TextFormat::Windows){Some(TextFormat::Windows)}else{offered.first().copied()};
let supports_text=chosen.is_some();
self.pending=None;
if supports_text{
if !supports_text{
// Format ids/names only (never data), to learn non-Windows peers' text formats.
let formats:Vec<(u64,String)>=fields.iter().filter(|f|f.number==1).filter_map(|f|match f.value{WireValue::Bytes(format)=>Some(format),_=>None})
.take(8).map(|format|(number(format,1).unwrap_or(u64::MAX),decode_wire(format).ok().and_then(|x|x.into_iter().find_map(|y|match (y.number,y.value){(n,WireValue::Bytes(s)) if n!=1=>std::str::from_utf8(s).ok().map(|s|s.chars().take(48).collect()),_=>None})).unwrap_or_default())).collect();
log::info!("Clipboard offer without a supported text format: formats={formats:?}");
}
if let Some(format)=chosen{
let id=next();
let epoch=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs() as u32;
let key=format!("{epoch:08x}-0000-4000-8000-{:012x}",id & 0xffffffffffff);
let mut ask=Vec::new();int(1,UNICODE_TEXT,&mut ask);string(2,&key,&mut ask);string(3,"CF_UNICODETEXT",&mut ask);
self.pending=Some(Pending{key,count:None,blocks:BTreeMap::new()});
let mut ask=Vec::new();int(1,format.id(),&mut ask);string(2,&key,&mut ask);string(3,format.name(),&mut ask);
self.pending=Some(Pending{key,format,count:None,blocks:BTreeMap::new()});
out.messages.push((21,request(id,2,&ask)));
}
}else if let Some(ask)=bytes(clip,2)?{
let key=text_field(ask,2)?;
if key.len()>256||key.is_empty(){return Err("invalid clipboard block key");}
let available=number(ask,1)?==UNICODE_TEXT&&self.local.is_some();
let mut confirm=Vec::new();int(1,if available{1}else{2},&mut confirm);string(2,key,&mut confirm);
let data=if available{Some(encode_windows(self.local.as_ref().unwrap()))}else{None};
let format=if number(ask,1)?==UNICODE_TEXT{Some(TextFormat::Windows)}else if text_field(ask,3).is_ok_and(|s|s==MAC_TEXT){Some(TextFormat::Mac)}else{None};
let data=format.zip(self.local.as_ref()).map(|(format,text)|format.encode(text));
let mut confirm=Vec::new();int(1,if data.is_some(){1}else{2},&mut confirm);string(2,key,&mut confirm);
if let Some(data)=&data{int(3,data.chunks(BLOCK_BYTES).len() as u64,&mut confirm);}
out.messages.push((22,response(h,2,&confirm)));
if let Some(data)=data{
@@ -144,13 +181,37 @@ impl State{
else if (1..=count).all(|i|pending.blocks.contains_key(&i)){1}
else{return Ok(None);};
let data:Vec<u8>=(first..first+count).flat_map(|i|pending.blocks[&i].iter().copied()).collect();
self.pending=None;decode_windows(&data).map(Some)
let format=pending.format;self.pending=None;format.decode(&data).map(Some)
}
}
#[cfg(test)]
mod tests{
use super::*;
#[test] fn mac_utf8_text_round_trips_both_directions(){
// Mac host offer: format list {1 id 0, 2 "public.utf8-plain-text"} (observed live).
let mut mac=Vec::new();int(1,0,&mut mac);string(2,MAC_TEXT,&mut mac);
let mut list=Vec::new();nested(1,&mac,&mut list);
let mut viewer=State::default();let mut id=200;let mut next=||{id+=1;id};
let asked=viewer.request(&request(7,1,&list),&mut next).unwrap();
assert_eq!(asked.messages.len(),2);
let ask_rpc=&asked.messages[1].1;let clip=bytes(ask_rpc,9).unwrap().unwrap();let ask=bytes(clip,2).unwrap().unwrap();
assert_eq!(number(ask,1),Ok(0));assert_eq!(text_field(ask,3),Ok(MAC_TEXT));
let key=text_field(ask,2).unwrap().to_owned();
let mut confirm=Vec::new();int(1,1,&mut confirm);string(2,&key,&mut confirm);int(3,1,&mut confirm);
assert_eq!(viewer.response(&response(header(ask_rpc).unwrap(),2,&confirm)).unwrap(),None);
let mut block=Vec::new();string(1,&key,&mut block);int(2,0,&mut block);nested(3,"中文 text\n".as_bytes(),&mut block);
assert_eq!(viewer.request(&request(8,3,&block),&mut next).unwrap().text.as_deref(),Some("中文 text\n"));
// Viewer offer lists both formats; a Mac-style ask gets UTF-8 bytes back.
let offer=viewer.offer_any_host(9,"hi".into()).unwrap();
assert_eq!(format_ids(&offer),vec![13,0]);
let mut ask=Vec::new();int(1,0,&mut ask);string(2,"k",&mut ask);string(3,MAC_TEXT,&mut ask);
let out=viewer.request(&request(10,2,&ask),&mut next).unwrap();
let data=bytes(bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap(),3).unwrap().unwrap();
assert_eq!(data,b"hi");
// Host-side offers are unchanged: CF_UNICODETEXT only.
assert_eq!(format_ids(&State::default().offer(1,"hi".into()).unwrap()),vec![13]);
}
#[test]
fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){
let text="UU-test-中文🙂\n".repeat(900);
+11
View File
@@ -15,6 +15,9 @@ pub enum ControlInput {
MouseAbsolute { x: f64, y: f64 },
MouseRelative { dx: i32, dy: i32 },
MouseScroll { dx: i32, dy: i32 },
/// Official Windows host `text_input {content}` (KeyboardMouseRunner::execTextInput): text typed by the
/// mobile clients' own input method. Never logged.
TextInput { text: String },
}
#[derive(Debug, Clone, PartialEq)]
@@ -58,6 +61,11 @@ pub fn decode_control(data: &[u8]) -> Result<ControlMessage, String> {
"mouse_move_relative" => ControlInput::MouseRelative {
dx: integer(&v, "delta_x")?, dy: integer(&v, "delta_y")?,
},
"text_input" => {
let text = v.get("content").and_then(Value::as_str).ok_or("CONTROL field content must be a string")?;
if text.len() > 16 * 1024 { return Err("text_input content exceeds 16 KiB".into()); }
ControlInput::TextInput { text: text.to_owned() }
}
"mouse_scroll" => ControlInput::MouseScroll {
dx: integer(&v, "delta_x")?, dy: integer(&v, "delta_y")?,
},
@@ -137,6 +145,9 @@ mod tests {
#[test]
fn does_not_invent_actions_for_unknown_json() {
assert!(matches!(decode_control(br#"{"action":"unverified"}"#).unwrap(), ControlMessage::Unsupported(_)));
assert_eq!(decode_control("{\"action\":\"text_input\",\"content\":\"你好 a\"}".as_bytes()).unwrap(),
ControlMessage::Input(ControlInput::TextInput { text: "你好 a".into() }));
assert!(decode_control(br#"{"action":"text_input"}"#).is_err());
}
}
+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"))]
+136
View File
@@ -0,0 +1,136 @@
//! `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())
}
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");
}
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");
}
}
+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)?; }
+97
View File
@@ -10,9 +10,12 @@ extern "C" {
fn x11_key_event(keycode: libc::c_int, is_press: libc::c_int) -> libc::c_int;
fn x11_release_all() -> libc::c_int;
fn x11_terminal_shortcut_state() -> libc::c_int;
fn x11_type_utf8(text: *const libc::c_char) -> libc::c_int;
}
#[cfg(not(target_os = "linux"))]
unsafe fn x11_terminal_shortcut_state() -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_type_utf8(_: *const libc::c_char) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn x11_mouse_move(_: libc::c_int, _: libc::c_int) -> libc::c_int { 0 }
@@ -248,6 +251,14 @@ impl InputInjector {
if AUDIT.fetch_add(1,std::sync::atomic::Ordering::Relaxed) < 8 {
log::info!("Desktop keyboard injection outcome: result={result}");
}
// KP_0..KP_9 type digits only with NumLock on (#46); record the server's NumLock state, not the key.
static NUMPAD: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if (0x60..=0x6f).contains(&key) && is_press && self.backend==crate::desktop_backend::DesktopBackend::X11
&& NUMPAD.fetch_add(1,std::sync::atomic::Ordering::Relaxed) < 4 {
let (mut x,mut y,mut mask)=(0,0,0u32);
let state=unsafe { x11_pointer_state(&mut x,&mut y,&mut mask) };
log::info!("Desktop numpad key: result={result} numlock={}", state==0 && mask & 0x10 != 0);
}
if result == 0 {
let mut held=self.held.lock().unwrap();
if is_press {held.keys.insert(symbol);} else {held.keys.remove(&symbol);}
@@ -314,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();
@@ -349,6 +366,34 @@ impl InputInjector {
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::key(symbol,pressed) }
else { unsafe { x11_key_symbol(symbol as libc::c_ulong,i32::from(pressed)) } }
}
/// Mobile input-method text (`text_input`). X11 types it directly; Wayland re-maps a spare
/// keycode in the virtual keyboard's keymap. Other backends log once.
pub fn text_input(&self, text: &str) {
let _serial=self.serial.lock().unwrap();
let Ok(c_text)=std::ffi::CString::new(text.replace('\0',"")) else { return };
if self.backend==crate::desktop_backend::DesktopBackend::X11 {
let typed=unsafe { x11_type_utf8(c_text.as_ptr()) };
log::info!("Desktop text input: chars={} result={}", text.chars().count(), typed);
} else if self.backend==crate::desktop_backend::DesktopBackend::Wayland {
// Escape hatch: keep the old behaviour without rebuilding.
if std::env::var("UU_WAYLAND_TEXT").is_ok_and(|v|v=="0") { return; }
let typed=crate::wayland::type_utf8(text);
if typed>=0 {
log::info!("Desktop text input: chars={} result={}", text.chars().count(), typed);
return;
}
// A keymap whose keycodes are all mapped cannot carry text; report it once.
static WARNED:std::sync::atomic::AtomicBool=std::sync::atomic::AtomicBool::new(false);
if !WARNED.swap(true,std::sync::atomic::Ordering::Relaxed) {
log::warn!("Mobile text input unavailable on the Wayland backend (no spare keycode in this keymap)");
}
} else {
static WARNED:std::sync::atomic::AtomicBool=std::sync::atomic::AtomicBool::new(false);
if !WARNED.swap(true,std::sync::atomic::Ordering::Relaxed) {
log::warn!("Mobile text input is not supported on the {:?} backend yet", self.backend);
}
}
}
pub fn key_event(&self, keycode: i32, is_press: bool) {
let _serial=self.serial.lock().unwrap();
if self.backend!=crate::desktop_backend::DesktopBackend::X11 { return; }
@@ -600,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));
}
}
}
}
}
+38 -3
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;
@@ -190,8 +193,8 @@ 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; 13] = ["show", "assist", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
"wayland-input-probe", "clipboard-acceptance", "portal-acceptance"];
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(" | "));
if matches!(arg.as_str(), "help" | "-h" | "--help") { println!("{usage}"); return Ok(()); }
@@ -353,6 +356,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if std::env::args().nth(1).as_deref() == Some("wayland-input-probe") {
return wayland::input_probe().map_err(|e|e.into());
}
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());
}
@@ -406,10 +415,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)
@@ -635,6 +650,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) => {
@@ -644,6 +664,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));
+4 -2
View File
@@ -61,6 +61,8 @@ fn save(settings: &Settings) {
#[derive(Default)]
pub struct PeerActions { started: AtomicBool }
/// Power actions pass --no-ask-password: without polkit permission (e.g. no active local session) systemctl
/// would otherwise wait for an authentication dialog on the controlled screen; fail and log instead.
fn quiet(program: &str, args: &[&str]) -> bool {
Command::new(program).args(args).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
.status().map(|s| s.success()).unwrap_or(false)
@@ -135,8 +137,8 @@ impl PeerActions {
let ok = detached("gnome-system-monitor", &[]) || detached("plasma-systemmonitor", &[]) || detached("xfce4-taskmanager", &[]);
log::info!("System action show_taskmgr: ok={}", ok); return false
}
REBOOT_SYSTEM => { log::warn!("System action reboot_system requested by viewer"); log::info!("reboot ok={}", quiet("systemctl", &["reboot"])); return false }
SHUTDOWN_SYSTEM => { log::warn!("System action shutdown_system requested by viewer"); log::info!("poweroff ok={}", quiet("systemctl", &["poweroff"])); return false }
REBOOT_SYSTEM => { log::warn!("System action reboot_system requested by viewer"); log::info!("reboot ok={}", quiet("systemctl", &["--no-ask-password", "reboot"])); return false }
SHUTDOWN_SYSTEM => { log::warn!("System action shutdown_system requested by viewer"); log::info!("poweroff ok={}", quiet("systemctl", &["--no-ask-password", "poweroff"])); return false }
_ => {}
}
let mut state = state().lock().unwrap();
+220 -31
View File
@@ -94,16 +94,57 @@ fn nal_offsets_for(bytes: &[u8], kind: u8, codec: VideoCodec) -> Vec<usize> {
let matches = match codec {
VideoCodec::H264 => header < bytes.len() && bytes[header] & 31 == kind,
// HEVC has a two-byte header: forbidden_zero_bit=0, temporal_id_plus1 != 0.
VideoCodec::H265 => header + 1 < bytes.len() && bytes[header] & 128 == 0
&& bytes[header + 1] & 7 != 0 && (bytes[header] >> 1) & 63 == kind,
VideoCodec::H265 => hevc_nal_kind(bytes, header) == Some(kind),
};
if matches { result.push(i); }
i += prefix;
}
result
}
fn aud_offsets_for(bytes: &[u8], codec: VideoCodec) -> Vec<usize> {
nal_offsets_for(bytes, if codec == VideoCodec::H265 { 35 } else { 9 }, codec)
/// Validated HEVC NAL unit type from the two-byte header (`None` when it is incomplete or the
/// forbidden bit is set or temporal_id_plus1 is zero).
fn hevc_nal_kind(bytes: &[u8], header: usize) -> Option<u8> {
(header + 1 < bytes.len() && bytes[header] & 128 == 0 && bytes[header + 1] & 7 != 0)
.then(|| (bytes[header] >> 1) & 63)
}
/// Access-unit starts for H.265, independent of where the encoder puts its AUDs. VAAPI writes an
/// AUD only at IRAPs, so splitting on AUD alone groups a whole GOP into one "frame" (and that
/// frame then fails the IRAP gate, so nothing is sent). RFC 7798 §3.1 puts the boundary at the
/// first NAL after a VCL NAL that is either non-VCL (AUD/VPS/SPS/PPS/SEI) or starts a picture
/// (first_slice_segment_in_pic_flag), which also keeps multi-slice pictures in one unit.
fn hevc_au_offsets(bytes: &[u8]) -> Vec<usize> {
let mut result = Vec::new();
let mut previous_vcl = false;
let mut first = true;
let mut i = 0;
while i + 3 < bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue };
let header = i + prefix;
if let Some(kind) = hevc_nal_kind(bytes, header) {
let vcl = kind < 32;
let starts_picture = vcl && bytes.get(header + 2).is_some_and(|byte| byte & 0x80 != 0);
// RFC 7798 / H.265 7.4.2.4.4: only these non-VCL types may open the next access unit.
// Suffix SEI (40), filler (38) and end of sequence/bitstream (36, 37) stay with the
// picture they follow.
let opens_unit = matches!(kind, 32..=35 | 39 | 41..=44 | 48..=55);
if first || (previous_vcl && (opens_unit || starts_picture)) { result.push(i); }
// Trailing NALs (suffix SEI, filler, end markers) do not end "after a VCL NAL".
if vcl || opens_unit { previous_vcl = vcl; }
first = false;
}
i += prefix;
}
result
}
fn au_offsets_for(bytes: &[u8], codec: VideoCodec) -> Vec<usize> {
match codec {
VideoCodec::H264 => nal_offsets_for(bytes, 9, codec),
VideoCodec::H265 => hevc_au_offsets(bytes),
}
}
fn is_independent_frame_for(bytes: &[u8], codec: VideoCodec) -> bool {
match codec {
@@ -114,11 +155,13 @@ fn is_independent_frame_for(bytes: &[u8], codec: VideoCodec) -> bool {
}
}
#[cfg(test)]
fn aud_offsets(bytes: &[u8]) -> Vec<usize> { aud_offsets_for(bytes, VideoCodec::H264) }
fn aud_offsets(bytes: &[u8]) -> Vec<usize> { au_offsets_for(bytes, VideoCodec::H264) }
fn is_independent_frame(bytes: &[u8]) -> bool { is_independent_frame_for(bytes, VideoCodec::H264) }
#[derive(Debug)]
struct CompleteFrame {
source_id: usize,
source_generation: u64,
codec: VideoCodec,
sequence: u64,
completed_at: Instant,
@@ -126,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)]
@@ -178,10 +227,17 @@ fn vaapi_options(settings: &VideoSettings, gop: &str) -> Vec<String> {
let (maxrate, buffer) = rate_args(settings, Encoder::Vaapi);
// QVBR is not uniformly available on Intel/AMD drivers. VBR + qmin sets a quality
// floor while retaining the viewer's bitrate cap; unsupported drivers fall back to CPU.
["-c:v", Encoder::Vaapi.name_for(settings.codec), "-profile:v", profile_for(settings.codec, true), "-g", gop, "-bf", "0",
"-rc_mode", "VBR", "-b:v", &settings.max_kbps().map_or("16M".into(), |k| format!("{}k",k*3/4)),
"-maxrate", &maxrate, "-bufsize", &buffer, "-qmin", &settings.cq().to_string(), "-async_depth", "1", "-aud", "1"]
.into_iter().map(str::to_owned).collect()
let mut options: Vec<String> = ["-c:v", Encoder::Vaapi.name_for(settings.codec), "-profile:v", profile_for(settings.codec, true),
"-g", gop, "-bf", "0", "-rc_mode", "VBR", "-b:v", &settings.max_kbps().map_or("16M".into(), |k| format!("{}k",k*3/4)),
"-maxrate", &maxrate, "-bufsize", &buffer, "-qmin", &settings.cq().to_string(), "-async_depth", "1"]
.into_iter().map(str::to_owned).collect();
// h264_vaapi writes an AUD per picture and the reader splits access units on it. hevc_vaapi
// does not: with `-aud 1` it writes an AUD only at IRAPs and drops every other picture from
// the bitstream (a 90-frame clip encoded to 3 IDRs and no P-frames), so HEVC leaves AUD off
// and hevc_au_offsets() splits pictures by their own boundaries. Parameter sets are still
// repeated in-band ahead of every IDR.
if settings.codec == VideoCodec::H264 { options.extend(["-aud".into(), "1".into()]); }
options
}
fn profile_for(codec: VideoCodec, vaapi: bool) -> &'static str {
@@ -238,8 +294,22 @@ fn encoder_options(settings: &VideoSettings, encoder: Encoder, gop: &str, rgb: O
options.into_iter().map(str::to_owned).collect()
}
fn scale_options(settings: &VideoSettings, encoder: Encoder) -> Vec<String> {
if encoder == Encoder::Vaapi { return vec!["-vf".into(), vaapi_filter(settings.output)]; }
/// Filter chain for a capture of `source` size (None when the input size is not known yet, e.g.
/// the fixed-input probe). H.264/HEVC 4:2:0 encoders — and NVENC's surface allocation — require
/// even frame dimensions, but the captured size is not always even: the portal backend reports the
/// compositor's logical desktop size, so two stacked monitors at 150% scale capture 2560x2507 and
/// every encoder failed to open ("height not divisible by 2 (2560x2507)" from libx264,
/// "InitializeEncoder failed: out of memory (10)" from h264_nvenc), leaving the viewer stuck on the
/// 正在传输画面 spinner. When the native capture size is odd, pad the odd row/column; the host
/// display mode and every reported capture setting stay untouched.
fn scale_options(settings: &VideoSettings, encoder: Encoder, source: Option<(u32,u32)>) -> Vec<String> {
const EVEN_PAD: &str = "pad=ceil(iw/2)*2:ceil(ih/2)*2:0:0:black";
let odd_capture = settings.output.is_none() && source.is_some_and(|(w,h)| w % 2 != 0 || h % 2 != 0);
if encoder == Encoder::Vaapi {
let filtered = if odd_capture { format!("{EVEN_PAD},{}", vaapi_filter(None)) } else { vaapi_filter(settings.output) };
return vec!["-vf".into(), filtered];
}
if odd_capture { return vec!["-vf".into(), EVEN_PAD.into()]; }
settings.output.map_or_else(Vec::new, |(w,h)| vec!["-vf".into(), format!("scale={w}:{h}:flags=bilinear")])
}
@@ -465,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.
@@ -480,7 +550,21 @@ async fn read_inprocess(
/// whole IDR frame, otherwise large desktops get near-grey keyframes that sharpen over the GOP (#8).
/// Half a second of bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not.
fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
if encoder == Encoder::Cpu { max_kbps.clamp(500, 8000) } else { (max_kbps / 8).clamp(100, 500) }
if encoder == Encoder::Cpu { max_kbps.clamp(500, 8000) }
else if encoder == Encoder::Vaapi {
let requested = std::env::var("UU_VAAPI_BUFFER_MS").ok();
vaapi_buffer_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500))
}
else { (max_kbps / 8).clamp(100, 500) }
}
/// Opt-in VAAPI VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` in 10-1000 ms.
/// The 100-500 kbit default is sized for NVENC; VAAPI quantizes a whole desktop keyframe when
/// the buffer is that small, which reads as a blur that sharpens over each GOP (#42).
/// Unset, out of range or unparsable values keep the default buffer.
fn vaapi_buffer_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> {
let ms = value?.trim().parse::<u32>().ok().filter(|ms| (10..=1000).contains(ms))?;
Some((max_kbps.saturating_mul(ms) / 1000).max(1))
}
fn buffer_for(settings: &VideoSettings, encoder: Encoder) -> u32 {
@@ -498,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);
@@ -520,6 +606,7 @@ async fn read_encoder_with(
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec));
return read_inprocess(config, latest, sequence, idr, budget).await;
}
let source_size = size;
let size = format!("{}x{}", size.0, size.1);
let fps = settings.fps.to_string();
// Keep the IDR interval at 2 s whatever the frame rate.
@@ -543,7 +630,7 @@ async fn read_encoder_with(
"-video_size",&size,"-i",&display,"-an"]);
}
// 其他分辨率: scale the captured desktop (the host display mode is left untouched).
command.args(scale_options(&settings, encoder));
command.args(scale_options(&settings, encoder, Some(source_size)));
command.args(encoder_options(&settings, encoder, &gop, rgb));
// x11grab paces against an absolute schedule; after a capture stall it grabs
// back-to-back to "catch up" (measured 69 frames in 200ms). vfr on a 1/FPS
@@ -560,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}"))?;
@@ -651,14 +740,14 @@ async fn read_encoder_with(
pending.extend_from_slice(&chunk[..count]);
// A chunk can include the next AUD, so split before enforcing the bound.
loop {
let aud = aud_offsets_for(&pending, settings.codec);
let aud = au_offsets_for(&pending, settings.codec);
if aud.len() < 2 { break; }
let next = aud[1];
if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
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(()); }
@@ -686,7 +775,16 @@ fn probe_settings() -> Result<VideoSettings,String> {
None=>crate::capture_setting::QUALITY_AUTO,
Some(v)=>v.parse::<u64>().ok().filter(|q|(1..=5).contains(q)).ok_or("UU_PROBE_QUALITY must be 1-5")?,
};
Ok(VideoSettings {fps,quality,..VideoSettings::default()})
Ok(VideoSettings {fps,quality,codec:probe_codec(),..VideoSettings::default()})
}
/// The probe follows `UU_VIDEO_CODEC` so the HEVC path can be measured at all (H.264 otherwise),
/// and its first access unit is then checked against that codec instead of always H.264.
fn probe_codec() -> VideoCodec {
match std::env::var("UU_VIDEO_CODEC").ok().as_deref().map(str::to_ascii_lowercase).as_deref() {
Some("h265") | Some("hevc") => VideoCodec::H265,
_ => VideoCodec::H264,
}
}
fn probe_input_command(spec:&FfmpegSpec,input:&std::ffi::OsStr,loop_input:bool,settings:&VideoSettings,
@@ -697,10 +795,10 @@ fn probe_input_command(spec:&FfmpegSpec,input:&std::ffi::OsStr,loop_input:bool,s
if loop_input { command.args(["-stream_loop","-1"]); }
// Override source timestamps so clips and image sequences use the same nominal probe rate.
command.args(["-r",&settings.fps.to_string(),"-i"]).arg(input).args(["-map","0:v:0","-an"]);
command.args(scale_options(settings,encoder));
command.args(scale_options(settings,encoder,None));
command.args(encoder_options(settings,encoder,&gop_frames(settings.fps,false).to_string(),None));
command.args(timing_args(timing,settings.fps));
command.args(["-frames:v",&wanted.to_string(),"-f","h264","pipe:1"]);
command.args(["-frames:v",&wanted.to_string(),"-f",if settings.codec==VideoCodec::H265 {"hevc"} else {"h264"},"pipe:1"]);
command
}
@@ -749,10 +847,10 @@ pub async fn probe_input(input:OsString,path:Option<String>)->Result<(),String>
let n=stdout.read(&mut chunk).await.map_err(|e|format!("Encoder read: {e}"))?;
pending.extend_from_slice(&chunk[..n]);
loop {
let aud=aud_offsets_for(&pending,settings.codec);
let aud=au_offsets_for(&pending,settings.codec);
let end=if aud.len()>1 { aud[1] } else if n==0 && !pending.is_empty() { pending.len() } else { break; };
if end>MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
if count==0 && !is_independent_frame(&pending[..end]) { return Err("Video probe did not begin with IDR".into()); }
if count==0 && !is_independent_frame_for(&pending[..end], settings.codec) { return Err("Video probe did not begin with IDR".into()); }
if let Some(file)=file.as_mut() { file.write_all(&pending[..end]).map_err(|e|e.to_string())?; }
bytes+=end; count+=1;
pending.drain(..end);
@@ -787,7 +885,7 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
tokio::time::timeout(Duration::from_secs(15+wanted/30),async {
while count<wanted {
let frame=rx.recv().await.ok_or("Video probe encoder ended")?;
if count==0 && !is_independent_frame(&frame.data) { return Err("Video probe did not begin with IDR".to_owned()); }
if count==0 && !is_independent_frame_for(&frame.data, settings.codec) { return Err("Video probe did not begin with IDR".to_owned()); }
if let Some(file)=file.as_mut() { file.write_all(&frame.data).map_err(|e|e.to_string())?; }
bytes+=frame.data.len(); count+=1;
}
@@ -835,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 {
@@ -859,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(()); } },
@@ -869,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());
@@ -878,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);
@@ -891,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;
@@ -910,6 +1025,28 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
#[cfg(test)]
mod tests {
#[test]
fn native_frame_dimensions_are_padded_to_even() {
// A scaled compositor can report an odd logical desktop (e.g. two stacked 150% monitors →
// 2560x2507); H.264/HEVC 4:2:0 encoders reject odd dimensions, so a native-size capture
// with a known odd size gets a pad filter. Even sizes, explicit output scaling and the
// fixed-input probe (size unknown) keep their existing filter chains.
let native = VideoSettings { output: None, ..Default::default() };
let pad = "pad=ceil(iw/2)*2:ceil(ih/2)*2:0:0:black";
for encoder in [Encoder::Cpu, Encoder::Nvenc] {
assert_eq!(scale_options(&native, encoder, Some((2560, 2507))), vec!["-vf".to_string(), pad.to_string()]);
assert!(scale_options(&native, encoder, Some((2560, 2508))).is_empty());
assert!(scale_options(&native, encoder, None).is_empty());
}
assert_eq!(scale_options(&native, Encoder::Vaapi, Some((2560, 2507))),
vec!["-vf".to_string(), format!("{pad},format=nv12,hwupload")]);
assert_eq!(scale_options(&native, Encoder::Vaapi, Some((2560, 2508))),
vec!["-vf".to_string(), "format=nv12,hwupload".to_string()]);
let scaled = VideoSettings { output: Some((1280, 720)), ..Default::default() };
assert_eq!(scale_options(&scaled, Encoder::Cpu, Some((2560, 2507))),
vec!["-vf".to_string(), "scale=1280:720:flags=bilinear".to_string()]);
}
#[test]
fn fixed_input_arguments_share_production_encoding_options() {
let spec=FfmpegSpec {program:"ffmpeg".into(),ld_library_path:None,path:None};
@@ -922,7 +1059,7 @@ mod tests {
let args:Vec<_>=command.as_std().get_args().map(|a|a.to_str().unwrap().to_owned()).collect();
let expected=encoder_options(&settings,encoder,&gop_frames(30,false).to_string(),None);
assert!(args.windows(expected.len()).any(|w|w==expected));
let scale=scale_options(&settings,encoder);
let scale=scale_options(&settings,encoder,None);
assert!(args.windows(scale.len()).any(|w|w==scale));
assert!(args.windows(4).any(|w|w==["-r","30","-i","frames/%05d.png"]));
assert!(args.windows(2).any(|w|w==["-frames:v","17"]));
@@ -974,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();
@@ -1066,6 +1203,20 @@ mod tests {
assert_eq!(buffer_kbits(30_000, Encoder::Cpu), 8000);
}
#[test]
fn vaapi_buffer_env_is_opt_in_and_bounded() {
assert_eq!(vaapi_buffer_kbits(30_000, None), None);
assert_eq!(vaapi_buffer_kbits(30_000, Some("250")), Some(7500));
assert_eq!(vaapi_buffer_kbits(30_000, Some(" 10 ")), Some(300));
assert_eq!(vaapi_buffer_kbits(30_000, Some("1000")), Some(30_000));
// Out of the documented range, empty or unparsable keeps the default buffer.
for value in ["", "9", "1001", "0", "abc", "-250", "250ms"] {
assert_eq!(vaapi_buffer_kbits(30_000, Some(value)), None, "{value}");
}
// A tiny cap must not produce a zero-sized buffer.
assert_eq!(vaapi_buffer_kbits(1, Some("10")), Some(1));
}
#[test]
fn vaapi_is_explicit_and_upload_follows_scale() {
assert_eq!(Encoder::from_setting(None, true), Encoder::Nvenc);
@@ -1094,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],
});
@@ -1189,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
@@ -1207,7 +1358,7 @@ mod tests {
#[test]
fn hevc_annex_b_boundaries_and_irap_use_two_byte_headers() {
let bytes = [0,0,0,1,70,1,80,0,0,1,64,1,42,0,0,1,38,1,42,0,0,1,70,1,80];
assert_eq!(aud_offsets_for(&bytes, VideoCodec::H265), vec![0,19]);
assert_eq!(au_offsets_for(&bytes, VideoCodec::H265), vec![0,19]);
assert!(is_independent_frame_for(&bytes[..19], VideoCodec::H265));
for kind in 16..=21 {
assert!(is_independent_frame_for(&[0,0,1,kind << 1,1,42], VideoCodec::H265));
@@ -1218,11 +1369,32 @@ mod tests {
assert!(!is_independent_frame_for(&[0,0,1,166,1,42], VideoCodec::H265));
assert!(!is_independent_frame_for(&[0,0,1,38,1,42,0,0,1,2,1,42], VideoCodec::H265));
}
#[test]
fn hevc_access_units_do_not_depend_on_aud_placement() {
// VAAPI writes an AUD only at IRAPs: AUD VPS SPS PPS IDR, then one P per picture.
let vaapi = [0,0,0,1,70,1,0x80, 0,0,0,1,64,1,0x42, 0,0,0,1,66,1,0x42,
0,0,0,1,68,1,0x42, 0,0,0,1,38,1,0x80, 0,0,0,1,2,1,0x80, 0,0,0,1,2,1,0x80];
assert_eq!(hevc_au_offsets(&vaapi), vec![0, 35, 42]);
// x265/nvenc style: an AUD in front of every picture.
let with_aud = [0,0,0,1,70,1,0x80, 0,0,0,1,64,1,0x42, 0,0,0,1,38,1,0x80,
0,0,0,1,70,1,0x80, 0,0,0,1,2,1,0x80, 0,0,0,1,70,1,0x80, 0,0,0,1,2,1,0x80];
assert_eq!(hevc_au_offsets(&with_aud), vec![0, 21, 35]);
// A picture split over several slices stays one access unit.
let multi_slice = [0,0,0,1,38,1,0x80, 0,0,0,1,38,1,0x00, 0,0,0,1,2,1,0x80];
assert_eq!(hevc_au_offsets(&multi_slice), vec![0, 14]);
// Truncated/invalid NALs must not invent boundaries. An invalid header is skipped, and
// the first valid NAL after it still opens the first unit.
assert_eq!(hevc_au_offsets(&[0,0,1,70]), Vec::<usize>::new());
assert_eq!(hevc_au_offsets(&[0,0,1,128,1,0x80]), Vec::<usize>::new());
assert_eq!(hevc_au_offsets(&[0,0,1,128,1,0x80, 0,0,1,2,1,0x80]), vec![6]);
// A suffix SEI (40) after a picture stays in that picture's unit; the next slice opens the next one.
assert_eq!(hevc_au_offsets(&[0,0,1,0x26,1,0x80, 0,0,1,0x50,1,0x05, 0,0,1,0x02,1,0x80]), vec![0, 12]);
}
#[tokio::test]
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());
@@ -1250,6 +1422,8 @@ mod tests {
for pair in [["-c:v", "hevc_vaapi"], ["-profile:v", "main"], ["-bf", "0"], ["-bufsize", "500k"]] {
assert!(vaapi.windows(2).any(|window| window == pair));
}
// hevc_vaapi with -aud drops every non-IRAP picture, so H.265 must not ask for AUDs.
assert!(!vaapi.iter().any(|option| option == "-aud"));
assert_eq!(Encoder::Nvenc.name_for(VideoCodec::H265), "hevc_nvenc");
assert_eq!(Encoder::Cpu.name_for(VideoCodec::H264), "libx264");
}
@@ -1261,3 +1435,18 @@ mod tests {
assert!(!is_independent_frame(&[0,0,0,1,9,48,0,0,1,1,154]));
}
}
#[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));
}
}
+459
View File
@@ -0,0 +1,459 @@
use crate::auth::UUAuthClient;
use serde::Deserialize;
use serde_json::{json, Value};
use std::time::Duration;
// No Debug: room/report tokens and signaling URLs are credentials.
#[derive(Deserialize)]
pub struct JoinData {
#[serde(default)] pub token: String,
#[serde(default)] pub signaling_list: Vec<String>,
#[serde(default)] pub ws_connect_timeout_ms: i32,
pub report_token: String,
pub report_url: String,
#[serde(default)] pub report_server_address: String,
#[serde(default)] pub streamer_retry_delta_ms: i32,
#[serde(default)] pub international_connect: bool,
#[serde(default)] pub publisher_platform: Option<i32>,
}
fn device_platform(data:&Value,device:&str)->Option<i64>{
["my_binded_devices","others_shared_devices"].into_iter()
.filter_map(|key|data.get(key).and_then(Value::as_array)).flatten()
.find(|d|d.get("device_id").and_then(Value::as_str)==Some(device))
.and_then(|d|d.get("platform")).and_then(Value::as_i64)
}
#[derive(Debug, PartialEq, Eq)]
pub enum Error { AuthenticationExpired, Api(i32, String), InvalidResponse, Transport, MissingRoom, InvalidDevice, InvalidAssist, UnknownKeyboardPlatform }
impl std::fmt::Display for Error {
// The server's short message is user-facing (e.g. 2002 「被控端正在被远控中,无法发起连接」).
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::Api(code, msg) if !msg.is_empty() => write!(f, "{msg} (code {code})"),
Error::AuthenticationExpired => write!(f, "登录已过期,请重新登录"),
Error::Transport => write!(f, "网络连接失败"),
Error::InvalidAssist => write!(f, "请输入对方的设备 ID 和有效验证码"),
Error::InvalidResponse => write!(f, "服务器响应格式无效"),
Error::MissingRoom => write!(f, "服务器未返回可用的房间或信令信息"),
Error::UnknownKeyboardPlatform => write!(f, "无法确定目标键盘平台,不能启用控制"),
Error::Api(code, _) => write!(f, "连接请求失败(错误码 {code})"),
_ => write!(f, "viewer API: {self:?}"),
}
}
}
// Mirrors Windows 0x140b77cd0 / 0x140b7a6d0, not host RoomData.
/// Treat the caller's device string as one opaque path segment, never a URL/query.
fn path_segment(device: &str) -> Result<String, Error> {
if device.is_empty() || device=="." || device==".." { return Err(Error::InvalidDevice); }
Ok(device.bytes().map(|b|if b.is_ascii_alphanumeric() || b"-._~".contains(&b) {(b as char).to_string()}else{format!("%{b:02X}")}).collect())
}
fn parse_ack(status: u16, body: Value) -> Result<(), Error> {
let code = body.get("code").and_then(Value::as_i64).unwrap_or(-1);
if code == 1120 { return Err(Error::AuthenticationExpired); }
if status == 200 && code == 0 { return Ok(()); }
let msg = body.get("msg").and_then(Value::as_str).unwrap_or("").chars().take(120).collect();
Err(Error::Api(i32::try_from(code).unwrap_or(-1), msg))
}
pub fn parse_join(status: u16, value: Value) -> Result<JoinData, Error> {
let code = value.get("code").and_then(Value::as_i64).and_then(|v| i32::try_from(v).ok()).ok_or(Error::InvalidResponse)?;
let msg = value.get("msg").and_then(Value::as_str).ok_or(Error::InvalidResponse)?.chars().take(120).collect::<String>();
if code == 1120 { return Err(Error::AuthenticationExpired); }
let code = if code == 0 && status != 200 { i32::from(status) } else { code };
// Error responses carry an empty data object (observed: 400 / 2002 with data {}); report the code.
if code != 0 { return Err(Error::Api(code, msg)); }
let data = match value.get("data") {
Some(Value::Object(o)) => Some(serde_json::from_value::<JoinData>(Value::Object(o.clone())).map_err(|_| Error::InvalidResponse)?),
_ => None,
};
data.ok_or(Error::MissingRoom)
}
fn parse_share(status: u16, mut body: Value, secrets: &[&str]) -> Result<JoinData, Error> {
if let Some(Value::String(msg)) = body.get_mut("msg") {
// A server error must not echo credentials to stderr or the launcher.
for secret in secrets {
if !secret.is_empty() { *msg = msg.replace(secret, "[已隐藏]"); }
}
*msg = msg.chars().filter(|c| !c.is_control()).collect();
}
let room = parse_join(status, body)?;
if room.token.is_empty() || room.signaling_list.is_empty() { return Err(Error::MissingRoom); }
Ok(room)
}
pub fn retry_delay(error: &Error, retries: usize, enabled: bool) -> Option<Duration> {
match error {
Error::Api(code, _) if enabled && retries < 5 && ![-1, 2002, 2006, 2007, 4042].contains(code) => Some(Duration::from_millis(3000)),
_ => None,
}
}
pub struct Api {
signer: UUAuthClient,
http: reqwest::Client,
base: String,
}
impl Api {
pub fn new(signer: UUAuthClient, base: &str) -> Self {
Self { signer, base: base.trim_end_matches('/').into(), http: crate::auth::http_client_builder().timeout(Duration::from_secs(12)).build().unwrap() }
}
pub async fn join_share(&self, connect_id: &str, connect_code: &str) -> Result<JoinData, Error> {
if connect_id.trim().is_empty() || connect_code.trim().is_empty() || connect_id.chars().chain(connect_code.chars()).any(char::is_control) { return Err(Error::InvalidAssist); }
// Win LiteInner 0x140b6db90 sends plaintext connect_code; Mac uses the v1 path.
let text = json!({"connect_id":connect_id,"connect_code":connect_code}).to_string();
for version in [2, 1] {
let path = format!("/api/v{version}/room/join/share/by_code");
let response = self.http.post(format!("{}{path}", self.base))
.headers(self.signer.build_headers("POST", &path, &text)).body(text.clone())
.send().await.map_err(|_| Error::Transport)?;
let status = response.status().as_u16();
log::info!("Assist join response: status={status}");
// A missing endpoint may return HTML; inspect HTTP status before decoding JSON.
if version == 2 && matches!(status, 404 | 405) { continue; }
let body = response.json().await.map_err(|_| Error::InvalidResponse)?;
return parse_share(status, body, &[connect_code, &self.signer.creds.token, &self.signer.creds.csrf]);
}
unreachable!()
}
async fn request(&self, method: reqwest::Method, path: &str, body: Option<Value>) -> Result<(u16, Value), Error> {
let text = body.map(|v| v.to_string()).unwrap_or_default();
let response = self.http.request(method.clone(), format!("{}{path}", self.base))
.headers(self.signer.build_headers(method.as_str(), path, &text)).body(text)
.send().await.map_err(|_| Error::Transport)?;
let status = response.status().as_u16();
Ok((status, response.json().await.map_err(|_| Error::InvalidResponse)?))
}
pub async fn join(&self, device: &str, force_join: bool, retry: bool) -> Result<JoinData, Error> {
let path = format!("/api/v1/room/join/by_device/{}", path_segment(device)?);
let mut retries = 0;
loop {
let result = match self.request(reqwest::Method::POST, &path, Some(json!({"force_join":force_join}))).await {
Ok((status, body)) => {
// Structure only (codes and key names), never the room token or URLs.
let shape = crate::protocol::json_shape(&body, 3);
let server_msg = body.get("msg").and_then(Value::as_str).map(|m| m.chars().take(120).collect::<String>());
let parsed = parse_join(status, body);
if parsed.is_err() {
// UU_VIEWER_DEBUG=1 adds the server's short error message (like UU_ASSIST_DEBUG on the host).
let msg = std::env::var("UU_VIEWER_DEBUG").is_ok_and(|v| v == "1").then_some(server_msg).flatten();
log::warn!("Join response: status={status} shape={shape} msg={msg:?}");
}
parsed
}
Err(e) => Err(e),
};
match result {
Ok(data) => {
if data.token.is_empty() || data.signaling_list.is_empty() { return Err(Error::MissingRoom); }
return Ok(data);
}
Err(error) => match retry_delay(&error, retries, retry) {
Some(delay) => { tokio::time::sleep(delay).await; retries += 1; }
None => return Err(error),
},
}
}
}
/// Remove a device from the account (official 「删除设备」). Paths from the Windows host strings
/// `/api/v1/device/%s/unbind` and `/api/v1/device/share/%s/unbind` (own vs. shared-with-me device).
/// POST verified live against an own device; the shared-device path is from strings only.
pub async fn unbind(&self, device: &str, shared: bool) -> Result<(), Error> {
let segment = path_segment(device)?;
let path = if shared { format!("/api/v1/device/share/{segment}/unbind") } else { format!("/api/v1/device/{segment}/unbind") };
let (status, body) = self.request(reqwest::Method::POST, &path, None).await?;
parse_ack(status, body)
}
/// Structure-only probe of the device list (status, JSON keys/types/lengths, never values).
pub async fn devices_shape(&self, method: reqwest::Method) -> Result<String, Error> {
let path = "/api/v1/device/list";
let response = self.http.request(method.clone(), format!("{}{path}", self.base))
.headers(self.signer.build_headers(method.as_str(), path, "")).send().await.map_err(|_| Error::Transport)?;
let status = response.status().as_u16();
let bytes = response.bytes().await.map_err(|_| Error::InvalidResponse)?;
Ok(match serde_json::from_slice::<Value>(&bytes) {
Ok(v) => format!("status={status} shape={}", crate::protocol::json_shape(&v, 7)),
Err(_) => format!("status={status} non_json_bytes={}", bytes.len()),
})
}
/// GET /api/v1/device/list → data {current_device, my_binded_devices[], others_shared_devices[]} (observed live).
pub async fn device_list(&self) -> Result<Value, Error> {
let (status, body) = self.request(reqwest::Method::GET, "/api/v1/device/list", None).await?;
if body.get("code").and_then(Value::as_i64) == Some(1120) { return Err(Error::AuthenticationExpired); }
if status != 200 || body.get("code").and_then(Value::as_i64) != Some(0) { return Err(Error::InvalidResponse); }
body.get("data").cloned().ok_or(Error::InvalidResponse)
}
pub async fn target_is_mac(&self,room:&JoinData,device:Option<&str>)->Result<bool,Error>{
let platform=match room.publisher_platform {
Some(platform)=>Some(i64::from(platform)),
None=>match device {
Some(device)=>device_platform(&self.device_list().await?,device),
None=>None,
},
};
// Observed device/share platforms: 1 = Windows (also our Linux host), 4 = Mac.
match platform {
Some(1)=>Ok(false),
Some(4)=>Ok(true),
_=>Err(Error::UnknownKeyboardPlatform),
}
}
/// Method and wire-key mapping remain unverified. Caller must select both explicitly.
pub async fn devices(&self, method: reqwest::Method, array_pointer: &str) -> Result<Vec<Value>, Error> {
let (status, body) = self.request(method, "/api/v1/device/list", None).await?;
if body.get("code").and_then(Value::as_i64) == Some(1120) { return Err(Error::AuthenticationExpired); }
if status != 200 || body.get("code").and_then(Value::as_i64) != Some(0) { return Err(Error::InvalidResponse); }
body.pointer(array_pointer).and_then(Value::as_array).cloned().ok_or(Error::InvalidResponse)
}
}
#[cfg(test)]
mod tests {
#[test] fn unbind_ack_and_device_segment(){
use super::*;
assert_eq!(parse_ack(200,json!({"code":0,"msg":"ok"})),Ok(()));
assert_eq!(parse_ack(422,json!({"code":1120})),Err(Error::AuthenticationExpired));
assert_eq!(parse_ack(200,json!({"code":5003,"msg":"no such device"})),Err(Error::Api(5003,"no such device".into())));
assert_eq!(parse_ack(404,json!({})),Err(Error::Api(-1,String::new())));
assert_eq!(path_segment("a/b?c").unwrap(),"a%2Fb%3Fc");
for bad in ["",".",".."]{assert_eq!(path_segment(bad),Err(Error::InvalidDevice));}
}
use super::*;
#[test]
fn target_platform_matches_only_the_selected_device(){
let data=json!({"my_binded_devices":[{"device_id":"windows","platform":1},{"device_id":"mac","platform":4}],
"others_shared_devices":[{"device_id":"shared-mac","platform":4}]});
assert_eq!(device_platform(&data,"windows"),Some(1));
assert_eq!(device_platform(&data,"mac"),Some(4));
assert_eq!(device_platform(&data,"shared-mac"),Some(4));
assert_eq!(device_platform(&data,"missing"),None);
assert_eq!(device_platform(&json!({}),"mac"),None);
}
#[test]
fn assistance_response_validation_and_safe_user_errors() {
let mut fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
fixture["data"]["publisher_device_id"]=json!("synthetic-publisher");
fixture["data"]["share_id"]=json!("synthetic-share");
assert!(!parse_share(200,fixture.clone(),&[]).unwrap().token.is_empty());
for key in ["token","signaling_list"] {
let mut v=fixture.clone();v["data"].as_object_mut().unwrap().remove(key);
assert_eq!(parse_share(200,v,&[]).err().unwrap(),Error::MissingRoom);
}
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
assert_eq!(parse_share(422,json!({"code":9876,"msg":msg}),&[]).err().unwrap().to_string(),format!("{msg} (code 9876)"));
}
assert_eq!(parse_share(422,json!({"code":9876,"msg":"fixture-code\nfixture-token"}),&["fixture-code","fixture-token",""]).err().unwrap(),Error::Api(9876,"[已隐藏][已隐藏]".into()));
assert_eq!(parse_share(422,json!({"code":1120,"msg":"expired"}),&[]).err().unwrap(),Error::AuthenticationExpired);
assert_eq!(parse_share(200,json!({"code":0,"msg":"","data":{}}),&[]).err().unwrap(),Error::InvalidResponse);
}
#[test]
fn join_schema_defaults_required_types_and_error_policy() {
let fixture: Value = serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
let data = parse_join(200, fixture.clone()).unwrap();
assert_eq!(data.signaling_list.len(), 1);
assert_eq!(data.publisher_platform,None);
let mut empty=fixture.clone();empty["data"]["publisher_platform"]=Value::Null;
assert_eq!(parse_join(200,empty).unwrap().publisher_platform,None);
let mut mac=fixture.clone();mac["data"]["publisher_platform"]=json!(4);
assert_eq!(parse_join(200,mac).unwrap().publisher_platform,Some(4));
for key in ["report_token", "report_url"] {
let mut v = fixture.clone(); v["data"].as_object_mut().unwrap().remove(key);
assert!(matches!(parse_join(200,v), Err(Error::InvalidResponse)));
let mut v = fixture.clone(); v["data"][key] = Value::Null;
assert!(matches!(parse_join(200,v), Err(Error::InvalidResponse)));
}
let v = json!({"code":0,"msg":"","data":{"report_token":"","report_url":""}});
let d = parse_join(200,v).unwrap();
assert!(d.token.is_empty() && d.signaling_list.is_empty() && !d.international_connect);
assert_eq!(d.ws_connect_timeout_ms,0); assert_eq!(d.streamer_retry_delta_ms,0);
assert!(matches!(parse_join(503,fixture),Err(Error::Api(503, _))));
for data in [Value::Null,json!([]),json!("ignored")] {
assert!(matches!(parse_join(422,json!({"code":1120,"msg":"","data":data})),Err(Error::AuthenticationExpired)));
}
for code in [-1,2002,2006,2007,4042] { assert_eq!(retry_delay(&Error::Api(code,String::new()),0,true),None); }
for retries in 0..5 { assert_eq!(retry_delay(&Error::Api(5000,String::new()),retries,true),Some(Duration::from_millis(3000))); }
assert_eq!(retry_delay(&Error::Api(5000,String::new()),5,true),None);
assert_eq!(retry_delay(&Error::Api(5000,String::new()),0,false),None);
for error in [Error::Transport,Error::InvalidResponse,Error::AuthenticationExpired] { assert_eq!(retry_delay(&error,0,true),None); }
}
}
#[cfg(test)]
mod http_tests {
use super::*;
use crate::auth::Credentials;
use tokio::{io::{AsyncReadExt,AsyncWriteExt},net::TcpListener};
pub async fn server(replies:Vec<(u16,Value)>)->(String,tokio::task::JoinHandle<Vec<String>>) {
server_raw(replies.into_iter().map(|(status,body)|(status,body.to_string())).collect()).await
}
async fn server_raw(replies:Vec<(u16,String)>)->(String,tokio::task::JoinHandle<Vec<String>>) {
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();
let url=format!("http://{}",listener.local_addr().unwrap());
let job=tokio::spawn(async move {
let mut requests=Vec::new();
for (status,body) in replies {
let(mut stream,_)=listener.accept().await.unwrap();let mut request=Vec::new();let mut buf=[0;1024];
loop {
let n=stream.read(&mut buf).await.unwrap();assert_ne!(n,0);request.extend_from_slice(&buf[..n]);
if let Some(end)=request.windows(4).position(|w|w==b"\r\n\r\n") {
let headers=String::from_utf8_lossy(&request[..end]);
let length=headers.lines().find_map(|l|l.to_lowercase().strip_prefix("content-length:").map(str::trim).and_then(|s|s.parse::<usize>().ok())).unwrap_or(0);
if request.len()>=end+4+length {break}
}
}
requests.push(String::from_utf8(request).unwrap());
let reply=format!("HTTP/1.1 {status} Mock\r\nContent-Type: application/json\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{body}",body.len());
stream.write_all(reply.as_bytes()).await.unwrap();
}
requests
});
(url,job)
}
fn signer()->UUAuthClient {UUAuthClient::new(Credentials{token:"synthetic-auth".into(),sign_key:"synthetic-key".into(),..Default::default()})}
fn room(platform:Option<i32>)->JoinData {
let mut room=parse_join(200,serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap()).unwrap();
room.publisher_platform=platform;room
}
#[tokio::test]
async fn keyboard_platform_uses_room_metadata_without_device_lookup(){
let api=Api::new(signer(),"http://127.0.0.1:1");
for device in [None,Some("synthetic-device")] {
assert_eq!(api.target_is_mac(&room(Some(1)),device).await,Ok(false));
assert_eq!(api.target_is_mac(&room(Some(4)),device).await,Ok(true));
for platform in [0,-1,2,3,5,999,i32::MIN,i32::MAX] {
assert_eq!(api.target_is_mac(&room(Some(platform)),device).await,Err(Error::UnknownKeyboardPlatform));
}
}
assert_eq!(api.target_is_mac(&room(None),None).await,Err(Error::UnknownKeyboardPlatform));
}
#[tokio::test]
async fn keyboard_platform_looks_up_only_the_selected_account_device(){
for list in ["my_binded_devices","others_shared_devices"] {
for (platform,mac) in [(1,false),(4,true)] {
let data=json!({list:[{"device_id":"unrelated","platform":4},
{"device_id":"synthetic-device","platform":platform}]});
let(url,job)=server(vec![(200,json!({"code":0,"data":data}))]).await;
assert_eq!(Api::new(signer(),&url).target_is_mac(&room(None),Some("synthetic-device")).await,Ok(mac));
let requests=job.await.unwrap();assert_eq!(requests.len(),1);
assert!(requests[0].starts_with("GET /api/v1/device/list "));
}
}
}
#[tokio::test]
async fn keyboard_platform_rejects_unknown_or_malformed_device_metadata(){
let mut devices=vec![json!({"device_id":"unrelated","platform":4}),json!({"device_id":"synthetic-device"})];
for platform in [json!(0),json!(-1),json!(999),json!("4"),json!(true),json!(4.5),json!(null),json!(u64::MAX)] {
devices.push(json!({"device_id":"synthetic-device","platform":platform}));
}
for device in devices {
let data=json!({"my_binded_devices":[device]});
let(url,job)=server(vec![(200,json!({"code":0,"data":data}))]).await;
assert_eq!(Api::new(signer(),&url).target_is_mac(&room(None),Some("synthetic-device")).await,Err(Error::UnknownKeyboardPlatform));
assert_eq!(job.await.unwrap().len(),1);
}
}
#[tokio::test]
async fn keyboard_platform_propagates_device_lookup_failures(){
for (status,body,error) in [
(422,json!({"code":1120}),Error::AuthenticationExpired),
(503,json!({"code":5000}),Error::InvalidResponse),
(200,json!({"code":0}),Error::InvalidResponse),
] {
let(url,job)=server(vec![(status,body)]).await;
assert_eq!(Api::new(signer(),&url).target_is_mac(&room(None),Some("synthetic-device")).await,Err(error));
assert_eq!(job.await.unwrap().len(),1);
}
let api=Api::new(signer(),"http://127.0.0.1:1");
assert_eq!(api.target_is_mac(&room(None),Some("synthetic-device")).await,Err(Error::Transport));
}
#[tokio::test]
async fn signed_join_and_explicit_device_list_use_only_loopback_http() {
let fixture=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
let(url,job)=server(vec![(200,json!({"code":0,"data":{"synthetic_devices":[{"id":"synthetic-device","name":"fixture"}]}})),(200,fixture)]).await;
let api=Api::new(signer(),&url);
let devices=api.devices(reqwest::Method::GET,"/data/synthetic_devices").await.unwrap();assert_eq!(devices.len(),1);
assert!(api.join("",true,true).await.is_err());
api.join("synthetic-device",true,true).await.unwrap();
let requests=job.await.unwrap();assert!(requests[0].starts_with("GET /api/v1/device/list "));
assert!(requests[1].starts_with("POST /api/v1/room/join/by_device/synthetic-device "));
assert!(requests[1].to_lowercase().contains("x-param-sign:"));
assert_eq!(requests[1].split("\r\n\r\n").nth(1).unwrap(),r#"{"force_join":true}"#);
}
#[tokio::test]
async fn assistance_uses_signed_json_and_only_http_endpoint_fallback() {
let mut fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
// Extra share identity fields do not change the existing room parser.
fixture["data"]["share_id"]=json!("synthetic-share");
fixture["data"]["publisher_device_id"]=json!("synthetic-publisher");
fixture["data"]["publisher_platform"]=json!(1);
for status in [200,404,405] {
let replies=if status==200 {vec![(200,fixture.to_string())]} else {vec![(status,"<html>endpoint unavailable</html>".into()),(200,fixture.to_string())]};
let(url,job)=server_raw(replies).await;
let room=Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.unwrap();
assert!(!room.token.is_empty());assert_eq!(room.signaling_list.len(),1);
let requests=job.await.unwrap();assert_eq!(requests.len(),if status==200{1}else{2});
for (i,request) in requests.iter().enumerate() {
let version=if i==0{2}else{1};
assert!(request.starts_with(&format!("POST /api/v{version}/room/join/share/by_code ")));
let(headers,body)=request.split_once("\r\n\r\n").unwrap();
assert!(!headers.contains("synthetic-code"));
assert!(headers.to_lowercase().contains("x-param-sign:"));
assert!(headers.to_lowercase().contains("content-type: application/json"));
assert_eq!(serde_json::from_str::<Value>(body).unwrap(),json!({"connect_id":"synthetic-id","connect_code":"synthetic-code"}));
}
}
}
#[tokio::test]
async fn assistance_reports_actual_errors_without_retrying_or_echoing_secrets() {
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
let(url,job)=server(vec![(422,json!({"code":9876,"msg":msg}))]).await;
let error=Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.err().unwrap();
assert_eq!(error.to_string(),format!("{msg} (code 9876)"));assert_eq!(job.await.unwrap().len(),1);
}
for (status,body,expected) in [
(200,json!({"code":405,"msg":"业务拒绝"}),Error::Api(405,"业务拒绝".into())),
(500,json!({"code":5000,"msg":"服务忙"}),Error::Api(5000,"服务忙".into())),
(422,json!({"code":1120,"msg":""}),Error::AuthenticationExpired),
(200,json!({"code":0,"msg":"","data":{"report_url":"","report_token":""}}),Error::MissingRoom),
(200,json!({"code":0,"msg":"","data":{}}),Error::InvalidResponse),
(422,json!({"code":9876,"msg":"synthetic-code synthetic-auth"}),Error::Api(9876,"[已隐藏] [已隐藏]".into())),
] {
let(url,job)=server(vec![(status,body)]).await;
assert_eq!(Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.err().unwrap(),expected);
assert_eq!(job.await.unwrap().len(),1);
}
let api=Api::new(signer(),"http://127.0.0.1:1");
for (id,code) in [("","fixture"),("id",""),("id","a\nb")] {assert_eq!(api.join_share(id,code).await.err().unwrap(),Error::InvalidAssist);}
}
#[tokio::test]
async fn retry_stops_after_five_delays_and_terminal_errors_stop_immediately() {
let(url,job)=server(vec![(503,json!({"code":5000,"msg":"fixture"}));6]).await;
let start=tokio::time::Instant::now();
assert!(matches!(Api::new(signer(),&url).join("synthetic-device",false,true).await,Err(Error::Api(5000, _))));
assert!(start.elapsed()>=Duration::from_secs(15));assert_eq!(job.await.unwrap().len(),6);
for code in [-1,1120,2002,2006,2007,4042] {
let(url,job)=server(vec![(422,json!({"code":code,"msg":"fixture"}))]).await;
let error=Api::new(signer(),&url).join("synthetic-device",false,true).await.err().unwrap();
if code==1120 {assert_eq!(error,Error::AuthenticationExpired)} else {assert!(matches!(error,Error::Api(c,_) if c==code))}
assert_eq!(job.await.unwrap().len(),1);
}
}
}
#[cfg(test)]
mod strict_tests {
use super::*;
#[test]
fn rejects_wrong_json_types_and_missing_envelope_members() {
let fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
for (key,bad) in [("token",json!(false)),("signaling_list",json!([7])),("ws_connect_timeout_ms",json!(2147483648u64)),("streamer_retry_delta_ms",json!(null)),("international_connect",json!(1)),("report_token",json!(null)),("report_url",json!(7)),("report_server_address",json!([]))] {
let mut v=fixture.clone();v["data"][key]=bad;assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
}
for platform in [json!("4"),json!(true),json!(4.5),json!(2147483648u64),json!(-2147483649i64)] {
let mut v=fixture.clone();v["data"]["publisher_platform"]=platform;
assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
}
for key in ["code","msg"] {
let mut v=fixture.clone();v.as_object_mut().unwrap().remove(key);assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
}
assert!(matches!(parse_join(200,json!({"code":0,"msg":"","data":{}})),Err(Error::InvalidResponse)));
assert!(matches!(parse_join(200,json!({"code":2147483648u64,"msg":""})),Err(Error::InvalidResponse)));
}
}
+45
View File
@@ -0,0 +1,45 @@
//! Assistance secrets travel only through memory and the child's stdin pipe.
use std::{io::BufRead,path::Path,process::Stdio};
use tokio::{io::AsyncWriteExt,process::{Child,Command}};
pub fn read_code(input: impl BufRead) -> Result<String,String> {
let mut code=String::new();
input.take(1025).read_line(&mut code).map_err(|_|"无法从 stdin 读取验证码")?;
if code.len()>1024 {return Err("验证码过长".into())}
if code.ends_with('\n') {code.pop();if code.ends_with('\r'){code.pop();}}
if code.trim().is_empty() || code.chars().any(char::is_control) {return Err("请输入有效验证码".into())}
Ok(code)
}
pub fn command(exe:&Path,id:&str)->Command {
let mut command=Command::new(exe);
command.args(["assist",id]).stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::piped()).kill_on_drop(true);
command
}
pub async fn send_code(child:&mut Child,code:&str)->Result<(),String> {
let result=async {
let mut stdin=child.stdin.take().ok_or("无法打开会话输入管道")?;
stdin.write_all(code.as_bytes()).await.map_err(|_|"无法向会话传递验证码")?;
stdin.write_all(b"\n").await.map_err(|_|"无法向会话传递验证码")?;
stdin.shutdown().await.map_err(|_|"无法关闭会话输入管道")
}.await;
if result.is_err() {let _=child.kill().await;}
result.map_err(str::to_owned)
}
#[cfg(test)] mod tests {
use super::*;
#[test] fn stdin_reads_one_line_without_changing_code() {
assert_eq!(read_code(&b"a b\r\nignored\n"[..]).unwrap(),"a b");
assert_eq!(read_code(&b"fixture"[..]).unwrap(),"fixture");
for input in ["","\n"," \r\n","a\tb\n","a\0b\n",&"x".repeat(1025)] {assert!(read_code(input.as_bytes()).is_err());}
}
#[tokio::test] async fn launcher_passes_only_id_in_arguments_and_closes_stdin() {
let command=command(Path::new("/bin/sh"),"synthetic-id");
assert_eq!(command.as_std().get_args().collect::<Vec<_>>(),["assist","synthetic-id"]);
// Local process mock: echo the pipe after EOF, without files or credentials.
let mut child=Command::new("/bin/sh").args(["-c","cat"]).stdin(Stdio::piped()).stdout(Stdio::piped()).spawn().unwrap();
send_code(&mut child,"synthetic-code").await.unwrap();
let output=child.wait_with_output().await.unwrap();
assert!(output.status.success());assert_eq!(output.stdout,b"synthetic-code\n");
}
}
+170
View File
@@ -0,0 +1,170 @@
use super::media::Latest;
const PACKETS:usize=12;
const MAX_PACKET:usize=8192;
#[derive(Clone)]
pub struct Packet { seq:u16, data:Vec<u8> }
#[derive(Clone)]
pub struct Audio { packets:Latest<Packet>, enabled:bool }
impl Default for Audio {
fn default()->Self {Self{packets:Latest::new(PACKETS),enabled:std::env::var("UU_VIEWER_AUDIO").map_or(true,|v|v!="0")}}
}
impl Audio {
#[cfg(test)] pub fn pop(&self)->Option<Vec<u8>> {self.packets.pop().map(|p|p.data)}
pub fn push(&self,seq:u16,data:&[u8]) {
if self.enabled && data.len()<=MAX_PACKET && samples(data).is_some() {self.packets.push(Packet{seq,data:data.to_vec()});}
}
}
fn samples(data:&[u8])->Option<u64> {
let toc=*data.first()?;
let frame=if toc&0x80!=0 {120u64<<(toc>>3&3)} else if toc&0x60==0x60 {if toc&8!=0 {960}else{480}} else {match toc>>3&3 {3=>2880,n=>480u64<<n}};
let count=match toc&3 {0=>1,1|2=>2,_=>u64::from(*data.get(1)?&63)};
let total=frame*count;(count>0 && total<=5760).then_some(total)
}
// One complete packet per page; zero pre-skip because RTP has no encoder pre-skip header.
#[derive(Default)]
struct Ogg { sequence:u32, granule:u64, last:Option<u16> }
impl Ogg {
fn page(&mut self,payload:&[u8],flags:u8)->Vec<u8> {
let mut page=b"OggS\0".to_vec();page.push(flags);page.extend(self.granule.to_le_bytes());
page.extend(1u32.to_le_bytes());page.extend(self.sequence.to_le_bytes());self.sequence=self.sequence.wrapping_add(1);
page.extend([0;4]);page.push((payload.len()/255+1) as u8);
page.extend(std::iter::repeat(255).take(payload.len()/255));page.push((payload.len()%255) as u8);page.extend(payload);
let mut crc=0u32;
for byte in &page {crc^=u32::from(*byte)<<24;for _ in 0..8 {crc=if crc&0x80000000!=0 {(crc<<1)^0x04c11db7}else{crc<<1};}}
page[22..26].copy_from_slice(&crc.to_le_bytes());page
}
fn headers(&mut self)->Vec<u8> {
let mut head=b"OpusHead\x01\x02\0\0".to_vec();head.extend(48000u32.to_le_bytes());head.extend([0,0,0]);
let mut out=self.page(&head,2);let mut tags=b"OpusTags".to_vec();tags.extend([0;8]);out.extend(self.page(&tags,0));out
}
fn packet(&mut self,packet:Packet)->Option<Vec<u8>> {
if self.last.is_some_and(|last|{let delta=packet.seq.wrapping_sub(last);delta==0 || delta>=0x8000}) {return None}
self.granule+=samples(&packet.data)?;self.last=Some(packet.seq);Some(self.page(&packet.data,0))
}
}
#[cfg(feature="viewer-sdl")]
mod playback {
use super::*;
use tokio::{io::{AsyncReadExt,AsyncWriteExt},process::{Child,Command},task::JoinHandle};
use std::{process::Stdio,time::Duration};
const PCM_SAMPLES:usize=1920;
const PCM_BYTES:usize=PCM_SAMPLES*2;
const SDL_BYTES:u32=48000*2*2/10;
struct Decoder { child:Option<Child>, tasks:Vec<JoinHandle<()>>, pcm:Latest<Vec<i16>> }
impl Decoder {
fn new(audio:Audio)->Result<Self,String> {
let mut child=Command::new(std::env::var_os("UU_VIEWER_FFMPEG").unwrap_or_else(||"ffmpeg".into()))
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-f","ogg","-i","pipe:0","-vn","-ac","2","-ar","48000","-c:a","pcm_s16le","-f","s16le","-flush_packets","1","pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|"Audio decoder start failed")?;
let mut input=child.stdin.take().ok_or("Audio decoder stdin missing")?;
let mut output=child.stdout.take().ok_or("Audio decoder stdout missing")?;
let pcm=Latest::new(PACKETS);let decoded=pcm.clone();
let writer=tokio::spawn(async move {
let mut ogg=Ogg::default();
let result:std::io::Result<()>=async {
input.write_all(&ogg.headers()).await?;
let mut tick=tokio::time::interval(Duration::from_millis(4));
loop {
tick.tick().await;
while let Some(packet)=audio.packets.pop() {if let Some(page)=ogg.packet(packet) {
tokio::time::timeout(Duration::from_secs(1),input.write_all(&page)).await??;
}}
}
}.await;
if result.is_err() {log::warn!("Viewer audio decoder input stopped");}
});
let reader=tokio::spawn(async move {
let mut bytes=[0u8;PCM_BYTES];
while output.read_exact(&mut bytes).await.is_ok() {
decoded.push(bytes.chunks_exact(2).map(|b|i16::from_le_bytes([b[0],b[1]])).collect());
}
});
Ok(Self{child:Some(child),tasks:vec![writer,reader],pcm})
}
fn alive(&mut self)->bool {self.child.as_mut().is_some_and(|child|matches!(child.try_wait(),Ok(None))) && self.tasks.iter().all(|t|!t.is_finished())}
}
impl Drop for Decoder {
fn drop(&mut self) {
for task in &self.tasks {task.abort();}
if let Some(mut child)=self.child.take() {let _=child.start_kill();tokio::spawn(async move {let _=child.wait().await;});}
}
}
pub struct Playback { queue:sdl2::audio::AudioQueue<i16>, decoder:Decoder }
impl Playback {
pub fn new(sdl:&sdl2::Sdl,audio:Audio)->Option<Self> {
if !audio.enabled {return None}
let result=(|| {
let subsystem=sdl.audio()?;
let queue=subsystem.open_queue::<i16,_>(None,&sdl2::audio::AudioSpecDesired{freq:Some(48000),channels:Some(2),samples:Some(960)})?;
let decoder=Decoder::new(audio)?;queue.resume();Ok::<_,String>(Self{queue,decoder})
})();
match result {Ok(p)=>Some(p),Err(_)=>{log::warn!("Viewer audio playback unavailable");None}}
}
pub fn pump(&mut self)->Result<(),String> {
if !self.decoder.alive() {return Err("Audio decoder stopped".into())}
while let Some(samples)=self.decoder.pcm.pop() {
if self.queue.size()+samples.len() as u32*2>SDL_BYTES {self.queue.clear();}
self.queue.queue_audio(&samples).map_err(|_|"Audio queue failed")?;
}Ok(())
}
}
#[cfg(test)] mod tests {
use super::*;
#[tokio::test] async fn sdl_dummy_queue_is_bounded_and_audio_can_be_disabled() {
if std::env::var_os("UU_VIEWER_AUDIO_TEST_CHILD").is_none() {
let output=std::process::Command::new(std::env::current_exe().unwrap()).args(["--exact","viewer::audio::playback::tests::sdl_dummy_queue_is_bounded_and_audio_can_be_disabled","--test-threads=1"])
.env("SDL_AUDIODRIVER","dummy").env("UU_VIEWER_AUDIO_TEST_CHILD","1").output().unwrap();
assert!(output.status.success(),"{}",String::from_utf8_lossy(&output.stdout));return
}
let sdl=sdl2::init().unwrap();
assert!(Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:false}).is_none());
let mut playback=Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:true}).unwrap();playback.queue.pause();
for value in 0..100 {playback.decoder.pcm.push(vec![value;PCM_SAMPLES]);}
playback.pump().unwrap();assert!(playback.queue.size()>0 && playback.queue.size()<=SDL_BYTES);
assert!(playback.decoder.pcm.pop().is_none());
}
#[tokio::test] async fn ffmpeg_streams_pcm_before_eof_and_is_reaped() {
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};let mut decoder=Decoder::new(audio.clone()).unwrap();
let id=decoder.child.as_ref().unwrap().id().unwrap();
tokio::time::timeout(Duration::from_secs(5),async {
for seq in 0..250 {audio.push(seq,&[0xf8,0xff,0xfe]);tokio::time::sleep(Duration::from_millis(8)).await;
if let Some(pcm)=decoder.pcm.pop() {assert_eq!(pcm.len(),PCM_SAMPLES);assert!(decoder.alive());return}
}panic!("No PCM before EOF");
}).await.unwrap();
drop(decoder);
tokio::time::timeout(Duration::from_secs(2),async {while unsafe{libc::kill(id as i32,0)}==0 {tokio::time::sleep(Duration::from_millis(10)).await;}}).await.unwrap();
}
}
}
#[cfg(feature="viewer-sdl")] pub use playback::Playback;
#[cfg(test)] mod tests {
use super::*;
#[test] fn duration_bounds_and_latest_packets() {
assert_eq!(samples(&[0xf8,0xff,0xfe]),Some(960));assert_eq!(samples(&[0x98]),Some(960));
assert_eq!(samples(&[0x18]),Some(2880));assert_eq!(samples(&[0x83,48]),Some(5760));
assert_eq!(samples(&[0x83,49]),None);assert_eq!(samples(&[3,0]),None);assert_eq!(samples(&[]),None);
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};
for seq in 0..1000 {audio.push(seq,&[0xf8,0xff,0xfe]);}
audio.push(1000,&vec![0;MAX_PACKET+1]);audio.push(1000,&[]);
for seq in 988..1000 {assert_eq!(audio.packets.pop().unwrap().seq,seq);}assert!(audio.packets.pop().is_none());
let disabled=Audio{enabled:false,..audio};disabled.push(0,&[0xf8,0xff,0xfe]);assert!(disabled.packets.pop().is_none());
}
#[test] fn ogg_headers_crc_lacing_and_sequence_wrap() {
let mut ogg=Ogg::default();let headers=ogg.headers();assert_eq!(&headers[..4],b"OggS");assert_eq!(&headers[28..36],b"OpusHead");
let page=ogg.page(&vec![0;255],0);assert_eq!(&page[27..29],&[255,0]);
let mut stream=headers;stream.extend(&page);
let (mut reader,head)=webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream.clone()),true).unwrap();
assert_eq!(head.channels,2);assert_eq!(head.sample_rate,48000);
assert!(reader.parse_next_page().unwrap().0.starts_with(b"OpusTags"));
assert_eq!(reader.parse_next_page().unwrap().0.len(),255);
stream[28]^=1;assert!(webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream),true).is_err());
let packet=|seq|Packet{seq,data:vec![0xf8,0xff,0xfe]};
assert!(ogg.packet(packet(65535)).is_some());assert!(ogg.packet(packet(0)).is_some());
assert!(ogg.packet(packet(0)).is_none());assert!(ogg.packet(packet(65534)).is_none());assert_eq!(ogg.granule,1920);
}
}
+396
View File
@@ -0,0 +1,396 @@
//! Session-scoped text clipboard. Payloads never enter logs or process arguments.
use super::{rtc::Observed,wire};
use crate::{clipboard_protocol as text,clipboard_rich as rich,protocol::{decode_wire,WireValue}};
use std::{path::PathBuf,process::Stdio,sync::{Arc,atomic::{AtomicBool,Ordering}},time::Duration};
use tokio::{io::{AsyncReadExt,AsyncWriteExt},sync::mpsc};
use webrtc::data_channel::RTCDataChannel;
// Same limit as src/clipboard.rs; shared host codecs enforce it on both wire formats.
pub const MAX_TEXT:usize=30*1024;
pub const CHANNEL:usize=1; // TEXT_DATA_CHANNEL; native host clipboard state is scoped to this channel.
const POLL:Duration=Duration::from_millis(500);
static WARNED:AtomicBool=AtomicBool::new(false);
fn warn(){if !WARNED.swap(true,Ordering::Relaxed){log::warn!("Viewer text clipboard unavailable; synchronization disabled");}}
#[derive(Clone)]
struct CommandBackend {read:PathBuf,read_args:Vec<&'static str>,write:PathBuf,write_args:Vec<&'static str>}
#[derive(Clone)]
enum Backend {
Command(CommandBackend),
#[cfg(feature="viewer-sdl")]
Sdl(mpsc::Sender<ClipboardRequest>),
}
#[cfg(feature="viewer-sdl")]
pub enum ClipboardRequest {
Read(tokio::sync::oneshot::Sender<Result<Option<String>,()>>),
// false means the unfocused window skipped the write.
Write(String,tokio::sync::oneshot::Sender<Result<bool,()>>),
}
fn executable(name:&str)->Option<PathBuf>{
use std::os::unix::fs::PermissionsExt;
std::env::var_os("PATH").and_then(|p|std::env::split_paths(&p).map(|d|d.join(name))
.find(|p|std::fs::metadata(p).is_ok_and(|m|m.is_file() && m.permissions().mode()&0o111!=0)))
}
impl Backend {
fn detect()->Option<Self>{
if std::env::var("UU_VIEWER_CLIPBOARD").as_deref()==Ok("0"){return None}
// Unit sessions must never inspect or change the developer's real clipboard.
if !cfg!(target_os="linux") || cfg!(test){return None}
let selected=CommandBackend::select(std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty()),executable).map(Self::Command);
if selected.is_none(){warn();}selected
}
async fn read(&self)->Result<Option<String>,()>{
match self {
Self::Command(backend)=>backend.read().await,
#[cfg(feature="viewer-sdl")]
Self::Sdl(tx)=>{
let(reply,rx)=tokio::sync::oneshot::channel();
tokio::time::timeout(Duration::from_secs(2),async {
tx.send(ClipboardRequest::Read(reply)).await.map_err(|_|())?;
rx.await.map_err(|_|())?
}).await.map_err(|_|())?
}
}
}
async fn write(&self,value:&str)->Result<bool,()>{
if value.len()>MAX_TEXT || value.contains('\0'){return Err(())}
match self {
Self::Command(backend)=>backend.write(value).await.map(|()|true),
#[cfg(feature="viewer-sdl")]
Self::Sdl(tx)=>{
let(reply,rx)=tokio::sync::oneshot::channel();
tokio::time::timeout(Duration::from_secs(2),async {
tx.send(ClipboardRequest::Write(value.into(),reply)).await.map_err(|_|())?;
rx.await.map_err(|_|())?
}).await.map_err(|_|())?
}
}
}
}
impl CommandBackend {
fn select(wayland:bool,find:impl Fn(&str)->Option<PathBuf>)->Option<Self>{
let selected=if wayland{
find("wl-paste").zip(find("wl-copy")).map(|(read,write)|Self{read,write,read_args:vec!["--no-newline","--type","text"],write_args:vec!["--type","text/plain;charset=utf-8"]})
}else{None};
selected.or_else(||find("xclip").map(|p|Self{read:p.clone(),write:p,read_args:vec!["-selection","clipboard","-out"],write_args:vec!["-selection","clipboard","-in"]}))
.or_else(||find("xsel").map(|p|Self{read:p.clone(),write:p,read_args:vec!["--clipboard","--output"],write_args:vec!["--clipboard","--input"]}))
}
async fn read(&self)->Result<Option<String>,()>{
let mut child=tokio::process::Command::new(&self.read).args(&self.read_args).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|())?;
let operation=async{
let mut data=Vec::new();child.stdout.take().ok_or(())?.take((MAX_TEXT+1) as u64).read_to_end(&mut data).await.map_err(|_|())?;
if data.len()>MAX_TEXT {let _=child.kill().await;return Ok(None)}
// No text selection (including an image-only selection) is not a fatal backend failure.
if !child.wait().await.map_err(|_|())?.success(){return Ok(None)}
Ok(String::from_utf8(data).ok())
};
tokio::time::timeout(Duration::from_secs(2),operation).await.map_err(|_|())?
}
async fn write(&self,value:&str)->Result<(),()>{
let mut child=tokio::process::Command::new(&self.write).args(&self.write_args).stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|())?;
let operation=async{
let mut stdin=child.stdin.take().ok_or(())?;stdin.write_all(value.as_bytes()).await.map_err(|_|())?;drop(stdin);
if child.wait().await.map_err(|_|())?.success(){Ok(())}else{Err(())}
};
tokio::time::timeout(Duration::from_secs(2),operation).await.map_err(|_|())?
}
}
#[derive(Default)]
// target_mac: Some(true) official Mac host, Some(false) Windows-type host (official or this project), None unknown.
struct SyncState {last:Option<String>,assembly:text::Assembly,rich:rich::State,seq:u64,target_mac:Option<bool>}
impl SyncState {
async fn apply(&mut self,backend:&Backend,value:String)->Result<(),()>{
if backend.write(&value).await? {
log::info!("Viewer remote clipboard applied: bytes={}",value.len());
self.last=Some(value);
}
Ok(())
}
fn next(&mut self)->u64{self.seq=self.seq.wrapping_add(1).max(100);self.seq}
/// Two requests per change: the rich format-list offer (this project's host asks for the data) and
/// RpcRequest case 10 ClipboardTextChangeRequest carrying the text, which the official Windows host applies
/// (handle_text_change_request -> notifyReceiveText); it only acknowledges the rich offer. Each host
/// ignores the other form.
fn local(&mut self,value:String)->Result<Option<Vec<Vec<u8>>>,&'static str>{
if self.last.as_ref()==Some(&value){return Ok(None)}
let id=self.next();let payload=self.rich.offer_any_host(id,value.clone())?;
let rich=wire::envelope(self.next(),21,&payload);
let text=wire::envelope(self.next(),21,&crate::clipboard_protocol::text_request(self.next(),&value));
self.last=Some(value);
// Live-verified: the official Windows host writes case-10 text, then a rich format list replaces it with a
// placeholder it never asks us to render (paste is empty). The Mac host only takes the rich offer.
Ok(Some(match self.target_mac {Some(true)=>vec![rich],Some(false)=>vec![text],None=>vec![rich,text]}))
}
fn receive(&mut self,data:&[u8])->Result<(Vec<Vec<u8>>,Option<String>),&'static str>{
if data.len()>MAX_TEXT*2+1024{return Err("clipboard message exceeds limit")}
let fields=decode_wire(data).map_err(|_|"invalid clipboard envelope")?;
let mut replies=Vec::new();let mut value=None;
for field in fields {
let WireValue::Bytes(payload)=field.value else{continue};
match field.number {
17=>if let Some(text)=self.assembly.accept(payload)?{value=Some(text)},
21=>{
let seq=&mut self.seq;
let result=self.rich.request(payload,&mut ||{*seq=seq.wrapping_add(1).max(100);*seq})?;
if result.text.is_some(){value=result.text;}
for (kind,body) in result.messages {replies.push(wire::envelope(self.next(),kind,&body));}
if let Some((header,text))=text::read_text_request(payload)?{
value=Some(text);replies.push(wire::envelope(self.next(),22,&text::text_response(&header)));
}
},
22=>{
// TextChangeResponse (case 6 {1 err}, CB_SUCCEEDED=1) answers our case 10 request: status only.
if let Some(status)=decode_wire(payload).ok().and_then(|f|f.into_iter().find_map(|x|match (x.number,x.value){(6,WireValue::Bytes(b))=>Some(b.to_vec()),_=>None})){
let err=decode_wire(&status).ok().and_then(|f|f.into_iter().find_map(|x|match (x.number,x.value){(1,WireValue::Varint(v))=>Some(v),_=>None})).unwrap_or(0);
log::info!("Viewer clipboard text change acknowledged: err={err}");
}
if let Some(text)=self.rich.response(payload)?{value=Some(text)}
},
_=>{},
}
}
if value.as_ref().is_some_and(|text|text.contains('\0')){return Err("clipboard text contains NUL")}
Ok((replies,value))
}
}
async fn send(channel:&RTCDataChannel,message:Vec<u8>)->Result<(),()>{
tokio::time::timeout(Duration::from_secs(2),channel.send(&bytes::Bytes::from(message))).await.map_err(|_|())?.map_err(|_|())?;Ok(())
}
pub struct Bridge {backend:Option<Backend>,pub enabled:bool,tx:Option<mpsc::Sender<Vec<u8>>>,task:Option<tokio::task::JoinHandle<()>>,target_mac:Option<bool>}
impl Bridge {
pub fn new(desktop:bool)->Self{
let backend=if desktop{Backend::detect()}else{None};let enabled=backend.is_some();
Self{backend,enabled,tx:None,task:None,target_mac:None}
}
#[cfg(feature="viewer-sdl")]
pub fn sdl(tx:mpsc::Sender<ClipboardRequest>)->Self{
let backend=(std::env::var("UU_VIEWER_CLIPBOARD").as_deref()!=Ok("0")).then_some(Backend::Sdl(tx));
Self{enabled:backend.is_some(),backend,tx:None,task:None,target_mac:None}
}
pub fn set_target_mac(&mut self,mac:Option<bool>){self.target_mac=mac;}
pub fn start(&mut self,channel:&Arc<RTCDataChannel>,control:&Arc<RTCDataChannel>,observed:Arc<Observed>){
let Some(backend)=self.backend.take() else{return};let target_mac=self.target_mac;
let (tx,mut rx)=mpsc::channel::<Vec<u8>>(16);self.tx=Some(tx);
let channel=Arc::downgrade(channel);let control=Arc::downgrade(control);
self.task=Some(tokio::spawn(async move{
let mut state=SyncState{target_mac,..SyncState::default()};let mut tick=tokio::time::interval(POLL);
let mut retries=0;let mut last_probe=std::time::Instant::now();
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
let Some(channel)=channel.upgrade() else{break};
tokio::select!{
data=rx.recv()=>{
let Some(data)=data else{break};
if !observed.clipboard_supported.load(Ordering::Acquire){continue}
match state.receive(&data){
Ok((replies,value))=>{
if let Some(value)=value {
// Update only after the write succeeds; the next poll cannot echo it.
if state.apply(&backend,value).await.is_err(){warn();break}
}
let mut failed=false;for reply in replies{if send(&channel,reply).await.is_err(){failed=true;break}}
if failed{break}
},
Err(_)=>log::warn!("Viewer clipboard message rejected"),
}
},
_=tick.tick()=>{
if observed.echo_received.load(Ordering::Acquire) && !observed.control_open.load(Ordering::Acquire){break}
if !observed.echo_received.load(Ordering::Acquire){continue}
if !observed.clipboard_supported.load(Ordering::Acquire){
// Host TEXT-channel initialization may finish after the initial CONTROL echo.
if retries<5 && last_probe.elapsed()>=Duration::from_secs(1){
retries+=1;last_probe=std::time::Instant::now();
let Some(control)=control.upgrade() else{break};
if send(&control,wire::echo_request_with_clipboard(1,true)).await.is_err(){break}
}
continue
}
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open{continue}
match backend.read().await {
Ok(Some(value))=>{let length=value.len();match state.local(value){
Ok(Some(messages))=>{let mut failed=false;for m in messages{if send(&channel,m).await.is_err(){failed=true;break}}if failed{break}log::info!("Viewer local clipboard offered: bytes={length}");},
Ok(None)=>{},Err(_)=>{},
}},
Ok(None)=>{},Err(())=>{warn();break},
}
}
}
}
}));
}
pub fn sender(&self)->Option<mpsc::Sender<Vec<u8>>>{self.tx.clone()}
pub fn stop(&self){if let Some(task)=&self.task{task.abort();}}
}
impl Drop for Bridge{fn drop(&mut self){self.stop();}}
#[cfg(test)] mod tests {
use super::*;
#[cfg(feature="viewer-sdl")]
#[tokio::test] async fn sdl_backend_requests_and_invalid_text(){
let(tx,mut rx)=mpsc::channel(8);let backend=Backend::Sdl(tx);
let ui=tokio::spawn(async move{
let Some(ClipboardRequest::Write(text,reply))=rx.recv().await else{panic!()};
assert_eq!(text,"text\n");reply.send(Ok(true)).unwrap();
let Some(ClipboardRequest::Read(reply))=rx.recv().await else{panic!()};
reply.send(Ok(Some("text\n".into()))).unwrap();
});
assert!(backend.write("nul\0text").await.is_err());
assert!(backend.write(&"a".repeat(MAX_TEXT+1)).await.is_err());
backend.write("text\n").await.unwrap();assert_eq!(backend.read().await.unwrap().as_deref(),Some("text\n"));
ui.await.unwrap();assert!(backend.read().await.is_err());
}
#[test] fn backend_priority_requires_a_complete_wayland_pair_and_falls_back(){
let select=|wayland,names:&[&str]|CommandBackend::select(wayland,|n|names.contains(&n).then(||PathBuf::from(n)));
let all=["wl-copy","wl-paste","xclip","xsel"];
assert_eq!(select(true,&all).unwrap().write,PathBuf::from("wl-copy"));
assert_eq!(select(false,&all).unwrap().write,PathBuf::from("xclip"));
assert_eq!(select(true,&["wl-copy","xclip","xsel"]).unwrap().write,PathBuf::from("xclip"));
assert_eq!(select(true,&["xsel"]).unwrap().write,PathBuf::from("xsel"));
assert!(select(true,&[]).is_none());
}
#[cfg(feature="viewer-sdl")]
#[tokio::test] async fn unfocused_write_does_not_mark_remote_text_as_applied(){
let(tx,mut rx)=mpsc::channel(8);let backend=Backend::Sdl(tx);
let ui=tokio::spawn(async move{
let Some(ClipboardRequest::Write(_,reply))=rx.recv().await else{panic!()};
reply.send(Ok(false)).unwrap();
});
let mut state=SyncState::default();state.last=Some("local".into());
state.apply(&backend,"remote".into()).await.unwrap();
assert_eq!(state.last.as_deref(),Some("local"));ui.await.unwrap();
}
#[test] fn limits_match_host_and_unchanged_or_remote_text_is_not_reoffered(){
assert!(include_str!("../clipboard.rs").contains("pub const MAX_TEXT: usize = 30 * 1024;"));
assert!(POLL>=Duration::from_millis(500));
let mut state=SyncState::default();
assert!(state.local("中文🙂\n".into()).unwrap().is_some());
assert!(state.local("中文🙂\n".into()).unwrap().is_none());
state.last=Some("remote".into());
assert!(state.local("remote".into()).unwrap().is_none());
assert!(state.local(String::new()).unwrap().is_some());
assert!(state.local(String::new()).unwrap().is_none());
assert!(state.local("a".repeat(MAX_TEXT+1)).is_err());
}
#[test] fn message17_fragments_and_mobile_rpc_keep_unicode_and_request_id(){
let mut state=SyncState::default();let value="中文🙂\n".repeat(2200);
let parts=text::chunks(&value).unwrap();
for (i,part) in parts.iter().enumerate(){
let (replies,received)=state.receive(&wire::envelope(1,17,&text::encode(3,part,i+1<parts.len()))).unwrap();
assert!(replies.is_empty());
assert_eq!(received,if i+1==parts.len(){Some(value.clone())}else{None});
}
let (replies,received)=state.receive(&wire::envelope(2,21,&text::text_request(73,"mobile"))).unwrap();
assert_eq!(received.as_deref(),Some("mobile"));assert_eq!(replies.len(),1);
let fields=decode_wire(&replies[0]).unwrap();
assert!(fields.iter().any(|f|f.number==22));
let WireValue::Bytes(response)=fields.iter().find(|f|f.number==22).unwrap().value else{panic!()};
let WireValue::Bytes(header)=decode_wire(response).unwrap().into_iter().find(|f|f.number==1).unwrap().value else{panic!()};
assert_eq!(decode_wire(header).unwrap()[0].value,WireValue::Varint(73));
assert!(state.receive(&wire::envelope(1,17,&[18,1,255])).is_err());
assert!(state.receive(&wire::envelope(1,17,&text::encode(1,&"a".repeat(MAX_TEXT+1),false))).is_err());
}
#[test] fn rejected_nul_does_not_stop_later_valid_updates(){
let mut state=SyncState::default();
for kind in [17,21]{
let payload=if kind==17{text::encode(1,"nul\0text",false)}else{text::text_request(73,"nul\0text")};
assert!(state.receive(&wire::envelope(1,kind,&payload)).is_err());
let(_,value)=state.receive(&wire::envelope(2,17,&text::encode(2,"valid",false))).unwrap();
assert_eq!(value.as_deref(),Some("valid"));
}
}
// Match webrtc.rs: CONTROL and TEXT have separate rich States, and only TEXT has a desktop sink.
fn native_host_exchange(outbound:usize,reverse:bool)->(Option<String>,bool){
let mut viewer=SyncState::default();let mut host=[rich::State::default(),rich::State::default()];let mut id=1000;
let value="clipboard-中文🙂\n".to_owned();
let offer=if reverse{wire::envelope(1,21,&host[1].offer(1,value.clone()).unwrap())}else{viewer.local(value.clone()).unwrap().unwrap().remove(0)};
let mut queue=std::collections::VecDeque::from([(reverse,if reverse{1}else{outbound},offer)]);
let mut received=None;let mut unavailable=false;let mut steps=0;
while let Some((to_viewer,channel,packet))=queue.pop_front(){
steps+=1;assert!(steps<20);
if to_viewer {
// Capture DataConfirm status without reading or logging text.
for field in decode_wire(&packet).unwrap(){
if let (22,WireValue::Bytes(body))=(field.number,field.value){
if let Some(clip)=super::super::tools::blob(body,5){
if let Some(confirm)=super::super::tools::blob(clip,2){unavailable|=super::super::tools::uint(confirm,1)==2;}
}
}
}
let (replies,text)=viewer.receive(&packet).unwrap();if text.is_some(){received=text;}
queue.extend(replies.into_iter().map(|p|(false,outbound,p)));
}else{
for field in decode_wire(&packet).unwrap(){let WireValue::Bytes(body)=field.value else{continue};
if field.number==21 {let result=host[channel].request(body,&mut ||{id+=1;id}).unwrap();
if channel==1 && result.text.is_some(){received=result.text;}
queue.extend(result.messages.into_iter().map(|(kind,body)|(true,channel,wire::envelope(1,kind,&body))));
}else if field.number==22 {let text=host[channel].response(body).unwrap();if channel==1 && text.is_some(){received=text;}}
}
}
}
if reverse && received.is_some(){viewer.last=Some(value.clone());assert!(viewer.local(value).unwrap().is_none());}
(received,unavailable)
}
#[test] fn local_change_follows_target_platform(){
for (mac,kinds) in [(Some(true),vec![9]),(Some(false),vec![10]),(None,vec![9,10])]{
let mut viewer=SyncState{target_mac:mac,..SyncState::default()};
let cases:Vec<u32>=viewer.local("text".into()).unwrap().unwrap().iter().map(|m|{
let rpc=decode_wire(m).unwrap().into_iter().find_map(|f|match (f.number,f.value){(21,WireValue::Bytes(b))=>Some(b.to_vec()),_=>None}).unwrap();
decode_wire(&rpc).unwrap().iter().map(|f|f.number).find(|n|*n!=1).unwrap()
}).collect();
assert_eq!(cases,kinds,"{mac:?}");
}
}
#[test] fn local_change_also_sends_windows_text_change_request(){
let mut viewer=SyncState::default();
let messages=viewer.local("windows 中文".into()).unwrap().unwrap();assert_eq!(messages.len(),2);
let rpc=decode_wire(&messages[1]).unwrap().into_iter().find_map(|f|match (f.number,f.value){(21,WireValue::Bytes(b))=>Some(b.to_vec()),_=>None}).unwrap();
let (_,text)=crate::clipboard_protocol::read_text_request(&rpc).unwrap().unwrap();assert_eq!(text,"windows 中文");
}
#[test] fn control_clipboard_reproduces_native_host_failures(){
assert_eq!(native_host_exchange(0,false),(None,false)); // Complete transfer, no CONTROL desktop sink.
assert_eq!(native_host_exchange(0,true),(None,true)); // TEXT offer, empty CONTROL provider.
}
#[test] fn text_clipboard_negotiates_both_directions_with_native_host(){
assert_eq!(wire::CHANNELS[CHANNEL],"TEXT_DATA_CHANNEL");
for reverse in [false,true]{
let (received,unavailable)=native_host_exchange(CHANNEL,reverse);
assert_eq!(received.as_deref(),Some("clipboard-中文🙂\n"));assert!(!unavailable);
}
}
#[test] fn clipboard_capability_is_version3_and_can_be_disabled(){
assert!(wire::echo_clipboard_supported(&wire::echo_request_with_clipboard(1,true)));
assert!(!wire::echo_clipboard_supported(&wire::echo_request_with_clipboard(1,false)));
assert!(wire::echo_matches(&wire::echo_response_with_clipboard(2,1,true),1));
assert!(!wire::echo_matches(&wire::echo_response_with_clipboard(2,7,true),1));
assert!(!Bridge::new(false).enabled);assert!(!Bridge::new(true).enabled);
let mut shape:wire::Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/shape.json")).unwrap();
shape.feature_flag=vec![[8,99]];
let options=shape.connect_options("synthetic-device",false).unwrap();
let WireValue::Bytes(flags)=decode_wire(&options).unwrap().into_iter().find(|f|f.number==11).unwrap().value else{panic!()};
assert!(!decode_wire(flags).unwrap().iter().any(|f|f.number==8));
let options=shape.connect_options("synthetic-device",true).unwrap();
let WireValue::Bytes(flags)=decode_wire(&options).unwrap().into_iter().find(|f|f.number==11).unwrap().value else{panic!()};
assert!(decode_wire(flags).unwrap().iter().any(|f|f.number==8 && f.value==WireValue::Varint(3)));
}
#[tokio::test] async fn backend_uses_stdin_preserves_text_and_bounds_reads(){
use std::os::unix::fs::PermissionsExt;
let root=std::env::temp_dir().join(format!("uu-clipboard-mock-{}",wire::uuid()));std::fs::create_dir(&root).unwrap();
let script=root.join("mock");
std::fs::write(&script,b"#!/bin/sh\ncd -- \"${0%/*}\" || exit 1\ncase \"$1\" in read) cat data;; write) cat > data;; esac\n").unwrap();
std::fs::set_permissions(&script,std::fs::Permissions::from_mode(0o700)).unwrap();
let command=CommandBackend{read:script.clone(),write:script,read_args:vec!["read"],write_args:vec!["write"]};
let backend=Backend::Command(command.clone());
let mut state=SyncState::default();
for value in ["中文🙂\n", "", "literal $(echo secret) `echo secret`"]{
state.apply(&backend,value.into()).await.unwrap();
let read=backend.read().await.unwrap().unwrap();assert_eq!(read,value);
assert!(state.local(read).unwrap().is_none());
}
let broken=Backend::Command(CommandBackend{write:root.join("missing"),..command});
let previous=state.last.clone();assert!(state.apply(&broken,"failed".into()).await.is_err());assert_eq!(state.last,previous);
std::fs::write(root.join("data"),vec![b'a';MAX_TEXT+1]).unwrap();assert!(backend.read().await.unwrap().is_none());
std::fs::write(root.join("data"),[255]).unwrap();assert!(backend.read().await.unwrap().is_none());
assert!(backend.write(&"a".repeat(MAX_TEXT+1)).await.is_err());
std::fs::remove_dir_all(root).unwrap();
}
}
+43
View File
@@ -0,0 +1,43 @@
//! Uses the same optional FFmpeg dependency as the host inproc-av feature.
use super::desktop::{Decoder,Frame};
use ffmpeg_next as av;
use super::media::Codec;
pub struct Ffmpeg { decoder:av::decoder::Video, codec:Codec }
impl Ffmpeg {
pub fn new()->Result<Self,String> {
Self::with_codec(Codec::H264)
}
fn with_codec(kind:Codec)->Result<Self,String>{
av::init().map_err(|_|"FFmpeg initialization failed")?;
// Library diagnostics can contain bitstream data; suppress them globally in this viewer process.
av::log::set_level(av::log::Level::Quiet);
let codec=av::decoder::find(match kind {Codec::H264=>av::codec::Id::H264,Codec::H265=>av::codec::Id::HEVC}).ok_or("Video decoder unavailable")?;
let decoder=av::codec::context::Context::new().decoder().open_as(codec).and_then(|d|d.video()).map_err(|_|"Video decoder initialization failed")?;
Ok(Self{decoder,codec:kind})
}
}
impl Decoder for Ffmpeg {
fn set_codec(&mut self,codec:Codec)->Result<(),String>{
if self.codec!=codec {*self=Self::with_codec(codec)?;}Ok(())
}
fn reset(&mut self){self.decoder.flush();}
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String>{
self.decoder.send_packet(&av::Packet::copy(au)).map_err(|_|"Video packet rejected")?;
let mut frames=Vec::new();let mut decoded=av::frame::Video::empty();
loop {
match self.decoder.receive_frame(&mut decoded) {
Ok(())=>{},
Err(av::Error::Other{errno}) if errno==libc::EAGAIN=>break,
Err(_)=>return Err("Video decode failed".into()),
}
if decoded.is_corrupt(){return Err("Corrupt video frame".into())}
let (w,h)=(decoded.width(),decoded.height());
if w==0 || h==0 || w>8192 || h>8192 {return Err("Decoded dimensions exceed limit".into())}
let mut scaler=av::software::scaling::context::Context::get(decoded.format(),w,h,av::format::Pixel::RGB24,w,h,av::software::scaling::flag::Flags::BILINEAR).map_err(|_|"Frame conversion unavailable")?;
let mut rgb=av::frame::Video::empty();scaler.run(&decoded,&mut rgb).map_err(|_|"Frame conversion failed")?;
let mut data=Vec::with_capacity(w as usize*h as usize*3);
for row in 0..h as usize {let start=row*rgb.stride(0);data.extend_from_slice(&rgb.data(0)[start..start+w as usize*3]);}
frames.push(Frame{width:w,height:h,rgb:data});
} Ok(frames)
}
}
+131
View File
@@ -0,0 +1,131 @@
//! H.264/H.265 decoding through an external `ffmpeg` process, like the host's encoder pipeline.
//! Needs only the ffmpeg CLI, not FFmpeg development libraries.
//! Output is scaled into a fixed letterboxed size so every frame has a known byte length.
use super::desktop::{Decoder,Frame};
use super::media::Codec;
use std::io::{Read,Write};
use std::process::{Child,ChildStdin,Command,Stdio};
use std::sync::mpsc::{Receiver,TryRecvError};
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32 }
impl Cli {
/// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary.
pub fn new()->Result<Self,String> {
let (width,height)=std::env::var("UU_VIEWER_SIZE").ok()
.and_then(|v|{let (w,h)=v.split_once('x')?;Some((w.parse().ok()?,h.parse().ok()?))})
.filter(|&(w,h):&(u32,u32)|(16..=8192).contains(&w)&&(16..=8192).contains(&h)&&w%2==0&&h%2==0)
.unwrap_or((1920,1080));
Self::with_codec(Codec::H264,width,height)
}
fn with_codec(codec:Codec,width:u32,height:u32)->Result<Self,String> {
let ffmpeg=std::env::var("UU_VIEWER_FFMPEG").unwrap_or_else(|_|"ffmpeg".into());
let filter=format!("scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2");
let passthrough=passthrough_args(&ffmpeg);
let mut child=Command::new(&ffmpeg)
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an","-vf",&filter,
"-pix_fmt","rgb24",
// Raw H.264/H.265 carries no timestamps; constant-rate output dropped almost every frame of
// the official Mac host's stream (270 → 2). Pass frames through unchanged.
passthrough.0,passthrough.1,"-f","rawvideo","pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null())
.spawn().map_err(|e|format!("Start ffmpeg decoder: {e}"))?;
let input=child.stdin.take().ok_or("ffmpeg stdin missing")?;
let mut output=child.stdout.take().ok_or("ffmpeg stdout missing")?;
let size=width as usize*height as usize*3;
// Bounded: a slow window drops decoded frames instead of growing memory.
let (tx,frames)=std::sync::mpsc::sync_channel(2);
std::thread::Builder::new().name("uu-viewer-decode".into()).spawn(move||{
loop {
let mut frame=vec![0;size];
if output.read_exact(&mut frame).is_err() {break;}
match tx.try_send(frame) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break }
}
}).map_err(|e|format!("Decoder reader: {e}"))?;
Ok(Self{child,input:Some(input),codec,frames,width,height})
}
}
/// FFmpeg ≥ 5.1 has `-fps_mode`; FFmpeg 8+ removed `-vsync`, and Ubuntu 22.04's 4.4 lacks `-fps_mode`.
/// Probe once per binary with a one-frame null run instead of parsing version strings.
fn passthrough_args(ffmpeg:&str)->(&'static str,&'static str) {
static CACHE:std::sync::Mutex<Vec<(String,bool)>>=std::sync::Mutex::new(Vec::new());
let mut cache=CACHE.lock().unwrap_or_else(|e|e.into_inner());
let fps_mode=match cache.iter().find(|(name,_)|name==ffmpeg) {
Some(&(_,known))=>known,
None=>{
let ok=Command::new(ffmpeg).args(["-hide_banner","-loglevel","quiet","-nostdin","-f","lavfi","-i","color=s=16x16:d=0.04",
"-fps_mode","passthrough","-f","null","-"]).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
.status().is_ok_and(|s|s.success());
cache.push((ffmpeg.into(),ok));ok
}
};
if fps_mode {("-fps_mode","passthrough")} else {("-vsync","0")}
}
impl Decoder for Cli {
fn set_codec(&mut self,codec:Codec)->Result<(),String>{
if self.codec!=codec {*self=Self::with_codec(codec,self.width,self.height)?;}Ok(())
}
fn reset(&mut self) {}
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String> {
let input=self.input.as_mut().ok_or("ffmpeg input closed")?;
input.write_all(au).and_then(|_|input.flush()).map_err(|_|"ffmpeg decoder exited")?;
let mut out=Vec::new();
loop {
match self.frames.try_recv() {
Ok(rgb)=>out.push(Frame{width:self.width,height:self.height,rgb}),
Err(TryRecvError::Empty)=>break,
Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()),
}
}
Ok(out)
}
}
impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.child.wait(); } }
#[cfg(test)] mod tests {
use super::*;
// Six synthetic red IDRs per fixture; no captured desktop or external encoder dependency.
#[cfg(unix)] #[test] fn passthrough_follows_ffmpeg_option_support(){
use std::os::unix::fs::PermissionsExt;
let dir=std::env::temp_dir().join(format!("uu-ffprobe-{}",std::process::id()));std::fs::create_dir_all(&dir).unwrap();
for (name,script,expected) in [("new","exit 0",("-fps_mode","passthrough")),("old","case \"$*\" in *-fps_mode*) exit 1;; esac",("-vsync","0"))]{
let path=dir.join(name);std::fs::write(&path,format!("#!/bin/sh\n{script}\n")).unwrap();
std::fs::set_permissions(&path,std::fs::Permissions::from_mode(0o755)).unwrap();
assert_eq!(super::passthrough_args(path.to_str().unwrap()),expected);
}
std::fs::remove_dir_all(dir).unwrap();
}
#[test] fn ffmpeg_decodes_h264_and_hevc_420_and_444_to_rgb24(){
match Command::new("ffmpeg").arg("-version").stdout(Stdio::null()).stderr(Stdio::null()).status(){
Err(e) if e.kind()==std::io::ErrorKind::NotFound=>{eprintln!("skip: ffmpeg is not on PATH");return},
result=>assert!(result.expect("ffmpeg availability").success()),
}
let mut cli=Cli::with_codec(Codec::H265,32,32).unwrap();
for (codec,data) in [
(Codec::H264,&include_bytes!("../../tests/fixtures/viewer/red-420.h264")[..]),
(Codec::H265,&include_bytes!("../../tests/fixtures/viewer/red-420.hevc")[..]),
(Codec::H264,&include_bytes!("../../tests/fixtures/viewer/red-444.h264")[..]),
(Codec::H265,&include_bytes!("../../tests/fixtures/viewer/red-444.hevc")[..]),
] {
cli.set_codec(codec).unwrap();
// Exercise the same streaming process and RGB conversion as SDL, then drain at EOF.
let mut frames=cli.decode(data).unwrap();drop(cli.input.take());
loop {match cli.frames.recv_timeout(std::time::Duration::from_secs(5)) {
Ok(rgb)=>frames.push(Frame{width:32,height:32,rgb}),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected)=>break,
Err(e)=>panic!("{codec:?} decoder did not finish: {e}"),
}}
let status=cli.child.wait().unwrap();
assert!(status.success(),"{codec:?}: ffmpeg exited with {status}");
assert!(!frames.is_empty(),"{codec:?}: no RGB frames");
for frame in frames {
assert_eq!(frame.rgb.len(),32*32*3);
assert!(frame.rgb.chunks_exact(3).all(|p|p[0]>220 && p[1]<30 && p[2]<30),"{codec:?}: RGB conversion");
}
}
}
}
+35
View File
@@ -0,0 +1,35 @@
use super::media::Latest;
use std::sync::{Arc, atomic::{AtomicBool,AtomicU32,Ordering}};
#[derive(Clone)]
pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<AtomicBool>, pub reset:Arc<AtomicBool>, pub ssrc:Arc<AtomicU32> }
impl Default for Desktop {
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
}
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8> }
pub trait Decoder { fn set_codec(&mut self,codec:super::media::Codec)->Result<(),String>; fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self); }
pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; }
/// Counts only (access units, presented frames, decode errors) for the periodic stats line.
pub static STATS:[std::sync::atomic::AtomicU64;3]=[std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0)];
pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Result<(),String> {
STATS[0].fetch_add(1,Ordering::Relaxed);
// Local diagnostic: UU_VIEWER_DUMP_H264=path appends the first 300 access units (owner's own stream).
if codec==super::media::Codec::H264 && STATS[0].load(Ordering::Relaxed)<=300 { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_H264") {
use std::io::Write; if let Ok(mut f)=std::fs::OpenOptions::new().create(true).append(true).open(path){let _=f.write_all(au);}
}}
match decoder.decode(au) {
Ok(frames)=>{for frame in frames {
sink.present(&frame)?;
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
}}
}Ok(())},
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Ok(())},
}
}
#[cfg(test)] mod tests {
use super::*;
struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3]}])}} fn reset(&mut self){self.0=false;}}
struct Sink(usize);impl FrameSink for Sink{fn present(&mut self,f:&Frame)->Result<(),String>{assert_eq!(f.rgb.len(),3);self.0+=1;Ok(())}}
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);}
}
+141
View File
@@ -0,0 +1,141 @@
//! SDL scancodes are USB HID usages; translate physical keys, not typed text.
use serde_json::{json, Value};
use std::collections::{BTreeMap,BTreeSet};
pub fn windows_vk(scan: i32) -> Option<i32> {
Some(match scan {
4..=29 => 0x41 + scan - 4, 30..=38 => 0x31 + scan - 30, 39 => 0x30,
40=>0x0d,41=>0x1b,42=>8,43=>9,44=>0x20,
45=>0xbd,46=>0xbb,47=>0xdb,48=>0xdd,49=>0xdc,51=>0xba,52=>0xde,53=>0xc0,54=>0xbc,55=>0xbe,56=>0xbf,
57=>0x14,58..=69=>0x70+scan-58,70=>0x2c,71=>0x91,72=>0x13,
73=>0x2d,74=>0x24,75=>0x21,76=>0x2e,77=>0x23,78=>0x22,
79=>0x27,80=>0x25,81=>0x28,82=>0x26,83=>0x90,
84=>0x6f,85=>0x6a,86=>0x6d,87=>0x6b,88=>0x0d,
89..=97=>0x61+scan-89,98=>0x60,99=>0x6e,101=>0x5d,
104..=115=>0x7c+scan-104,
224=>0xa2,225=>0xa0,226=>0xa4,227=>0x5b,228=>0xa3,229=>0xa1,230=>0xa5,231=>0x5c,
_=>return None,
})
}
pub fn mac_keycode(scan:i32)->Option<i32>{
// Inverted SDL Darwin table (release-2.32.10/src/events/scancodes_darwin.h).
// Live Mac host evidence: Windows VK 49 becomes Space, and VK 8 becomes C.
Some(match scan{
4=>0,22=>1,7=>2,9=>3,11=>4,10=>5,29=>6,27=>7,6=>8,25=>9,100=>10,5=>11,
20=>12,26=>13,8=>14,21=>15,28=>16,23=>17,30=>18,31=>19,32=>20,33=>21,
35=>22,34=>23,46=>24,38=>25,36=>26,45=>27,37=>28,39=>29,48=>30,18=>31,
24=>32,47=>33,12=>34,19=>35,40=>36,15=>37,13=>38,52=>39,14=>40,51=>41,
49=>42,54=>43,56=>44,17=>45,16=>46,55=>47,43=>48,44=>49,53=>50,42=>51,
41=>53,231=>54,227=>55,225=>56,57=>57,226=>58,224=>59,229=>60,230=>61,228=>62,
108=>64,99=>65,85=>67,87=>69,83=>71,84=>75,88=>76,86=>78,109=>79,110=>80,
103=>81,98=>82,89=>83,90=>84,91=>85,92=>86,93=>87,94=>88,95=>89,96=>91,97=>92,
62=>96,63=>97,64=>98,60=>99,65=>100,66=>101,68=>103,104=>105,107=>106,105=>107,
70=>105,71=>107,72=>113,
67=>109,101=>110,69=>111,106=>113,73=>114,74=>115,75=>116,76=>117,61=>118,
77=>119,59=>120,78=>121,58=>122,80=>123,79=>124,81=>125,82=>126,
_=>return None,
})
}
#[derive(Clone,Copy,Debug,PartialEq)]
pub struct Viewport { pub x:f64, pub y:f64, pub width:f64, pub height:f64 }
impl Viewport {
pub fn fit(window:(u32,u32), frame:(u32,u32))->Self {
let scale=(window.0 as f64 / frame.0.max(1) as f64).min(window.1 as f64 / frame.1.max(1) as f64);
let (w,h)=(frame.0 as f64*scale,frame.1 as f64*scale);
Self{x:(window.0 as f64-w)/2.,y:(window.1 as f64-h)/2.,width:w,height:h}
}
pub fn motion(self,x:f64,y:f64)->Option<Value> {
if self.width<=0. || self.height<=0. || !x.is_finite() || !y.is_finite() {return None}
Some(json!({"action":"mouse_move_absolute","abs_x":((x-self.x)/self.width).clamp(0.,1.),"abs_y":((y-self.y)/self.height).clamp(0.,1.)}))
}
}
#[derive(Default)]
pub struct Input { view_only:bool, mac:bool, keys:BTreeMap<i32,i32>, buttons:BTreeSet<i32> }
pub fn view_only(argument:Option<&str>,environment:Option<&str>)->Result<bool,String> {
match argument {None=>Ok(environment==Some("1")),Some("--view-only")=>Ok(true),_=>Err("Expected --view-only".into())}
}
impl Input {
pub fn new(view_only:bool)->Self {Self{view_only,..Default::default()}}
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
pub fn enabled(&self)->bool {!self.view_only}
pub fn key(&mut self,scan:i32,down:bool)->Option<Value> {
if self.view_only {return None}
let vk=if self.mac{mac_keycode(scan)}else{windows_vk(scan)}?;
let changed=if down {
if self.keys.contains_key(&scan) {return None}
let already=self.keys.values().any(|v|*v==vk);self.keys.insert(scan,vk);!already
}else{
if self.keys.remove(&scan).is_none(){return None}
!self.keys.values().any(|v|*v==vk)
};
changed.then(||json!({"action":if down{"kbd_press"}else{"kbd_release"},"key":vk}))
}
pub fn button(&mut self,button:i32,down:bool)->Option<Value> {
if self.view_only {return None}
if !matches!(button,1|2|4) {return None}
let changed=if down{self.buttons.insert(button)}else{self.buttons.remove(&button)};
changed.then(||json!({"action":if down{"mouse_press"}else{"mouse_release"},"button":button}))
}
pub fn release_all(&mut self)->Vec<Value> {
let mut out=Vec::new();
for key in std::mem::take(&mut self.keys).into_values().collect::<BTreeSet<_>>() {out.push(json!({"action":"kbd_release","key":key}));}
for button in std::mem::take(&mut self.buttons) {out.push(json!({"action":"mouse_release","button":button}));}
out
}
pub fn heartbeat()->Value {json!({"heartbeat":"kbd_heartbeat"})}
}
#[cfg(test)] mod tests {
use super::*;
#[test] fn mac_target_uses_native_codes_and_releases_same_keys(){
let mut input=Input::default();input.set_mac(true);
for (scan,code) in [(30,18),(39,29),(42,51),(44,49),(6,8),(4,0),(40,36),(43,48),
(80,123),(79,124),(81,125),(82,126),(224,59),(225,56),(226,58),(227,55)]{
assert_eq!(input.key(scan,true).unwrap()["key"],code);
assert_eq!(input.key(scan,false).unwrap()["key"],code);
}
input.set_mac(false);assert_eq!(input.key(30,true).unwrap()["key"],49);
}
#[test] fn mac_focus_release_keeps_zero_keycode_and_modifiers(){
let mut input=Input::default();input.set_mac(true);
assert!(input.key(4,true).is_some());assert!(input.key(4,true).is_none());
input.key(225,true);input.key(227,true);
let release=input.release_all();
assert_eq!(release,vec![json!({"action":"kbd_release","key":0}),
json!({"action":"kbd_release","key":55}),json!({"action":"kbd_release","key":56})]);
assert!(input.release_all().is_empty());assert!(input.key(4,false).is_none());
let mut watch=Input::new(true);watch.set_mac(true);assert!(watch.key(4,true).is_none());
}
#[test] fn mac_function_key_aliases_release_after_last_keyup(){
for (pc,function,code) in [(70,104,105),(71,105,107),(72,106,113)]{
let mut input=Input::default();input.set_mac(true);
assert_eq!(input.key(pc,true).unwrap()["key"],code);
assert!(input.key(function,true).is_none());assert!(input.key(pc,false).is_none());
assert_eq!(input.key(function,false).unwrap()["key"],code);
}
}
#[test] fn watch_switch_is_explicit_and_validated(){
assert!(!view_only(None,None).unwrap());assert!(!view_only(None,Some("0")).unwrap());
assert!(view_only(None,Some("1")).unwrap());assert!(view_only(Some("--view-only"),Some("0")).unwrap());
assert!(view_only(Some("invalid"),None).is_err());
}
#[test] fn mappings_encoding_and_focus() {
for (scan,vk) in [(4,65),(29,90),(39,48),(58,112),(80,37),(224,162),(230,165),(52,222)] {assert_eq!(windows_vk(scan),Some(vk));}
assert_eq!(windows_vk(100),None);
let mut i=Input::default();assert_eq!(i.key(4,true).unwrap(),json!({"action":"kbd_press","key":65}));assert!(i.key(4,true).is_none());
i.key(225,true);i.button(2,true);let release=i.release_all();assert_eq!(release.len(),3);
assert!(release.iter().all(|v|v["action"].as_str().unwrap().ends_with("release")));
assert!(i.release_all().is_empty());
assert_eq!(Input::heartbeat(),json!({"heartbeat":"kbd_heartbeat"}));
}
#[test] fn aliased_physical_keys_release_only_after_last_keyup() {
let mut i=Input::default();assert!(i.key(40,true).is_some());assert!(i.key(88,true).is_none());
assert!(i.key(40,false).is_none());assert_eq!(i.key(88,false).unwrap(),json!({"action":"kbd_release","key":13}));
assert!(i.button(3,true).is_none());assert_eq!(i.button(4,true).unwrap()["button"],4);
}
#[test] fn letterbox() {
let v=Viewport::fit((1000,1000),(1920,1080));
assert_eq!(v.motion(500.,500.).unwrap()["abs_y"],0.5);
assert_eq!(v.motion(-10.,0.).unwrap()["abs_y"],0.0);
assert_eq!(v.motion(1010.,1000.).unwrap()["abs_x"],1.0);
assert!(v.motion(f64::NAN,0.).is_none());
}
}
+228
View File
@@ -0,0 +1,228 @@
//! Bounded RFC 6184 / RFC 7798 non-interleaved receivers (no DONL). No media contents in logs.
use std::{collections::VecDeque, sync::{Arc, Mutex}};
use std::time::{Duration,Instant};
#[derive(Clone,Copy,Debug,Default,PartialEq,Eq)]
pub enum Codec { #[default] H264, H265 }
impl Codec {
pub fn from_mime(mime:&str)->Option<Self> {
if mime.eq_ignore_ascii_case("video/H264"){Some(Self::H264)}
else if mime.eq_ignore_ascii_case("video/H265"){Some(Self::H265)}else{None}
}
pub fn demuxer(self)->&'static str {match self {Self::H264=>"h264",Self::H265=>"hevc"}}
}
pub struct AccessUnit {pub codec:Codec,pub data:Vec<u8>}
const MAX_AU: usize = 8 * 1024 * 1024;
#[derive(Clone)]
pub struct Packet { pub seq: u16, pub timestamp: u32, pub marker: bool, pub payload: Vec<u8> }
#[derive(Default)]
pub struct Output { pub units: Vec<Vec<u8>>, pub pli: bool }
pub struct Receiver {
codec: Codec,
next: Option<u16>, pending: Vec<Packet>, timestamp: Option<u32>,
au: Vec<u8>, fragment: Option<u16>, damaged: bool, gap_since:Option<Instant>, last_packet:Instant,
}
impl Default for Receiver {
fn default() -> Self { Self { codec: Codec::H264, next: None, pending: Vec::new(), timestamp: None, au: Vec::new(), fragment: None, damaged: false, gap_since:None,last_packet:Instant::now() } }
}
impl Receiver {
pub fn new(codec:Codec)->Self {Self{codec,..Self::default()}}
pub fn codec(&self)->Codec {self.codec}
pub fn push(&mut self, p: Packet) -> Output {
if p.payload.len()>65536 {return Output{units:Vec::new(),pli:true}}
let next = *self.next.get_or_insert(p.seq);
if p.seq.wrapping_sub(next) >= 32768 || self.pending.iter().any(|q| q.seq == p.seq) { return Output::default() }
self.last_packet=Instant::now();
self.pending.push(p);
let mut out = Output::default();
self.drain(&mut out);
if self.pending.len() >= 32 { self.skip_gap(&mut out); }
if self.pending.is_empty(){self.gap_since=None;}else{self.gap_since.get_or_insert(Instant::now());}
out
}
// A timer bounds latency even if the missing packet is the last packet sent.
pub fn expire(&mut self) -> Output {
self.expire_at(Instant::now())
}
fn expire_at(&mut self,now:Instant)->Output {
let mut out=Output::default();
if self.gap_since.is_some_and(|since|now.duration_since(since)>=Duration::from_millis(40)) && !self.pending.is_empty() {
self.skip_gap(&mut out);self.gap_since=if self.pending.is_empty(){None}else{Some(now)};
}
if !self.au.is_empty() && now.duration_since(self.last_packet)>=Duration::from_millis(200) {
self.au.clear();self.fragment=None;self.damaged=true;out.pli=true;
}
out
}
fn skip_gap(&mut self, out: &mut Output) {
let next = self.next.unwrap();
self.next = self.pending.iter().min_by_key(|p| p.seq.wrapping_sub(next)).map(|p| p.seq);
self.au.clear(); self.fragment = None; self.damaged = true; out.pli = true;
self.drain(out);
}
fn drain(&mut self, out: &mut Output) {
while let Some(i) = self.pending.iter().position(|p| Some(p.seq) == self.next) {
let p = self.pending.remove(i); self.next = Some(p.seq.wrapping_add(1));
if self.timestamp != Some(p.timestamp) {
// A timestamp transition without marker is an incomplete AU.
if !self.au.is_empty() || self.fragment.is_some() { out.pli = true; }
self.au.clear(); self.fragment = None; self.damaged = false; self.timestamp = Some(p.timestamp);
}
if !self.damaged && self.nal(&p.payload).is_err() { self.damaged = true; self.au.clear(); self.fragment = None; out.pli = true; }
if p.marker {
if self.fragment.is_some() { out.pli = true; self.damaged = true; }
if !self.damaged && !self.au.is_empty() { out.units.push(std::mem::take(&mut self.au)); }
self.au.clear(); self.fragment = None;
}
}
}
fn append(&mut self, bytes: &[u8]) -> Result<(), ()> {
if self.au.len() + bytes.len() > MAX_AU { return Err(()) }
self.au.extend_from_slice(bytes); Ok(())
}
fn nal(&mut self, p: &[u8]) -> Result<(), ()> {
if self.codec==Codec::H265 {return self.hevc(p)}
let h = *p.first().ok_or(())?;
if h & 0x80 != 0 { return Err(()) }
match h & 31 {
1..=23 if self.fragment.is_none() => { self.append(&[0,0,0,1])?; self.append(p) }
24 if self.fragment.is_none() => {
let mut rest = &p[1..]; if rest.is_empty() { return Err(()) }
while !rest.is_empty() {
if rest.len() < 2 { return Err(()) }
let n = u16::from_be_bytes([rest[0], rest[1]]) as usize; rest = &rest[2..];
if n == 0 || rest.len() < n || rest[0] & 0x80 != 0 || !(1..=23).contains(&(rest[0] & 31)) { return Err(()) }
self.append(&[0,0,0,1])?; self.append(&rest[..n])?; rest = &rest[n..];
} Ok(())
}
28 if p.len() > 2 => {
let f = p[1]; let kind = f & 31; let start = f & 128 != 0; let end = f & 64 != 0;
if f & 32 != 0 || kind == 0 || kind > 23 || (start && end) { return Err(()) }
let header = (h & 0xe0) | kind;
if start {
if self.fragment.is_some() { return Err(()) }
self.append(&[0,0,0,1,header])?; self.fragment = Some(u16::from(header));
} else if self.fragment != Some(u16::from(header)) { return Err(()) }
self.append(&p[2..])?;
if end { self.fragment = None; } Ok(())
}
_ => Err(()),
}
}
fn hevc_header(p:&[u8])->Result<u16,()> {
if p.len()<2 || p[0]&0x80!=0 || p[1]&7==0 {return Err(())}
Ok(u16::from_be_bytes([p[0],p[1]]))
}
fn hevc(&mut self,p:&[u8])->Result<(),()> {
Self::hevc_header(p)?;
match (p[0]>>1)&63 {
0..=47 if self.fragment.is_none()=>{self.append(&[0,0,0,1])?;self.append(p)},
48 if self.fragment.is_none()=>{
let mut rest=&p[2..];if rest.is_empty(){return Err(())}
while !rest.is_empty() {
if rest.len()<2 {return Err(())}
let n=u16::from_be_bytes([rest[0],rest[1]]) as usize;rest=&rest[2..];
if n<2 || rest.len()<n {return Err(())}
Self::hevc_header(&rest[..n])?;
if (rest[0]>>1)&63>=48 {return Err(())}
self.append(&[0,0,0,1])?;self.append(&rest[..n])?;rest=&rest[n..];
}Ok(())
},
49 if p.len()>3=>{
let f=p[2];let kind=f&63;let start=f&128!=0;let end=f&64!=0;
if kind>=48 || (start&&end){return Err(())}
// RFC 7798 4.4.3: preserve LayerId and TID, replacing only FU's NAL type.
let header=[(p[0]&0x81)|(kind<<1),p[1]];let key=u16::from_be_bytes(header);
if start {
if self.fragment.is_some(){return Err(())}
self.append(&[0,0,0,1])?;self.append(&header)?;self.fragment=Some(key);
}else if self.fragment!=Some(key){return Err(())}
self.append(&p[3..])?;if end{self.fragment=None;}Ok(())
},
_=>Err(()),
}
}
}
/// Drop the oldest item on overflow; never block the RTP reader on a decoder/UI.
pub struct Latest<T>(Arc<Mutex<VecDeque<T>>>, usize);
impl<T> Clone for Latest<T> { fn clone(&self) -> Self { Self(self.0.clone(), self.1) } }
impl<T> Latest<T> {
pub fn new(capacity: usize) -> Self { assert!(capacity > 0); Self(Arc::new(Mutex::new(VecDeque::new())), capacity) }
pub fn push(&self, value: T) -> bool { let mut q = self.0.lock().unwrap(); let dropped = q.len() == self.1; if dropped { q.pop_front(); } q.push_back(value); dropped }
pub fn pop(&self) -> Option<T> { self.0.lock().unwrap().pop_front() }
}
#[cfg(test)]
mod tests {
use super::*;
fn p(seq:u16, ts:u32, marker:bool, payload:&[u8])->Packet { Packet{seq,timestamp:ts,marker,payload:payload.into()} }
#[test] fn single_stap_and_boundary() {
let mut r=Receiver::default();
assert!(r.push(p(1,1,false,&[0x67,1])).units.is_empty());
assert_eq!(r.push(p(2,1,true,&[24,0,2,0x68,2,0,2,0x65,3])).units[0],vec![0,0,0,1,0x67,1,0,0,0,1,0x68,2,0,0,0,1,0x65,3]);
r.push(p(3,2,false,&[0x61,1]));
let o=r.push(p(4,3,true,&[0x65,4])); assert!(o.pli); assert_eq!(o.units.len(),1);
}
#[test] fn fu_reorder_wrap_duplicate_and_loss() {
let mut r=Receiver::default(); r.push(p(65535,1,false,&[0x7c,0x85,1]));
assert!(r.push(p(1,1,true,&[0x7c,0x45,3])).units.is_empty());
let o=r.push(p(0,1,false,&[0x7c,5,2])); assert_eq!(o.units[0],vec![0,0,0,1,0x65,1,2,3]);
assert!(r.push(p(0,1,false,&[0x61])).units.is_empty());
r.push(p(2,2,false,&[0x7c,0x85,1]));r.push(p(4,2,true,&[0x7c,0x45,3]));
let o=r.expire_at(Instant::now()+Duration::from_millis(50));assert!(o.pli);assert!(o.units.is_empty());
assert_eq!(r.push(p(5,3,true,&[0x65])).units.len(),1);
}
#[test] fn missing_tail_and_reorder_window_are_bounded() {
let mut r=Receiver::default();r.push(p(0,1,false,&[0x7c,0x85,1]));
assert!(!r.expire().pli);assert!(r.expire_at(Instant::now()+Duration::from_millis(201)).pli);
let mut pli=false;for seq in 2..34{pli|=r.push(p(seq,seq as u32,true,&[0x65])).pli;}
assert!(pli);assert!(r.pending.len()<32);
}
#[test] fn malformed_and_bounded() {
for bytes in [vec![],vec![24,0,4,0x65],vec![0x7c,0xc5,1],vec![0xff]] {
assert!(Receiver::default().push(p(1,1,true,&bytes)).pli);
}
let q=Latest::new(2);assert!(!q.push(1));q.push(2);assert!(q.push(3));assert_eq!(q.pop(),Some(2));assert_eq!(q.pop(),Some(3));
}
}
#[cfg(test)] mod hevc_tests {
use super::*;
fn packet(seq:u16,ts:u32,marker:bool,payload:Vec<u8>)->Packet {Packet{seq,timestamp:ts,marker,payload}}
fn sample()->Vec<u8>{
let mut au=vec![0,0,0,1,64,1,9,0,0,0,1,66,1,8,0,0,0,1,68,1,7,0,0,0,1,0x27,0x2b];
au.extend((0..2501).map(|i|(i%251+1)as u8));au
}
#[test] fn host_payloader_round_trip_single_fu_and_reorder(){
for mtu in [4,5,7,1190,9000] {
let au=sample();let payloads=crate::hevc::payload(mtu,&au).unwrap();let n=payloads.len();
let mut packets:Vec<_>=payloads.into_iter().enumerate().map(|(i,b)|packet(65534u16.wrapping_add(i as u16),10,i+1==n,b.to_vec())).collect();
// Start at the first sequence, then reorder adjacent packets across wraparound.
for i in (1..n.saturating_sub(1)).step_by(2){packets.swap(i,i+1);}
let mut r=Receiver::new(Codec::H265);let mut units=Vec::new();
for p in packets {let o=r.push(p);assert!(!o.pli);units.extend(o.units);}
assert_eq!(units,vec![au]);
}
}
#[test] fn aggregation_and_malformed_packets(){
let ap=vec![96,1,0,3,64,1,9,0,3,38,1,7];
let mut r=Receiver::new(Codec::H265);
assert_eq!(r.push(packet(0,0,true,ap)).units,vec![vec![0,0,0,1,64,1,9,0,0,0,1,38,1,7]]);
for payload in [vec![],vec![64],vec![128,1],vec![64,0],vec![96,1],vec![96,1,0,4,38,1,7],
vec![96,1,0,2,96,1],vec![98,1,0xc1,3],vec![98,1,0x41,3],vec![98,1,0xb0,3],vec![100,1,7]] {
let o=Receiver::new(Codec::H265).push(packet(1,1,true,payload));assert!(o.pli);assert!(o.units.is_empty());
}
}
#[test] fn loss_duplicates_incomplete_tail_and_header_mismatch(){
let payloads=crate::hevc::payload(1190,&sample()).unwrap();
let mut r=Receiver::new(Codec::H265);
// Parameter sets followed by a fragmented IDR; lose its middle fragment.
for (i,p) in payloads.iter().enumerate().take(4){r.push(packet(i as u16,1,false,p.to_vec()));}
let tail=packet(5,1,true,payloads[5].to_vec());
assert!(r.push(tail.clone()).units.is_empty());assert!(r.push(tail).units.is_empty());
let o=r.expire_at(Instant::now()+Duration::from_millis(50));assert!(o.pli);assert!(o.units.is_empty());
assert_eq!(r.push(packet(6,2,true,vec![38,1,9])).units.len(),1);
r.push(packet(7,3,false,vec![98,1,0x93,7]));
assert!(r.expire_at(Instant::now()+Duration::from_millis(201)).pli);
let mut r=Receiver::new(Codec::H265);r.push(packet(0,0,false,vec![98,1,0x93,7]));
let o=r.push(packet(1,0,true,vec![98,2,0x53,8]));assert!(o.pli);assert!(o.units.is_empty());
}
}
+37
View File
@@ -0,0 +1,37 @@
//! Opt-in controller session; independent of the host room and peer lifecycle.
pub mod api;
pub mod assist;
pub mod wire;
pub mod signal;
pub mod rtc;
pub mod session;
#[cfg(test)] mod tests;
pub mod media;
pub mod audio;
pub mod input;
pub mod desktop;
#[cfg(feature="viewer-ffmpeg")] pub mod decoder;
#[cfg(any(test,feature="viewer-sdl"))] pub mod decoder_cli;
#[cfg(uu_gtk)] pub mod ui;
#[cfg(uu_gtk)] pub mod tools_ui;
#[cfg(feature="viewer-sdl")] pub mod sdl;
pub mod tools;
pub mod clipboard;
pub mod power;
fn device_label(name:Option<&str>)->&str{
name.filter(|name|!name.is_empty()).unwrap_or("远端设备")
}
#[cfg(test)]
mod device_label_tests {
#[test]
fn device_name_or_fallback(){
assert_eq!(super::device_label(Some("测试电脑")),"测试电脑");
assert_eq!(super::device_label(None),"远端设备");
assert_eq!(super::device_label(Some("")),"远端设备");
}
}
+70
View File
@@ -0,0 +1,70 @@
//! SimpleAction numbers are from src/system_actions.rs (REBOOT_SYSTEM / SHUTDOWN_SYSTEM).
use super::{session::Session,wire};
use std::{sync::atomic::Ordering,time::Duration};
#[derive(Clone,Copy,Debug,PartialEq)]
pub enum Action {Reboot,Shutdown}
impl Action {
pub fn parse(value:&str)->Result<Self,String>{match value{"reboot"=>Ok(Self::Reboot),"shutdown"=>Ok(Self::Shutdown),_=>Err("Power action must be reboot or shutdown".into())}}
pub fn message(self,seq:u64)->Vec<u8>{
let mut action=Vec::new();wire::int(1,match self{Self::Reboot=>9,Self::Shutdown=>12},&mut action);
wire::envelope(seq,3,&action)
}
}
pub async fn run(session:&mut Session,action:Action)->Result<(),String>{
let channel=session.peer.channels[0].clone();
let ready=async{
loop {
if session.peer.observed.control_open.load(Ordering::Acquire) && session.peer.observed.echo_received.load(Ordering::Acquire){return Ok::<_,String>(())}
tokio::select!{r=session.step()=>r?,_=tokio::time::sleep(Duration::from_millis(20))=>{}}
}
};
let send=async move {
tokio::time::timeout(Duration::from_secs(5),channel.send(&bytes::Bytes::from(action.message(2))))
.await.map_err(|_|"Power command send timed out")?.map_err(|_|"Power command send failed")?;
// Drain SCTP locally before closing; this is not a remote execution acknowledgement.
let drain=async{while channel.buffered_amount().await>0 {tokio::time::sleep(Duration::from_millis(20)).await;}};
tokio::time::timeout(Duration::from_secs(2),drain).await.map_err(|_|"Power command drain timed out")?;
tokio::time::sleep(Duration::from_millis(200)).await;Ok(())
};
after_echo(ready,send,Duration::from_secs(30)).await
}
async fn after_echo(ready:impl std::future::Future<Output=Result<(),String>>,send:impl std::future::Future<Output=Result<(),String>>,timeout:Duration)->Result<(),String>{
tokio::time::timeout(timeout,ready).await.map_err(|_|"CONTROL echo timed out")??;
send.await
}
#[cfg(test)] mod tests {
use super::*;
use crate::protocol::{decode_wire,WireValue};
#[test] fn only_host_evidenced_actions_are_encoded(){
for (name,number) in [("reboot",9),("shutdown",12)]{
let bytes=Action::parse(name).unwrap().message(2);let fields=decode_wire(&bytes).unwrap();
let WireValue::Bytes(body)=fields.iter().find(|f|f.number==3).unwrap().value else{panic!()};
assert_eq!(decode_wire(body).unwrap()[0].value,WireValue::Varint(number));
let host=include_str!("../system_actions.rs");
assert!(host.contains(&format!("pub const {}_SYSTEM: u64 = {number};",name.to_uppercase())));
}
for value in ["logout","wol","9",""]{assert!(Action::parse(value).is_err());}
}
#[tokio::test] async fn waits_for_echo_and_sends_once_without_retrying_failure(){
use std::sync::{Arc,atomic::AtomicUsize};
for fail in [false,true]{
let calls=Arc::new(AtomicUsize::new(0));let recorded=calls.clone();
let(tx,rx)=tokio::sync::oneshot::channel();
let operation=tokio::spawn(after_echo(async{rx.await.map_err(|_|"closed".into())},async move{
recorded.fetch_add(1,Ordering::Relaxed);if fail{Err("send failed".into())}else{Ok(())}
},Duration::from_secs(1)));
tokio::task::yield_now().await;assert_eq!(calls.load(Ordering::Relaxed),0);
tx.send(()).unwrap();assert_eq!(operation.await.unwrap().is_err(),fail);
assert_eq!(calls.load(Ordering::Relaxed),1);
}
}
#[tokio::test] async fn failed_or_missing_echo_never_sends(){
for failed in [false,true]{
let called=std::sync::atomic::AtomicBool::new(false);
let result=after_echo(async{if failed{return Err("connection closed".into())}std::future::pending().await},async{called.store(true,Ordering::Relaxed);Ok(())},Duration::from_millis(5)).await;
assert!(result.is_err());assert!(!called.load(Ordering::Relaxed));
}
}
}
+350
View File
@@ -0,0 +1,350 @@
use super::wire::{self, Shape, CHANNELS};
use serde_json::{json, Value};
use std::sync::{Arc,atomic::{AtomicBool,AtomicU32,AtomicU64,Ordering}};
use tokio::sync::mpsc;
use webrtc::{api::{APIBuilder,media_engine::MediaEngine,setting_engine::SettingEngine}, peer_connection::{RTCPeerConnection,configuration::RTCConfiguration,sdp::session_description::RTCSessionDescription,policy::ice_transport_policy::RTCIceTransportPolicy}, ice_transport::{ice_server::RTCIceServer,ice_candidate::RTCIceCandidateInit}, data_channel::{RTCDataChannel,data_channel_init::RTCDataChannelInit}, rtp_transceiver::{rtp_codec::RTPCodecType,rtp_transceiver_direction::RTCRtpTransceiverDirection,RTCRtpTransceiverInit}};
pub fn configuration(result:&Value)->Result<RTCConfiguration,String> {
let list=result.get("iceServers").and_then(Value::as_array).ok_or("Control acknowledgement missing iceServers")?;
let mut servers=Vec::new();
for server in list {
let urls=match server.get("urls") {
Some(Value::String(s))=>vec![s.clone()],
Some(Value::Array(a))=>a.iter().map(|v|v.as_str().map(str::to_owned).ok_or("Invalid ICE URL")).collect::<Result<Vec<_>,_>>()?,
_=>return Err("Invalid ICE URLs".into()),
};
if urls.is_empty() || urls.iter().any(|u| !["stun:","stuns:","turn:","turns:"].iter().any(|p|u.starts_with(p))) {return Err("Invalid ICE URL scheme".into())}
let string=|key|match server.get(key) {Some(Value::String(s))=>Ok(s.clone()),None=>Ok(String::new()),_=>Err("Invalid ICE authentication")};
// webrtc-rs rejects TURN unless the credential type is Password (as in the host's session_ice.rs).
servers.push(RTCIceServer { urls,username:string("username")?,credential:string("credential")?,
credential_type:webrtc::ice_transport::ice_credential_type::RTCIceCredentialType::Password });
}
let relay=match result.get("force_relay") {None=>false,Some(Value::Bool(b))=>*b,_=>return Err("Invalid relay policy".into())};
if relay && !servers.iter().any(|s|s.urls.iter().any(|u|u.starts_with("turn:")||u.starts_with("turns:"))) {return Err("Relay-only session without TURN".into())}
// An empty cloud list means host candidates only. Never invent public STUN.
Ok(RTCConfiguration{ice_servers:servers,ice_transport_policy:if relay{RTCIceTransportPolicy::Relay}else{RTCIceTransportPolicy::All},..Default::default()})
}
#[derive(Clone,Copy)]
pub enum ReadyPolicy { EchoOnly, Explicit }
#[derive(Default)]
pub struct Observed {
pub control_open:AtomicBool,
pub echo_received:AtomicBool,
pub clipboard_supported:AtomicBool,
pub control_messages:AtomicU64,
pub other_messages:AtomicU64,
pub media_packets:AtomicU64,
pub encoder_codecs:AtomicU32,
pub chroma:AtomicU32,
}
pub struct Peer {
clipboard:super::clipboard::Bridge,
pub tools:super::tools::Inbox,
pub pc:Arc<RTCPeerConnection>,
pub channels:Vec<Arc<RTCDataChannel>>,
pub observed:Arc<Observed>,
pub desktop:super::desktop::Desktop,
pub audio:super::audio::Audio,
answered:bool,
early:Vec<RTCIceCandidateInit>,
app_id:String,
ice_id:String,
remote_client:String,
}
fn media_engine(shape:&Shape)->Result<MediaEngine,String>{
use webrtc::rtp_transceiver::rtp_codec::{RTCRtpCodecParameters,RTCRtpCodecCapability};
let mut engine=MediaEngine::default();
let mut codecs=vec![(RTPCodecType::Video,"video/H264",90000,0,"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",102),
(RTPCodecType::Audio,"audio/opus",48000,2,"minptime=10;useinbandfec=1",111)];
// RFC 7798 single-layer non-interleaved mode: no sprop-max-don-diff, hence no DONL.
if shape.decoders.iter().any(|d|d.codec==2){codecs.insert(0,(RTPCodecType::Video,"video/H265",90000,0,"",104));}
for (kind,mime,rate,channels,fmtp,payload) in codecs {
engine.register_codec(RTCRtpCodecParameters{capability:RTCRtpCodecCapability{mime_type:mime.into(),clock_rate:rate,channels,sdp_fmtp_line:fmtp.into(),..Default::default()},payload_type:payload,..Default::default()},kind).map_err(|_|"Codec initialization failed")?;
}Ok(engine)
}
impl Peer {
pub async fn new(config:RTCConfiguration, shape:&Shape, app_id:&str, ice_id:&str, remote_client:&str, outbound:mpsc::Sender<Value>, settings:SettingEngine, mut clipboard:super::clipboard::Bridge)->Result<Self,String> {
shape.validate_session()?;
let mut engine=media_engine(shape)?;
// UU RTP metadata the official Mac viewer offers (src/rtp_metadata.rs on the host side).
for uri in ["http://www.webrtc.org/experiments/rtp-hdrext/video-capture-index","http://www.webrtc.org/experiments/rtp-hdrext/video-frame-is-new-frame"] {
engine.register_header_extension(webrtc::rtp_transceiver::rtp_codec::RTCRtpHeaderExtensionCapability{uri:uri.into()},RTPCodecType::Video,None).map_err(|_|"RTP header extension registration failed")?;
}
let registry=webrtc::api::interceptor_registry::register_default_interceptors(webrtc::interceptor::registry::Registry::new(),&mut engine).map_err(|_|"RTP interceptor initialization failed")?;
let api=APIBuilder::new().with_media_engine(engine).with_setting_engine(settings).with_interceptor_registry(registry).build();
let pc=Arc::new(api.new_peer_connection(config).await.map_err(|e|format!("Peer creation failed: {}",crate::auth::transport_error(&e)))?);
let tools:super::tools::Inbox=Arc::new(std::sync::Mutex::new(None));
let inbox=tools.clone();
pc.on_peer_connection_state_change(Box::new(move |state|{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
log::info!("Viewer peer connection state: {state}");
if matches!(state,RTCPeerConnectionState::Failed|RTCPeerConnectionState::Closed){inbox.lock().unwrap().take();}
Box::pin(async{})
}));
let observed=Arc::new(Observed::default());
let (app,ice,client)=(app_id.to_owned(),ice_id.to_owned(),remote_client.to_owned());
let weak_pc=Arc::downgrade(&pc);
pc.on_ice_candidate(Box::new(move |candidate| {
let weak_pc=weak_pc.clone();let tx=outbound.clone();let(app,ice,client)=(app.clone(),ice.clone(),client.clone());
Box::pin(async move {if let Some(candidate)=candidate {if let Ok(mut value)=candidate.to_json() {
// Candidate callbacks can omit MID. Bind to the first actual bundled m-line.
if let Some(pc)=weak_pc.upgrade() {
if let Some(local)=pc.local_description().await {
if let Some(mid)=local.sdp.lines().find_map(|line|line.strip_prefix("a=mid:")) {
value.sdp_mid=Some(mid.trim().into());value.sdp_mline_index=Some(0);
}
}
}
let _=tx.send(json!({"client_id":client,"data":{"type":"candidate","candidate":value,"ice_id":ice,"app_control_id":app}})).await;
}}})
}));
let counters=observed.clone();
let desktop=super::desktop::Desktop::default();
let audio=super::audio::Audio::default();let sound=audio.clone();
let receiver=desktop.clone();let weak_pc=Arc::downgrade(&pc);
pc.on_track(Box::new(move |track,_,_| {
let counters=counters.clone();let desktop=receiver.clone();let audio=sound.clone();let weak_pc=weak_pc.clone();
// The handler must return: webrtc-rs awaits it before surfacing the next track,
// so an inline read loop on the audio track starved the video track.
Box::pin(async move { tokio::spawn(async move {
let video=track.kind()==RTPCodecType::Video;
log::info!("Viewer track: kind={} mime={} payload_type={}",track.kind(),track.codec().capability.mime_type,track.payload_type());
let opus=track.kind()==RTPCodecType::Audio && track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus");
if video && super::media::Codec::from_mime(&track.codec().capability.mime_type).is_none() {return}
if video {desktop.ssrc.store(track.ssrc(),Ordering::Release);}
let mut receiver=super::media::Receiver::new(super::media::Codec::from_mime(&track.codec().capability.mime_type).unwrap_or_default());
let mut tick=tokio::time::interval(std::time::Duration::from_millis(40));
let mut last_pli=std::time::Instant::now()-std::time::Duration::from_secs(1);
loop {
let output=tokio::select! {
packet=track.read_rtp()=>match packet {
Ok((p,_))=>{
counters.media_packets.fetch_add(1,Ordering::Relaxed);
if !video {if opus {audio.push(p.header.sequence_number,&p.payload);}continue}
// TrackRemote updates codec from the negotiated payload type on each read.
let Some(codec)=super::media::Codec::from_mime(&track.codec().capability.mime_type) else{continue};
if receiver.codec()!=codec {
receiver=super::media::Receiver::new(codec);
desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);
}
receiver.push(super::media::Packet{seq:p.header.sequence_number,timestamp:p.header.timestamp,marker:p.header.marker,payload:p.payload.to_vec()})
},
Err(_)=>break,
},
_=tick.tick()=>{if !video {continue} receiver.expire()},
};
if output.pli {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}
for au in output.units {if desktop.units.push(super::media::AccessUnit{codec:receiver.codec(),data:au}) {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}}
if desktop.pli.load(Ordering::Acquire) && last_pli.elapsed()>=std::time::Duration::from_millis(250) {
desktop.pli.swap(false,Ordering::AcqRel);
if let Some(pc)=weak_pc.upgrade() {
use webrtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication;
let _=pc.write_rtcp(&[Box::new(PictureLossIndication{sender_ssrc:0,media_ssrc:track.ssrc()})]).await;
} else {break}
last_pli=std::time::Instant::now();
}
}
}); })
}));
let result=async {
if shape.capture_type==1 {
// The official Mac viewer offers five recvonly video sections (observed live).
let videos=std::env::var("UU_VIEWER_VIDEO_SECTIONS").ok().and_then(|v|v.parse::<usize>().ok()).filter(|n|(1..=8).contains(n)).unwrap_or(1);
for kind in std::iter::repeat(RTPCodecType::Video).take(videos).chain([RTPCodecType::Audio]) {
pc.add_transceiver_from_kind(kind,Some(RTCRtpTransceiverInit{direction:RTCRtpTransceiverDirection::Recvonly,send_encodings:vec![]})).await.map_err(|_|"Media transceiver failed")?;
}
}
let mut channels=Vec::new();
let clipboard_enabled=clipboard.enabled;
// Diagnostic: hosts may open their own channels; log the label and message count only.
pc.on_data_channel(Box::new(|channel|Box::pin(async move {
let label=channel.label().to_owned();log::info!("Viewer remote data channel opened: label={label}");
let count=Arc::new(std::sync::atomic::AtomicU64::new(0));
channel.on_message(Box::new(move |m|{let n=count.fetch_add(1,Ordering::Relaxed);if n<8 {log::info!("Viewer remote channel message: label={label} bytes={} fields={:?}",m.data.len(),crate::protocol::decode_wire(&m.data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}Box::pin(async{})}));
})));
for label in CHANNELS {
channels.push(pc.create_data_channel(label,Some(RTCDataChannelInit{ordered:Some(true),..Default::default()})).await.map_err(|_|"Data channel creation failed")?);
}
// Native host TEXT offers are RPC 21/case 9; CONTROL replies hit a separate empty State.
// Keep clipboard offers/replies on TEXT, where the host desktop bridge lives.
clipboard.start(&channels[super::clipboard::CHANNEL],&channels[0],observed.clone());
for (index,channel) in channels.iter().enumerate() {
if index==0 {
let weak=Arc::downgrade(&channel);let state=observed.clone();
let chroma444=shape.capture_type==1 && std::env::var("UU_VIEWER_CHROMA").is_ok_and(|v|v=="444");
channel.on_open(Box::new(move ||Box::pin(async move {
state.control_open.store(true,Ordering::Release);
if let Some(channel)=weak.upgrade(){
let _=channel.send(&bytes::Bytes::from(wire::echo_request_with_clipboard(1,clipboard_enabled))).await;
if chroma444 {let _=channel.send(&bytes::Bytes::from(wire::request_chroma444())).await;}
}
})));
}
let closed=tools.clone();let state=observed.clone();
channel.on_close(Box::new(move ||{let closed=closed.clone();let state=state.clone();Box::pin(async move {
if index==0 {state.control_open.store(false,Ordering::Release);}
if [0,3,4].contains(&index){closed.lock().unwrap().take();}
})}));
let state=observed.clone();let inbox=tools.clone();let clipboard_tx=clipboard.sender();
let control_for_echo=if index==0 {Arc::downgrade(&channel)} else {std::sync::Weak::new()};
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();Box::pin(async move {
if index==0 {
let (codecs,chroma)=wire::media_control(&message.data);
if let Some(codecs)=codecs {state.encoder_codecs.store(codecs,Ordering::Release);}
if let Some(chroma)=chroma {
if state.chroma.swap(chroma,Ordering::AcqRel)!=chroma {log::info!("Viewer capture sync: chroma={chroma}");}
}
let count=state.control_messages.fetch_add(1,Ordering::Relaxed);
if wire::echo_matches(&message.data,1) {let supported=wire::echo_clipboard_supported(&message.data);
if state.clipboard_supported.swap(supported,Ordering::AcqRel)!=supported || !state.echo_received.load(Ordering::Acquire) {log::info!("Viewer echo: clipboard_supported={supported}");}state.echo_received.store(true,Ordering::Release);}
if let Some(request)=wire::echo_request_seq(&message.data) {
if let Some(control)=control_for_echo.upgrade() {let _=control.send(&bytes::Bytes::from(wire::echo_response_with_clipboard(1_000_000+request,request,clipboard_enabled))).await;}
}
// Observe only protobuf field numbers; never print channel payloads.
if count<32 {if let Ok(fields)=crate::protocol::decode_wire(&message.data) {let action=fields.iter().find_map(|f|match(f.number,&f.value){(3,crate::protocol::WireValue::Bytes(b))=>Some(super::tools::uint(b,1)),_=>None});
log::info!("Viewer CONTROL fields={:?} simple_action={:?}",fields.iter().take(32).map(|f|f.number).collect::<Vec<_>>(),action);}}
}
if [0,1].contains(&index) && message.data.len()<=super::clipboard::MAX_TEXT*2+1024 {
if let Some(tx)=clipboard_tx {
if crate::protocol::decode_wire(&message.data).is_ok_and(|f|f.iter().any(|f|[17,21,22].contains(&f.number))){let _=tx.try_send(message.data.to_vec());}
}
}
// Tools need FILE/BINARY traffic and CONTROL RPC replies (Message 22) only. Official
// hosts stream many other CONTROL messages; a full queue drops that message instead of
// detaching the tool, which previously lost every later reply.
if index!=0 {let n=state.other_messages.fetch_add(1,Ordering::Relaxed);if n<8 {
// Shape only: protobuf field numbers or JSON keys, never values.
let shape=match serde_json::from_slice::<serde_json::Value>(&message.data){Ok(serde_json::Value::Object(o))=>format!("json{:?}",o.keys().collect::<Vec<_>>()),
_=>format!("pb{:?}",crate::protocol::decode_wire(&message.data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default())};
let inner=crate::protocol::decode_wire(&message.data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{crate::protocol::WireValue::Bytes(b) if x.number>2=>Some((x.number,crate::protocol::decode_wire(b).map(|g|g.iter().map(|y|y.number).collect::<Vec<_>>()).unwrap_or_default())),_=>None}));
log::info!("Viewer channel message: index={index} bytes={} shape={shape} inner={inner:?}",message.data.len());}}
// The official Windows host answers file RPCs (Message 21/22) on TEXT_DATA_CHANNEL (observed
// on SHARE: a 320-byte Message 22 on index 1); our host uses FILE. Treat both as the file channel.
let has=|n:&[u32]|crate::protocol::decode_wire(&message.data).is_ok_and(|f|f.iter().any(|x|n.contains(&x.number)));
let route=if index==1 && has(&[21,22,27]) {3} else {index};
// CONTROL carries host-initiated file RPCs (Message 21 with ftp case 8) during downloads too.
let route=if index==0 && crate::protocol::decode_wire(&message.data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{crate::protocol::WireValue::Bytes(b) if x.number==21=>Some(super::tools::blob(b,8).is_some()),_=>None}))==Some(true) {3} else {route};
let wanted=index==3 || index==4 || route==3 || (index==0 && has(&[22]));
let sender=inbox.lock().unwrap().clone();
if let (true,Some(sender))=(wanted,sender) {
if let Err(tokio::sync::mpsc::error::TrySendError::Closed(_))=sender.try_send((route,message.data.to_vec())) {
let mut slot=inbox.lock().unwrap();if slot.as_ref().is_some_and(|s|s.same_channel(&sender)){slot.take();}
}
}
})}));
}
Ok::<_,String>((channels,tools,clipboard))
}.await;
match result {
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
Err(e)=>{let _=pc.close().await;Err(e)},
}
}
pub async fn offer(&self)->Result<Value,String> {
let offer=self.pc.create_offer(None).await.map_err(|_|"Create offer failed")?;
let mut sdp=offer.sdp.clone();self.pc.set_local_description(offer).await.map_err(|_|"Set local offer failed")?;
// The official Mac viewer's offer carries a bare session-level a=x-uuremote-quic. Only the sent
// copy is changed: webrtc-rs rejects a modified local description.
if !sdp.contains("a=x-uuremote-quic") { if let Some(i)=sdp.find("a=group:BUNDLE") { sdp.insert_str(i,"a=x-uuremote-quic\r\n"); } }
// webrtc-rs omits a=max-message-size, so the host assumes 64 KB and drops larger replies (a 5600-entry
// directory listing compresses to ~73 KB). Advertise libwebrtc's 256 KB like the host does; the
// vendored data channel already accepts messages of that size.
sdp=with_max_message_size(&sdp);
// Local diagnostic: UU_VIEWER_DUMP_OFFER=path writes the sent offer SDP (stays on the operator's machine).
if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_OFFER") {let _=std::fs::write(path,&sdp);}
// ice_network_type=3 as sent by the official Mac viewer (observed on our host's SOAC shape log).
Ok(json!({"client_id":self.remote_client,"data":{"type":"offer","sdp":sdp,"ice_id":self.ice_id,"app_control_id":self.app_id,"ice_network_type":3}}))
}
pub async fn receive(&mut self,event:&Value)->Result<(),String> {
let body=event.get("data").unwrap_or(event);
if !self.matches_route(event) {return Ok(())}
match body.get("type").and_then(Value::as_str) {
Some("answer")=> {
if self.answered {return Ok(())}
let sdp=answer_sdp(body)?;
let answer=RTCSessionDescription::answer(sdp).map_err(|_|"Invalid answer")?;
self.pc.set_remote_description(answer).await.map_err(|_|"Set remote answer failed")?;
self.answered=true;
for c in self.early.drain(..) {self.pc.add_ice_candidate(c).await.map_err(|_|"Queued ICE candidate failed")?;}
}
Some("candidate")=> {
let value=body.get("candidate").ok_or("Missing candidate")?;
let candidate=if let Some(s)=value.as_str() {
RTCIceCandidateInit {candidate:s.into(),sdp_mid:body.get("sdp_mid").and_then(Value::as_str).map(str::to_owned),sdp_mline_index:body.get("sdp_mline_index").and_then(Value::as_u64).and_then(|v|u16::try_from(v).ok()),..Default::default()}
} else {serde_json::from_value(value.clone()).map_err(|_|"Invalid candidate")?};
if self.answered {self.pc.add_ice_candidate(candidate).await.map_err(|_|"ICE candidate failed")?;}
else {if self.early.len()>=256{return Err("Too many early ICE candidates".into())}self.early.push(candidate);}
}
_=>{},
}
Ok(())
}
pub fn matches_route(&self,event:&Value)->bool {
let body=event.get("data").unwrap_or(event);
!body.get("ice_id").is_some_and(|v|v.as_str()!=Some(self.ice_id.as_str()))
&& !body.get("app_control_id").is_some_and(|v|v.as_str()!=Some(self.app_id.as_str()))
&& !event.get("client_id").is_some_and(|v|v.as_str()!=Some(self.remote_client.as_str()))
}
pub fn ready(&self,policy:ReadyPolicy,explicit:bool)->bool {
self.observed.echo_received.load(Ordering::Acquire) && match policy {ReadyPolicy::EchoOnly=>true,ReadyPolicy::Explicit=>explicit}
}
pub async fn send_input(&self,value:&Value)->Result<(),String> {
let channel=&self.channels[0];
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {return Err("CONTROL is not open".into())}
channel.send(&bytes::Bytes::from(value.to_string())).await.map_err(|_|"CONTROL input send failed")?;Ok(())
}
pub async fn close(&self) {self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
}
fn answer_sdp(body:&Value)->Result<String,String> {
if let Some(s)=body.get("sdp").and_then(Value::as_str) {if s.len()<=1024*1024{return Ok(s.into())}}
if let Some(s)=body.get("gzip_sdp").and_then(Value::as_str) {
use base64::Engine;use std::io::Read;
if s.len()>2*1024*1024 {return Err("Compressed answer too large".into())}
let data=base64::engine::general_purpose::STANDARD.decode(s).map_err(|_|"Invalid compressed answer")?;
let mut output=String::new();flate2::read::GzDecoder::new(data.as_slice()).take(1024*1024+1).read_to_string(&mut output).map_err(|_|"Invalid compressed answer")?;
if output.len()<=1024*1024 {return Ok(output)}
}
Err("Answer missing or too large".into())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn compressed_answers_are_supported_and_bounded() {
use base64::Engine;use std::io::Write;
let mut encoder=flate2::write::GzEncoder::new(Vec::new(),flate2::Compression::default());
encoder.write_all(b"synthetic-sdp").unwrap();
let encoded=base64::engine::general_purpose::STANDARD.encode(encoder.finish().unwrap());
assert_eq!(answer_sdp(&json!({"gzip_sdp":encoded})).unwrap(),"synthetic-sdp");
assert!(answer_sdp(&json!({"gzip_sdp":"invalid!"})).is_err());
assert!(answer_sdp(&json!({"sdp":"x".repeat(1024*1024+1)})).is_err());
}
}
/// Adds `a=max-message-size:262144` after `a=sctp-port` when missing (sent copy only).
pub fn with_max_message_size(sdp:&str)->String{
if sdp.contains("a=max-message-size:"){return sdp.to_owned()}
let eol=if sdp.contains("\r\n"){"\r\n"}else{"\n"};
let mut out=String::with_capacity(sdp.len()+32);
for line in sdp.split_inclusive('\n'){out.push_str(line);if line.trim_end().starts_with("a=sctp-port:"){out.push_str("a=max-message-size:262144");out.push_str(eol);}}
out
}
#[cfg(test)] #[test] fn offer_advertises_max_message_size(){
assert_eq!(with_max_message_size("m=application 9\r\na=sctp-port:5000\r\na=mid:0\r\n"),"m=application 9\r\na=sctp-port:5000\r\na=max-message-size:262144\r\na=mid:0\r\n");
assert_eq!(with_max_message_size("a=max-message-size:1\r\n"),"a=max-message-size:1\r\n");
}
#[cfg(test)] #[tokio::test] async fn offers_both_codecs_or_h264_only(){
for force in [false,true] {
let shape:Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap();
let shape=shape.video_preferences(force);
let api=APIBuilder::new().with_media_engine(media_engine(&shape).unwrap()).build();
let pc=api.new_peer_connection(RTCConfiguration::default()).await.unwrap();
pc.add_transceiver_from_kind(RTPCodecType::Video,Some(RTCRtpTransceiverInit{direction:RTCRtpTransceiverDirection::Recvonly,send_encodings:vec![]})).await.unwrap();
let offer=pc.create_offer(None).await.unwrap();
assert!(offer.sdp.contains("a=rtpmap:102 H264/90000"));
assert_eq!(offer.sdp.contains("a=rtpmap:104 H265/90000"),!force);
assert!(!offer.sdp.contains("sprop-max-don-diff"));pc.close().await.unwrap();
}
}
+250
View File
@@ -0,0 +1,250 @@
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool,
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest> }
impl Window {
pub fn new()->Result<Self,String>{
let sdl=sdl2::init()?;let video=sdl.video()?;
let window=video.window("Native viewer (experimental)",1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
let canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
let events=sdl.event_pump()?;let clipboard=video.clipboard();
let(clipboard_tx,clipboard_requests)=tokio::sync::mpsc::channel(16);
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests})
}
pub fn clipboard_bridge(&self)->super::clipboard::Bridge{super::clipboard::Bridge::sdl(self.clipboard_tx.clone())}
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
fn viewport(&self)->Viewport {Viewport::fit(self.canvas.window().size(),self.frame)}
fn poll_clipboard(&mut self){
// Use the existing SDL window; wl-paste creates a transient toplevel on GNOME every poll.
while let Ok(request)=self.clipboard_requests.try_recv(){
use super::clipboard::ClipboardRequest;
match request {
ClipboardRequest::Read(reply)=>{
if self.clipboard_dirty {log::debug!("Viewer clipboard read: focused={} has_text={}",self.focused,self.clipboard.has_clipboard_text());}
let result=if self.focused && std::mem::take(&mut self.clipboard_dirty) && self.clipboard.has_clipboard_text(){read_clipboard()}else{Ok(None)};
let _=reply.send(result);
},
ClipboardRequest::Write(text,reply)=>{
let result=if self.focused {
self.clipboard_dirty=true;
self.clipboard.set_clipboard_text(&text).map(|()|true).map_err(|_|())
}else{Ok(false)};
let _=reply.send(result);
},
}
}
}
pub fn poll(&mut self,input:&mut Input)->(bool,Vec<serde_json::Value>){
let viewport=self.viewport();
let dirty=&mut self.clipboard_dirty;
let events=self.events.poll_iter().inspect(|event|{
if matches!(event,Event::ClipboardUpdate{..}|Event::Window{win_event:WindowEvent::FocusGained,..}){*dirty=true;}
});
translate_actions(events,input,viewport,&mut self.focused,&mut self.files)
}
}
fn clipboard_text(bytes:&[u8])->Option<String>{
if bytes.len()>super::clipboard::MAX_TEXT{return None}
std::str::from_utf8(bytes).ok().map(str::to_owned)
}
fn read_clipboard()->Result<Option<String>,()>{
// SDL2 0.37's String wrapper panics on invalid UTF-8; validate native bytes before copying.
// SDL still acquires the selection synchronously; the bridge timeout cannot interrupt it.
unsafe{
let data=sdl2::sys::SDL_GetClipboardText();
if data.is_null(){return Err(())}
let length=libc::strnlen(data,super::clipboard::MAX_TEXT+1);
let text=clipboard_text(std::slice::from_raw_parts(data.cast::<u8>(),length));
sdl2::sys::SDL_free(data.cast());Ok(text)
}
}
fn translate(events:impl IntoIterator<Item=Event>,input:&mut Input,viewport:Viewport,focused:&mut bool)->(bool,Vec<serde_json::Value>){
translate_actions(events,input,viewport,focused,&mut false)
}
fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewport:Viewport,focused:&mut bool,files:&mut bool)->(bool,Vec<serde_json::Value>){
let mut messages=Vec::new();let mut quit=false;
for event in events{
let message=match event {
Event::Quit{..}|Event::Window{win_event:WindowEvent::Close,..}=>{quit=true;messages.extend(input.release_all());None},
Event::Window{win_event:WindowEvent::FocusLost,..}=>{*focused=false;messages.extend(input.release_all());None},
Event::Window{win_event:WindowEvent::FocusGained,..}=>{*focused=true;None},
Event::KeyDown{scancode:Some(sdl2::keyboard::Scancode::F),keymod,repeat,..}
if *focused && keymod.intersects(sdl2::keyboard::Mod::LCTRLMOD|sdl2::keyboard::Mod::RCTRLMOD)
&& keymod.intersects(sdl2::keyboard::Mod::LALTMOD|sdl2::keyboard::Mod::RALTMOD)=>{
if !repeat{*files=true;messages.extend(input.release_all());}None
},
_ if !*focused || !input.enabled()=>None,
Event::KeyDown{scancode:Some(s),repeat:false,..}=>input.key(s as i32,true),
Event::KeyUp{scancode:Some(s),..}=>input.key(s as i32,false),
Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64),
Event::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)),
Event::MouseButtonUp{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,false)),
_=>None,
};if let Some(m)=message{messages.push(m);}
} (quit,messages)
}
fn button(b:MouseButton)->Option<i32>{match b{MouseButton::Left=>Some(1),MouseButton::Right=>Some(2),MouseButton::Middle=>Some(4),_=>None}}
impl FrameSink for Window {
fn present(&mut self,frame:&Frame)->Result<(),String>{
self.frame=(frame.width,frame.height);let v=self.viewport();let creator=self.canvas.texture_creator();
let mut texture=creator.create_texture_streaming(PixelFormatEnum::RGB24,frame.width,frame.height).map_err(|_|"Texture creation failed")?;
texture.update(None,&frame.rgb,frame.width as usize*3).map_err(|_|"Texture update failed")?;
self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear();
self.canvas.copy(&texture,None,Some(Rect::new(v.x as i32,v.y as i32,v.width as u32,v.height as u32)))?;self.canvas.present();Ok(())
}
}
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool)->Result<(),String>{
#[cfg(uu_gtk)]
let mut files:Option<tokio::task::JoinHandle<Result<(),String>>>=None;
let(tx,mut commands)=tokio::sync::mpsc::channel(8);
if std::env::var("UU_VIEWER_COMMANDS").as_deref()==Ok("1") {
std::thread::spawn(move||{
use std::io::Read;
let mut input=std::io::stdin().lock();let mut line=Vec::new();let mut byte=[0];
while input.read(&mut byte).ok()==Some(1){
if byte[0]==b'\n'{if line==b"files" && tx.blocking_send(()).is_err(){break}line.clear();}
else if line.len()<32{line.push(byte[0]);}else{break}
}
});
}else{drop(tx);}
let mut command_open=true;let mut requested=false;
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
let mut audio=super::audio::Playback::new(&window._sdl,session.peer.audio.clone());
let mut input=Input::new(view_only);input.set_mac(window.mac);let mut tick=tokio::time::interval(std::time::Duration::from_millis(8));
let mut heartbeat=tokio::time::interval(std::time::Duration::from_secs(1));
let deadline=tokio::time::sleep(std::time::Duration::from_secs(30));tokio::pin!(deadline);
let result=async {
loop {tokio::select!{
command=commands.recv(),if command_open=>{if command.is_some(){requested=true}else{command_open=false}},
_=terminate.recv()=>return Ok(()),
_=tokio::signal::ctrl_c()=>return Ok(()),
result=session.step()=>result?,
_=&mut deadline,if !session.peer.observed.echo_received.load(std::sync::atomic::Ordering::Acquire)=>return Err("CONTROL echo timed out".into()),
_=heartbeat.tick()=>{
if input.enabled() && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){session.peer.send_input(&Input::heartbeat()).await?;}
let o=&session.peer.observed;let s=&super::desktop::STATS;let r=std::sync::atomic::Ordering::Relaxed;
log::info!("Viewer desktop stats: control_open={} echo={} media_packets={} access_units={} presented={} decode_errors={}",
o.control_open.load(r),o.echo_received.load(r),o.media_packets.load(r),s[0].load(r),s[1].load(r),s[2].load(r));
},
_=tick.tick()=>{
if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}}
let (quit,messages)=window.poll(&mut input);
window.poll_clipboard();
requested|=std::mem::take(&mut window.files);
#[cfg(uu_gtk)] {
if files.as_ref().is_some_and(|f|f.is_finished()){
if let Some(f)=files.take(){let _=f.await;}session.peer.tools.lock().unwrap().take();
}
if requested && !(files.is_some() && super::tools_ui::closed()) && session.peer.channels[super::tools::FILE].ready_state()==webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {
if files.is_some(){super::tools_ui::present();}
else {let(io,rx)=super::tools::attach(&session.peer)?;
let name=super::device_label(std::env::var("UU_VIEWER_DEVICE_NAME").ok().as_deref()).to_owned();
files=Some(tokio::spawn(async move{super::tools_ui::files(io,rx,&name).await}));}
requested=false;
}
}
#[cfg(not(uu_gtk))] {if requested{log::warn!("File window requires GTK3");requested=false;}}
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
else {input.release_all();}
if quit{return Ok(())}
// At most one AU per iteration keeps local event polling responsive.
if let Some(au)=session.peer.desktop.units.pop(){
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();}
decoder.set_codec(au.codec)?;
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;}
}
}}
}.await;
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
result
}
#[cfg(test)] mod tests {
use super::*;
// macOS: SDL video must start on the main thread, which the test harness does not use; CI runs it on Linux.
#[cfg_attr(target_os="macos",ignore)]
#[tokio::test] async fn clipboard_requests_use_existing_window(){
if std::env::var_os("UU_VIEWER_CLIPBOARD_TEST_CHILD").is_none(){
let output=std::process::Command::new(std::env::current_exe().unwrap())
.args(["--exact","viewer::sdl::tests::clipboard_requests_use_existing_window","--test-threads=1"])
.env("SDL_VIDEODRIVER","dummy").env("UU_VIEWER_CLIPBOARD_TEST_CHILD","1").output().unwrap();
assert!(output.status.success(),"{}{}",String::from_utf8_lossy(&output.stdout),String::from_utf8_lossy(&output.stderr));return
}
let mut window=Window::new().unwrap();
let tx=window.clipboard_tx.clone();
use super::super::clipboard::ClipboardRequest;
for text in ["clipboard text\n",""]{
let(reply,rx)=tokio::sync::oneshot::channel();
tx.send(ClipboardRequest::Write(text.into(),reply)).await.unwrap();
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(true));
let(reply,rx)=tokio::sync::oneshot::channel();
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok((!text.is_empty()).then(||text.to_owned())));
let(reply,rx)=tokio::sync::oneshot::channel();
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));
}
window.focused=false;window.clipboard_dirty=true;
let(reply,rx)=tokio::sync::oneshot::channel();
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));assert!(window.clipboard_dirty);
let(reply,rx)=tokio::sync::oneshot::channel();
tx.send(ClipboardRequest::Write("background".into(),reply)).await.unwrap();
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(false));
window.focused=true;
let(reply,rx)=tokio::sync::oneshot::channel();
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));
window.clipboard_dirty=false;
window._sdl.event().unwrap().push_event(Event::Window{timestamp:0,window_id:window.canvas.window().id(),win_event:WindowEvent::FocusGained}).unwrap();
window.poll(&mut Input::new(true));assert!(window.clipboard_dirty);
let bridge=window.clipboard_bridge();assert!(bridge.enabled);
drop(window);
assert!(tx.is_closed());drop(bridge);
let window=Window::new().unwrap();assert!(window.clipboard_bridge().enabled);
}
#[test] fn clipboard_text_rejects_invalid_or_large_data_and_keeps_empty_text(){
assert_eq!(clipboard_text(b""),Some(String::new()));
assert_eq!(clipboard_text(b"text\n"),Some("text\n".into()));
assert_eq!(clipboard_text(&[255]),None);
assert_eq!(clipboard_text(&vec![b'a';super::super::clipboard::MAX_TEXT+1]),None);
}
#[test] fn file_shortcut_is_local_in_control_and_watch_modes(){
use sdl2::keyboard::{Scancode as S,Mod as M};
for watch in [false,true]{
let mut input=Input::new(watch);let mut focused=true;let mut files=false;
input.key(S::LCtrl as i32,true);input.key(S::LAlt as i32,true);
let key=|repeat|Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(S::F),keymod:M::LCTRLMOD|M::LALTMOD,repeat};
let (_,out)=translate_actions([key(false),key(true),Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(S::F),keymod:M::NOMOD,repeat:false}],
&mut input,Viewport::fit((800,600),(1920,1080)),&mut focused,&mut files);
assert!(files);assert!(out.iter().all(|v|v["action"]=="kbd_release"));
assert!(input.release_all().is_empty());
}
}
#[test] fn watch_events_never_emit_input_and_still_close(){
let mut input=Input::new(true);let mut focused=true;
assert!(input.key(4,true).is_none());assert!(input.button(1,true).is_none());assert!(!input.enabled());
let events=[
Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false},
Event::MouseMotion{timestamp:0,window_id:1,which:0,mousestate:sdl2::mouse::MouseState::from_sdl_state(0),x:12,y:34,xrel:1,yrel:1},
Event::MouseButtonDown{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:12,y:34},
Event::MouseButtonUp{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:12,y:34},
Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false},
Event::Window{timestamp:0,window_id:1,win_event:WindowEvent::FocusLost},
Event::Window{timestamp:0,window_id:1,win_event:WindowEvent::FocusGained},Event::Quit{timestamp:0}];
let (quit,out)=translate(events,&mut input,Viewport::fit((800,600),(1920,1080)),&mut focused);
assert!(quit);assert!(out.is_empty());assert!(input.release_all().is_empty());
}
#[test] fn focus_event_releases_and_suppresses_input_until_focus_returns(){
let mut input=Input::default();input.key(4,true);input.button(1,true);let mut focused=true;
let focus=|win_event|Event::Window{timestamp:0,window_id:1,win_event};
let key=Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false};
let v=Viewport::fit((800,600),(1920,1080));
let (quit,out)=translate([focus(WindowEvent::FocusLost),key.clone()],&mut input,v,&mut focused);
assert!(!quit);assert_eq!(out.len(),2);assert!(input.release_all().is_empty());assert!(!focused);
let (_,out)=translate([focus(WindowEvent::FocusGained),key,Event::Quit{timestamp:0}],&mut input,v,&mut focused);
assert_eq!(out.len(),2);assert_eq!(out[0]["action"],"kbd_press");assert_eq!(out[1]["action"],"kbd_release");
}
}
+89
View File
@@ -0,0 +1,89 @@
use super::{api::JoinData,wire::{self,Shape},signal::Signal,rtc::{self,Peer,ReadyPolicy}};
use serde_json::Value;
use std::{sync::atomic::Ordering,time::Duration};
use tokio::sync::mpsc;
use webrtc::api::setting_engine::SettingEngine;
pub struct Options {pub timeout:Duration,pub legacy_prefix:bool,pub ready_policy:ReadyPolicy,pub clipboard:super::clipboard::Bridge}
pub struct Session {pub peer:Peer,signal:Signal,candidates:mpsc::Receiver<Value>,policy:ReadyPolicy}
impl Session {
pub async fn open(room:&JoinData,shape:&Shape,device:&str,client:&str,options:Options,settings:SettingEngine)->Result<Self,String> {
shape.validate_session()?;
let shape=shape.video_preferences(std::env::var("UU_VIEWER_CODEC").is_ok_and(|v|v.eq_ignore_ascii_case("h264")));
shape.validate_session()?;
let app=wire::uuid();let ice=hex::encode(rand::random::<[u8;16]>());
let timeout=if room.ws_connect_timeout_ms>0 {Duration::from_millis(room.ws_connect_timeout_ms as u64)}else{options.timeout};
let mut signal=Signal::connect(&room.signaling_list,&room.token,timeout,options.legacy_prefix).await?;
let result=async {
let result=signal.control(shape.control(client,&app,&ice)?,shape.connect_options(device,options.clipboard.enabled)?,options.timeout).await?;
// Key names per ICE entry and URL scheme only (no values) to see where TURN credentials live.
if let Some(list)=result.get("iceServers").and_then(Value::as_array) {
let summary:Vec<String>=list.iter().map(|s|{
let scheme=s.get("urls").and_then(|u|u.as_str().map(str::to_owned).or_else(||u.get(0).and_then(Value::as_str).map(str::to_owned))).unwrap_or_default();
let keys:Vec<&str>=s.as_object().map(|o|o.keys().map(String::as_str).collect()).unwrap_or_default();
format!("{}:{:?}",scheme.split(':').next().unwrap_or(""),keys)}).collect();
log::info!("Control ack ICE entries: {:?}",summary);
}
// Structure and relations only; never the ids or ICE credentials.
log::info!("Control ack shape={} app_control_id_matches={:?} ice_id_matches={:?}",crate::protocol::json_shape(&result,5),
result.get("app_control_id").map(|v|v.as_str()==Some(app.as_str())),result.get("ice_id").map(|v|v.as_str()==Some(ice.as_str())));
if result.get("app_control_id").is_some_and(|v|v.as_str()!=Some(app.as_str())) {return Err("Control acknowledgement belongs to another session".into())}
// Observed live: the cloud assigns the session ice_id in this ack rather than echoing ours.
let ice=result.get("ice_id").and_then(Value::as_str).filter(|s|!s.is_empty()&&s.len()<=128).map(str::to_owned).unwrap_or(ice);
let remote=result.get("client_id").and_then(Value::as_str).filter(|s|!s.is_empty()).ok_or("Control acknowledgement missing peer route")?;
let config=rtc::configuration(&result)?;
let(tx,rx)=mpsc::channel(256);
let peer=Peer::new(config,&shape,&app,&ice,remote,tx,settings,options.clipboard).await?;
// The official host drops an offer whose ice_id is not yet in its connection table
// (libstreamer 0xc3080); give it time to process be-controlled first.
let delay=std::env::var("UU_VIEWER_OFFER_DELAY_MS").ok().and_then(|v|v.parse().ok()).unwrap_or(0u64).min(10_000);
tokio::time::sleep(Duration::from_millis(delay)).await;
match peer.offer().await {
Ok(offer)=>match signal.soac(offer).await {Ok(())=>Ok((peer,rx)),Err(e)=>{peer.close().await;Err(e)}},
Err(e)=>{peer.close().await;Err(e)},
}
}.await;
match result {
Ok((peer,candidates))=>Ok(Self{peer,signal,candidates,policy:options.ready_policy}),
Err(e)=>{signal.close().await;Err(e)},
}
}
pub async fn step(&mut self)->Result<(),String> {
tokio::select! {
candidate=self.candidates.recv()=>if let Some(candidate)=candidate {self.signal.soac(candidate).await?},
event=self.signal.event()=> {
let event=event?;
// Event name and SOAC type only.
log::info!("Viewer signaling event: name={} soac_type={}",event.get(0).and_then(Value::as_str).unwrap_or("-"),
event.get(1).and_then(|b|b.get("type").or_else(||b.get("data").and_then(|d|d.get("type")))).and_then(Value::as_str).unwrap_or("-"));
match event.get(0).and_then(Value::as_str) {
Some("soac")=>if let Some(body)=event.get(1) {self.peer.receive(body).await?},
Some("released"|"left"|"leave")=> {
// An event for another peer must not tear down this session.
if self.peer.matches_route(event.get(1).unwrap_or(&Value::Null)) {return Err("Remote session released".into())}
}
_=>{},
}
}
}
Ok(())
}
pub async fn run(&mut self)->Result<(),String> {
let mut interval=tokio::time::interval(Duration::from_secs(1));
let mut reported=(false,false,false);
let deadline=tokio::time::sleep(Duration::from_secs(30));tokio::pin!(deadline);
loop {
tokio::select! {
_=tokio::signal::ctrl_c()=>return Ok(()),
result=self.step()=>result?,
_=&mut deadline,if !self.peer.observed.echo_received.load(Ordering::Acquire)=>return Err("CONTROL echo timed out".into()),
_=interval.tick()=> {
if self.peer.observed.control_open.load(Ordering::Acquire) {self.peer.send_input(&super::input::Input::heartbeat()).await?;}
let state=(self.peer.observed.control_open.load(Ordering::Acquire),self.peer.observed.echo_received.load(Ordering::Acquire),self.peer.ready(self.policy,false));
if state!=reported {log::info!("Viewer session: control_open={} echo_received={} configured_ready={} control_messages={} media_packets={}",state.0,state.1,state.2,self.peer.observed.control_messages.load(Ordering::Relaxed),self.peer.observed.media_packets.load(Ordering::Relaxed));reported=state;}
}
}
}
}
pub async fn close(&mut self) {self.peer.close().await;self.signal.close().await;}
}
+138
View File
@@ -0,0 +1,138 @@
//! Framing/ack evidence: internal viewer-evidence-20261016.md section 3.
//! Raw Engine.IO4 attachments and legacy SDK 0x04 framing are explicit alternatives.
use base64::Engine as _;
use futures_util::{SinkExt, StreamExt};
use serde_json::Value;
use tokio::net::TcpStream;
use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
use tokio_tungstenite::tungstenite::{client::IntoClientRequest, Message};
use std::{collections::VecDeque,time::Duration};
pub struct Signal {
ws: WebSocketStream<MaybeTlsStream<TcpStream>>,
next_ack:u64,
pending:VecDeque<Value>,
legacy_prefix:bool,
}
impl Signal {
pub async fn connect(urls:&[String], token:&str, timeout:Duration, legacy_prefix:bool)->Result<Self,String> {
for url in urls {
if let Ok(Ok(signal))=tokio::time::timeout(timeout,Self::one(url,token,legacy_prefix)).await {return Ok(signal)}
}
Err("Signaling connection failed (details omitted)".into())
}
async fn one(url:&str,token:&str,legacy_prefix:bool)->Result<Self,String> {
let mut request=format!("{}/socket.io/?transport=websocket&EIO=4",url.trim_end_matches('/')).into_client_request().map_err(|_|"Invalid signaling endpoint")?;
request.headers_mut().insert("X-NRD-AUTH",token.parse().map_err(|_|"Invalid room authentication header")?);
let (ws,_)=connect_async(request).await.map_err(|_|"Signaling transport failed")?;
let mut s=Self{ws,next_ack:10,pending:VecDeque::new(),legacy_prefix};
let mut opened=false;
loop {
match s.ws.next().await {
Some(Ok(Message::Text(t))) if t.starts_with('0') && !opened => {
serde_json::from_str::<Value>(&t[1..]).map_err(|_|"Invalid Engine.IO open")?;
opened=true;s.send(Message::Text("40".into())).await?;
}
Some(Ok(Message::Text(t))) if t.starts_with("40") && opened =>return Ok(s),
Some(Ok(Message::Text(t))) if t.starts_with('2')=>s.send(Message::Text(format!("3{}",&t[1..]))).await?,
Some(Ok(Message::Ping(b)))=>s.send(Message::Pong(b)).await?,
_=>return Err("Signaling handshake failed".into()),
}
}
}
async fn send(&mut self,message:Message)->Result<(),String> {self.ws.send(message).await.map_err(|_|"Signaling send failed".into())}
pub async fn control(&mut self, header:Value, app_data:Vec<u8>, timeout:Duration)->Result<Value,String> {
self.next_ack+=1;let id=self.next_ack;
self.send(Message::Text(format!("451-{id}{}",serde_json::json!(["control",header])))).await?;
let mut attachment=Vec::new();if self.legacy_prefix {attachment.push(4)} attachment.extend(app_data);
self.send(Message::Binary(attachment)).await?;
tokio::time::timeout(timeout,async {
loop {
match self.packet().await? {
Packet::Ack(ack,value) if ack==id=> {
let a=value.as_array().ok_or("Invalid control acknowledgement")?;
if a.len()!=2 || a[0].as_str()!=Some("success") || !a[1].is_object() {return Err("Control refused or malformed acknowledgement".into())}
return Ok(a[1].clone());
}
Packet::Event(value)=> {
if self.pending.len()>=64 {return Err("Too many pre-control signaling events".into())}
self.pending.push_back(value);
}
_=>{},
}
}
}).await.map_err(|_|"Control acknowledgement timed out")?
}
async fn packet(&mut self)->Result<Packet,String> {
loop {
match self.ws.next().await {
Some(Ok(Message::Text(t))) if t.starts_with('2')=>self.send(Message::Text(format!("3{}",&t[1..]))).await?,
Some(Ok(Message::Ping(b)))=>self.send(Message::Pong(b)).await?,
Some(Ok(Message::Text(t))) if t.starts_with("43")=> {
let begin=t.find('[').ok_or("Malformed signaling acknowledgement")?;
let id=t[2..begin].parse().map_err(|_|"Malformed signaling acknowledgement id")?;
let value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed signaling acknowledgement body")?;
return Ok(Packet::Ack(id,value))
}
Some(Ok(Message::Text(t))) if t.starts_with("42")=> {
let begin=t.find('[').ok_or("Malformed signaling event")?;
let value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed signaling event body")?;
return Ok(Packet::Event(value))
}
// Socket.IO binary event (45N-[...] / 46N-[...] ack) followed by N attachment frames.
// The official host sends its answer this way (binary gzip_sdp); attachments are
// substituted as base64 strings so the existing gzip_sdp decoder applies.
Some(Ok(Message::Text(t))) if t.starts_with("45") || t.starts_with("46")=> {
let dash=t.find('-').ok_or("Malformed binary signaling packet")?;
let count:usize=t[2..dash].parse().map_err(|_|"Malformed binary attachment count")?;
if count>8 {return Err("Too many signaling attachments".into())}
let begin=t.find('[').ok_or("Malformed binary signaling packet")?;
let mut value:serde_json::Value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed binary signaling body")?;
let mut attachments=Vec::with_capacity(count);
while attachments.len()<count {
match self.ws.next().await {
Some(Ok(Message::Binary(mut b)))=>{
if b.len()>2 && b[0]==4 && b[1]==0x1f {b.remove(0);}
if b.len()>4*1024*1024 {return Err("Signaling attachment too large".into())}
attachments.push(base64::engine::general_purpose::STANDARD.encode(&b));
}
Some(Ok(Message::Text(t))) if t.starts_with('2')=>self.send(Message::Text(format!("3{}",&t[1..]))).await?,
Some(Ok(_))=>{},
_=>return Err("Signaling disconnected".into()),
}
}
fn fill(v:&mut serde_json::Value,a:&[String]) {
match v {
serde_json::Value::Object(o) if o.get("_placeholder")==Some(&serde_json::Value::Bool(true))=>{
if let Some(s)=o.get("num").and_then(|n|n.as_u64()).and_then(|n|a.get(n as usize)) {*v=serde_json::Value::String(s.clone());}
}
serde_json::Value::Object(o)=>for x in o.values_mut(){fill(x,a)},
serde_json::Value::Array(l)=>for x in l{fill(x,a)},
_=>{},
}
}
fill(&mut value,&attachments);
log::info!("Viewer binary signaling event: name={} attachments={}",value.get(0).and_then(|v|v.as_str()).unwrap_or("-"),count);
if t.starts_with("46") {
let id=t[dash+1..begin].parse().map_err(|_|"Malformed binary acknowledgement id")?;
return Ok(Packet::Ack(id,value))
}
return Ok(Packet::Event(value))
}
Some(Ok(Message::Text(t))) if t=="41" || t=="1"=>return Err("Signaling room closed".into()),
Some(Ok(Message::Close(_)))|None|Some(Err(_))=>return Err("Signaling disconnected".into()),
// Type, short prefix and length only, to see what else the room delivers.
Some(Ok(Message::Text(t)))=>log::info!("Viewer signaling frame ignored: text prefix={} bytes={}",t.chars().take(3).collect::<String>(),t.len()),
Some(Ok(Message::Binary(b)))=>log::info!("Viewer signaling frame ignored: binary bytes={}",b.len()),
_=>{},
}
}
}
pub async fn event(&mut self)->Result<Value,String> {
if let Some(v)=self.pending.pop_front(){return Ok(v)}
loop {if let Packet::Event(v)=self.packet().await?{return Ok(v)}}
}
pub async fn soac(&mut self, value:Value)->Result<(),String> {self.send(Message::Text(format!("42{}",serde_json::json!(["soac",value])))).await}
pub async fn close(&mut self) {let _=self.ws.close(None).await;}
}
enum Packet { Ack(u64,Value), Event(Value) }
+341
View File
@@ -0,0 +1,341 @@
use super::{api::JoinData,session::{Session,Options},signal::Signal,rtc::{self,Peer,ReadyPolicy},wire::{self,Shape}};
use serde_json::{json,Value};
use std::{sync::{Arc,atomic::{AtomicUsize,Ordering}},time::Duration};
use tokio::{net::TcpListener,sync::{Mutex,mpsc}};
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::{accept_async,tungstenite::Message};
use webrtc::{api::{APIBuilder,media_engine::MediaEngine,setting_engine::SettingEngine},peer_connection::{configuration::RTCConfiguration,sdp::session_description::RTCSessionDescription},util::vnet::{net::{Net,NetConfig},router::{Router,RouterConfig}}};
async fn virtual_network()->(SettingEngine,SettingEngine,Arc<Mutex<Router>>) {
// RFC 5737 documentation addresses live only inside webrtc's in-memory network.
let router=Arc::new(Mutex::new(Router::new(RouterConfig{cidr:"192.0.2.0/24".into(),..Default::default()}).unwrap()));
let mut settings=Vec::new();
for address in ["192.0.2.10","192.0.2.11"] {
let net=Arc::new(Net::new(Some(NetConfig{static_ips:vec![address.into()],..Default::default()})));
let nic=net.get_nic().unwrap();router.lock().await.add_net(nic.clone()).await.unwrap();
nic.lock().await.set_router(router.clone()).await.unwrap();
let mut setting=SettingEngine::default();setting.set_vnet(Some(net));
setting.set_network_types(vec![webrtc::ice::network_type::NetworkType::Udp4]);
settings.push(setting);
}
router.lock().await.start().await.unwrap();
let b=settings.pop().unwrap();(settings.pop().unwrap(),b,router)
}
fn shape()->Shape {serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap()}
#[test]
fn ice_configuration_preserves_credentials_without_public_fallback() {
let result=json!({"iceServers":[{"urls":"turn:relay.example.invalid:3478","username":"synthetic-user","credential":"synthetic-pass"}],"force_relay":true});
let config=rtc::configuration(&result).unwrap();assert_eq!(config.ice_servers.len(),1);
assert_eq!(config.ice_servers[0].credential,"synthetic-pass");
assert_eq!(config.ice_transport_policy,webrtc::peer_connection::policy::ice_transport_policy::RTCIceTransportPolicy::Relay);
assert!(rtc::configuration(&json!({"iceServers":[]})).unwrap().ice_servers.is_empty());
for result in [json!({}),json!({"iceServers":[],"force_relay":true}),json!({"iceServers":[{"urls":"https://invalid.example"}]}),json!({"iceServers":[{"urls":[7]}]})] {assert!(rtc::configuration(&result).is_err());}
}
#[tokio::test]
async fn websocket_control_ack_framing_heartbeat_failure_and_timeout() {
for legacy in [false,true] {
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();
let url=format!("ws://{}",listener.local_addr().unwrap());
let server=tokio::spawn(async move {
let(stream,_)=listener.accept().await.unwrap();let mut ws=accept_async(stream).await.unwrap();
ws.send(Message::Text("0{}".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("40".into()));
ws.send(Message::Text("40{}".into())).await.unwrap();
let Message::Text(t)=ws.next().await.unwrap().unwrap() else{panic!()};assert!(t.starts_with("451-11["));
let Message::Binary(b)=ws.next().await.unwrap().unwrap() else{panic!()};assert_eq!(b,if legacy{vec![4,8,1]}else{vec![8,1]});
ws.send(Message::Text("2fixture".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("3fixture".into()));
ws.send(Message::Text("43999[\"success\",{}]".into())).await.unwrap();
ws.send(Message::Text("4311[\"fail\",{}]".into())).await.unwrap();
});
let mut signal=Signal::connect(&["invalid endpoint".into(),url],"synthetic-ticket",Duration::from_millis(100),legacy).await.unwrap();
assert!(signal.control(json!({}),vec![8,1],Duration::from_secs(2)).await.unwrap_err().contains("refused"));signal.close().await;server.await.unwrap();
}
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();let url=format!("ws://{}",listener.local_addr().unwrap());
let job=tokio::spawn(async move {
let(s,_)=listener.accept().await.unwrap();let mut ws=accept_async(s).await.unwrap();ws.send(Message::Text("0{}".into())).await.unwrap();let _=ws.next().await;
ws.send(Message::Text("40{}".into())).await.unwrap();while ws.next().await.is_some(){}
});
let mut signal=Signal::connect(&[url],"synthetic-ticket",Duration::from_secs(2),false).await.unwrap();
assert!(signal.control(json!({}),vec![],Duration::from_millis(20)).await.unwrap_err().contains("timed out"));signal.close().await;job.await.unwrap();
}
#[tokio::test]
async fn complete_session_uses_loopback_signaling_and_virtual_rtc_through_echo() {
tokio::time::timeout(Duration::from_secs(20),async {
let(viewer_settings,host_settings,router)=virtual_network().await;
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter};
let track=Arc::new(TrackLocalStaticRTP::new(webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability{mime_type:"video/H264".into(),clock_rate:90000,sdp_fmtp_line:"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(),..Default::default()},"synthetic-video".into(),"synthetic-stream".into()));
let sender=host.add_track(track.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
let (input_tx,mut input_rx)=mpsc::channel(8);
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
host.on_data_channel(Box::new(move |channel| {
let count=count.clone();let input_tx=input_tx.clone();Box::pin(async move {
assert!(wire::CHANNELS.contains(&channel.label()));assert!(channel.ordered());assert!(!channel.negotiated());
let c=count.clone();channel.on_open(Box::new(move ||Box::pin(async move{c.fetch_add(1,Ordering::Relaxed);} )));
if channel.label()==wire::CHANNELS[0] {
let weak=Arc::downgrade(&channel);
channel.on_message(Box::new(move |message| {let weak=weak.clone();let input_tx=input_tx.clone();Box::pin(async move {
if message.data.first()==Some(&b'{') {input_tx.send(serde_json::from_slice::<Value>(&message.data).unwrap()).await.unwrap();return}
for (action,number) in [(super::power::Action::Reboot,9),(super::power::Action::Shutdown,12)] {
if message.data.as_ref()==action.message(2).as_slice(){input_tx.send(json!({"power":number})).await.unwrap();return}
}
assert_eq!(&message.data[..],&wire::echo_request(1));
let mut action=Vec::new();wire::int(1,1,&mut action);wire::bytes(2,br#"{"seq":1}"#,&mut action);
if let Some(channel)=weak.upgrade(){channel.send(&bytes::Bytes::from(wire::envelope(100,3,&action))).await.unwrap();}
})}));
} else if [wire::CHANNELS[3],wire::CHANNELS[4]].contains(&channel.label()) {
let weak=Arc::downgrade(&channel);
channel.on_message(Box::new(move |message|{let weak=weak.clone();Box::pin(async move{
if let Some(dc)=weak.upgrade(){dc.send(&message.data).await.unwrap();}
})}));
}
})
}));
let(tx,mut candidates)=mpsc::channel(256);
host.on_ice_candidate(Box::new(move |candidate| {let tx=tx.clone();Box::pin(async move {
if let Some(candidate)=candidate {let mut c=candidate.to_json().unwrap();c.sdp_mid=Some("0".into());c.sdp_mline_index=Some(0);tx.send(c).await.unwrap();}
})}));
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();let url=format!("ws://{}",listener.local_addr().unwrap());
let server_host=host.clone();let(done_tx,mut done_rx)=mpsc::channel::<()>(1);
let server=tokio::spawn(async move {
let(stream,_)=listener.accept().await.unwrap();
let mut ws=tokio_tungstenite::accept_hdr_async(stream,|request:&tokio_tungstenite::tungstenite::handshake::server::Request,response| {
assert_eq!(request.headers()["X-NRD-AUTH"],"synthetic-room-ticket");assert_eq!(request.uri().path(),"/socket.io/");Ok(response)
}).await.unwrap();
ws.send(Message::Text("0{\"sid\":\"fixture\"}".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("40".into()));ws.send(Message::Text("40{}".into())).await.unwrap();
let Message::Text(packet)=ws.next().await.unwrap().unwrap() else{panic!()};
let begin=packet.find('[').unwrap();let ack=packet[4..begin].parse::<u64>().unwrap();let args:Value=serde_json::from_str(&packet[begin..]).unwrap();assert_eq!(args[0],"control");
let app=args[1]["app_control_id"].clone();
// As observed live: the viewer sends no ice_id and the cloud assigns one in the ack.
assert!(args[1].get("ice_id").is_none()&&args[1].get("client_id").is_none()&&args[1].get("controller_platform").is_none());
let ice=json!("synthetic-cloud-ice");
let streamer:Value=serde_json::from_str(args[1]["streamer_data"].as_str().unwrap()).unwrap();assert_eq!(streamer["control_id"],app);
let Message::Binary(b)=ws.next().await.unwrap().unwrap() else{panic!()};assert!(crate::protocol::decode_wire(&b).is_ok());
// A queued foreign candidate must not be installed into this PC.
ws.send(Message::Text(format!("42{}",json!(["soac",{"data":{"type":"candidate","ice_id":"synthetic-other-session","candidate":"invalid"}}])))).await.unwrap();
ws.send(Message::Text(format!("43{ack}{}",json!(["success",{"iceServers":[],"client_id":"synthetic-host","app_control_id":app,"ice_id":ice}])))).await.unwrap();
loop {
tokio::select! {
_=done_rx.recv()=>break,
candidate=candidates.recv()=>if let Some(candidate)=candidate {
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"candidate","candidate":candidate,"app_control_id":app,"ice_id":ice}}])))).await.unwrap();
},
message=ws.next()=> {
let Some(Ok(Message::Text(packet)))=message else{break};
let value:Value=serde_json::from_str(&packet[2..]).unwrap();let body=&value[1]["data"];
match body["type"].as_str() {
Some("offer")=> {
let offered=body["sdp"].as_str().unwrap();
assert!(offered.contains("H264/90000") && offered.contains("opus/48000"));
assert!(offered.contains("H265/90000") && !offered.contains("VP8"));
assert_eq!(offered.matches("a=recvonly").count(),2);
server_host.set_remote_description(RTCSessionDescription::offer(offered.into()).unwrap()).await.unwrap();
let answer=server_host.create_answer(None).await.unwrap();let sdp=answer.sdp.clone();let mut gathered=server_host.gathering_complete_promise().await;server_host.set_local_description(answer).await.unwrap();
gathered.recv().await;
// Force one real remote candidate to arrive before the answer.
let candidate=candidates.recv().await.unwrap();
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"candidate","candidate":candidate,"app_control_id":app,"ice_id":ice}}])))).await.unwrap();
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"answer","sdp":sdp,"ice_id":ice,"app_control_id":app}}])))).await.unwrap();
}
Some("candidate")=>server_host.add_ice_candidate(serde_json::from_value(body["candidate"].clone()).unwrap()).await.unwrap(),
_=>panic!("unexpected synthetic event"),
}
}
}
}
});
let room:JoinData=serde_json::from_value(json!({"token":"synthetic-room-ticket","signaling_list":[url],"report_token":"synthetic-report","report_url":""})).unwrap();
let options=Options{timeout:Duration::from_secs(3),legacy_prefix:false,ready_policy:ReadyPolicy::Explicit,clipboard:super::clipboard::Bridge::new(false)};
let mut session=Session::open(&room,&shape(),"synthetic-device","synthetic-client",options,viewer_settings).await.unwrap();
assert_eq!(session.peer.channels.len(),5);
let(tool_io,mut tool_rx)=super::tools::attach(&session.peer).unwrap();
assert!(super::tools::attach(&session.peer).is_err());
loop {
tokio::select! {_=tokio::time::sleep(Duration::from_millis(20))=>{},result=session.step()=>result.unwrap()}
if session.peer.ready(ReadyPolicy::EchoOnly,false) && opened.load(Ordering::Relaxed)==5 {break}
}
assert!(!session.peer.ready(ReadyPolicy::Explicit,false));assert!(session.peer.ready(ReadyPolicy::Explicit,true));
assert!(session.peer.observed.control_open.load(Ordering::Acquire));
for channel in [super::tools::FILE,super::tools::BINARY] {
let data=vec![channel as u8;32*1024];tool_io.send(channel,data.clone()).await.unwrap();
loop{let(c,b)=tool_rx.recv().await.unwrap();if c==channel{assert_eq!(b,data);break}}
}
let mut input=super::input::Input::default();
let press=input.key(4,true).unwrap();session.peer.send_input(&press).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),press);
for release in input.release_all(){session.peer.send_input(&release).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),release);}
let heartbeat=super::input::Input::heartbeat();session.peer.send_input(&heartbeat).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),heartbeat);
let packet=|seq,ts,marker,payload:&[u8]|webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:ts,marker,..Default::default()},payload:bytes::Bytes::copy_from_slice(payload)};
track.write_rtp(&packet(9,1,true,&[0x65,1])).await.unwrap();
loop {if let Some(au)=session.peer.desktop.units.pop(){assert_eq!(au.codec,super::media::Codec::H264);assert_eq!(au.data,vec![0,0,0,1,0x65,1]);break}tokio::time::sleep(Duration::from_millis(10)).await;}
track.write_rtp(&packet(10,2,false,&[0x7c,0x85,1])).await.unwrap();
track.write_rtp(&packet(12,2,true,&[0x7c,0x45,3])).await.unwrap();
loop {let (packets,_)=sender.read_rtcp().await.unwrap();if packets.iter().any(|p|p.as_any().is::<webrtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication>()){break}}
assert!(session.peer.desktop.units.pop().is_none());
for (action,number) in [(super::power::Action::Reboot,9),(super::power::Action::Shutdown,12)]{
super::power::run(&mut session,action).await.unwrap();
assert_eq!(input_rx.recv().await.unwrap(),json!({"power":number}));
assert!(input_rx.try_recv().is_err());
}
done_tx.send(()).await.unwrap();server.await.unwrap();session.close().await;
assert!(tool_rx.recv().await.is_none());
host.close().await.unwrap();router.lock().await.stop().await.unwrap();
}).await.expect("offline RTC/session timed out");
}
#[tokio::test]
async fn early_candidates_and_foreign_session_messages_are_scoped() {
let(settings,_,router)=virtual_network().await;let(tx,_rx)=mpsc::channel(256);
let mut peer=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-app","synthetic-ice","synthetic-host",tx,settings,super::clipboard::Bridge::new(false)).await.unwrap();
assert!(!peer.matches_route(&json!({"ice_id":"foreign"})));
assert!(!peer.matches_route(&json!({"app_control_id":"foreign"})));
peer.receive(&json!({"type":"answer","ice_id":"foreign","sdp":"invalid"})).await.unwrap();
for _ in 0..256 {peer.receive(&json!({"type":"candidate","candidate":{"candidate":""}})).await.unwrap();}
assert!(peer.receive(&json!({"type":"candidate","candidate":{"candidate":""}})).await.is_err());
peer.close().await;router.lock().await.stop().await.unwrap();
}
#[tokio::test]
async fn closing_one_peer_preserves_another_peer() {
let(a,b,router)=virtual_network().await;
let(tx1,_rx1)=mpsc::channel(256);let(tx2,_rx2)=mpsc::channel(256);
let first=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-first","synthetic-first-ice","synthetic-host",tx1,a,super::clipboard::Bridge::new(false)).await.unwrap();
let second=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-second","synthetic-second-ice","synthetic-host",tx2,b,super::clipboard::Bridge::new(false)).await.unwrap();
first.close().await;
assert_ne!(second.pc.connection_state(),webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed);
assert_eq!(second.channels.len(),5);
second.close().await;router.lock().await.stop().await.unwrap();
}
#[tokio::test]
async fn opus_and_video_tracks_are_received_independently_in_memory() {
tokio::time::timeout(Duration::from_secs(10),async {
let(viewer_settings,host_settings,router)=virtual_network().await;
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
use webrtc::{track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter},rtp_transceiver::rtp_codec::RTCRtpCodecCapability};
let audio=Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability{mime_type:"audio/opus".into(),clock_rate:48000,channels:2,..Default::default()},"audio".into(),"test".into()));
let video=Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability{mime_type:"video/H264".into(),clock_rate:90000,sdp_fmtp_line:"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(),..Default::default()},"video".into(),"test".into()));
host.add_track(audio.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();host.add_track(video.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
let(tx,_rx)=mpsc::channel(256);
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
let offer=peer.pc.local_description().await.unwrap();assert!(offer.sdp.contains("m=audio") && offer.sdp.contains("opus/48000/2"));
host.set_remote_description(offer).await.unwrap();let answer=host.create_answer(None).await.unwrap();
let mut gathered=host.gathering_complete_promise().await;host.set_local_description(answer).await.unwrap();gathered.recv().await;
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while peer.pc.connection_state()!=webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected {tokio::time::sleep(Duration::from_millis(10)).await;}
let mut heard=false;let mut seen=false;
for seq in 0..200 {
let packet=|payload:&[u8]|webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:u32::from(seq)*960,marker:true,..Default::default()},payload:bytes::Bytes::copy_from_slice(payload)};
audio.write_rtp(&packet(&[0xf8,0xff,0xfe])).await.unwrap();video.write_rtp(&packet(&[0x65,1])).await.unwrap();
tokio::time::sleep(Duration::from_millis(10)).await;
if let Some(data)=peer.audio.pop(){assert_eq!(data,vec![0xf8,0xff,0xfe]);heard=true;}
if let Some(data)=peer.desktop.units.pop(){assert_eq!(data.codec,super::media::Codec::H264);assert_eq!(data.data,vec![0,0,0,1,0x65,1]);seen=true;}
if heard && seen {break}
}
assert!(heard && seen);peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
}).await.expect("in-memory media timed out");
}
#[tokio::test]
async fn desktop_file_window_reattaches_without_replacing_peer(){
tokio::time::timeout(Duration::from_secs(10),async{
use super::tools::{self,files::Files};
let(viewer_settings,host_settings,router)=virtual_network().await;
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let file:Arc<std::sync::Mutex<Option<Arc<webrtc::data_channel::RTCDataChannel>>>>=Default::default();
let(tx,mut received)=mpsc::channel(32);
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
host.on_data_channel(Box::new(move|channel|{let(tx,file,count)=(tx.clone(),file.clone(),count.clone());Box::pin(async move{
count.fetch_add(1,Ordering::Relaxed);
if channel.label()==wire::CHANNELS[tools::FILE]{*file.lock().unwrap()=Some(channel.clone());}
if channel.label()==wire::CHANNELS[tools::CONTROL]{channel.on_message(Box::new(move|m|{
let(tx,file)=(tx.clone(),file.clone());Box::pin(async move{
if let Some(r)=tools::blob(&m.data,21){
if tools::blob(r,8).and_then(|b|tools::blob(b,10)).is_some(){
let id=tools::uint(tools::blob(r,1).unwrap(),1);
let reply=tools::rpc(id,true,7,&tools::ints(&[(4,1)]));
let file=file.lock().unwrap().clone().unwrap();file.send(&bytes::Bytes::from(reply)).await.unwrap();return
}
}
let _=tx.send(m.data.to_vec()).await;
})
}));}
})}));
let(tx,_rx)=mpsc::channel(256);
let peer=Peer::new(RTCConfiguration::default(),&shape(),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
host.set_remote_description(peer.pc.local_description().await.unwrap()).await.unwrap();
let answer=host.create_answer(None).await.unwrap();let mut gathered=host.gathering_complete_promise().await;
host.set_local_description(answer).await.unwrap();gathered.recv().await;
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while opened.load(Ordering::Relaxed)!=5 || peer.channels.iter().any(|c|c.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open){tokio::time::sleep(Duration::from_millis(10)).await;}
let pc=peer.pc.clone();
for _ in 0..2{
let(io,rx)=tools::attach(&peer).unwrap();assert!(tools::attach(&peer).is_err());
let(f,_)=Files::new(io,rx);assert!(f.list_dir(":/").await.unwrap().is_empty());drop(f);
peer.tools.lock().unwrap().take();
assert!(Arc::ptr_eq(&pc,&peer.pc));
let heartbeat=super::input::Input::heartbeat();peer.send_input(&heartbeat).await.unwrap();
loop{if serde_json::from_slice::<Value>(&received.recv().await.unwrap()).ok()==Some(heartbeat.clone()){break}}
}
assert_eq!(opened.load(Ordering::Relaxed),5);
peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
}).await.expect("desktop file reuse timed out");
}
#[tokio::test]
async fn hevc_track_uses_negotiated_payload_type_in_memory(){
tokio::time::timeout(Duration::from_secs(10),async {
use super::media::Codec;
use webrtc::{track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter},
rtp_transceiver::rtp_codec::{RTCRtpCodecCapability,RTCRtpCodecParameters,RTPCodecType}};
let(viewer_settings,host_settings,router)=virtual_network().await;
// The host uses a different local PT; the answer binds its track to the viewer offer.
let mut engine=MediaEngine::default();
let capability=RTCRtpCodecCapability{mime_type:"video/H265".into(),clock_rate:90000,..Default::default()};
engine.register_codec(RTCRtpCodecParameters{capability:capability.clone(),payload_type:126,..Default::default()},RTPCodecType::Video).unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let video=Arc::new(TrackLocalStaticRTP::new(capability,"video".into(),"test".into()));
host.add_track(video.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
host.on_data_channel(Box::new(|channel|Box::pin(async move {
if channel.label()=="CONTROL_DATA_CHANNEL" {
let weak=Arc::downgrade(&channel);
channel.on_open(Box::new(move||Box::pin(async move {
if let Some(channel)=weak.upgrade(){
let mut caps=Vec::new();for codec in [1,2]{let mut cap=Vec::new();wire::int(3,codec,&mut cap);wire::bytes(1,&cap,&mut caps);}
channel.send(&bytes::Bytes::from(wire::envelope(2,18,&caps))).await.unwrap();
// Model a host that declines 4:4:4 and encodes 4:2:0.
channel.send(&bytes::Bytes::from(wire::envelope(3,25,&[24,1]))).await.unwrap();
}
})));
}
})));
let(tx,_rx)=mpsc::channel(256);
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
host.set_remote_description(peer.pc.local_description().await.unwrap()).await.unwrap();
let answer=host.create_answer(None).await.unwrap();
assert!(answer.sdp.contains("H265/90000"));assert!(!answer.sdp.contains("H264/90000"));
let mut gathered=host.gathering_complete_promise().await;host.set_local_description(answer).await.unwrap();gathered.recv().await;
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while peer.pc.connection_state()!=webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected {tokio::time::sleep(Duration::from_millis(10)).await;}
let mut au=vec![0,0,0,1,64,1,9,0,0,0,1,38,1];au.extend(vec![7;200]);
let payloads=crate::hevc::payload(80,&au).unwrap();let mut seq=0;let mut seen=false;
for timestamp in 0..100 {
for (i,payload) in payloads.iter().enumerate(){
video.write_rtp(&webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:timestamp*3000,marker:i+1==payloads.len(),..Default::default()},payload:payload.clone()}).await.unwrap();seq=seq.wrapping_add(1);
}
tokio::time::sleep(Duration::from_millis(10)).await;
if let Some(unit)=peer.desktop.units.pop(){assert_eq!(unit.codec,Codec::H265);assert_eq!(unit.data,au);seen=true;}
if seen && peer.observed.chroma.load(Ordering::Acquire)==1 {break}
}
assert!(seen);assert_eq!(peer.observed.encoder_codecs.load(Ordering::Acquire),3);
assert_eq!(peer.observed.chroma.load(Ordering::Acquire),1);
peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
}).await.expect("in-memory H265 timed out");
}
+73
View File
@@ -0,0 +1,73 @@
//! Command-line adapters; terminal output is intentional user output, never a log.
use super::*;
use std::os::fd::AsRawFd;
use tokio::io::AsyncWriteExt;
struct Tty {fd:i32,saved:libc::termios}
impl Tty {
fn raw()->Result<Self,String>{
let fd=std::io::stdin().as_raw_fd();let mut saved=unsafe{std::mem::zeroed()};
if unsafe{libc::tcgetattr(fd,&mut saved)}!=0{return Err("Terminal command requires a local TTY".into())}
let mut raw=saved;unsafe{libc::cfmakeraw(&mut raw)};
if unsafe{libc::tcsetattr(fd,libc::TCSANOW,&raw)}!=0{return Err("Cannot set terminal raw mode".into())}Ok(Self{fd,saved})
}
}
impl Drop for Tty {fn drop(&mut self){unsafe{libc::tcsetattr(self.fd,libc::TCSANOW,&self.saved);}}}
pub fn size()->(u16,u16){let mut w:libc::winsize=unsafe{std::mem::zeroed()};if unsafe{libc::ioctl(0,libc::TIOCGWINSZ as _,&mut w)}==0{(w.ws_col.max(1),w.ws_row.max(1))}else{(80,24)}}
pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,session:Option<u32>)->Result<(),String>{
let(t,output)=terminal::Terminal::new(io,rx);t.check_env().await?;
let(c,r)=size();let id=match session{Some(id)=>t.attach(id,c,r).await?,None=>t.open(c,r).await?};
let result=terminal_loop(&t,output,id).await;let _=t.close(id).await;result
}
#[async_trait::async_trait]
pub trait TerminalInput:Sync {
async fn write(&self,id:u32,data:&[u8])->Result<(),String>;
async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>;
}
#[async_trait::async_trait]
impl TerminalInput for terminal::Terminal {
async fn write(&self,id:u32,data:&[u8])->Result<(),String>{self.write(id,data).await}
async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>{self.resize(id,cols,rows).await}
}
pub async fn terminal_loop(t:&impl TerminalInput,mut output:mpsc::Receiver<terminal::Event>,id:u32)->Result<(),String>{
async{
let _tty=Tty::raw()?;
use std::os::unix::fs::OpenOptionsExt;
let input=std::fs::OpenOptions::new().read(true).custom_flags(libc::O_NONBLOCK).open("/dev/tty").map_err(|_|"Cannot open local TTY")?;
let input=tokio::io::unix::AsyncFd::new(input).map_err(|_|"Cannot watch local TTY")?;let mut stdout=tokio::io::stdout();let mut buf=vec![0;16*1024];
let mut resize=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::window_change()).map_err(|_|"Cannot watch terminal size")?;
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
loop{tokio::select!{
_=terminate.recv()=>break,
n=async {
loop {let mut ready=input.readable().await?;
match ready.try_io(|fd|std::io::Read::read(&mut fd.get_ref(),&mut buf)){Ok(n)=>break n,Err(_)=>continue}
}
}=>{let n=n.map_err(|_|"TTY read failed")?;if n==0{break}t.write(id,&buf[..n]).await?;},
_=resize.recv()=>{let(c,r)=size();t.resize(id,c,r).await?;},
e=output.recv()=>match e{
Some(terminal::Event::Output{session,data})if session==id=>{stdout.write_all(&data).await.map_err(|_|"TTY write failed")?;stdout.flush().await.map_err(|_|"TTY flush failed")?;},
Some(terminal::Event::Exit{session,code})if session==id=>{if code!=0{return Err(format!("Remote shell exited with code {code}"))}break},
Some(terminal::Event::Error{..})|None=>return Err("Terminal session failed".into()),_=>{},
}
}}Ok(())
}.await
}
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,args:&[String])->Result<(),String>{
let(f,mut progress)=files::Files::new(io,rx);
let reporter=tokio::spawn(async move{while let Some(p)=progress.recv().await{eprintln!("{} / {} bytes",p.transferred,p.total);}});
let operation=async {match args.first().map(String::as_str){
Some("ls")if args.len()==2=>match f.list_dir(&args[1]).await{Ok(entries)=>{for e in entries{println!("{}",serde_json::json!({"kind":e.kind,"name":e.name,"size":e.size,"path":e.path}));}Ok(())},Err(e)=>Err(e)},
Some("get")if args.len()==3=>f.download(&args[1],&args[2]).await,
Some("put")if args.len()==3=>f.upload(&args[1],&args[2]).await,
_=>Err("files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE".into()),
}};
tokio::pin!(operation);
let result=tokio::select!{r=&mut operation=>r,_=tokio::signal::ctrl_c()=>{f.cancel();operation.await}};
reporter.abort();result
}
pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,local:u16,host:&str,port:u16)->Result<(),String>{
let p=portmap::PortMap::new(io,rx);let id=p.add_rule("CLI",local,host,port).await?;
eprintln!("Listening on 127.0.0.1:{}",p.status()[0].local_port);
let result=tokio::select!{r=tokio::signal::ctrl_c()=>r.map_err(|_|"Cannot watch interrupt".to_owned()),_=p.closed()=>Err("Forwarding transport closed".into())};
p.remove_rule(id).await?;result
}
+213
View File
@@ -0,0 +1,213 @@
//! FTP RPC cases and 1-based file indexes follow src/file_trans.rs.
use super::*;
use std::{collections::{BTreeMap,HashMap},io::Read,path::{Path,PathBuf},sync::atomic::{AtomicBool,AtomicU64,Ordering}};
use tokio::{io::{AsyncReadExt,AsyncWriteExt},sync::{Mutex as AsyncMutex,Notify}};
#[derive(Debug,Clone)]
pub struct Entry {pub kind:u64,pub name:String,pub size:u64,pub modified:u64,pub path:String}
#[derive(Clone,Copy,Debug)]
pub struct Progress {pub task:u64,pub transferred:u64,pub total:u64}
// Keep request/task ids unique when a desktop file window is reopened.
static NEXT:AtomicU64=AtomicU64::new(100);
pub struct Files {io:Transport,rx:AsyncMutex<mpsc::Receiver<Packet>>,next:&'static AtomicU64,canceled:AtomicBool,poisoned:AtomicBool,wake:Notify,progress:mpsc::Sender<Progress>}
fn check(code:u64)->Result<(),String>{if code==1{Ok(())}else{Err(format!("File transfer error code {code}"))}}
fn id(task:u64,index:u64)->Vec<u8>{nested(1,&ints(&[(1,task),(2,index)]))}
fn all(data:&[u8],n:u32)->Result<Vec<&[u8]>,String>{Ok(decode_wire(data).map_err(|_|"Invalid file protobuf")?.into_iter().filter_map(|f|match(f.number,f.value){(k,WireValue::Bytes(b))if k==n=>Some(b),_=>None}).collect())}
pub fn inflate(data:&[u8])->Result<Vec<u8>,String>{
let mut out=Vec::new();flate2::read::ZlibDecoder::new(data).take(16*1024*1024+1).read_to_end(&mut out).map_err(|_|"Invalid directory compression")?;
if out.len()>16*1024*1024{return Err("Directory expansion limit".into())}Ok(out)
}
/// Splits a remote target into (directory, file name). Windows hosts list paths with `\\` (C:\\Users\\...),
/// Linux hosts with `/`; the directory keeps the host's own separator style. No directory means home.
/// Download block limit. Our host sends 32 KiB blocks; the official Windows host sends larger ones
/// (a 64 KiB file arrived as one block), bounded by the 256 KiB SCTP message size.
const MAX_BLOCK:usize=256*1024;
fn split_remote(remote:&str)->Option<(&str,&str)>{
let cut=remote.rfind(['/','\\']);
let (dir,name)=match cut{Some(i)=>(&remote[..i],&remote[i+1..]),None=>("",remote)};
if name.is_empty(){return None}
// "/x" keeps the root; "C:\\x" keeps "C:\\" (a bare drive letter is not a directory).
let dir=match cut{None=>"~/",Some(i) if dir.is_empty()||dir.ends_with(':')=>&remote[..i+1],_=>dir};
Some((dir,name))
}
fn safe(path:&str)->Result<PathBuf,String>{
let normalized=path.replace('\\',"/");let p=Path::new(&normalized);
if p.as_os_str().is_empty() || p.components().any(|c|!matches!(c,std::path::Component::Normal(_))) || normalized.contains(':') {return Err("Unsafe remote relative path".into())}Ok(p.to_owned())
}
struct Stage(PathBuf);
impl Drop for Stage {fn drop(&mut self){let _=std::fs::remove_dir_all(&self.0);}}
/// Download block ids start at 1 on the official Windows host and at 0 (sent out of order within a
/// 16-block window) on ours. `next` stays unset until block 0 arrives, 16 blocks are buffered, or the
/// file completes; the lowest buffered id is then the base.
struct Download {file:tokio::fs::File,written:u64,next:Option<u64>,blocks:BTreeMap<u64,Vec<u8>>}
impl Files {
pub fn new(io:Transport,rx:mpsc::Receiver<Packet>)->(Self,mpsc::Receiver<Progress>){let(tx,progress)=mpsc::channel(64);(Self{io,rx:AsyncMutex::new(rx),next:&NEXT,canceled:AtomicBool::new(false),poisoned:AtomicBool::new(false),wake:Notify::new(),progress:tx},progress)}
/// Cancels the active operation; subsequent operations can reuse the session.
pub fn cancel(&self){self.canceled.store(true,Ordering::Release);self.wake.notify_waiters();}
async fn recv(&self,rx:&mut mpsc::Receiver<Packet>)->Result<Vec<u8>,String>{loop{
let notified=self.wake.notified();tokio::pin!(notified);notified.as_mut().enable();
if self.canceled.load(Ordering::Acquire){return Err("File transfer canceled".into())}
let(c,b)=tokio::select!{r=receive(rx)=>r?,_=notified=>return Err("File transfer canceled".into())};if c==FILE{return Ok(b)}
}}
async fn request(&self,rx:&mut mpsc::Receiver<Packet>,case:u32,body:&[u8],expected:u32)->Result<Vec<u8>,String>{
if self.poisoned.load(Ordering::Acquire){return Err("File session requires reconnect after failed cleanup".into())}
let rid=self.next.fetch_add(1,Ordering::Relaxed);self.io.send(CONTROL,rpc(rid,false,case,body)).await?;
loop{let b=self.recv(rx).await?;
// Ids and field numbers only, to match official-host replies.
if let Some(r)=blob(&b,22){log::info!("File RPC reply: want_id={rid} got_id={} case_fields={:?}",blob(r,1).map(|h|uint(h,1)).unwrap_or(0),blob(r,4).and_then(|f|crate::protocol::decode_wire(f).ok()).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}
else {log::info!("File channel message: fields={:?}",crate::protocol::decode_wire(&b).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}
if let Some(r)=blob(&b,22){if blob(r,1).is_some_and(|h|uint(h,1)==rid){return blob(r,4).and_then(|f|blob(f,expected)).map(Vec::from).ok_or("Unexpected file response case".into())}}}
}
pub async fn list_dir(&self,path:&str)->Result<Vec<Entry>,String>{
let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
let mut body=id(self.next.fetch_add(1,Ordering::Relaxed),0);wire::bytes(2,path.as_bytes(),&mut body);
let b=self.request(&mut rx,10,&body,7).await?;check(uint(&b,4))?;
let expanded=blob(&b,5).map(inflate).transpose()?;
let rows=if let Some(ref d)=expanded {all(d,1)?}else{all(&b,3)?};
rows.into_iter().map(|r|Ok(Entry{kind:uint(r,1),name:text(r,2)?,size:uint(r,3),modified:uint(r,4),path:text(r,5)?})).collect()
}
pub async fn mkdir(&self,path:&str)->Result<(),String>{let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);let b=self.request(&mut rx,6,&nested(1,path.as_bytes()),5).await?;check(uint(&b,1))}
fn report(&self,task:u64,transferred:u64,total:u64){let _=self.progress.try_send(Progress{task,transferred,total});}
pub async fn upload(&self,local:impl AsRef<Path>,remote:&str)->Result<(),String>{
let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
let mut file=tokio::fs::File::open(local).await.map_err(|_|"Cannot open upload file")?;
let meta=file.metadata().await.map_err(|_|"Cannot stat upload file")?;if !meta.is_file(){return Err("Upload requires a regular file".into())}let size=meta.len();
let (parent,name)=split_remote(remote).ok_or("Invalid remote file name")?;safe(name)?;
let task=self.next.fetch_add(1,Ordering::Relaxed);
// GvPb_FileInfo {1 rel_path, 2 size, 3 modified_time (unix s)}; receive_request {.., 7 task_unique_id}.
// The official Windows host rejects (code 2) a request without the modified time / unique id.
let modified=meta.modified().ok().and_then(|t|t.duration_since(std::time::UNIX_EPOCH).ok()).map_or(0,|d|d.as_secs());
let mut info=nested(1,name.as_bytes());wire::int(2,size,&mut info);wire::int(3,modified,&mut info);
let now=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default();
let unique=format!("{:08x}-{:04x}-4{:03x}-8{:03x}-{:012x}",now.as_secs() as u32,task&0xffff,(now.subsec_nanos()>>20)&0xfff,std::process::id()&0xfff,now.as_nanos()&0xffff_ffff_ffff);
let mut body=id(task,0);wire::bytes(2,parent.as_bytes(),&mut body);wire::bytes(3,&info,&mut body);wire::int(4,1,&mut body);
// Official viewers with the list-compress feature send FileList{1 files} zlib-compressed in list_data (6);
// the official Windows host only registers files from there. Keep the inline copy for older hosts.
let mut list=Vec::new();wire::bytes(1,&info,&mut list);
let mut z=flate2::write::ZlibEncoder::new(Vec::new(),flate2::Compression::default());
std::io::Write::write_all(&mut z,&list).map_err(|_|"Cannot compress file list")?;
wire::bytes(6,&z.finish().map_err(|_|"Cannot compress file list")?,&mut body);
wire::bytes(7,unique.as_bytes(),&mut body);
let result=async {
let r=self.request(&mut rx,1,&body,1).await?;check(uint(&r,3))?;
let mut ask=id(task,1);wire::int(3,size,&mut ask);let r=self.request(&mut rx,3,&ask,3).await?;check(uint(&r,3))?;
if uint(&r,2)!=0 || uint(&r,4)!=0{return Err("Unexpected upload skip/resume".into())}
let mut done=0;let mut block=0;let mut buf=vec![0;32*1024];
loop{let n=file.read(&mut buf).await.map_err(|_|"Upload read failed")?;if n==0{break}
let mut b=id(task,1);wire::int(2,block,&mut b);wire::bytes(3,&buf[..n],&mut b);
let r=self.request(&mut rx,4,&b,4).await?;check(uint(&r,3))?;
if uint(&r,2)!=block || uint(&r,4)!=n as u64{return Err("Invalid upload block acknowledgement".into())}
done+=n as u64;block+=1;self.report(task,done,size);
}
if done!=size{return Err("Upload size changed".into())}
let mut b=id(task,1);wire::int(2,1,&mut b);let r=self.request(&mut rx,9,&b,6).await?;check(uint(&r,2))?;self.report(task,done,size);Ok(())
}.await;
if result.is_err(){let mut b=id(task,1);wire::int(2,7,&mut b);let _=self.io.send(CONTROL,rpc(self.next.fetch_add(1,Ordering::Relaxed),false,9,&b)).await;}
result
}
pub async fn download(&self,remote:&str,local:impl AsRef<Path>)->Result<(),String>{
let local=local.as_ref();let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
let task=self.next.fetch_add(1,Ordering::Relaxed);let mut b=id(task,0);wire::bytes(2,remote.as_bytes(),&mut b);
let mut accepted=false;let mut ended=false;
let result=async {
let r=self.request(&mut rx,2,&b,2).await?;check(uint(&r,2))?;accepted=true;
let expanded=blob(&r,5).map(inflate).transpose()?;
let list=if let Some(ref e)=expanded{all(e,1)?}else{all(&r,3)?};
let files:Vec<(PathBuf,u64)>=list.iter().map(|f|Ok((safe(&text(f,1)?)?,uint(f,2)))).collect::<Result<_,String>>()?;
let folder=!text(&r,4)?.is_empty();if !folder && files.len()!=1{return Err("Invalid single file list".into())}
let stage=Stage(local.with_file_name(format!(".uu-download-{}",wire::uuid())));
tokio::fs::create_dir(&stage.0).await.map_err(|_|"Cannot create download staging directory")?;
let mut open:HashMap<u64,Download>=HashMap::new();let mut completed=std::collections::HashSet::new();let total=files.iter().try_fold(0u64,|sum,x|sum.checked_add(x.1)).ok_or("Download size overflow")?;let mut done=0;
loop {
let data=self.recv(&mut rx).await?;
let Some(rpc_body)=blob(&data,21).filter(|r|blob(r,8).is_some()) else{
// Shape only (field numbers, size): what the host sent that is not a file RPC request.
log::info!("Download skipped message: bytes={} fields={:?} inner={:?}",data.len(),decode_wire(&data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default(),
decode_wire(&data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{WireValue::Bytes(b) if x.number>2=>decode_wire(b).ok().map(|g|(x.number,g.iter().map(|y|y.number).collect::<Vec<_>>())),_=>None})));
continue};
let ftp=blob(rpc_body,8).unwrap();
let rid=blob(rpc_body,1).map(|h|uint(h,1)).unwrap_or(0);
let Some(f)=decode_wire(ftp).ok().and_then(|v|v.into_iter().find(|f|matches!(f.value,WireValue::Bytes(_))))else{return Err("Invalid download request".into())};
let WireValue::Bytes(body)=f.value else{unreachable!()};let tid=blob(body,1).unwrap_or_default();if uint(tid,1)!=task{return Err("Unexpected download task".into())}let index=uint(tid,2);
let mut reply=id(task,index);let mut code=1;
let response=match f.number {
3=>{
if let Some((path,size))=index.checked_sub(1).and_then(|i|files.get(i as usize)) {
if uint(body,3)!=*size || open.contains_key(&index)||completed.contains(&index){code=3}else{
let path=stage.0.join(path);if let Some(p)=path.parent(){tokio::fs::create_dir_all(p).await.map_err(|_|"Cannot create download directory")?;}
match tokio::fs::OpenOptions::new().write(true).create_new(true).open(&path).await {
Ok(file)=>{open.insert(index,Download{file,written:0,next:None,blocks:BTreeMap::new()});},Err(_)=>code=6,
}
}
}else{code=3}wire::int(3,code,&mut reply);3
},
4=>{
let block=uint(body,2);let chunk=blob(body,3).unwrap_or_default();
if let Some(d)=open.get_mut(&index){
let expected=files[index as usize-1].1;
if chunk.len()>MAX_BLOCK || d.next.is_some_and(|n|block<n) || d.blocks.contains_key(&block)||d.blocks.len()>=32 {code=3}else{
d.blocks.insert(block,chunk.to_vec());
if d.next.is_none() && (block==0 || d.blocks.len()>=16) {d.next=d.blocks.keys().next().copied();}
while let Some(chunk)=d.next.and_then(|n|d.blocks.remove(&n)){
if d.written+chunk.len() as u64>expected || d.file.write_all(&chunk).await.is_err(){code=6;break}
d.written+=chunk.len() as u64;done+=chunk.len() as u64;d.next=d.next.map(|n|n+1);
}
}
}else{code=3}
wire::int(2,block,&mut reply);wire::int(3,code,&mut reply);wire::int(4,chunk.len() as u64,&mut reply);self.report(task,done,total);4
},
9=>{
if index==u64::MAX {
ended=true;check(uint(body,2))?;
if completed.len()!=files.len() || !open.is_empty(){return Err("Incomplete download task".into())}
if folder {tokio::fs::rename(&stage.0,local).await.map_err(|_|"Cannot finalize download directory")?;}else{tokio::fs::rename(stage.0.join(&files[0].0),local).await.map_err(|_|"Cannot finalize download file")?;}
self.report(task,done,total);return Ok(())
}
if let Some(mut d)=open.remove(&index){
if d.next.is_none(){d.next=d.blocks.keys().next().copied();}
while let Some(chunk)=d.next.and_then(|n|d.blocks.remove(&n)){
if d.written+chunk.len() as u64>files[index as usize-1].1 || d.file.write_all(&chunk).await.is_err(){break}
d.written+=chunk.len() as u64;done+=chunk.len() as u64;d.next=d.next.map(|n|n+1);
}
if uint(body,2)!=1 || d.written!=files[index as usize-1].1 || !d.blocks.is_empty() || d.file.flush().await.is_err(){code=6}else{completed.insert(index);}
}else{code=3}wire::int(2,code,&mut reply);6
},_=>return Err("Unexpected download request case".into()),
};
// Numbers only: request case, file index, expected/declared sizes, our result code.
if code!=1 || f.number!=4 {log::info!("Download step: case={} index={} files={} declared={} expected={} status={} code={code}",f.number,index,files.len(),uint(body,3),index.checked_sub(1).and_then(|i|files.get(i as usize)).map_or(0,|x|x.1),uint(body,2));}
self.io.send(CONTROL,rpc(rid,true,response,&reply)).await?;
if code!=1{return Err(format!("Download rejected with code {code}"))}
}
}.await;
if result.is_err() && !ended && (accepted || self.canceled.load(Ordering::Acquire)) {
// Reject outstanding host requests so cancellation releases its transfer window.
let cleanup=async {
loop {
let Some((channel,data))=rx.recv().await else{return};if channel!=FILE{continue}
let Some(r)=blob(&data,21)else{continue};let Some(ftp)=blob(r,8)else{continue};
let rid=blob(r,1).map(|h|uint(h,1)).unwrap_or(0);
for (request,response,error_field) in [(3,3,3),(4,4,3),(9,6,2)] {
let Some(body)=blob(ftp,request)else{continue};let tid=blob(body,1).unwrap_or_default();
if uint(tid,1)!=task{continue}
if request==9 && uint(tid,2)==u64::MAX{return}
let mut reply=nested(1,tid);wire::int(error_field,7,&mut reply);
if request==4{wire::int(2,uint(body,2),&mut reply);}
let _=self.io.send(CONTROL,rpc(rid,true,response,&reply)).await;
}
}
};
if tokio::time::timeout(Duration::from_secs(3),cleanup).await.is_err(){self.poisoned.store(true,Ordering::Release);}
}
result
}
}
#[cfg(test)]
mod split_tests{
#[test] fn remote_targets_keep_the_host_separator(){
assert_eq!(super::split_remote(r"C:\Users\Public\Downloads\a.bin"),Some((r"C:\Users\Public\Downloads","a.bin")));
assert_eq!(super::split_remote(r"C:\a.bin"),Some((r"C:\","a.bin")));
assert_eq!(super::split_remote("/tmp/a.bin"),Some(("/tmp","a.bin")));
assert_eq!(super::split_remote("/a.bin"),Some(("/","a.bin")));
assert_eq!(super::split_remote("a.bin"),Some(("~/","a.bin")));
assert_eq!(super::split_remote("/tmp/"),None);
}
}
+58
View File
@@ -0,0 +1,58 @@
//! Tool transports use only this peer's ordered channels; payloads are never logged.
pub mod terminal;
pub mod files;
pub mod portmap;
pub mod cli;
pub mod terminal_ipc;
use std::{sync::{Arc,Mutex},time::Duration};
use tokio::sync::mpsc;
use crate::protocol::{decode_wire,WireValue};
use super::wire;
pub const CONTROL:usize=0;
pub const FILE:usize=3;
pub const BINARY:usize=4;
pub type Packet=(usize,Vec<u8>);
pub type Inbox=Arc<Mutex<Option<mpsc::Sender<Packet>>>>;
pub const TIMEOUT:Duration=Duration::from_secs(30);
#[async_trait::async_trait]
pub trait Send:std::marker::Send+Sync {async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String>;}
#[derive(Clone)]
pub struct Transport(pub Arc<dyn Send>);
impl Transport {
pub async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String> {
tokio::time::timeout(TIMEOUT,self.0.send(channel,data)).await.map_err(|_|"Tool send timeout")?
}
}
struct Rtc(Vec<Arc<webrtc::data_channel::RTCDataChannel>>);
#[async_trait::async_trait]
impl Send for Rtc {
async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String> {
let dc=self.0.get(channel).ok_or("Unknown tool channel")?;
while dc.buffered_amount().await>1024*1024 {tokio::time::sleep(Duration::from_millis(5)).await;}
dc.send(&bytes::Bytes::from(data)).await.map_err(|_|"Tool data channel send failed")?;Ok(())
}
}
pub fn attach(peer:&super::rtc::Peer)->Result<(Transport,mpsc::Receiver<Packet>),String> {
let(tx,rx)=mpsc::channel(256);
let mut slot=peer.tools.lock().unwrap();
if slot.is_some(){return Err("Tool transport already attached".into())}
*slot=Some(tx);Ok((Transport(Arc::new(Rtc(peer.channels.clone()))),rx))
}
pub fn uint(data:&[u8],n:u32)->u64 {decode_wire(data).ok().and_then(|f|f.into_iter().find_map(|f|match(f.number,f.value){(k,WireValue::Varint(v))if k==n=>Some(v),_=>None})).unwrap_or(0)}
pub fn blob(data:&[u8],n:u32)->Option<&[u8]> {decode_wire(data).ok()?.into_iter().find_map(|f|match(f.number,f.value){(k,WireValue::Bytes(v))if k==n=>Some(v),_=>None})}
pub fn text(data:&[u8],n:u32)->Result<String,String> {String::from_utf8(blob(data,n).unwrap_or_default().to_vec()).map_err(|_|"Invalid UTF-8 field".into())}
pub fn ints(fields:&[(u32,u64)])->Vec<u8>{let mut b=Vec::new();for &(n,v) in fields{wire::int(n,v,&mut b)}b}
pub fn nested(n:u32,b:&[u8])->Vec<u8>{let mut out=Vec::new();wire::bytes(n,b,&mut out);out}
pub fn rpc(id:u64,response:bool,case:u32,body:&[u8])->Vec<u8>{
let mut b=nested(1,&ints(&[(1,id)]));wire::bytes(if response{4}else{8},&nested(case,body),&mut b);
wire::envelope(id,if response{22}else{21},&b)
}
pub async fn receive(rx:&mut mpsc::Receiver<Packet>)->Result<Packet,String>{tokio::time::timeout(TIMEOUT,rx.recv()).await.map_err(|_|"Tool response timeout")?.ok_or("Tool transport closed".into())}
#[cfg(test)]
pub mod tests;
pub struct Abort<T>(pub tokio::task::JoinHandle<T>);
impl<T> Drop for Abort<T>{fn drop(&mut self){self.0.abort();}}
pub struct Cancel(pub tokio::task::AbortHandle);
impl Drop for Cancel{fn drop(&mut self){self.0.abort();}}
+90
View File
@@ -0,0 +1,90 @@
//! Message27/SYN JSON follows src/port_mapping.rs; TCP half-close is unsupported.
use super::*;
use std::{collections::HashMap,sync::atomic::{AtomicU64,Ordering}};
use tokio::{net::{TcpListener,TcpStream},io::{AsyncReadExt,AsyncWriteExt},sync::watch};
#[derive(Clone,Debug)]
pub struct Status {pub id:u64,pub name:String,pub local_port:u16,pub streams:usize,pub failures:u64}
struct Rule {status:Arc<Mutex<Status>>,stop:watch::Sender<bool>,task:tokio::task::JoinHandle<()>}
type Routes=Arc<Mutex<HashMap<(u64,u64),mpsc::Sender<(u64,Vec<u8>)>>>>;
pub struct PortMap {io:Transport,session:u64,next:Arc<AtomicU64>,routes:Routes,rules:Mutex<HashMap<u64,Rule>>,alive:watch::Receiver<()>,worker:tokio::task::JoinHandle<()>}
pub fn frame(session:u64,rule:u64,stream:u64,kind:u64,payload:&[u8])->Vec<u8>{let mut b=ints(&[(1,session),(2,rule),(3,stream),(4,kind)]);wire::bytes(5,payload,&mut b);wire::envelope(0,27,&b)}
struct Route {routes:Routes,key:(u64,u64),status:Arc<Mutex<Status>>}
impl Drop for Route {fn drop(&mut self){self.routes.lock().unwrap().remove(&self.key);self.status.lock().unwrap().streams-=1;}}
impl Drop for PortMap {fn drop(&mut self){self.worker.abort();for(_,r)in self.rules.lock().unwrap().drain(){let _=r.stop.send(true);}self.routes.lock().unwrap().clear();}}
impl PortMap {
pub fn new(io:Transport,mut rx:mpsc::Receiver<Packet>)->Self{
// The official Windows host answers every frame with session_id 1 whatever the viewer sent (observed),
// and this project's host echoes it; one port-mapping peer carries one session, so use 1.
let session=1u64;let routes:Routes=Arc::new(Mutex::new(HashMap::new()));let route=routes.clone();
let(life,alive)=watch::channel(());
let worker=tokio::spawn(async move{
let _life=life;
while let Some((channel,b))=rx.recv().await {
if channel!=FILE{continue}let Some(f)=blob(&b,27)else{continue};
let key=(uint(f,2),uint(f,3));let sender=route.lock().unwrap().get(&key).cloned();
// Diagnostics without payload: wire types per field and whether session/route matched.
if uint(f,1)!=session || sender.is_none() {
let kinds=crate::protocol::decode_wire(f).map(|x|x.iter().map(|w|(w.number,match w.value{crate::protocol::WireValue::Varint(_)=>"varint",crate::protocol::WireValue::Bytes(_)=>"bytes",_=>"fixed"})).collect::<Vec<_>>()).unwrap_or_default();
log::warn!("Port mapping frame unmatched: fields={kinds:?} session_match={} route_match={} type={}",uint(f,1)==session,sender.is_some(),uint(f,4));
continue;
}
if let Some(tx)=sender {if tx.try_send((uint(f,4),blob(f,5).unwrap_or_default().to_vec())).is_err(){route.lock().unwrap().remove(&key);}}
}
route.lock().unwrap().clear();
});
Self{io,session,next:Arc::new(AtomicU64::new(1)),routes,rules:Mutex::new(HashMap::new()),alive,worker}
}
pub async fn closed(&self){let mut alive=self.alive.clone();let _=alive.changed().await;}
pub fn status(&self)->Vec<Status>{self.rules.lock().unwrap().values().map(|r|r.status.lock().unwrap().clone()).collect()}
pub async fn add_rule(&self,name:impl Into<String>,local_port:u16,target_host:impl Into<String>,target_port:u16)->Result<u64,String>{
if self.worker.is_finished(){return Err("Forwarding transport closed".into())}
let host=target_host.into();if host.trim().is_empty() || target_port==0 {return Err("Invalid forwarding target".into())}
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,local_port)).await.map_err(|_|"Cannot bind local forwarding port")?;
let port=listener.local_addr().map_err(|_|"Cannot inspect local forwarding port")?.port();
let id=self.next.fetch_add(1,Ordering::Relaxed);let status=Arc::new(Mutex::new(Status{id,name:name.into(),local_port:port,streams:0,failures:0}));
let(stopper,mut stop)=watch::channel(false);let st=status.clone();let io=self.io.clone();let routes=self.routes.clone();let next=self.next.clone();let session=self.session;
let mut disconnected=self.alive.clone();
let task=tokio::spawn(async move {
let mut streams=tokio::task::JoinSet::new();
loop {tokio::select!{
_=stop.changed()=>break,
_=disconnected.changed()=>break,
_=streams.join_next(),if !streams.is_empty()=>{},
accepted=listener.accept()=>{
let Ok((socket,_))=accepted else{break};
if st.lock().unwrap().streams>=128 {continue}
let stream=next.fetch_add(1,Ordering::Relaxed);let(tx,rx)=mpsc::channel(64);
routes.lock().unwrap().insert((id,stream),tx);st.lock().unwrap().streams+=1;
let guard=Route{routes:routes.clone(),key:(id,stream),status:st.clone()};
let io=io.clone();let host=host.clone();let mut cancel=stop.clone();let mut transport_closed=disconnected.clone();
streams.spawn(async move {
let result=tokio::select!{r=forward(&io,session,id,stream,socket,rx,&host,target_port)=>r,_=cancel.changed()=>Ok(()),_=transport_closed.changed()=>Err("Forwarding transport closed".into())};
// Reason only (fixed strings), never forwarded bytes or the target address.
if let Err(reason)=&result{guard.status.lock().unwrap().failures+=1;log::warn!("Port mapping stream ended: {reason}");}
let _=io.send(FILE,frame(session,id,stream,1,&[])).await;drop(guard);
});
}
}}
drop(listener);
while streams.join_next().await.is_some(){}
});
self.rules.lock().unwrap().insert(id,Rule{status,stop:stopper,task});Ok(id)
}
pub async fn remove_rule(&self,id:u64)->Result<(),String>{
let rule=self.rules.lock().unwrap().remove(&id).ok_or("Unknown forwarding rule")?;
let _=rule.stop.send(true);let mut task=rule.task;
if tokio::time::timeout(TIMEOUT+Duration::from_secs(1),&mut task).await.is_err(){task.abort();return Err("Forwarding shutdown timed out".into())}Ok(())
}
}
async fn forward(io:&Transport,session:u64,rule:u64,stream:u64,mut socket:TcpStream,mut rx:mpsc::Receiver<(u64,Vec<u8>)>,host:&str,port:u16)->Result<(),String>{
let syn=serde_json::json!({"version":1,"target_host":host,"target_port":port}).to_string();
io.send(FILE,frame(session,rule,stream,0,syn.as_bytes())).await?;
let ack=tokio::time::timeout(Duration::from_secs(12),rx.recv()).await.map_err(|_|"Forwarding SYN timeout")?.ok_or("Forwarding channel closed")?;
if ack.0!=3 {return Err(format!("Forwarding SYN answered with frame type {}",ack.0))}
if serde_json::from_slice::<serde_json::Value>(&ack.1).ok().and_then(|v|v["ok"].as_bool())!=Some(true){return Err("Forwarding target rejected".into())}
let mut buf=vec![0;16*1024];
loop {tokio::select!{
r=socket.read(&mut buf)=>{let n=r.map_err(|_|"Forwarding read failed")?;if n==0{break}io.send(FILE,frame(session,rule,stream,2,&buf[..n])).await?;},
f=rx.recv()=>match f {Some((2,b))=>if socket.write_all(&b).await.is_err(){break}/* local client hung up: a normal close */,Some((1,_))|None=>break,Some((4,_))=>{},_=>return Err("Unexpected forwarding frame".into())},
}}let _=socket.shutdown().await;Ok(())
}
+167
View File
@@ -0,0 +1,167 @@
//! TERM types and JSON shapes follow src/terminal.rs (including bare LIST_RESP arrays).
use super::*;
use std::{collections::HashMap,sync::atomic::{AtomicU32,AtomicU64,Ordering}};
use tokio::sync::oneshot;
use serde_json::{json,Value};
pub const OPEN:u8=1;pub const STDIN:u8=2;pub const RESIZE:u8=3;pub const CLOSE:u8=4;
pub const STDOUT:u8=5;pub const EXIT:u8=6;pub const ERROR:u8=8;
pub const LIST_REQ:u8=9;pub const LIST_RESP:u8=10;pub const KILL_REQ:u8=11;pub const KILL_RESP:u8=12;pub const OPEN_RESP:u8=13;
pub struct Frame {pub kind:u8,pub session:u32,pub payload:Vec<u8>}
pub fn encode(kind:u8,session:u32,payload:&[u8])->Vec<u8>{
let mut b=b"TERM\x01".to_vec();b.extend([kind,0,0]);b.extend(session.to_le_bytes());b.extend((payload.len() as u32).to_le_bytes());b.extend(payload);b
}
#[derive(Default)]
pub struct Decoder {buffer:Vec<u8>}
impl Decoder {
pub fn push(&mut self,data:&[u8])->Result<Vec<Frame>,String>{
if self.buffer.len()+data.len()>2*1024*1024 {return Err("Terminal buffer limit".into())}
self.buffer.extend(data);let mut out=Vec::new();let mut at=0;
while self.buffer.len()-at>=16 {
let b=&self.buffer[at..];
if &b[..5]!=b"TERM\x01" || !(1..=16).contains(&b[5]) {return Err("Invalid TERM header".into())}
let len=u32::from_le_bytes(b[12..16].try_into().unwrap()) as usize;
if len>1024*1024{return Err("TERM payload limit".into())}
if b.len()<16+len {break}
out.push(Frame{kind:b[5],session:u32::from_le_bytes(b[8..12].try_into().unwrap()),payload:b[16..16+len].to_vec()});at+=16+len;
}
self.buffer.drain(..at);Ok(out)
}
}
#[derive(Clone)]
pub enum Event {Output{session:u32,data:Vec<u8>},Exit{session:u32,code:i64},Error{session:u32}}
type Pending=Arc<Mutex<HashMap<(u8,u64),oneshot::Sender<Result<Vec<u8>,String>>>>>;
struct Request {pending:Pending,key:(u8,u64)}
impl Drop for Request {fn drop(&mut self){self.pending.lock().unwrap().remove(&self.key);}}
pub struct Terminal {io:Transport,pending:Pending,next:AtomicU32,rpc:AtomicU64,worker:tokio::task::JoinHandle<()>}
impl Drop for Terminal {fn drop(&mut self){self.worker.abort();}}
impl Terminal {
pub fn new(io:Transport,mut rx:mpsc::Receiver<Packet>)->(Self,mpsc::Receiver<Event>){
let pending:Pending=Arc::new(Mutex::new(HashMap::new()));let p=pending.clone();let(tx,events)=mpsc::channel(256);
let worker=tokio::spawn(async move {
let mut decoder=Decoder::default();
while let Some((channel,data))=rx.recv().await {
// Terminal RPC answers (check_env) come on CONTROL or, from the official Mac host, on BINARY
// next to TERM frames (as this project's host does).
if channel==CONTROL || (channel==BINARY && !data.starts_with(b"TERM")) {
if let Some(r)=blob(&data,22) {if let (Some(h),Some(body))=(blob(r,1),blob(r,24)) {
if let Some(t)=p.lock().unwrap().remove(&(24,uint(h,1))) {let _=t.send(Ok(body.to_vec()));}
}}continue
}
if channel!=BINARY {continue}
let Ok(frames)=decoder.push(&data) else {break};
let mut overflow=false;
for f in frames {
let event=match f.kind {
STDOUT=>Some(Event::Output{session:f.session,data:f.payload.clone()}),
EXIT=>Some(Event::Exit{session:f.session,code:serde_json::from_slice::<Value>(&f.payload).ok().and_then(|v|v["exit_code"].as_i64()).unwrap_or(-1)}),
ERROR=>Some(Event::Error{session:f.session}),_=>None,
};
if let Some(event)=event {if tx.try_send(event).is_err(){overflow=true;break}}
let key=if f.kind==OPEN_RESP {(OPEN_RESP,0)}else{(f.kind,f.session as u64)};
let payload=if f.kind==OPEN_RESP {
// Our host puts the new session in the frame header; the official Windows host answers with header 0,
// so only a nonzero header overrides the JSON body.
serde_json::from_slice::<Value>(&f.payload).ok().filter(Value::is_object).map(|mut v|{if f.session!=0{v["session_id"]=json!(f.session);}v.to_string().into_bytes()}).unwrap_or(f.payload)
}else{f.payload};
if let Some(t)=p.lock().unwrap().remove(&key){let _=t.send(Ok(payload));}
}
if overflow {break}
}
for (_,t) in p.lock().unwrap().drain(){let _=t.send(Err("Terminal channel closed or output overflow".into()));}
});
(Self{io,pending,next:AtomicU32::new(1),rpc:AtomicU64::new(10),worker},events)
}
async fn request(&self,key:(u8,u64),channel:usize,data:Vec<u8>)->Result<Vec<u8>,String>{
if self.worker.is_finished(){return Err("Terminal channel closed".into())}
let(tx,rx)=oneshot::channel();{
let mut pending=self.pending.lock().unwrap();
if pending.contains_key(&key){return Err("Terminal request already pending".into())}pending.insert(key,tx);
}
let _request=Request{pending:self.pending.clone(),key};
let result=async {self.io.send(channel,data).await?;tokio::time::timeout(TIMEOUT,rx).await.map_err(|_|"Terminal request timeout")?.map_err(|_|"Terminal closed")?}.await;
result
}
pub async fn check_env(&self)->Result<(),String>{
let id=self.rpc.fetch_add(1,Ordering::Relaxed);let mut r=nested(1,&ints(&[(1,id)]));wire::bytes(28,&[],&mut r);
// The official Windows host's rpc_main.proto has no check_env (requests end at 25): no answer means
// "not implemented", not "unavailable"; go on and let OPEN report availability.
match tokio::time::timeout(std::time::Duration::from_secs(3),self.request((24,id),CONTROL,wire::envelope(id,21,&r))).await{
Err(_)=>Ok(()),
Ok(b)=>{let b=b?;let code=uint(&b,1);
if code!=0 {
let message=blob(&b,2).map(|m|String::from_utf8_lossy(m).chars().take(80).collect::<String>()).unwrap_or_default();
log::info!("Terminal check_env: code={code} message={message:?}");
return Err("Terminal environment unavailable".into())
}Ok(())}
}
}
pub async fn list_sessions(&self)->Result<Vec<Value>,String>{
let id=self.next.fetch_add(1,Ordering::Relaxed);
serde_json::from_slice(&self.request((LIST_RESP,id as u64),BINARY,encode(LIST_REQ,id,&[])).await?).map_err(|_|"Invalid terminal session list".into())
}
pub async fn open(&self,cols:u16,rows:u16)->Result<u32,String>{
self.open_session(0,cols,rows).await
}
pub async fn attach(&self,id:u32,cols:u16,rows:u16)->Result<u32,String>{
if id==0 || !self.list_sessions().await?.iter().any(|s|s["session_id"].as_u64()==Some(id as u64)){return Err("Terminal session no longer exists".into())}
self.open_session(id,cols,rows).await
}
async fn open_session(&self,id:u32,cols:u16,rows:u16)->Result<u32,String>{
// Host TerminalConn handles OPEN(nonzero) as reattachment. The official Windows host rejects an OPEN
// without "option" ("terminal open: missing 'option' field", kError 1004); "none" is its plain mode.
let b=self.request((OPEN_RESP,0),BINARY,encode(OPEN,id,json!({"cols":cols.max(1),"rows":rows.max(1),"option":"none"}).to_string().as_bytes())).await?;
let v:Value=serde_json::from_slice(&b).map_err(|_|"Invalid terminal open response")?;
if v["code"].as_i64()!=Some(0){return Err("Terminal open rejected".into())}
let id=v["session_id"].as_u64().or_else(||v["session_id"].as_str().and_then(|s|s.parse().ok())).and_then(|n|u32::try_from(n).ok()).filter(|n|*n!=0);
// The official Windows host answers {"code":0,"message"} with header 0 and keeps one terminal per
// connection addressed as session 0 (it then prints "[terminal] resumed existing session").
if id.is_none(){log::info!("Terminal open response without a session id: keys={:?}; using session 0",v.as_object().map(|o|o.keys().collect::<Vec<_>>()));}
Ok(id.unwrap_or(0))
}
pub async fn write(&self,id:u32,data:&[u8])->Result<(),String>{for b in data.chunks(16*1024){self.io.send(BINARY,encode(STDIN,id,b)).await?}Ok(())}
pub async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>{self.io.send(BINARY,encode(RESIZE,id,json!({"cols":cols.max(1),"rows":rows.max(1)}).to_string().as_bytes())).await}
pub async fn close(&self,id:u32)->Result<(),String>{self.io.send(BINARY,encode(CLOSE,id,&[])).await}
pub async fn kill(&self,id:u32)->Result<(),String>{
let b=self.request((KILL_RESP,id as u64),BINARY,encode(KILL_REQ,id,&[])).await?;
if serde_json::from_slice::<Value>(&b).ok().and_then(|v|v["code"].as_u64())!=Some(0){return Err("Terminal kill rejected".into())}Ok(())
}
}
/// The remote shell needs a real terminal emulator: `$TERMINAL`, else the first installed common one.
/// On failure the window stays open so the error is readable.
pub fn terminal_command(exe: &std::path::Path, id: &str, session: Option<u32>) -> Option<std::process::Command> {
terminal_launcher(exe,"terminal",id,session)
}
pub fn local_terminal_command(exe:&std::path::Path,path:&std::path::Path,session:Option<u32>)->Option<std::process::Command>{
terminal_launcher(exe,"terminal-local",path.to_str()?,session)
}
fn terminal_launcher(exe:&std::path::Path,mode:&str,id:&str,session:Option<u32>)->Option<std::process::Command>{
let script = r#""$0" "$1" "$2" ${3:+"$3"} || { printf '\n终端连接失败,按回车关闭'; read _; }"#;
let inner = ["sh", "-c", script, &exe.to_string_lossy(), mode, id].map(str::to_owned);
let mut inner = inner.to_vec();
if let Some(id) = session { inner.push(id.to_string()); }
let found = |name: &str| std::env::var_os("PATH").is_some_and(|p| std::env::split_paths(&p).any(|d| d.join(name).is_file()));
let custom = std::env::var("TERMINAL").ok().filter(|t| !t.is_empty() && found(t));
let candidates = ["xdg-terminal-exec", "x-terminal-emulator", "kitty", "foot", "alacritty", "wezterm", "ghostty", "gnome-terminal", "konsole", "xfce4-terminal", "xterm"];
let program = custom.or_else(|| candidates.iter().find(|c| found(c)).map(|c| c.to_string()))?;
let prefix: &[&str] = match program.as_str() {
"xdg-terminal-exec" | "kitty" | "foot" => &[],
"wezterm" => &["start", "--"],
"gnome-terminal" => &["--"],
"xfce4-terminal" => &["-x"],
_ => &["-e"],
};
let mut command = std::process::Command::new(program);
command.args(prefix).args(inner).stdin(std::process::Stdio::null()).stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null());
Some(command)
}
/// Only known metadata is allowed across the GTK boundary; never serialize the full host object.
pub fn session_rows(sessions:&[Value])->String{
let mut rows:Vec<_>=sessions.iter().filter_map(|s|{
let id=u32::try_from(s["session_id"].as_u64()?).ok().filter(|n|*n!=0)?;
let shell=s["shell"].as_str().unwrap_or("--").chars().take(256).collect::<String>().replace(['\t','\n','\r','\0']," ");
let state=match s["state"].as_str(){Some("running")=>"运行中",Some("detached")=>"已分离",_=>"--"};
Some((id,format!("{id}\t{shell}\t{}\t{state}\n",s["created_at_ms"].as_u64().unwrap_or(0))))
}).collect();rows.sort_by_key(|r|r.0);rows.into_iter().map(|r|r.1).collect()
}
+152
View File
@@ -0,0 +1,152 @@
//! Local TTY clients share the list process's Terminal; no cloud credentials cross IPC.
use super::{terminal::{Terminal,Event},cli};
use std::{path::{Path,PathBuf},sync::Arc};
use tokio::{io::{AsyncRead,AsyncReadExt,AsyncWrite,AsyncWriteExt},net::{UnixListener,UnixStream},sync::{broadcast,mpsc,Mutex},task::JoinSet};
use serde::{Serialize,Deserialize};
const MAX:usize=4*1024*1024+1024;
#[derive(Serialize,Deserialize)]
enum Message {Open{session:Option<u32>,cols:u16,rows:u16},Ready(u32),Input(Vec<u8>),Resize(u16,u16),Output(Vec<u8>),Exit(i64),Close,Error}
async fn read(r:&mut (impl AsyncRead+Unpin))->Result<Message,String>{
let n=r.read_u32().await.map_err(|_|"Local terminal closed")? as usize;
if n>MAX{return Err("Local terminal frame limit".into())}
let mut b=vec![0;n];r.read_exact(&mut b).await.map_err(|_|"Local terminal closed")?;
serde_json::from_slice(&b).map_err(|_|"Invalid local terminal frame".into())
}
async fn write(w:&mut (impl AsyncWrite+Unpin),m:&Message)->Result<(),String>{
let b=serde_json::to_vec(m).map_err(|_|"Invalid local terminal frame")?;
if b.len()>MAX{return Err("Local terminal frame limit".into())}
w.write_u32(b.len() as u32).await.map_err(|_|"Local terminal closed")?;
w.write_all(&b).await.map_err(|_|"Local terminal closed".into())
}
pub struct Server {dir:PathBuf,pub path:PathBuf,listener:UnixListener}
impl Drop for Server {fn drop(&mut self){let _=std::fs::remove_file(&self.path);let _=std::fs::remove_dir(&self.dir);}}
impl Server {
pub fn new()->Result<Self,String>{
use std::os::unix::fs::DirBuilderExt;
let dir=std::env::temp_dir().join(format!("uu-tty-{}",super::super::wire::uuid()));
std::fs::DirBuilder::new().mode(0o700).create(&dir).map_err(|_|"Cannot create private terminal directory")?;
let path=dir.join("tty");
match UnixListener::bind(&path){Ok(listener)=>Ok(Self{dir,path,listener}),Err(_)=>{let _=std::fs::remove_dir(dir);Err("Cannot bind local terminal socket".into())}}
}
pub async fn run(self,t:Arc<Terminal>,events:broadcast::Sender<Event>){
let opening=Arc::new(Mutex::new(()));let active=Arc::new(std::sync::Mutex::new(std::collections::HashSet::new()));let mut clients=JoinSet::new();
loop{tokio::select!{
accepted=self.listener.accept(),if clients.len()<16=>match accepted{
Ok((socket,_))=>{let(t,opening,active,output)=(t.clone(),opening.clone(),active.clone(),events.subscribe());clients.spawn(async move{let _=serve(socket,t,opening,active,output).await;});},
Err(_)=>break,
},
_=clients.join_next(),if !clients.is_empty()=>{},
}}
}
}
type Sessions=Arc<std::sync::Mutex<std::collections::HashSet<u32>>>;
struct Active {id:u32,sessions:Sessions}
impl Drop for Active {fn drop(&mut self){self.sessions.lock().unwrap().remove(&self.id);}}
async fn serve<S:AsyncRead+AsyncWrite+Unpin+Send+'static>(mut socket:S,t:Arc<Terminal>,opening:Arc<Mutex<()>>,active:Sessions,mut output:broadcast::Receiver<Event>)->Result<(),String>{
let first=tokio::time::timeout(super::TIMEOUT,read(&mut socket)).await.map_err(|_|"Local terminal open timeout")??;
let Message::Open{session,cols,rows}=first else{return Err("Expected local terminal open".into())};
let id={let _guard=opening.lock().await;
if session.is_some_and(|id|active.lock().unwrap().contains(&id)){return Err("Terminal session already attached locally".into())}
let id=match session{Some(id)=>t.attach(id,cols,rows).await?,None=>t.open(cols,rows).await?};
active.lock().unwrap().insert(id);id
};
let _active=Active{id,sessions:active};
let result=async{
write(&mut socket,&Message::Ready(id)).await?;
let(mut r,mut w)=tokio::io::split(socket);let(tx,mut commands)=mpsc::channel(32);
let _reader=super::Abort(tokio::spawn(async move{loop{
let message=read(&mut r).await;let failed=message.is_err();
if tx.send(message).await.is_err() || failed{break}
}}));
loop{tokio::select!{
m=commands.recv()=>match m.ok_or("Local terminal closed")??{
Message::Input(b)=>t.write(id,&b).await?,Message::Resize(c,r)=>t.resize(id,c,r).await?,Message::Close=>break,
_=>return Err("Invalid local terminal command".into()),
},
e=output.recv()=>match e{
Ok(Event::Output{session,data})if session==id=>write(&mut w,&Message::Output(data)).await?,
Ok(Event::Exit{session,code})if session==id=>{write(&mut w,&Message::Exit(code)).await?;break},
Ok(Event::Error{session})if session==id=>{write(&mut w,&Message::Error).await?;break},
Err(_)=>return Err("Local terminal output closed or overflowed".into()),_=>{},
},
}}Ok(())
}.await;
let _=t.close(id).await;result
}
struct Input(Mutex<tokio::net::unix::OwnedWriteHalf>);
#[async_trait::async_trait]
impl cli::TerminalInput for Input {
async fn write(&self,_:u32,b:&[u8])->Result<(),String>{write(&mut *self.0.lock().await,&Message::Input(b.to_vec())).await}
async fn resize(&self,_:u32,c:u16,r:u16)->Result<(),String>{write(&mut *self.0.lock().await,&Message::Resize(c,r)).await}
}
pub async fn client(path:&Path,session:Option<u32>)->Result<(),String>{
let mut socket=UnixStream::connect(path).await.map_err(|_|"Terminal list is no longer available")?;
let(c,r)=cli::size();write(&mut socket,&Message::Open{session,cols:c,rows:r}).await?;
let Message::Ready(id)=read(&mut socket).await? else{return Err("Local terminal open failed".into())};
let(mut r,w)=socket.into_split();let input=Input(Mutex::new(w));let(tx,rx)=mpsc::channel(256);
let worker=tokio::spawn(async move{loop{
let event=match read(&mut r).await{Ok(Message::Output(data))=>Event::Output{session:id,data},Ok(Message::Exit(code))=>Event::Exit{session:id,code},_=>break};
if tx.send(event).await.is_err(){break}
}});
let result=cli::terminal_loop(&input,rx,id).await;
worker.abort();let _=worker.await;let _=write(&mut *input.0.lock().await,&Message::Close).await;result
}
#[cfg(test)] mod tests {
use super::*;
struct Mock(mpsc::Sender<super::super::Packet>);
#[async_trait::async_trait]
impl super::super::Send for Mock {
async fn send(&self,c:usize,b:Vec<u8>)->Result<(),String>{self.0.send((c,b)).await.map_err(|_|"Mock closed".into())}
}
#[tokio::test] async fn two_local_ttys_share_one_terminal_and_close_independently(){
tokio::time::timeout(std::time::Duration::from_secs(3),async{
use super::super::{terminal as term,BINARY};
let(tx,mut requests)=mpsc::channel(256);let(input,rx)=mpsc::channel(256);
let(t,mut events)=Terminal::new(super::super::Transport(Arc::new(Mock(tx))),rx);let t=Arc::new(t);
let(output,_)=broadcast::channel(256);let sender=output.clone();
let _relay=super::super::Abort(tokio::spawn(async move{while let Some(e)=events.recv().await{let _=sender.send(e);}}));
let(closed,mut closes)=mpsc::channel(8);
let _host=super::super::Abort(tokio::spawn(async move{
let mut next=40;
while let Some((channel,b))=requests.recv().await{
assert_eq!(channel,BINARY);let f=term::Decoder::default().push(&b).unwrap().remove(0);
let reply=match f.kind{
term::OPEN=>{next+=1;term::encode(term::OPEN_RESP,next,br#"{"code":0}"#)},
term::STDIN=>term::encode(term::STDOUT,f.session,&f.payload),
term::CLOSE=>{closed.send(f.session).await.unwrap();continue},_=>panic!("Unexpected remote request"),
};input.send((BINARY,reply)).await.unwrap();
}
}));
let opening=Arc::new(Mutex::new(()));let active:Sessions=Default::default();let mut clients=Vec::new();let mut tasks=Vec::new();
for _ in 0..2{
let(mut client,server)=tokio::io::duplex(4096);
let(t,opening,active,events)=(t.clone(),opening.clone(),active.clone(),output.subscribe());
tasks.push(tokio::spawn(serve(server,t,opening,active,events)));
write(&mut client,&Message::Open{session:None,cols:80,rows:24}).await.unwrap();
let Message::Ready(id)=read(&mut client).await.unwrap()else{panic!()};clients.push((client,id));
}
let(mut first,id)=clients.remove(0);write(&mut first,&Message::Close).await.unwrap();
assert_eq!(closes.recv().await.unwrap(),id);tasks.remove(0).await.unwrap().unwrap();
let(mut second,id)=clients.remove(0);
// Split an incoming frame while remote output is ready: the reader must retain framing.
let b=serde_json::to_vec(&Message::Input(vec![0,255,27])).unwrap();second.write_u32(b.len() as u32).await.unwrap();second.write_all(&b[..2]).await.unwrap();
assert!(output.send(Event::Output{session:id,data:b"synthetic".to_vec()}).is_ok());
assert!(matches!(read(&mut second).await,Ok(Message::Output(b))if b==b"synthetic"));
second.write_all(&b[2..]).await.unwrap();
assert!(matches!(read(&mut second).await,Ok(Message::Output(b))if b==[0,255,27]));
drop(second);assert_eq!(closes.recv().await.unwrap(),id);tasks.remove(0).await.unwrap().unwrap_err();
assert!(active.lock().unwrap().is_empty());
}).await.unwrap();
}
#[tokio::test] async fn framing_rejects_oversize_before_payload(){
let(mut a,mut b)=tokio::io::duplex(64);a.write_u32(MAX as u32+1).await.unwrap();
assert!(read(&mut b).await.err().unwrap().contains("limit"));
}
#[tokio::test] async fn framing_roundtrips_binary_and_detects_truncation(){
let(mut a,mut b)=tokio::io::duplex(256);
write(&mut a,&Message::Input(vec![0,255,27])).await.unwrap();
assert!(matches!(read(&mut b).await,Ok(Message::Input(v))if v==[0,255,27]));
a.write_u32(30).await.unwrap();drop(a);assert!(read(&mut b).await.is_err());
}
}
+194
View File
@@ -0,0 +1,194 @@
use super::*;
use tokio::io::{AsyncReadExt,AsyncWriteExt};
struct Mock(mpsc::Sender<Packet>);
#[async_trait::async_trait]
impl Send for Mock {async fn send(&self,c:usize,b:Vec<u8>)->Result<(),String>{self.0.send((c,b)).await.map_err(|_|"Mock closed".into())}}
fn pair()->(Transport,mpsc::Receiver<Packet>,mpsc::Sender<Packet>,mpsc::Receiver<Packet>){let(tx,out)=mpsc::channel(256);let(input,rx)=mpsc::channel(256);(Transport(Arc::new(Mock(tx))),rx,input,out)}
struct Temp(std::path::PathBuf);
impl Temp {fn new()->Self{let p=std::env::temp_dir().join(format!("uu-tools-test-{}",wire::uuid()));std::fs::create_dir(&p).unwrap();Self(p)}}
impl Drop for Temp {fn drop(&mut self){let _=std::fs::remove_dir_all(&self.0);}}
fn host_files()->(files::Files,mpsc::Receiver<files::Progress>,tokio::task::JoinHandle<()>,tokio::task::JoinHandle<()>){
let(io,rx,input,mut out)=pair();let(tx,mut host)=mpsc::unbounded_channel();
let session=crate::file_trans::FileSession::new(tx,Arc::new(std::sync::atomic::AtomicU64::new(1)));
let server=tokio::spawn(async move{while let Some((c,b))=out.recv().await{assert_eq!(c,CONTROL);assert!(session.handle(&decode_wire(&b).unwrap()));}});
let pump=tokio::spawn(async move{while let Some(b)=host.recv().await{if input.send((FILE,b)).await.is_err(){break}}});
let(f,p)=files::Files::new(io,rx);(f,p,server,pump)
}
#[test]
fn terminal_frames_match_host_and_incremental_decoder(){
let a=terminal::encode(terminal::OPEN,7,br#"{"cols":80,"rows":24}"#);
assert_eq!(a,crate::terminal::encode(crate::terminal::OPEN,7,br#"{"cols":80,"rows":24}"#));
let mut d=terminal::Decoder::default();let b=[a.clone(),terminal::encode(terminal::STDOUT,7,b"synthetic")].concat();let mut frames=Vec::new();
for part in b.chunks(3){frames.extend(d.push(part).unwrap());}assert_eq!(frames.len(),2);assert_eq!(frames[1].payload,b"synthetic");
assert!(terminal::Decoder::default().push(b"TERM\x02\x01\0\0\0\0\0\0\0\0\0\0").is_err());
let mut bad=a;bad[12..16].copy_from_slice(&u32::MAX.to_le_bytes());assert!(terminal::Decoder::default().push(&bad).is_err());
}
#[tokio::test]
async fn terminal_rpc_list_open_io_and_errors(){
let(io,rx,input,mut out)=pair();let(t,mut events)=terminal::Terminal::new(io,rx);
let server=tokio::spawn(async move{
let(tx,mut replies)=mpsc::unbounded_channel();let host=crate::terminal::TerminalConn::new(tx);
while let Some((c,b))=out.recv().await{
if c==CONTROL{let r=crate::terminal::rpc_response(&decode_wire(blob(&b,21).unwrap()).unwrap()).unwrap();input.send((CONTROL,wire::envelope(1,22,&r))).await.unwrap();continue}
assert_eq!(c,BINARY);let f=crate::terminal::decode(&b).unwrap();
match f.kind{
terminal::LIST_REQ=>{host.handle(&b);input.send((BINARY,replies.recv().await.unwrap())).await.unwrap();},
terminal::OPEN=>{let v:serde_json::Value=serde_json::from_slice(&f.payload).unwrap();assert_eq!(v["cols"],91);input.send((BINARY,terminal::encode(terminal::OPEN_RESP,37,br#"{"code":0}"#))).await.unwrap();},
terminal::STDIN=>input.send((BINARY,terminal::encode(terminal::STDOUT,f.session,&f.payload))).await.unwrap(),
terminal::RESIZE=>assert_eq!(serde_json::from_slice::<serde_json::Value>(&f.payload).unwrap()["rows"],40),
terminal::KILL_REQ=>input.send((BINARY,terminal::encode(terminal::KILL_RESP,f.session,br#"{"code":1}"#))).await.unwrap(),
terminal::CLOSE=>break,_=>panic!(),
}
}
});
t.check_env().await.unwrap();let _sessions=t.list_sessions().await.unwrap();let id=t.open(91,30).await.unwrap();
let data=vec![42;50_000];t.write(id,&data).await.unwrap();let mut received=Vec::new();
while received.len()<data.len(){match tokio::time::timeout(TIMEOUT,events.recv()).await.unwrap().unwrap(){terminal::Event::Output{data,..}=>{assert!(data.len()<=16*1024);received.extend(data)},_=>panic!()}}
assert_eq!(received,data);t.resize(id,100,40).await.unwrap();assert!(t.kill(id).await.is_err());t.close(id).await.unwrap();server.await.unwrap();
}
#[tokio::test]
async fn file_host_roundtrip_multiblock_empty_mkdir_and_errors(){
let tmp=Temp::new();let(f,mut progress,server,pump)=host_files();
let remote=tmp.0.join("remote");f.mkdir(remote.to_str().unwrap()).await.unwrap();
let source=tmp.0.join("source");let data:Vec<u8>=(0..130_111).map(|i|(i%251)as u8).collect();std::fs::write(&source,&data).unwrap();
let dest=remote.join("uploaded");f.upload(&source,dest.to_str().unwrap()).await.unwrap();assert_eq!(std::fs::read(&dest).unwrap(),data);
let entries=f.list_dir(remote.to_str().unwrap()).await.unwrap();assert_eq!(entries.len(),1);assert_eq!(entries[0].size,data.len()as u64);
let downloaded=tmp.0.join("downloaded");f.download(dest.to_str().unwrap(),&downloaded).await.unwrap();assert_eq!(std::fs::read(downloaded).unwrap(),data);
let empty=tmp.0.join("empty");std::fs::write(&empty,[]).unwrap();f.upload(&empty,remote.join("empty").to_str().unwrap()).await.unwrap();
let copy=tmp.0.join("empty-copy");f.download(empty.to_str().unwrap(),&copy).await.unwrap();assert_eq!(std::fs::metadata(copy).unwrap().len(),0);
let folder_copy=tmp.0.join("folder-copy");f.download(remote.to_str().unwrap(),&folder_copy).await.unwrap();assert_eq!(std::fs::read(folder_copy.join("uploaded")).unwrap(),data);
assert!(f.list_dir(tmp.0.join("missing").to_str().unwrap()).await.unwrap_err().contains("9"));
assert!(f.download(tmp.0.join("missing").to_str().unwrap(),tmp.0.join("absent")).await.unwrap_err().contains("9"));
assert!(progress.try_recv().is_ok());server.abort();pump.abort();
}
#[test]
fn directory_expansion_and_invalid_compression(){
use std::io::Write;let mut z=flate2::write::ZlibEncoder::new(Vec::new(),flate2::Compression::fast());z.write_all(&nested(1,b"synthetic")).unwrap();let data=z.finish().unwrap();assert_eq!(files::inflate(&data).unwrap(),nested(1,b"synthetic"));assert!(files::inflate(b"invalid").is_err());
}
#[tokio::test]
async fn files_cancel_wakes_pending_request(){
let(io,rx,_input,mut out)=pair();let(f,_)=files::Files::new(io,rx);
let op=f.list_dir("synthetic");tokio::pin!(op);
tokio::select!{r=&mut op=>panic!("unexpected {r:?}"),_=out.recv()=>{}};
f.cancel();assert!(tokio::time::timeout(Duration::from_secs(1),op).await.unwrap().unwrap_err().contains("canceled"));
}
#[tokio::test]
async fn forwarding_mock_loopback_echo_fragmentation_remove_and_reject(){
let target=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();let port=target.local_addr().unwrap().port();
let echo=tokio::spawn(async move{let(mut s,_)=target.accept().await.unwrap();let mut b=vec![0;4096];loop{let n=s.read(&mut b).await.unwrap();if n==0{break}s.write_all(&b[..n]).await.unwrap();}});
let(io,rx,input,mut out)=pair();let p=portmap::PortMap::new(io,rx);
let host=tokio::spawn(async move{
let mut tcp:Option<tokio::net::TcpStream>=None;
while let Some((c,b))=out.recv().await{
assert_eq!(c,FILE);let f=blob(&b,27).unwrap();let(s,r,t)=(uint(f,1),uint(f,2),uint(f,3));
match uint(f,4){
0=>{let v:serde_json::Value=serde_json::from_slice(blob(f,5).unwrap()).unwrap();assert_eq!(v["version"],1);let target=v["target_port"].as_u64().unwrap()as u16;
let connected=if target==port {tokio::net::TcpStream::connect(("127.0.0.1",target)).await.ok()}else{None};let ok=connected.is_some();tcp=connected;
input.send((FILE,portmap::frame(s,r,t,3,if ok{br#"{"version":1,"ok":true}"#}else{br#"{"version":1,"ok":false}"#}))).await.unwrap();},
2=>{let payload=blob(f,5).unwrap();assert!(payload.len()<=16*1024);let socket=tcp.as_mut().unwrap();socket.write_all(payload).await.unwrap();let mut b=vec![0;payload.len()];socket.read_exact(&mut b).await.unwrap();input.send((FILE,portmap::frame(s,r,t,2,&b))).await.unwrap();},
1=>{tcp.take();},_=>panic!(),
}
}
});
let id=p.add_rule("echo",0,"127.0.0.1",port).await.unwrap();let local=p.status()[0].local_port;
let mut socket=tokio::net::TcpStream::connect(("127.0.0.1",local)).await.unwrap();let bytes=vec![91;100_000];socket.write_all(&bytes).await.unwrap();let mut received=vec![0;bytes.len()];tokio::time::timeout(TIMEOUT,socket.read_exact(&mut received)).await.unwrap().unwrap();assert_eq!(received,bytes);
p.remove_rule(id).await.unwrap();assert!(p.status().is_empty());assert!(tokio::net::TcpStream::connect(("127.0.0.1",local)).await.is_err());
let id=p.add_rule("reject",0,"127.0.0.1",1).await.unwrap();let mut socket=tokio::net::TcpStream::connect(("127.0.0.1",p.status()[0].local_port)).await.unwrap();assert_eq!(tokio::time::timeout(TIMEOUT,socket.read(&mut [0])).await.unwrap().unwrap(),0);
assert_eq!(p.status()[0].failures,1);p.remove_rule(id).await.unwrap();host.abort();echo.await.unwrap();
}
#[tokio::test]
async fn file_download_reorders_blocks_and_rejects_traversal(){
for (unsafe_name,one_based) in [(false,true),(false,false),(true,false)]{
let tmp=Temp::new();let(io,rx,input,mut out)=pair();let(f,_)=files::Files::new(io,rx);
let host=tokio::spawn(async move{
let(_,b)=out.recv().await.unwrap();let r=blob(&b,21).unwrap();let rid=uint(blob(r,1).unwrap(),1);let req=blob(blob(r,8).unwrap(),2).unwrap();let task=uint(blob(req,1).unwrap(),1);
let mut info=nested(1,if unsafe_name{b"../escape"}else{b"file"});wire::int(2,6,&mut info);
let mut response=nested(1,&ints(&[(1,task)]));wire::int(2,1,&mut response);wire::bytes(3,&info,&mut response);
input.send((FILE,rpc(rid,true,2,&response))).await.unwrap();
if unsafe_name{
// Let the client reject an ask, then close the host task normally.
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,6,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();
let(_,reply)=out.recv().await.unwrap();assert_eq!(uint(blob(blob(blob(&reply,22).unwrap(),4).unwrap(),3).unwrap(),3),7);
}else{
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,6,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();out.recv().await.unwrap();
// Official Windows host numbering starts at 1 (base fixed at completion); our host sends 0-based out of order.
let blocks:&[(u64,&[u8;2])]=if one_based {&[(1,b"ab"),(3,b"ef"),(2,b"cd")]} else {&[(2,b"ef"),(0,b"ab"),(1,b"cd")]};
for &(block,data) in blocks {let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,block,&mut b);wire::bytes(3,data,&mut b);input.send((FILE,rpc(901+block,false,4,&b))).await.unwrap();out.recv().await.unwrap();}
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,1,&mut b);input.send((FILE,rpc(903,false,9,&b))).await.unwrap();out.recv().await.unwrap();
}
let mut b=nested(1,&ints(&[(1,task),(2,u64::MAX)]));wire::int(2,1,&mut b);input.send((FILE,rpc(904,false,9,&b))).await.unwrap();
});
let target=tmp.0.join("received");let result=f.download("synthetic",&target).await;
if unsafe_name{assert!(result.unwrap_err().contains("Unsafe"));assert!(!tmp.0.join("escape").exists());assert!(!target.exists());}else{result.unwrap();assert_eq!(std::fs::read(target).unwrap(),b"abcdef");}
host.await.unwrap();
}
}
#[tokio::test]
async fn cancel_download_rejects_host_and_removes_staging(){
let tmp=Temp::new();let(io,rx,input,mut out)=pair();let(f,_)=files::Files::new(io,rx);let(asked,ready)=tokio::sync::oneshot::channel();
let host=tokio::spawn(async move{
let(_,b)=out.recv().await.unwrap();let r=blob(&b,21).unwrap();let rid=uint(blob(r,1).unwrap(),1);let req=blob(blob(r,8).unwrap(),2).unwrap();let task=uint(blob(req,1).unwrap(),1);
let mut info=nested(1,b"file");wire::int(2,10,&mut info);let mut b=nested(1,&ints(&[(1,task)]));wire::int(2,1,&mut b);wire::bytes(3,&info,&mut b);
input.send((FILE,rpc(rid,true,2,&b))).await.unwrap();let _=asked.send(());
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,10,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();
let(_,reply)=out.recv().await.unwrap();let code=uint(blob(blob(blob(&reply,22).unwrap(),4).unwrap(),3).unwrap(),3);
if code==1{
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,0,&mut b);wire::bytes(3,b"synthetic!",&mut b);input.send((FILE,rpc(901,false,4,&b))).await.unwrap();let(_,r)=out.recv().await.unwrap();assert_eq!(uint(blob(blob(blob(&r,22).unwrap(),4).unwrap(),4).unwrap(),3),7);
}else{assert_eq!(code,7);}
let mut b=nested(1,&ints(&[(1,task),(2,u64::MAX)]));wire::int(2,7,&mut b);input.send((FILE,rpc(902,false,9,&b))).await.unwrap();
});
let target=tmp.0.join("received");let op=f.download("synthetic",&target);tokio::pin!(op);
tokio::select!{r=&mut op=>panic!("unexpected {r:?}"),_=ready=>{}}f.cancel();
assert!(tokio::time::timeout(Duration::from_secs(4),op).await.unwrap().unwrap_err().contains("canceled"));host.await.unwrap();assert!(!target.exists());assert_eq!(std::fs::read_dir(&tmp.0).unwrap().count(),0);
}
#[tokio::test]
async fn forwarding_transport_close_stops_listener(){
let(io,rx,input,_out)=pair();let p=portmap::PortMap::new(io,rx);let id=p.add_rule("closed",0,"127.0.0.1",1).await.unwrap();let port=p.status()[0].local_port;
drop(input);tokio::time::timeout(Duration::from_secs(1),p.closed()).await.unwrap();
p.remove_rule(id).await.unwrap();assert!(tokio::net::TcpStream::connect(("127.0.0.1",port)).await.is_err());
assert!(p.add_rule("unavailable",0,"127.0.0.1",1).await.is_err());
}
#[test]
fn terminal_metadata_is_allowlisted_and_sorted(){
let rows=terminal::session_rows(&[
serde_json::json!({"session_id":9,"shell":"/bin/sh\tX\nY\0","state":"detached","created_at_ms":123,"output":"PRIVATE","name":"PRIVATE"}),
serde_json::json!({"session_id":2,"shell":"/bin/bash","state":"running"}),
serde_json::json!({"session_id":0}),serde_json::json!({"session_id":4294967296u64}),
]);
assert_eq!(rows,"2\t/bin/bash\t0\t运行中\n9\t/bin/sh X Y \t123\t已分离\n");
assert!(!rows.contains("PRIVATE"));assert!(terminal::session_rows(&[]).is_empty());
}
#[tokio::test]
async fn terminal_attach_uses_existing_id_and_rejects_absent_session(){
let(io,rx,input,mut out)=pair();let(t,_events)=terminal::Terminal::new(io,rx);
let host=tokio::spawn(async move{
for id in [37,99]{
let(c,b)=out.recv().await.unwrap();assert_eq!(c,BINARY);
let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::LIST_REQ);
input.send((BINARY,terminal::encode(terminal::LIST_RESP,f.session,br#"[{"session_id":37}]"#))).await.unwrap();
if id==37{
let(_,b)=out.recv().await.unwrap();let f=crate::terminal::decode(&b).unwrap();
assert_eq!(f.kind,terminal::OPEN);assert_eq!(f.session,37);
let v:serde_json::Value=serde_json::from_slice(&f.payload).unwrap();assert_eq!(v["cols"],90);assert_eq!(v["rows"],30);
input.send((BINARY,terminal::encode(terminal::OPEN_RESP,37,br#"{"code":0}"#))).await.unwrap();
}
}
assert!(out.try_recv().is_err());
});
assert_eq!(t.attach(37,90,30).await.unwrap(),37);
assert!(t.attach(99,90,30).await.is_err());assert!(t.attach(0,90,30).await.is_err());host.await.unwrap();
}
#[tokio::test]
async fn terminal_kill_acknowledgement_and_empty_refresh(){
let(io,rx,input,mut out)=pair();let(t,_events)=terminal::Terminal::new(io,rx);
let host=tokio::spawn(async move{
let(c,b)=out.recv().await.unwrap();assert_eq!(c,BINARY);
let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::KILL_REQ);assert_eq!(f.session,42);
input.send((BINARY,terminal::encode(terminal::KILL_RESP,42,br#"{"code":0}"#))).await.unwrap();
let(_,b)=out.recv().await.unwrap();let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::LIST_REQ);
input.send((BINARY,terminal::encode(terminal::LIST_RESP,f.session,b"[]"))).await.unwrap();
});
t.kill(42).await.unwrap();assert!(t.list_sessions().await.unwrap().is_empty());host.await.unwrap();
}
+240
View File
@@ -0,0 +1,240 @@
//! GTK windows for file transfer, port mapping and terminal sessions. Paths, names and
//! ports are shown only in the local window; logs keep to the existing id/field diagnostics.
use super::tools::{files::{Entry,Files},portmap::PortMap,Packet,Transport};
use std::ffi::{CStr,CString};
use std::os::raw::{c_char,c_int,c_ulonglong};
use std::sync::{Arc,Mutex,atomic::{AtomicU64,AtomicBool,Ordering}};
use std::time::{Duration,Instant};
use tokio::sync::mpsc;
extern "C" {
fn uu_tools_ui_start(kind:*const c_char,name:*const c_char)->c_int;
fn uu_tools_ui_take(out:*mut c_char,len:usize)->c_int;
fn uu_tools_ui_closed()->c_int;
fn uu_tools_ui_hide();
fn uu_tools_ui_present();
fn uu_tools_ui_toast(text:*const c_char);
fn uu_files_ui_set_remote(path:*const c_char,rows:*const c_char);
fn uu_files_ui_task(id:c_int,name:*const c_char,status:*const c_char,transferred:c_ulonglong,total:c_ulonglong,from:*const c_char,to:*const c_char,done:c_int);
fn uu_files_ui_refresh_local();
fn uu_terminal_ui_set(rows:*const c_char,connected:c_int);
fn uu_portmap_ui_set_rules(rows:*const c_char);
}
fn c(text:&str)->CString{CString::new(text.replace('\0',"")).unwrap_or_default()}
fn toast(text:&str){let t=c(text);unsafe{uu_tools_ui_toast(t.as_ptr())}}
fn take()->Option<String>{
let mut buf=vec![0 as c_char;4096];
(unsafe{uu_tools_ui_take(buf.as_mut_ptr(),buf.len())}!=0).then(||unsafe{CStr::from_ptr(buf.as_ptr())}.to_string_lossy().into_owned())
}
pub fn hide(){unsafe{uu_tools_ui_hide()}}
pub fn present(){unsafe{uu_tools_ui_present()}}
pub fn closed()->bool{(unsafe{uu_tools_ui_closed()})!=0}
fn start(kind:&str,name:&str)->Result<(),String>{
let(k,n)=(c(kind),c(name));
if unsafe{uu_tools_ui_start(k.as_ptr(),n.as_ptr())}!=0{return Err("Cannot open the window (GTK3 and a graphical session are required)".into())}Ok(())
}
/// Last path component for either separator; hosts may be Windows (`C:\x`) or Unix.
pub fn base_name(path:&str)->&str{path.trim_end_matches(['/','\\']).rsplit(['/','\\']).next().filter(|s|!s.is_empty()).unwrap_or(path)}
pub fn remote_join(dir:&str,name:&str)->String{
let sep=if dir.contains('\\') && !dir.contains('/'){'\\'}else{'/'};
if dir.ends_with(['/','\\']){format!("{dir}{name}")}else{format!("{dir}{sep}{name}")}
}
/// First free `name`, `name (1)`, ... in `dir` so a download never replaces a local file.
pub fn free_local(dir:&std::path::Path,name:&str)->std::path::PathBuf{
let(stem,ext)=match name.rfind('.'){Some(i) if i>0=>(&name[..i],&name[i..]),_=>(name,"")};
(0..).map(|n|dir.join(if n==0{name.to_owned()}else{format!("{stem} ({n}){ext}")})).find(|p|!p.exists()).unwrap()
}
pub fn entry_rows(entries:&[Entry])->String{
let clean=|s:&str|s.replace(['\t','\n','\r']," ");
entries.iter().map(|e|format!("{}\t{}\t{}\t{}\t{}\n",e.kind,clean(&e.name),e.size,e.modified,clean(&e.path))).collect()
}
enum Job {List(String),Mkdir(String,String),Transfer{id:i32,upload:bool,from:String,dir:String,generation:u64}}
struct Active {id:i32,name:String,from:String,to:String,last:Instant}
fn task(id:i32,name:&str,status:&str,done:u64,total:u64,from:&str,to:&str,state:i32){
let(n,s,f,t)=(c(name),c(status),c(from),c(to));
unsafe{uu_files_ui_task(id,n.as_ptr(),s.as_ptr(),done,total,f.as_ptr(),t.as_ptr(),state)}
}
fn reason(error:&str)->String{if error.contains("canceled"){"已取消".into()}else{format!("失败:{error}")}}
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
start("files",name)?;
let(f,mut progress)=Files::new(io,rx);let f=Arc::new(f);
let generation=Arc::new(AtomicU64::new(0));
let active:Arc<Mutex<Option<Active>>>=Arc::new(Mutex::new(None));
let shown=active.clone();
let reporter=tokio::spawn(async move{
while let Some(p)=progress.recv().await{
let mut guard=shown.lock().unwrap();let Some(a)=guard.as_mut() else{continue};
if a.last.elapsed()<Duration::from_millis(200) && p.transferred<p.total{continue}a.last=Instant::now();
let percent=if p.total>0{p.transferred*100/p.total}else{0};
task(a.id,&a.name,&format!("传输中 {percent}%"),p.transferred,p.total,&a.from,&a.to,0);
}
});
let _reporter=super::tools::Cancel(reporter.abort_handle());
let(jobs,mut queue)=mpsc::unbounded_channel::<Job>();
let closing=Arc::new(AtomicBool::new(false));let worker_closing=closing.clone();
let(worker_f,worker_gen,worker_active)=(f.clone(),generation.clone(),active.clone());
let mut worker=tokio::spawn(async move{
let mut remote=":/".to_owned();
while let Some(job)=queue.recv().await{if worker_closing.load(Ordering::Acquire){break}match job{
Job::List(path)=>match worker_f.list_dir(&path).await{
Ok(entries)=>{remote=path.clone();let(p,r)=(c(&path),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}
Err(e)=>toast(&format!("无法读取远端目录:{e}")),
},
Job::Mkdir(path,parent)=>match worker_f.mkdir(&path).await{
Ok(())=>if parent==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}},
Err(e)=>toast(&format!("无法创建远端文件夹:{e}")),
},
Job::Transfer{id,upload,from,dir,generation}=>{
let name=base_name(&from).to_owned();
let to=if upload{remote_join(&dir,&name)}else{free_local(std::path::Path::new(&dir),&name).to_string_lossy().into_owned()};
if generation!=worker_gen.load(Ordering::Acquire){task(id,&name,"已取消",0,0,&from,&to,2);continue}
*worker_active.lock().unwrap()=Some(Active{id,name:name.clone(),from:from.clone(),to:to.clone(),last:Instant::now()});
task(id,&name,"传输中",0,0,&from,&to,0);
let result=if upload{worker_f.upload(&from,&to).await}else{worker_f.download(&from,&to).await};
*worker_active.lock().unwrap()=None;
match result{
Ok(())=>{
let size=std::fs::metadata(if upload{&from}else{&to}).map(|m|if m.is_file(){m.len()}else{0}).unwrap_or(0);
task(id,&name,"已完成",size,size,&from,&to,1);
if upload{if dir==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}}}
else{unsafe{uu_files_ui_refresh_local()}}
}
Err(e)=>task(id,&name,&reason(&e),0,0,&from,&to,2),
}
}
}}
});
let _worker=super::tools::Cancel(worker.abort_handle());
let _=jobs.send(Job::List(":/".into()));
static NEXT_TASK:std::sync::atomic::AtomicI32=std::sync::atomic::AtomicI32::new(1);
let result=loop{
if closed(){break Ok(())}
if worker.is_finished(){break Err("File transfer worker stopped".into())}
while let Some(cmd)=take(){
let parts:Vec<&str>=cmd.split('\t').collect();
match parts.as_slice(){
["ls",path]=>{let _=jobs.send(Job::List((*path).into()));}
["mkdir",path]=>{let parent=path.rfind(['/','\\']).map(|i|path[..i.max(1)].to_owned()).unwrap_or_default();let _=jobs.send(Job::Mkdir((*path).into(),parent));}
[kind@("put"|"get"),from,dir]=>{
let(id,upload)=(NEXT_TASK.fetch_add(1,Ordering::Relaxed),*kind=="put");
let name=base_name(from);task(id,name,"等待中",0,0,from,dir,0);
let _=jobs.send(Job::Transfer{id,upload,from:(*from).into(),dir:(*dir).into(),generation:generation.load(Ordering::Acquire)});
}
["cancel"]=>{generation.fetch_add(1,Ordering::AcqRel);f.cancel();}
_=>{}
}
}
tokio::time::sleep(Duration::from_millis(100)).await;
};
closing.store(true,Ordering::Release);drop(jobs);f.cancel();
// Allow the existing transfer cancellation handshake to release the host's window.
if tokio::time::timeout(Duration::from_secs(5),&mut worker).await.is_err(){worker.abort();let _=worker.await;}
reporter.abort();let _=reporter.await;result
}
pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
start("portmap",name)?;
let p=PortMap::new(io,rx);
let mut targets:std::collections::HashMap<u64,String>=Default::default();
let mut last=String::from("-");
let closed_transport=p.closed();tokio::pin!(closed_transport);
let result=loop{
if closed(){break Ok(())}
while let Some(cmd)=take(){
let parts:Vec<&str>=cmd.split('\t').collect();
match parts.as_slice(){
["add",rule,local,host,port]=>match(local.parse::<u16>(),port.parse::<u16>()){
(Ok(local),Ok(port))=>match p.add_rule(*rule,local,*host,port).await{
Ok(id)=>{targets.insert(id,format!("{host}:{port}"));}
Err(e)=>toast(&format!("添加失败:{}",if e.contains("bind"){"本地端口已被占用".to_owned()}else{e})),
},
_=>toast("端口无效"),
},
["remove",id]=>if let Ok(id)=id.parse::<u64>(){
if let Err(e)=p.remove_rule(id).await{toast(&format!("删除失败:{e}"))}targets.remove(&id);
},
_=>{}
}
}
let mut status=p.status();status.sort_by_key(|s|s.id);
let rows:String=status.iter().map(|s|format!("{}\t{}\t127.0.0.1:{}\t{}\t{}\n",s.id,s.name.replace(['\t','\n']," "),s.local_port,
targets.get(&s.id).map(String::as_str).unwrap_or("-"),
if s.failures>0{format!("已启用 · {} 个连接 · {} 次失败",s.streams,s.failures)}else{format!("已启用 · {} 个连接",s.streams)})).collect();
if rows!=last{let r=c(&rows);unsafe{uu_portmap_ui_set_rules(r.as_ptr())};last=rows;}
tokio::select!{_=&mut closed_transport=>{toast("连接已断开");tokio::time::sleep(Duration::from_secs(3)).await;break Err("Forwarding transport closed".into())},_=tokio::time::sleep(Duration::from_millis(200))=>{}}
};
let ids:Vec<u64>=p.status().iter().map(|s|s.id).collect();for id in ids{let _=p.remove_rule(id).await;}
result
}
// The worker serializes LIST/KILL requests; GTK commands remain responsive during network waits.
pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&str)->Result<(),String>{
use super::tools::terminal::{Terminal,session_rows,local_terminal_command};
let exe=std::env::current_exe().map_err(|_|"Cannot locate executable")?;
start("terminal",name)?;
let(t,mut events)=Terminal::new(io,rx);let t=Arc::new(t);
let server=super::tools::terminal_ipc::Server::new()?;let path=server.path.clone();
let(output,_)=tokio::sync::broadcast::channel(256);
let ipc=super::tools::Abort(tokio::spawn(server.run(t.clone(),output.clone())));
let relay=super::tools::Abort(tokio::spawn(async move{while let Some(e)=events.recv().await{let _=output.send(e);}}));
let(jobs,mut queue)=mpsc::unbounded_channel::<u32>();
let worker=tokio::spawn(async move{
let operation=async{
t.check_env().await?;
let mut refresh=tokio::time::interval(Duration::from_secs(2));
refresh.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop{tokio::select!{
_=refresh.tick()=>{
let rows=c(&session_rows(&t.list_sessions().await?));
unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}
},
id=queue.recv()=>match id{
Some(id)=>{if t.kill(id).await.is_err(){toast("结束会话失败,会话可能已退出")}
let rows=c(&session_rows(&t.list_sessions().await?));unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}},
None=>return Ok::<(),String>(()),
},
_=tokio::time::sleep(Duration::from_millis(100)),if relay.0.is_finished()=>return Err("Terminal channel closed".into()),
}}
}.await;
if operation.is_err(){unsafe{uu_terminal_ui_set(c("").as_ptr(),0)};toast("终端连接已断开,请关闭窗口后重试")}
});
let _worker=super::tools::Cancel(worker.abort_handle());
let mut children:Vec<std::process::Child>=Vec::new();
while !closed(){
if worker.is_finished(){ipc.0.abort();}
children.retain_mut(|child|matches!(child.try_wait(),Ok(None)));
while let Some(cmd)=take(){
if worker.is_finished(){toast("连接已断开");continue}
let parts:Vec<_>=cmd.split('\t').collect();
let session=match parts.as_slice(){
["create"]=>None,
["open",id]=>match id.parse::<u32>().ok().filter(|n|*n!=0){Some(id)=>Some(id),None=>continue},
["kill",id]=>{if let Ok(id)=id.parse::<u32>(){let _=jobs.send(id);}continue},
_=>continue,
};
match local_terminal_command(&exe,&path,session){
Some(mut command)=>match command.spawn(){Ok(child)=>children.push(child),Err(_)=>toast("无法启动本机终端程序")},
None=>toast("没有找到本机终端程序(可设置 TERMINAL 环境变量)"),
}
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
worker.abort();let _=worker.await;
drop(ipc);
// Closing the list drops all local IPC clients; reap emulator launchers off-thread.
std::thread::spawn(move||{for mut child in children{let _=child.wait();}});
Ok(())
}
#[cfg(test)] mod tests {
use super::*;
#[test] fn path_helpers_handle_both_separators() {
assert_eq!(base_name("/home/u/a.txt"),"a.txt");assert_eq!(base_name("C:\\Users\\x\\"),"x");assert_eq!(base_name("/"),"/");
assert_eq!(remote_join("/home/u","a"),"/home/u/a");assert_eq!(remote_join("/","a"),"/a");assert_eq!(remote_join("C:\\Users","a"),"C:\\Users\\a");
let dir=std::env::temp_dir().join(format!("uu-free-{}",super::super::wire::uuid()));std::fs::create_dir(&dir).unwrap();
std::fs::write(dir.join("a.txt"),b"").unwrap();
assert_eq!(free_local(&dir,"a.txt"),dir.join("a (1).txt"));assert_eq!(free_local(&dir,"b"),dir.join("b"));
std::fs::remove_file(dir.join("a.txt")).unwrap();std::fs::remove_dir(&dir).unwrap();
}
}
+226
View File
@@ -0,0 +1,226 @@
//! Launcher window (`uuremote-viewer ui`): QR sign-in, device list, and one child process per
//! remote session so each SDL window is isolated. Account data never reaches the logs.
use serde_json::Value;
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int};
use std::time::{Duration, Instant, SystemTime};
extern "C" {
fn uu_viewer_ui_start() -> c_int;
fn uu_viewer_ui_set_devices(tsv: *const c_char);
fn uu_viewer_ui_set_login(signed_in: c_int, qr_png: *const c_char, status: *const c_char, user: *const c_char);
fn uu_viewer_ui_take_command(out: *mut c_char, len: usize) -> c_int;
fn uu_viewer_ui_closed() -> c_int;
fn uu_viewer_ui_confirm_replace() -> c_int;
fn uu_viewer_ui_toast(text: *const c_char);
}
fn toast(text: &str) { let t = c(text); unsafe { uu_viewer_ui_toast(t.as_ptr()) } }
/// Runs one session child; on failure shows its last error line (log lines start with '[').
fn watch_session(mut child: tokio::process::Child, mut cancel: tokio::sync::oneshot::Receiver<()>, success: Option<&'static str>) -> tokio::task::JoinHandle<()> {
use tokio::io::AsyncBufReadExt;
let stderr = child.stderr.take();
tokio::spawn(async move {
let mut last = String::new();
let mut lines = stderr.map(|e| tokio::io::BufReader::new(e).lines());
let status = loop {
tokio::select! {
_ = &mut cancel => {
if let Some(id)=child.id(){unsafe{libc::kill(id as i32,libc::SIGTERM);}}
if tokio::time::timeout(Duration::from_secs(6),child.wait()).await.is_err(){let _=child.kill().await;}return;
}
status = child.wait() => break status,
line = async { match lines.as_mut() { Some(l) => l.next_line().await, None => std::future::pending().await } } => match line {
Ok(Some(l)) => { if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); } }
_ => lines = None,
},
}
};
// wait() may win before the final stderr line is read.
let _ = tokio::time::timeout(Duration::from_millis(200), async {
if let Some(lines) = lines.as_mut() {
while let Ok(Some(l)) = lines.next_line().await {
if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); }
}
}
}).await;
if !status.is_ok_and(|s| s.success()) {
let reason = match last.as_str() {
"" => "连接已断开".to_owned(),
"CONTROL echo timed out" => "连接超时:被控端没有响应(官方主机互通尚未完成)".to_owned(),
"Remote session released" => "被控端结束了本次连接".to_owned(),
other => other.to_owned(),
};
toast(&format!("连接失败:{reason}"));
} else if let Some(message) = success { toast(message); }
})
}
struct Running { cancel:tokio::sync::oneshot::Sender<()>, task:tokio::task::JoinHandle<()>, input:Option<tokio::process::ChildStdin> }
impl Running { async fn stop(self){let _=self.cancel.send(());let _=self.task.await;} }
async fn replace(sessions:&mut std::collections::HashMap<String,Running>,id:&str)->bool{
if sessions.get(id).is_some_and(|s|!s.task.is_finished()) && unsafe{uu_viewer_ui_confirm_replace()}!=1{return false}
if let Some(old)=sessions.remove(id){old.stop().await;}true
}
fn c(text: &str) -> CString { CString::new(text.replace('\0', "")).unwrap_or_default() }
fn set_login(signed_in: bool, qr: &str, status: &str, user: &str) {
let (q, s, u) = (c(qr), c(status), c(user));
unsafe { uu_viewer_ui_set_login(signed_in as c_int, q.as_ptr(), s.as_ptr(), u.as_ptr()) }
}
fn take() -> Option<String> {
let mut buf = [0 as c_char; 200];
(unsafe { uu_viewer_ui_take_command(buf.as_mut_ptr(), buf.len()) } != 0)
.then(|| unsafe { CStr::from_ptr(buf.as_ptr()) }.to_string_lossy().into_owned())
}
/// "id\tname\tplatform\tonline\tcurrent" lines; tabs and newlines in names are flattened.
pub fn device_rows(devices: &[Value], current: Option<&str>) -> String {
let clean = |s: &str| s.replace(['\t', '\n', '\r'], " ");
devices.iter().filter_map(|d| {
let id = d.get("device_id")?.as_str()?;
let name = d.get("alias").and_then(Value::as_str).unwrap_or(id);
let platform = d.get("platform").and_then(Value::as_i64).unwrap_or(0);
let online = d.get("status").and_then(Value::as_str) == Some("CONNECTED");
Some(format!("{}\t{}\t{}\t{}\t{}\n", clean(id), clean(name), platform, online as u8, (current == Some(id)) as u8))
}).collect()
}
pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, String>) -> Result<(), String> {
if unsafe { uu_viewer_ui_start() } != 0 { return Err("Cannot open the window (GTK3 and a graphical session are required)".into()); }
let exe = std::env::current_exe().map_err(|_| "Cannot locate executable")?;
let qr = std::env::temp_dir().join(format!("uu-viewer-qr-{}.png", std::process::id()));
let mut login: Option<tokio::process::Child> = None;
let mut qr_seen: Option<SystemTime> = None;
let mut next_refresh = Instant::now();
let mut sessions:std::collections::HashMap<String,Running>=Default::default();
let mut names: std::collections::HashMap<String, String> = Default::default();
let refresh = |creds: &crate::auth::Credentials| {
let api = super::api::Api::new(crate::auth::UUAuthClient::new(creds.clone()), crate::auth::BASE_URL);
async move { api.device_list().await }
};
loop {
if unsafe { uu_viewer_ui_closed() } != 0 { break; }
sessions.retain(|_,s| !s.task.is_finished());
if let Some(child) = login.as_mut() {
if let Ok(meta) = std::fs::metadata(&qr) {
if meta.modified().ok() != qr_seen { qr_seen = meta.modified().ok(); set_login(false, &qr.to_string_lossy(), "请用手机扫码并确认", ""); }
}
if let Ok(Some(_)) = child.try_wait() { login = None; let _ = std::fs::remove_file(&qr); next_refresh = Instant::now(); }
} else if Instant::now() >= next_refresh {
next_refresh = Instant::now() + Duration::from_secs(30);
match credentials() {
Ok(creds) => {
set_login(true, "", "", "已登录");
match refresh(&creds).await {
Ok(data) => {
let list = data.get("my_binded_devices").and_then(Value::as_array).cloned().unwrap_or_default();
let current = data.pointer("/current_device/device_id").and_then(Value::as_str);
names = list.iter().filter_map(|d| Some((d.get("device_id")?.as_str()?.to_owned(),
d.get("alias").and_then(Value::as_str).unwrap_or("远端设备").to_owned()))).collect();
let rows = c(&device_rows(&list, current)); unsafe { uu_viewer_ui_set_devices(rows.as_ptr()) }
}
Err(super::api::Error::AuthenticationExpired) => set_login(false, "", "登录已过期,请重新登录", ""),
Err(_) => {}
}
}
Err(_) => set_login(false, "", "尚未登录", ""),
}
}
while let Some(cmd) = take() {
let parts: Vec<&str> = cmd.split('\t').collect();
match parts.as_slice() {
["quit"] => break,
["refresh"] => next_refresh = Instant::now(),
["logout"] => {
// Sign out locally: drop the account token, keep the device identity.
let path = crate::config::path();
if let Ok(mut v) = std::fs::read_to_string(&path).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()).ok_or(()) {
if let Some(o) = v.as_object_mut() { o.remove("token"); o.remove("csrf"); }
let _ = std::fs::write(&path, v.to_string());
}
for (_,s) in sessions.drain() { s.stop().await; }
unsafe { uu_viewer_ui_set_devices(c("").as_ptr()) }
set_login(false, "", "已退出登录", "");
next_refresh = Instant::now() + Duration::from_secs(3600);
}
["login"] if login.is_none() => {
let server = exe.with_file_name("uuremote-server");
login = tokio::process::Command::new(server).args(["login", "--no-gui"])
.env("UU_LOGIN_QR_PNG", &qr).stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null())
.kill_on_drop(true).spawn().ok();
if login.is_none() { set_login(false, "", "找不到配套的 uuremote-server", ""); }
}
["connect", id, kind] if matches!(*kind, "desktop" | "watch") => {
if !replace(&mut sessions,id).await{continue}
// One process per session; "-" selects the built-in desktop connection shape.
let mut command=tokio::process::Command::new(&exe);
command.args(["connect", id, "false", "-", "echo", "legacy"]);
command.env("UU_VIEWER_DEVICE_NAME", super::device_label(names.get(*id).map(String::as_str)));
if *kind=="watch" {command.arg("--view-only");}
match command.env("UU_VIEWER_COMMANDS","1").stdin(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
Ok(mut child) => { let input=child.stdin.take();let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input}); }
Err(_) => toast("连接失败:无法启动会话进程"),
}
}
["assist", id, code] => {
match super::assist::command(&exe, id).spawn() {
Ok(mut child) => match super::assist::send_code(&mut child, code).await {
Ok(()) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert(format!("assist:{id}"),Running{cancel,task,input:None}); }
Err(reason) => toast(&format!("连接失败:{reason}")),
},
Err(_) => toast("连接失败:无法启动协助会话进程"),
}
}
["connect", id, kind @ ("file" | "portmap" | "terminal")] => {
if *kind=="file" {if let Some(s)=sessions.get_mut(*id){if let Some(input)=s.input.as_mut(){
use tokio::io::AsyncWriteExt;
if input.write_all(b"files\n").await.is_err(){toast("桌面会话命令发送失败,请重试")}continue
}}}
if !replace(&mut sessions,id).await{continue}
let name = names.get(*id).cloned().unwrap_or_else(|| "远端设备".into());
let tool = if *kind == "file" { "files-ui" } else if *kind == "terminal" { "terminal-ui" } else { "portmap-ui" };
match tokio::process::Command::new(&exe).args([tool, id, &name])
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input:None}); }
Err(_) => toast("连接失败:无法启动工具进程"),
}
}
["connect", id, kind @ ("reboot" | "shutdown")] => {
if !replace(&mut sessions,id).await{continue}
match tokio::process::Command::new(&exe).args(["power", id, kind])
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,Some("电源指令已发送,未确认远端执行结果"));sessions.insert((*id).into(),Running{cancel,task,input:None}); }
Err(_) => toast("电源指令失败:无法启动会话进程"),
}
}
["connect", id, "unbind"] => {
if let Some(s)=sessions.remove(*id){s.stop().await;}
let result=match credentials(){
Ok(creds)=>super::api::Api::new(crate::auth::UUAuthClient::new(creds),crate::auth::BASE_URL).unbind(id,false).await.map_err(|e|e.to_string()),
Err(e)=>Err(e),
};
match result {Ok(())=>toast("设备已从账号删除"),Err(e)=>toast(&format!("删除设备失败:{e}"))}
next_refresh=Instant::now();
}
["connect", _, kind] => log::info!("Viewer UI: {kind} is not supported yet"),
_ => {}
}
}
tokio::time::sleep(Duration::from_millis(200)).await;
}
for (_,s) in sessions {s.stop().await;}
Ok(())
}
#[cfg(test)] mod tests {
#[test] fn device_rows_flatten_names_and_mark_online() {
let rows = super::device_rows(&[
serde_json::json!({"device_id":"d1","alias":"a\tb","platform":4,"status":"CONNECTED"}),
serde_json::json!({"device_id":"d2","platform":1,"status":"DISCONNECTED"}),
serde_json::json!({"alias":"no id"}),
], Some("d2"));
assert_eq!(rows, "d1\ta b\t4\t1\t0\nd2\td2\t1\t0\t1\n");
}
}
+250
View File
@@ -0,0 +1,250 @@
//! Shapes from viewer-connect-shape-20261016.md; values describe caller capabilities.
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use crate::protocol::{decode_wire, WireValue};
pub const CHANNELS: [&str; 5] = ["CONTROL_DATA_CHANNEL", "TEXT_DATA_CHANNEL", "STREAMER_DATA_CHANNEL", "FILE_DATA_CHANNEL", "BINARY_DATA_CHANNEL"];
pub fn uuid() -> String {
let mut b: [u8;16] = rand::random(); b[6] = (b[6] & 15) | 64; b[8] = (b[8] & 63) | 128;
let s = hex::encode(b);
format!("{}-{}-{}-{}-{}", &s[..8], &s[8..12], &s[12..16], &s[16..20], &s[20..])
}
pub fn varint(mut n: u64, out: &mut Vec<u8>) { while n >= 128 { out.push(n as u8 | 128); n >>= 7; } out.push(n as u8); }
pub fn int(field: u32, value: u64, out: &mut Vec<u8>) { varint(u64::from(field) << 3,out); varint(value,out); }
pub fn bytes(field: u32, value: &[u8], out: &mut Vec<u8>) { varint((u64::from(field)<<3)|2,out); varint(value.len() as u64,out); out.extend(value); }
pub fn envelope(seq:u64, kind:u32, payload:&[u8]) -> Vec<u8> {
let mut out=Vec::new(); int(1,seq,&mut out); bytes(kind,payload,&mut out); out
}
#[derive(Clone, Deserialize)]
pub struct Decoder { pub fps:u32, pub codec:u32, pub width:u32, pub height:u32, pub chroma:u32 }
#[derive(Clone, Deserialize, Serialize)]
pub struct Display { pub id:u32, pub fps:u32, pub r#type:u32, pub hdr:u32 }
#[derive(Clone, Deserialize, Serialize)]
pub struct Codec { pub video_codec:u32, pub chroma_sampling:u32, pub codec_impl:u32, pub bit_depth:u32, pub width:u32, pub height:u32 }
#[derive(Clone, Deserialize)]
pub struct Shape {
pub capture_type:u32,
pub platform:u32,
pub client_version:String,
pub width:u32,
pub height:u32,
pub fps:u32,
pub chroma:u32,
pub decoders:Vec<Decoder>,
pub display_modes:Vec<[u32;3]>,
pub displays:Vec<Display>,
pub codecs:Vec<Codec>,
/// FeatureFlag {field: version} pairs (ConnectOptions 11). Empty by default; official hosts may
/// require it (live: official Mac/Windows hosts did not answer an empty flag set).
#[serde(default)]
pub feature_flag:Vec<[u32;2]>,
}
impl Shape {
pub fn validate(&self) -> Result<(),String> {
if ![1,5,8,9].contains(&self.capture_type) || ![3,4].contains(&self.platform)
|| self.width==0 || self.height==0 || self.fps==0 || ![1,3].contains(&self.chroma) {
return Err("Invalid explicit viewer shape".into());
}
if self.decoders.iter().any(|d| ![1,2].contains(&d.codec) || ![1,3].contains(&d.chroma) || d.width==0 || d.height==0 || d.fps==0) {
return Err("Invalid decoder capability".into());
}
Ok(())
}
pub fn validate_session(&self)->Result<(),String> {
self.validate()?;
if self.codecs.iter().any(|c|![1,2].contains(&c.video_codec) || ![1,3].contains(&c.chroma_sampling))
|| (self.capture_type==1 && self.decoders.is_empty()) {
return Err("Sessions require supported decoder and codec capabilities".into());
}
Ok(())
}
/// Advertise software decoding of both 8-bit chroma formats. Keep caller size/fps limits.
/// The explicit chroma request is sent on CONTROL, so initial capture stays 4:2:0.
pub fn video_preferences(&self,h264_only:bool)->Self {
let mut shape=self.clone();
if shape.capture_type==1 {
shape.chroma=1;
shape.decoders.clear();
for codec in if h264_only {&[1][..]}else{&[2,1][..]} {
let base=self.decoders.iter().find(|d|d.codec==*codec).or_else(||self.decoders.first());
if let Some(base)=base {for chroma in [1,3] {
let mut d=base.clone();d.codec=*codec;d.chroma=chroma;shape.decoders.push(d);
}}
}
}
if h264_only {shape.decoders.retain(|d|d.codec==1);shape.codecs.retain(|c|c.video_codec==1);}
shape
}
pub fn connect_options(&self, device:&str, clipboard:bool) -> Result<Vec<u8>,String> {
self.validate()?;
let mut out=Vec::new(); int(1,self.capture_type.into(),&mut out);
if [1,8].contains(&self.capture_type) { int(2,u64::MAX,&mut out); }
if [1,5].contains(&self.capture_type) {
let mut params=Vec::new(); int(1,2,&mut params); int(2,4,&mut params); int(4,2,&mut params);
let mut size=Vec::new(); int(1,self.width.into(),&mut size); int(2,self.height.into(),&mut size);
bytes(5,&size,&mut params); bytes(6,&[],&mut params);
if self.capture_type==1 { int(7,self.chroma.into(),&mut params); int(9,1,&mut params); int(11,self.fps.into(),&mut params); }
bytes(3,&params,&mut out);
for d in &self.decoders {
let mut cap=Vec::new();
for (f,v) in [(1,d.fps),(2,d.codec),(3,d.width),(4,d.height)] { int(f,v.into(),&mut cap); }
if self.capture_type==1 { int(5,d.chroma.into(),&mut cap); }
bytes(4,&cap,&mut out);
}
for mode in &self.display_modes {
let mut value=Vec::new(); for (f,v) in mode.iter().enumerate() { int(f as u32+1,(*v).into(),&mut value); }
bytes(6,&value,&mut out);
}
bytes(7,&size,&mut out);
}
int(8,self.platform.into(),&mut out); bytes(9,device.as_bytes(),&mut out); int(10,1,&mut out);
if self.capture_type==1 {
let mut flags=Vec::new(); for [field,version] in &self.feature_flag { if *field!=8 {int((*field).into(),(*version).into(),&mut flags);} }
if clipboard{int(8,3,&mut flags);}
bytes(11,&flags,&mut out);
}
if self.capture_type!=5 { bytes(12,self.client_version.as_bytes(),&mut out); }
Ok(out)
}
pub fn control(&self, client:&str, id:&str, ice:&str) -> Result<Value,String> {
self.validate()?;
let streamer=json!({"control_id":id,"device_capability":{"display_info":self.displays,"ice_id":"","video_codec_capability":self.codecs}});
// Official Control::SerializeSioMsg (libstreamer 0x107bf8) sends only these three keys. A
// viewer-chosen ice_id reaches the host via be-controlled while the ack assigns another, and the
// official host drops the offer ("drop the soac event ... not in current ice connections").
let _=(client,ice);
Ok(json!({"app_control_id":id,"app_data":{"_placeholder":true,"num":0},"streamer_data":streamer.to_string()}))
}
}
/// Existing viewer FeatureFlag pairs; clipboard uses the host text protocol version (3).
/// Session encoders omit clipboard when its local backend is disabled or unavailable.
pub const VIEWER_FEATURES:[[u32;2];8]=[[1,6],[2,2],[3,1],[4,2],[6,2],[7,2],[8,3],[9,1]];
pub fn feature_flag(flags:&[[u32;2]]) -> Vec<u8> { let mut out=Vec::new(); for [f,v] in flags { int(*f,(*v).into(),&mut out); } out }
pub fn echo_request(seq:u64) -> Vec<u8> {echo_request_with_clipboard(seq,false)}
fn session_features(clipboard:bool)->Vec<u8>{
let mut flags:Vec<_>=VIEWER_FEATURES.iter().copied().filter(|p|p[0]!=8).collect();
if clipboard{flags.push([8,3]);}feature_flag(&flags)
}
pub fn echo_request_with_clipboard(seq:u64,clipboard:bool)->Vec<u8>{
let mut action=Vec::new();int(1,0,&mut action);bytes(4,&session_features(clipboard),&mut action);envelope(seq,3,&action)
}
pub fn echo_clipboard_supported(data:&[u8])->bool{
let Ok(fields)=decode_wire(data) else{return false};
fields.iter().any(|f|match (f.number,&f.value){
(3,WireValue::Bytes(action))=>decode_wire(action).is_ok_and(|fields|fields.iter().any(|f|match (f.number,&f.value){
(4,WireValue::Bytes(flags))=>decode_wire(flags).is_ok_and(|flags|flags.iter().any(|f|matches!((f.number,&f.value),(8,WireValue::Varint(3..))))),_=>false,
})),_=>false,
})
}
/// Official hosts also send an echo request (SimpleAction action 0) and repeat it until answered.
/// Returns the request's Message seq when `data` is such a request.
pub fn echo_request_seq(data:&[u8]) -> Option<u64> {
let fields=decode_wire(data).ok()?;
let seq=fields.iter().find_map(|f|match (f.number,&f.value){(1,WireValue::Varint(v))=>Some(*v),_=>None})?;
fields.iter().find_map(|f|match (f.number,&f.value) {
// proto3 omits the default action 0, so a SimpleAction without field 1 is an echo request too.
(3,WireValue::Bytes(action))=>decode_wire(action).ok()?.iter().find_map(|f|match (f.number,&f.value){(1,WireValue::Varint(v))=>Some(*v),_=>None}).unwrap_or(0).eq(&0).then_some(seq),
_=>None,
})
}
/// Answer like the host side does: action 1, args {"seq": request seq}, our FeatureFlag.
pub fn echo_response(seq:u64,request_seq:u64)->Vec<u8>{echo_response_with_clipboard(seq,request_seq,false)}
pub fn echo_response_with_clipboard(seq:u64, request_seq:u64,clipboard:bool) -> Vec<u8> {
let mut action=Vec::new(); int(1,1,&mut action);
bytes(2,format!("{{\"seq\":{request_seq}}}").as_bytes(),&mut action);
bytes(4,&session_features(clipboard),&mut action); envelope(seq,3,&action)
}
pub fn echo_matches(data:&[u8], seq:u64) -> bool {
let Ok(fields)=decode_wire(data) else {return false};
fields.iter().any(|f| match (f.number,&f.value) {
(3,WireValue::Bytes(action))=> {
let Ok(fields)=decode_wire(action) else {return false};
let response=fields.iter().any(|f|f.number==1 && f.value==WireValue::Varint(1));
response && fields.iter().any(|f|match (f.number,&f.value) {
(2,WireValue::Bytes(args))=>serde_json::from_slice::<Value>(args).ok().and_then(|v|v.get("seq").and_then(Value::as_u64))==Some(seq), _=>false,
})
}, _=>false,
})
}
#[cfg(test)]
mod tests {
use super::*;
pub fn shape()->Shape { serde_json::from_str(include_str!("../../tests/fixtures/viewer/shape.json")).unwrap() }
#[test]
fn session_shape_uses_observed_field_presence_and_nested_values() {
let mut s=shape();
for capture in [1,5,8,9] {
s.capture_type=capture;
let b=s.connect_options("synthetic-device",false).unwrap(); let f=decode_wire(&b).unwrap();
let numbers:Vec<u32>=f.iter().map(|f|f.number).collect();
let expected=match capture {1=>vec![1,2,3,4,4,4,4,6,6,7,8,9,10,11,12],5=>vec![1,3,4,4,4,4,6,6,7,8,9,10],8=>vec![1,2,8,9,10,12],_=>vec![1,8,9,10,12]};
assert_eq!(numbers,expected);
for f in f.iter().filter(|f|f.number==4) {
let WireValue::Bytes(b)=f.value else {panic!()}; let cap=decode_wire(b).unwrap();
assert_eq!(cap.len(),if capture==1 {5}else{4});
}
if [1,8].contains(&capture) { assert!(f.iter().any(|f| f.number==2 && f.value==WireValue::Varint(u64::MAX))); }
}
}
#[test]
fn streamer_identity_and_echo_correlation_are_separate_from_socket_ack() {
let s=shape();let id=uuid(); let v=s.control("synthetic-client",&id,"synthetic-ice").unwrap();
let streamer:Value=serde_json::from_str(v["streamer_data"].as_str().unwrap()).unwrap();
assert_eq!(streamer["control_id"],v["app_control_id"]); assert_eq!(id.len(),36); assert_ne!(id,uuid()); assert_eq!(&id[14..15],"4");
let mut action=Vec::new();int(1,1,&mut action);bytes(2,br#"{"seq":7}"#,&mut action);
let reply=envelope(99,3,&action); assert!(echo_matches(&reply,7)); assert!(!echo_matches(&reply,99));
assert!(!echo_matches(&echo_request(7),7)); assert!(!echo_matches(&[255],7));
}
}
/// CaptureSettingRequest field 7 = ChromaFormat 3, wrapped in RPC 21/case 2.
pub fn request_chroma444()->Vec<u8>{
let mut header=Vec::new();int(1,2_000_000,&mut header);
let mut setting=Vec::new();int(7,3,&mut setting);
let mut rpc=Vec::new();bytes(1,&header,&mut rpc);bytes(2,&setting,&mut rpc);
envelope(2_000_000,21,&rpc)
}
/// Message 18 is an encoder capability LIST, not the chosen codec; RTP's negotiated PT is authoritative.
/// Message 25 reports actual encoded chroma, which may fall back to 4:2:0.
pub fn media_control(data:&[u8])->(Option<u32>,Option<u32>){
let mut codecs=None;let mut chroma=None;
if let Ok(fields)=decode_wire(data){for field in fields {
if let WireValue::Bytes(body)=field.value {match field.number {
18=>{if let Ok(caps)=decode_wire(body){let mut mask=0;for cap in caps {if let (1,WireValue::Bytes(cap))=(cap.number,cap.value){
match super::tools::uint(cap,3){1=>mask|=1,2=>mask|=2,_=>{}}
}}codecs=Some(mask);}},
25=>{let value=super::tools::uint(body,3);if [1,3].contains(&value){chroma=Some(value as u32);}},
_=>{},
}}
}}(codecs,chroma)
}
#[cfg(test)] mod video_tests {
use super::*;
#[test] fn decoder_caps_cover_both_codecs_and_chroma_and_force_h264(){
let original:Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap();
for force in [false,true] {
let s=original.video_preferences(force);s.validate_session().unwrap();assert_eq!(s.chroma,1);
let options=s.connect_options("synthetic-device",false).unwrap();
let mut caps=Vec::new();
for f in decode_wire(&options).unwrap(){if let (4,WireValue::Bytes(cap))=(f.number,f.value){
assert_eq!(super::super::tools::uint(cap,1),30);
assert_eq!(super::super::tools::uint(cap,3),1280);assert_eq!(super::super::tools::uint(cap,4),720);
caps.push((super::super::tools::uint(cap,2),super::super::tools::uint(cap,5)));
}}
assert_eq!(caps,if force{vec![(1,1),(1,3)]}else{vec![(2,1),(2,3),(1,1),(1,3)]});
assert!(s.video_preferences(force).connect_options("synthetic-device",false).unwrap()==options);
}
}
#[test] fn chroma_request_and_actual_sync_are_independent_of_encoder_list(){
let request=request_chroma444();let rpc=super::super::tools::blob(&request,21).unwrap();
let setting=super::super::tools::blob(rpc,2).unwrap();assert_eq!(super::super::tools::uint(setting,7),3);
assert_eq!(decode_wire(setting).unwrap().len(),1);
let mut caps=Vec::new();for codec in [1,2] {let mut cap=Vec::new();int(3,codec,&mut cap);bytes(1,&cap,&mut caps);}
let mut msg=envelope(1,18,&caps);let mut sync=Vec::new();int(3,1,&mut sync);bytes(25,&sync,&mut msg);
assert_eq!(media_control(&msg),(Some(3),Some(1)));
assert_eq!(media_control(&envelope(2,25,&[24,3])),(None,Some(3)));
assert_eq!(media_control(&[255]),(None,None));
}
}
+193
View File
@@ -0,0 +1,193 @@
//! Experimental controller session, built only with --features native-viewer.
#![allow(dead_code)]
#[path = "auth.rs"] mod auth;
#[path = "config.rs"] mod config;
#[path = "protocol.rs"] mod protocol;
mod viewer;
#[cfg(test)] #[path="hevc.rs"] mod hevc;
use viewer::clipboard;
#[path="clipboard_protocol.rs"] mod clipboard_protocol;
#[path="clipboard_rich.rs"] mod clipboard_rich;
#[cfg(test)] #[path="terminal.rs"] mod terminal;
#[cfg(test)] #[path="file_trans.rs"] mod file_trans;
#[cfg(test)] #[path="initialization.rs"] mod initialization;
use viewer::{api::Api,rtc::ReadyPolicy,session::{Options,Session},wire::Shape};
use std::time::Duration;
const HELP:&str="Experimental native viewer.\n uuremote-viewer ui (GTK window: sign-in, devices, sessions) Desktop UI requires viewer-sdl (decodes with the ffmpeg CLI, or FFmpeg 6.x libraries with viewer-ffmpeg).\n uuremote-viewer power DEVICE reboot|shutdown\n uuremote-viewer unbind DEVICE [--shared] (从账号删除设备 / remove a device from the account)\n uuremote-viewer terminal DEVICE [SESSION]\n uuremote-viewer files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE\n uuremote-viewer portmap DEVICE LOCAL_PORT HOST PORT\n uuremote-viewer files-ui|portmap-ui|terminal-ui DEVICE NAME (GTK tool windows)\n uuremote-viewer login [--no-gui]\n uuremote-viewer devices METHOD ARRAY_POINTER ID_POINTER NAME_POINTER\n uuremote-viewer assist CONNECT_ID (验证码从 stdin 读取一行)\n uuremote-viewer connect DEVICE true|false SHAPE_JSON echo|manual raw|legacy [--view-only]\nVideo: UU_VIEWER_CODEC=h264 forces H.264; UU_VIEWER_CHROMA=444 requests true color (default 4:2:0).\nAudio: UU_VIEWER_AUDIO=0 disables playback. UU_VIEWER_VIEW_ONLY=1 disables desktop input.\nDevice-list method/JSON pointers and compatibility shape require verified operator configuration.\nQR login reuses the sibling uuremote-server login command. Never run login in a captured log.\nEcho readiness is transport observation only; no sendVideoTrack RPC is emitted.";
const DEFAULT_SHAPE:&str=r#"{"capture_type":1,"platform":3,"client_version":"4.42.0","width":1920,"height":1080,"fps":60,"chroma":1,
"decoders":[{"fps":60,"codec":1,"width":3840,"height":2160,"chroma":1}],"display_modes":[[1920,1080,60]],
"displays":[{"id":1,"fps":60,"type":0,"hdr":0}],
"codecs":[{"video_codec":1,"chroma_sampling":1,"codec_impl":34,"bit_depth":8,"width":3840,"height":2160}],
"feature_flag":[[1,6],[2,2],[3,1],[4,2],[6,2],[7,2],[8,3],[9,1]]}"#;
#[tokio::main]
async fn main() {
// Do not inherit broad RUST_LOG filters that could expose third-party wire diagnostics.
let args:Vec<String>=std::env::args().skip(1).collect();
// The terminal tool owns the TTY: diagnostics would interleave with the remote shell's screen.
let level=if args.first().is_some_and(|m|matches!(m.as_str(),"terminal"|"terminal-local")){log::LevelFilter::Off}else{log::LevelFilter::Info};
env_logger::Builder::new().filter_level(log::LevelFilter::Off).filter_module("uuremote_viewer",level).init();
match run(&args).await {Ok(())=>{},Err(error)=>{eprintln!("{error}");std::process::exit(2)}}
}
async fn run(args:&[String])->Result<(),String> {
match args.first().map(String::as_str) {
None|Some("--help"|"help")=>{println!("{HELP}");Ok(())},
Some("login") if args.len()==1 || (args.len()==2 && args[1]=="--no-gui")=> {
let executable=std::env::current_exe().map_err(|_|"Cannot locate companion login binary")?.with_file_name("uuremote-server");
login_command(&executable,&args[1..]).await
}
#[cfg(uu_gtk)]
Some("ui") if args.len()==1=> viewer::ui::run(credentials).await,
Some("devices-shape") if args.len()==2=> {
let method=match args[1].as_str(){"GET"=>reqwest::Method::GET,"POST"=>reqwest::Method::POST,_=>return Err("Device list method must be GET or POST".into())};
println!("{}",api()?.devices_shape(method).await.map_err(|e|e.to_string())?);
Ok(())
}
Some("devices") if args.len()==5=> {
let method=match args[1].as_str(){"GET"=>reqwest::Method::GET,"POST"=>reqwest::Method::POST,_=>return Err("Device list method must be GET or POST".into())};
let api=api()?;
let devices=api.devices(method,&args[2]).await.map_err(|e|e.to_string())?;
for device in devices {
// Deliberate UI output, restricted to selected identity/display fields.
// Strings verbatim; numbers/booleans (platform, status flags) as their JSON text.
let id=device.pointer(&args[3]).map(|v|v.as_str().map(str::to_owned).unwrap_or_else(||v.to_string())).unwrap_or_default();
let name=device.pointer(&args[4]).and_then(serde_json::Value::as_str).unwrap_or("");
println!("{}",serde_json::json!({"device":id,"name":name}));
}
Ok(())
}
Some("unbind") if (args.len()==2 || (args.len()==3 && args[2]=="--shared")) && !args[1].is_empty() => {
api()?.unbind(&args[1],args.len()==3).await.map_err(|e|format!("删除设备失败:{e}"))?;
println!("已从账号删除设备");Ok(())
}
Some("power")=>power_command(args).await,
Some("terminal-local") if args.len()==2 || args.len()==3=>{
let session=if args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
viewer::tools::terminal_ipc::client(std::path::Path::new(&args[1]),session).await
},
Some("terminal"|"files"|"portmap"|"files-ui"|"portmap-ui"|"terminal-ui")=>tool_command(args).await,
Some("assist") if args.len()==2=> {
let code=viewer::assist::read_code(std::io::stdin().lock())?;
desktop_command(&["connect".into(),args[1].clone(),"false".into(),"-".into(),"echo".into(),"legacy".into()],Some(code)).await.map_err(|e|format!("协助连接失败:{e}"))
}
Some("connect") if args.len()==6 || args.len()==7=> desktop_command(args,None).await,
_=>Err(HELP.into()),
}
}
async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String> {
let view_only=viewer::input::view_only(args.get(6).map(String::as_str),std::env::var("UU_VIEWER_VIEW_ONLY").ok().as_deref())?;
let force=match args[2].as_str(){"true"=>true,"false"=>false,_=>return Err("force_join must be explicit true or false".into())};
let policy=match args[4].as_str(){"echo"=>ReadyPolicy::EchoOnly,"manual"=>ReadyPolicy::Explicit,_=>return Err("Ready policy must be echo or manual".into())};
let legacy=match args[5].as_str(){"raw"=>false,"legacy"=>true,_=>return Err("Attachment framing must be raw or legacy".into())};
// "-" selects the built-in desktop shape (mirrors the official Mac viewer's observed request).
let text=if args[3]=="-" {DEFAULT_SHAPE.to_owned()} else {std::fs::read_to_string(&args[3]).map_err(|_|"Cannot read explicit viewer shape")?};
let shape:Shape=serde_json::from_str(&text).map_err(|_|"Invalid explicit viewer shape JSON")?;shape.validate_session()?;
#[cfg(feature="viewer-sdl")]
let mut desktop=if shape.capture_type==1 {
if matches!(policy,ReadyPolicy::Explicit) {return Err("Desktop manual readiness has no verified activation protocol".into())}
// Library decoding with viewer-ffmpeg (FFmpeg 6.x headers); otherwise an ffmpeg CLI process.
#[cfg(feature="viewer-ffmpeg")]
let decoder:Box<dyn viewer::desktop::Decoder>=Box::new(viewer::decoder::Ffmpeg::new()?);
#[cfg(not(feature="viewer-ffmpeg"))]
let decoder:Box<dyn viewer::desktop::Decoder>=Box::new(viewer::decoder_cli::Cli::new()?);
Some((viewer::sdl::Window::new()?,decoder))
}else{None};
let creds=credentials()?;
let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let account_connection=code.is_none();
let room=match code {
Some(code)=>api.join_share(&args[1],&code).await,
None=>api.join(&args[1],force,true).await,
}.map_err(|e|e.to_string())?;
let target_mac=if shape.capture_type==1 {api.target_is_mac(&room,account_connection.then_some(args[1].as_str())).await} else {Err(viewer::api::Error::UnknownKeyboardPlatform)};
#[cfg(feature="viewer-sdl")]
if let Some((window,_))=desktop.as_mut().filter(|_|!view_only){
window.set_mac(*target_mac.as_ref().map_err(|e|e.to_string())?);
}
#[cfg(feature="viewer-sdl")]
let mut clipboard=desktop.as_ref().map(|(window,_)|window.clipboard_bridge()).unwrap_or_else(||clipboard::Bridge::new(false));
#[cfg(not(feature="viewer-sdl"))]
let mut clipboard=clipboard::Bridge::new(shape.capture_type==1);
clipboard.set_target_mac(target_mac.ok());
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy,clipboard};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
#[cfg(feature="viewer-sdl")]
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only).await}else{session.run().await};
#[cfg(not(feature="viewer-sdl"))]
let result=session.run().await;
session.close().await;result
}
fn credentials()->Result<auth::Credentials,String> {auth::Credentials::load(config::read_fresh().map_err(|_|"Cannot read credential configuration")?.as_ref())}
fn api()->Result<Api,String> {Ok(Api::new(auth::UUAuthClient::new(credentials()?),auth::BASE_URL))}
async fn login_command(executable:&std::path::Path,options:&[String])->Result<(),String> {
let status=tokio::process::Command::new(executable).arg("login").args(options).status().await.map_err(|_|"Build sibling uuremote-server to reuse QR login")?;
if status.success(){Ok(())}else{Err("QR login did not complete".into())}
}
#[cfg(test)]
mod cli_tests {
use super::*;
#[tokio::test]
async fn invalid_commands_never_fall_through_to_login_or_host_service() {
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["login","--invalid"],vec!["connect"],vec!["assist"],vec!["assist","id","forbidden-code-argument"],vec!["terminal"],vec!["terminal","device","extra"],vec!["terminal","device","0"],vec!["terminal","device","4294967296"],vec!["terminal-ui","device"],vec!["files","device","bad","path"],vec!["portmap","device","bad","host","80"],vec!["portmap","device","8000","host","0"],vec!["devices","DELETE","/data","/id","/name"],vec!["unbind"],vec!["unbind",""],vec!["unbind","device","--other"],vec!["unbind","device","--shared","extra"]] {
assert!(run(&args.into_iter().map(str::to_owned).collect::<Vec<_>>()).await.is_err());
}
}
#[tokio::test]
async fn login_reuses_companion_subcommand_with_a_local_process_mock() {
use std::os::unix::fs::PermissionsExt;
let path=std::env::temp_dir().join(format!("uu-viewer-login-mock-{}",viewer::wire::uuid()));
std::fs::write(&path,b"#!/bin/sh\n[ \"$#\" -eq 2 ] && [ \"$1\" = login ] && [ \"$2\" = --no-gui ]\n".as_slice()).unwrap();
std::fs::set_permissions(&path,std::fs::Permissions::from_mode(0o700)).unwrap();
let result=login_command(&path,&["--no-gui".into()]).await;
std::fs::remove_file(path).unwrap();assert!(result.is_ok());
}
}
async fn tool_command(args:&[String])->Result<(),String>{
let capture=match args[0].as_str(){"terminal" if args.len()==2 || args.len()==3=>8,"terminal-ui" if args.len()==3=>8,"files" if (args.len()==4 && args[2]=="ls") || (args.len()==5 && ["get","put"].contains(&args[2].as_str()))=>5,"portmap" if args.len()==5=>9,"files-ui" if args.len()==3=>5,"portmap-ui" if args.len()==3=>9,_=>return Err(HELP.into())};
let terminal_session=if args[0]=="terminal" && args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
#[cfg(not(uu_gtk))] if args[0].ends_with("-ui"){return Err("Tool windows require the GTK build".into())}
let ports=if args[0]=="portmap"{Some((args[2].parse::<u16>().map_err(|_|"Invalid local port")?,args[4].parse::<u16>().map_err(|_|"Invalid target port")?))}else{None};
if ports.is_some_and(|(_,port)|port==0) || (args[0]=="portmap" && args[3].trim().is_empty()){return Err("Invalid forwarding target".into())}
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in tool shape")?;
shape.capture_type=capture;shape.feature_flag.clear();
if capture!=5{shape.decoders.clear();shape.display_modes.clear();shape.displays.clear();shape.codecs.clear();}
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
// Match the existing UI connection framing (9bb42d5); the host tolerates this prefix.
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
let result=async{
let(io,rx)=viewer::tools::attach(&session.peer)?;
let ready=async{
loop{if session.peer.channels.iter().enumerate().filter(|(i,_)|[0,if capture==8{4}else{3}].contains(i)).all(|(_,c)|c.ready_state()==webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) && session.peer.observed.echo_received.load(std::sync::atomic::Ordering::Acquire){break}tokio::select!{r=session.step()=>r?,_=tokio::time::sleep(Duration::from_millis(20))=>{}}}Ok::<_,String>(())
};
tokio::time::timeout(Duration::from_secs(30),ready).await.map_err(|_|"Tool connection timed out")??;
let operation=async{match args[0].as_str(){"terminal"=>viewer::tools::cli::terminal(io,rx,terminal_session).await,"files"=>viewer::tools::cli::files(io,rx,&args[2..]).await,
#[cfg(uu_gtk)] "terminal-ui"=>viewer::tools_ui::terminal(io,rx,&args[1],&args[2]).await,
#[cfg(uu_gtk)] "files-ui"=>viewer::tools_ui::files(io,rx,&args[2]).await,
#[cfg(uu_gtk)] "portmap-ui"=>viewer::tools_ui::portmap(io,rx,&args[2]).await,
"portmap"=>{let(local,port)=ports.unwrap();viewer::tools::cli::portmap(io,rx,local,&args[3],port).await}
_=>Err("Tool windows require the GTK build".into())}};
tokio::pin!(operation);
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
loop{tokio::select!{r=&mut operation=>break r,r=session.step()=>r?,_=terminate.recv()=>break Ok(()),_=tokio::signal::ctrl_c()=>break Ok(())}}
}.await;
session.close().await;result
}
async fn power_command(args:&[String])->Result<(),String>{
if args.len()!=3 || args[1].trim().is_empty(){return Err(HELP.into())}
let action=viewer::power::Action::parse(&args[2])?;
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in power shape")?;
// File-tool peers carry CONTROL without starting desktop capture or clipboard.
shape.capture_type=5;shape.feature_flag.clear();
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
let result=viewer::power::run(&mut session,action).await;
session.close().await;
if result.is_ok(){println!("电源指令已发送;未确认远端执行结果。");}
result
}
+211 -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;
@@ -8,6 +9,26 @@ extern "C" {
fn uu_wl_key(symbol: u64, pressed: i32) -> i32;
fn uu_wl_wake() -> i32;
fn uu_wl_release_all() -> i32;
fn uu_wl_type_utf8(text: *const libc::c_char) -> i32;
fn uu_wl_text_ready() -> i32;
}
/// How many characters one keymap upload can carry; 0 means this keymap has no spare keycode.
pub fn text_ready()->i32 {
#[cfg(all(target_os="linux",feature="wayland"))]
{ return unsafe { uu_wl_text_ready() }; }
#[cfg(not(all(target_os="linux",feature="wayland")))]
-1
}
/// Mobile input-method text (#13/#46). Returns the number of characters typed, or a negative code
/// when this keymap has no spare keycode to carry them. Never logs the text.
pub fn type_utf8(text:&str)->i32 {
#[cfg(all(target_os="linux",feature="wayland"))]
{
let Ok(c_text)=std::ffi::CString::new(text.replace('\0',"")) else { return -1 };
return unsafe { uu_wl_type_utf8(c_text.as_ptr()) };
}
#[cfg(not(all(target_os="linux",feature="wayland")))]
{ let _=text; -1 }
}
pub fn release_all()->i32 {
#[cfg(all(target_os="linux",feature="wayland"))]
@@ -18,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")))]
@@ -144,3 +173,184 @@ pub fn input_probe()->Result<(),String> {
println!("Wayland test events sent; verify the native GTK acceptance report.");
Ok(())
}
/// Local diagnostic for the mobile-text path: report the keymap's capacity for it, then type a
/// sample into the focused window. Only the built-in sample is echoed; UU_PROBE_TEXT stays private.
pub fn text_probe()->Result<(),String> {
init()?;
let ready=text_ready();
if ready<=0 { return Err("this keymap has no spare keycode: mobile text input cannot be carried".into()); }
const SAMPLE:&str="uu remote abc 你好世界";
let (sample,builtin)=match std::env::var("UU_PROBE_TEXT") {
Ok(value)=>(value,false), Err(_)=>(SAMPLE.to_owned(),true),
};
println!("Wayland text probe: spare keycodes={ready} characters={} bytes={}",sample.chars().count(),sample.len());
if builtin { println!("Sample: {sample}"); }
// UU_PROBE_SEQUENCE types each |-separated field as its own call - one text_input message each,
// the way the phone's input method sends them - with UU_PROBE_STEP_MS between the calls. One
// process means one virtual keyboard, exactly as the host has.
let step=std::env::var("UU_PROBE_STEP_MS").ok().and_then(|v|v.parse::<u64>().ok()).unwrap_or(0);
let sequence=std::env::var("UU_PROBE_SEQUENCE").unwrap_or_else(|_|sample.clone());
let mut typed=0;
for (index,message) in sequence.split('|').enumerate() {
if index>0 && step>0 { std::thread::sleep(std::time::Duration::from_millis(step)); }
let one=type_utf8(message);
if one<0 { return Err(format!("Wayland text typing failed ({one})")); }
typed+=one;
}
if typed<0 { return Err(format!("Wayland text typing failed ({typed})")); }
println!("Typed {typed} of {} characters in {} calls; check that they match.",
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());
}
}
+123 -11
View File
@@ -177,10 +177,27 @@ impl WebRtcSession {
tokio::spawn(async move {
let ctx = ctx.lock().await.clone();
if let (Some(client), Some(ice)) = (&ctx.client_id, ctx.ice_id.as_ref().and_then(|v| v.as_str())) {
let payload = crate::capability::device_capability(client, ice, 0, crate::video::display_fps() as i32, 5, hevc);
let encoder = crate::video::Encoder::requested();
let codec_impl = if encoder == crate::video::Encoder::Nvenc { crate::capability::CODEC_IMPL_NVENC } else { 5 };
let payload = crate::capability::device_capability(client, ice, 0, crate::video::display_fps() as i32, codec_impl,
hevc, crate::video::full_chroma_available());
if let Err(e) = sig.emit_event(crate::capability::FORWARD_SETTING_EVENT, payload).await {
log::error!("Device capability notification failed: {}", e);
}
let capture_impl = match crate::desktop_backend::detect() {
Ok(crate::desktop_backend::DesktopBackend::Portal) => "PipeWire",
Ok(crate::desktop_backend::DesktopBackend::Wayland) => "Wayland",
_ => "X11",
};
let encoder_impl = match encoder {
crate::video::Encoder::Nvenc => "NVIDIA NVENC",
crate::video::Encoder::Vaapi => "VAAPI",
crate::video::Encoder::Cpu => "Software",
};
if let Err(e) = sig.emit_event(crate::capability::FORWARD_SETTING_EVENT,
crate::capability::sender_para_info(client, ice, capture_impl, encoder_impl)).await {
log::error!("Sender parameter notification failed: {}", e);
}
if let Some(control) = ctx.app_control_id.as_ref().and_then(|v| v.as_str()) {
if let Err(e) = sig.emit_event(crate::capability::ICE_FINISHED_EVENT,
crate::capability::ice_finished(ice, control)).await {
@@ -374,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();
@@ -428,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();
@@ -436,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 {
@@ -450,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 {
@@ -475,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) {
@@ -484,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");
@@ -628,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;
@@ -716,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)))),
@@ -805,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");
@@ -1041,28 +1125,46 @@ impl WebRtcSession {
if let Ok(txt) = std::str::from_utf8(&msg.data) {
log::debug!("DataChannel [{}] received UTF-8 data: {} bytes", channel_name, txt.len());
if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) {
if !channel_name.contains("CONTROL") {
// Input JSON on another channel (mobile input-method text was missing from CONTROL, #13/#46):
// record action names only, once per name, and accept text_input wherever it arrives.
if let Some(action) = val.get("action").and_then(serde_json::Value::as_str) {
static SEEN: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
let mut seen = SEEN.lock().unwrap();
if seen.len() < 32 && action.len() <= 40 && action.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') && !seen.iter().any(|s| s == action) {
seen.push(action.to_owned());
log::info!("JSON action on {} channel: action={}", if channel_name.contains("STREAMER") {"STREAMER"} else if channel_name.contains("TEXT") {"TEXT"} else {"other"}, action);
}
}
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(|| {if crate::wayland::input_ready() {input_worker.text_input(&text);}}); }
}
}
if channel_name.contains("CONTROL") {
match crate::control_protocol::decode_control(&msg.data) {
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];
let (slot, kind) = match &event {
ControlInput::MouseButton {..} | ControlInput::MouseClick {..} => (0, "button"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} => (1, "keyboard"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} | ControlInput::TextInput {..} => (1, "keyboard"),
_ => (2, "motion"),
};
if RECEIPTS[slot].fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
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),
ControlInput::TextInput {text} => input_worker.text_input(text),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
@@ -1071,6 +1173,16 @@ impl WebRtcSession {
});}
},
Ok(crate::control_protocol::ControlMessage::Unsupported(v)) => {
// Action name and key names only, never values (an IME text event would carry typed text).
static UNSUPPORTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if UNSUPPORTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
let action = v.get("action").and_then(serde_json::Value::as_str)
.filter(|a| a.len() <= 40 && a.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')).unwrap_or("?");
let keys: Vec<&str> = v.as_object().map(|o| o.keys().map(String::as_str).take(12).collect()).unwrap_or_default();
log::info!("Unsupported CONTROL input: action={action} keys={keys:?}");
}
},
_ => {}
}
} else if channel_name.contains("STREAMER") {
+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());
}
}
+15
View File
@@ -0,0 +1,15 @@
The `red-{420,444}.{h264,hevc}` fixtures contain six synthetic 32x32 red IDRs,
not desktop captures. Their decoded pixel formats are yuv420p and yuv444p.
They let the CLI decoder test run without requiring encoders at test time.
Generated with FFmpeg (substitute `420` / `444` for `CHROMA`):
```sh
ffmpeg -f lavfi -i color=c=red:s=32x32:r=10 -frames:v 6 -pix_fmt yuvCHROMAp \
-c:v libx264 -threads 1 -preset ultrafast -tune zerolatency -g 1 \
-f h264 red-CHROMA.h264
ffmpeg -f lavfi -i color=c=red:s=32x32:r=10 -frames:v 6 -pix_fmt yuvCHROMAp \
-c:v libx265 -threads 1 -preset ultrafast -tune zerolatency -g 1 \
-x265-params pools=none:frame-threads=1:log-level=none:info=0 \
-f hevc red-CHROMA.hevc
```
+1
View File
@@ -0,0 +1 @@
{"code":0,"msg":"fixture only","data":{"token":"synthetic-room-ticket","signaling_list":["ws://signaling.example.invalid"],"ws_connect_timeout_ms":1000,"report_token":"synthetic-report-ticket","report_url":"https://reports.example.invalid","report_server_address":"","streamer_retry_delta_ms":0,"international_connect":false}}
Binary file not shown.
Loaded 100 of 105 files, more files were not shown because too many files have changed in this diff. Show more