Compare commits

...
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 b2a9dcf4d4 Add experimental X11 privacy screen (防窥模式, #140)
Answer the viewer's PrivateScreenSettingRequest (RpcRequest 7 -> RpcResponse 3)
by zeroing the X11 output brightness through xrandr: the monitors go black while
the captured framebuffer is unchanged. Declared on X11 only (ff_private_screen=1,
ff_system_metrics=3, SettingMetric 4/7). Saved gamma/brightness is restored when
the last desktop session ends, on SIGTERM and on the next start after a crash.
Field numbers from the official host protobuf maps; not yet accepted with an
official viewer.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-31 13:44:57 +08:00
tingfeng347 6bf05a6361 修复 niri 主控端控制官方 Windows 时的双向文本剪贴板同步 (#138)
Fixes #139.
2026-10-30 13:43:36 +08:00
VallierDevandClaude Opus 5.5 d9c43897c7 Release v0.2.41
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-29 23:46:34 +08:00
9fe1351de1 控制端:重置后关键帧等待接受 I 片/恢复点 SEI 并 1.5 秒超时放行 (#136) (#137)
v0.2.40 在本地重置后只接受 IDR,Mac 被控端对 PLI 不回 IDR 时画面一直空白。
现在 H.264 的 I 片和恢复点 SEI 也算重启点,等待超过 1.5 秒照常解码;
丢弃单元时也取走解码器已完成的画面。

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-29 23:43:34 +08:00
Its.spixy c0b0ca6afb GNOME Portal:手机控制端拖动滚动、按住选中、短按点击 (#134)
Replayed as touch, a phone drag scrolled in browsers but still selected
text in VTE terminals (Ptyxis, GNOME Terminal), as on a real touchscreen.
By default on the portal backend the host now decides per press: moving
past 12 px within 450 ms scrolls smoothly (NotifyPointerAxis or EIS
scroll, content follows the finger, `finish` on release so clients may
coast), holding still selects with button 1 down, and a short press
clicks. This works in terminals too and needs no touchscreen consent.
UU_TOUCH_INPUT=touch keeps the touchscreen replay (with its one-time
consent upgrade); UU_TOUCH_INPUT=0 keeps plain mouse drags.
2026-10-29 23:34:30 +08:00
Its.spixy 11097b5847 GNOME Portal:手机触控模式拖动按触摸屏重放,输入法 ASCII 直接按键输入 (#131)
* portal: mobile touch-mode drags become touch, consent asks once for it

In touch mode the Android viewer sends a finger as a left-button drag at
absolute positions (observed: press, mouse_move_absolute stream, release),
which on GNOME selects text instead of scrolling. SelectDevices now also
asks for the touchscreen type where AvailableDeviceTypes offers it, and a
drag from an Android/iOS controller (controller_platform 2/3) that follows
absolute motion is replayed as one finger through NotifyTouch* or EIS
touch, so the desktop scrolls and taps as on a touch screen. Relative
motion (the trackpad mode) and every other viewer keep mouse buttons.

A consent saved before this restores keyboard and pointer only. The first
mobile drag then asks the host once per run in the background (GNOME's
share dialog, also visible on the phone; the consent timeout closes it)
and swaps the new session in only when it grants the touchscreen for the
same monitor and size. The saved consent is never removed beforehand.
UU_TOUCH_INPUT=0 keeps mouse drags and never asks.

* input: type mobile IME text as portal keysyms on Latin GNOME layouts

Each mobile text_input was set as the clipboard and pasted with
Shift+Insert, which VTE terminals bind to the PRIMARY selection: text
typed from the phone into a terminal pasted whatever was last selected
(observed: a selected line of box-drawing characters for every letter).
When GNOME's active input source (first of mru-sources) is a Latin xkb
layout, printable ASCII, newline and tab now go through
NotifyKeyboardKeysym, where Mutter picks the key and Shift level of the
active layout. Other text, IBus engines, KDE and EIS sessions keep the
clipboard paste, which no longer replaces the clipboard for plain typing.

* portal test: accept libei before 1.3 rejecting a touch outside one of two regions

libei 1.2 (Ubuntu 24.04, CI) accepts a touch only inside every region of the
device; 1.3.0 checks any region. The harness device also carries a region for
another screen, so the older library rejects the touch with a client-bug
diagnostic. A real one-stream session has one region.
2026-10-29 19:49:15 +08:00
Its.spixy 6a0cd5bda6 控制端:跨会话记住画质、帧率和真彩设置 (#133)
The host starts every session at the official defaults (Auto, 60 fps,
4:2:0), so a choice made for a slow link was lost on reconnect. Save them
in viewer.json with the other preferences and send the ones that differ
once CONTROL answers the echo.
2026-10-29 18:48:30 +08:00
VallierDevandClaude Opus 5.5 4cfdd563f7 Release v0.2.40
TURN TCP: report an inspecting proxy that answers with HTTP inside the relay stream.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-29 11:46:02 +08:00
Its.spixyandClaude Opus 5.5 0cbfc5b4f1 控制端:原生分辨率、中英文界面、控制中心、实测 RTT 与稳定性修复 (#129)
* viewer: decode at the host's native size and filter window scaling

Every frame was scaled into a fixed 1920x1080 canvas and SDL then stretched it
to the window with nearest-neighbour sampling, so remote text looked uneven and
blurry. Decode at the native size (read from ffmpeg's verbose scaler line),
restart the decoder when the host resolution changes, and use linear render
scaling. UU_VIEWER_SIZE keeps the fixed canvas, now resampled with Lanczos.

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

* Add Chinese/English UI language

All GTK windows (viewer launcher, tool windows, host main window and QR login)
and viewer messages are available in Chinese and English. The language comes
from UU_LANG, the choice saved in Settings -> General, then the locale.
README: document the fork's changes and language selection.

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

* Host main window: add the language selector

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

* viewer: control center, network status, loading screen, device previews

In-window chrome drawn on the SDL canvas with a fontconfig font (ab_glyph):
- loading animation with the connection stage instead of a black window
- control center (Ctrl+Alt+M or the top tab): quality, fps, true color,
  resolution, fit/1:1, volume, auto lock and host mute (SimpleAction 19,
  14/18/16), system shortcut grab, file transfer, watch mode, full screen,
  disconnect
- network status panel (Ctrl+Alt+G): time, route, fps, bitrate, RTT, loss
- launcher device previews from the last remote picture (local 0600 cache)
- viewer sign-in keeps the local host user service running, so this
  computer joins the account's device list; the settings switch controls it

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

* viewer: compact cascading control center

Narrow category list with an options card beside the selected row, sized to
its content; opaque cards with a hairline border and soft shadow, so the
remote picture no longer shows through.

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

* viewer: keep the control center responsive; resync on a key frame

The menu was rasterized on every mouse event just to hit-test it; hit testing
now uses the layout alone and the drawn menu is cached until what it shows
changes. A stalled UI overflowed the access-unit queue, and the reset decoder
then smeared P-frames into blocks; after a reset it now waits for an IDR/IRAP
while requesting key frames. The tab icon is drawn, since fonts without U+2630
showed a box.

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

* viewer: measured RTT, no crash on closing tool windows, account card

webrtc-ice never measured the round trip, so the network panel always read
'RTT --'. Binding responses now record it on their pair, and the selected
pair is pinged when the sample is older than the keepalive interval, since
a streaming pair never idles (vendor/webrtc-ice/PATCHES.md).

On Wayland, libdecor's GTK plugin drew SDL's title bar with GTK3 from SDL's
thread while the file window ran gtk_main on its own; closing that window
crashed in GTK's style code. GTK builds now offer libdecor only the cairo
plugin unless LIBDECOR_PLUGIN_DIR is set.

Settings > General gets an Account card with the signed-in user and Sign out.

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

* README: keep the language section, without the fork notes

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

* viewer: English server errors in the English UI; stable type_ipc tests

UU servers answer in Chinese only. The English UI now translates the known
messages (2002 target already controlled, assistance refusals) and shows the
code for unknown ones instead of Chinese text.

type_ipc tests shared one temp directory per process and read
XDG_RUNTIME_DIR while another test pointed it at a planted directory; each
call now gets its own directory and socket tests hold the environment lock.

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

* viewer launcher: switching the language restarts the launcher

The choice was saved but took effect only on the next start, so the window
seemed to ignore it. The launcher now re-executes itself in place; session
windows are separate processes and stay connected.

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

* viewer: show pictures as soon as decoded; coalesce mouse motion

The raw-stream parser closed an access unit only when the next began, and
frames were collected only when another one arrived, so a single remote
change (a typed letter) waited for the next one. An access unit delimiter
now follows each unit and the loop drains finished frames between units.

Motions within one 8 ms poll collapse to the newest position (click order
kept), so a drag no longer queues behind itself on a relayed path.

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

* viewer launcher: hosting is opt-in

Signing in to the viewer no longer installs or enables uuremote-native.service.
Only the Settings switch enables or disables it, and the unit's enabled state is
the saved choice, so turning it off survives a restart. A new sign-in restarts the
host only when the user turned it on and it is running.

PATCHES.md: the RTT keepalive also runs on the host; checked with the official
Android client controlling a Linux host.

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

* viewer: drop SDL event types sdl2 0.37 does not define

sdl2 0.37 transmutes every event type into SDL_EventType. sdl2-compat on SDL3
delivers types SDL 2 does not define (0x207), which is undefined behaviour and
aborts with debug checks (clipboard_requests_use_existing_window on Fedora 44).
Poll raw events and skip those types before the crate converts them.

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

* Keep the package version at 0.2.39

The maintainer sets the version at release time.

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

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-29 10:45:11 +08:00
Its.spixyandClaude Opus 5.5 47c7728822 GNOME Portal:多显示器切换、精确触控、断开后停止共享 (#128)
* portal: switch monitors on GNOME, precise touch, stop sharing when idle

GNOME grants one monitor per portal consent and refuses multi-select, so
each Mutter monitor gets its own saved consent (gnome@<connector>). The
monitors are advertised as screens; a switch opens that monitor's session
(silently once consented, GNOME asks on the host the first time) and swaps
it into the shared PortalSession, whose frame size follows the monitor.

Absolute motion and clicks go through the portal session: a uinput tablet
spans every monitor, and clicks on the separate uinput queue could land
before the compositor moved the pointer.

An idle watch ends the portal session (screen-share indicator off) once no
desktop controller is left for two checks; the next one reopens it with the
saved consent.

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

* portal: stop screen sharing as soon as the last controller leaves

The idle watch stays as the fallback for controllers that vanish without
a release event.

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

* portal test: accept the runtime-engine message in portal builds

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

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-29 10:44:30 +08:00
Its.spixy e503041dac 登录:跨进程串行化设备注册 (#127)
主机扫码窗口与控制端登录可能各自调用 device/windows/init,导致账号绑定一台设备而 config.json 保存另一台(主机显示离线的幽灵设备)。现在在 config.json 旁的排他文件锁下注册设备,取锁后重读配置,第二个流程复用已注册设备。

感谢 @spixyy7 的贡献。

🤖 Generated with [Claude Code](https://claude.com/claude-code)
2026-10-29 04:40:52 +08:00
Sile Liu 835bfa2319 Fix niri monitor switching, rotated input and mobile text (#71)
niri 实验性支持:三屏切换、90°/180°/270° 旋转输出的采集与指针映射、手机中文文本输入,全部 gated 在 NIRI_SOCKET,不影响 Hyprland/X11 路径。新增 wayland_transform.h 及其 ASAN 单测。

感谢 @WALKERKILLER 的贡献与 CachyOS + niri 实机验收。

🤖 Generated with [Claude Code](https://claude.com/claude-code)
2026-10-29 01:39:01 +08:00
VallierDevandClaude Opus 5.5 482c01a85d viewer tests: accept the video track RPC in the loopback session
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:45:43 +08:00
VallierDevandClaude Opus 5.5 7f6cf6e092 Release v0.2.39
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:39:58 +08:00
VallierDevandClaude Opus 5.5 c0c04a2c98 viewer: request the desktop video track like the official viewer (#124)
The official iPhone viewer sends RpcRequest case 15 SendVideoTrackReq (no
fields) right after CONTROL opens. Without it a second session only joins the
stream already encoded for another viewer: no SPS/PPS/IDR, so it stays black.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:37:43 +08:00
VallierDevandClaude Opus 5.5 b636f1b278 Release v0.2.38
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:22:03 +08:00
VallierDevandClaude Opus 5.5 64d2ffbdd3 ICE: trust the system certificate store for TURN over TLS
A TLS-inspecting HTTP proxy re-signs the TURN certificate with a CA that the
host's administrator installed in the system store; OpenSSL accepts it while
the bundled Mozilla roots alone fail with UnknownIssuer.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:21:37 +08:00
VallierDevandClaude Opus 5.5 5656f33d86 Release v0.2.37
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 19:35:12 +08:00
VallierDevandClaude Opus 5.5 6a633e1bc4 ICE: gather TURN relays over TCP/TLS through the HTTP proxy with UU_USE_PROXY=1
Upstream webrtc-ice only gathers UDP relays. Forced-relay sessions also offer
turns:<ip>:<port>?transport=tcp, the only media path on hosts whose UDP cannot
reach the TURN servers but whose TCP goes through an HTTP proxy. Vendor
webrtc-ice 0.10.1 with a TCP/TLS dialer (optional HTTP CONNECT) that frames
STUN/ChannelData for the unchanged turn client. Certificates are chain-verified;
a name mismatch is accepted only for IP-literal TURN URLs. Enabled only with
UU_USE_PROXY=1; default UDP gathering is unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 19:34:24 +08:00
VallierDevandClaude Opus 5.5 ab137a1b20 Release v0.2.36
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 17:27:17 +08:00
VallierDevandClaude Opus 5.5 092ea713f8 X11: fall back to XGetImage when MIT-SHM attach is refused
XShmAttach fails asynchronously with BadAccess when the X server cannot reach
the segment (for example a server in another container); Xlib's default error
handler exited the host before the existing XGetImage fallback could run.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 17:26:01 +08:00
VallierDevandClaude Opus 5.5 53d5f0e144 viewer: request key frames until the first frame is shown (#124)
A session that joins a host already streaming to another viewer can receive a
clean stream with no IDR in flight, so the loss-driven PLI never fired. Ask
every 30 access units until something is presented, and warn after 300.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 16:36:35 +08:00
VallierDevandClaude Opus 5.5 6b5216df35 Release v0.2.35
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 15:21:34 +08:00
VallierDevandClaude Opus 5.5 d66937a01c Signaling: honor the REST client's opt-in HTTP proxy policy (#123)
Route host and viewer WebSocket signaling through the shared reqwest client so UU_USE_PROXY=1 applies to signaling as well (HTTP/HTTPS proxies only, no direct fallback, no redirects, strict upgrade validation). ICE/WebRTC media is not proxied.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:42:12 +08:00
VallierDevandClaude Opus 5.5 825f964f7d doctor: warn about extra host instances; README: never share config.json (#122)
Count only top-level hosts (helpers such as the Wayland capture process and
the login window are children) and explain that two instances with one
identity kick each other out of the room.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:32:37 +08:00
VallierDevandClaude Opus 5.5 3f2da6f587 doctor: count re-executed host processes by executable (#122)
The host re-execs through /proc/self/exe, so its process name becomes "exe"
and pgrep -x uuremote-server missed duplicate hosts.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:26:34 +08:00
VallierDevandClaude Opus 5.5 027abba44d Signaling: log the shape of cloud room leaves without a peer id (#122)
Keys, value types and lengths only, as for SOAC offers.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:02:10 +08:00
VallierDevandClaude Opus 5.5 ef86019b39 Login: distinguish QR polling failures from expiry with safe diagnostics (#121)
Classify QR request failures (timeout/connect/decode/body/request) with phase, elapsed time and HTTP/API status only; never print tickets, URLs or server content. Extract and test the polling decisions; keep the 60 s timeout and official refresh behaviour.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 13:28:50 +08:00
shofukantktsandshofukantkts 003da254a6 Wayland: type mobile text_input via clipboard paste on Portal and compositors without spare keycodes (#119)
* Wayland: type mobile text_input via clipboard paste on Portal and compositors without spare keycodes

* Wayland: address review comments for mobile text_input clipboard fallback

- Guard external clipboard commands in unit tests to eliminate desktop side effects
- Narrow paste fallback to Wayland and Portal backends only
- Document clipboard override and two-way sync behavior in README (both zh and en)
- Unify disable switch via UU_WAYLAND_TEXT=0

---------

Co-authored-by: shofukantkts <[email protected]>
2026-10-27 22:14:56 +08:00
VallierDevandClaude Opus 5.5 7a86fab340 Release v0.2.34
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-27 13:10:49 +08:00
VallierDevandClaude Opus 5.5 d631849f1d Viewer: map the desktop window before the first decoded frame (#118)
Wayland shows a toplevel only after its first buffer, so a stream that never
yields a picture left no window at all. Present a black buffer on creation and
on resize/expose while no frame has arrived.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-27 12:10:35 +08:00
VallierDevandClaude Opus 5.5 d04d241411 Viewer: repaint the last frame after a compositor resize (#118)
Tiling or maximizing the SDL viewer resized the surface, but nothing was
drawn until the next decoded frame, so a static remote desktop stayed blank.
Repaint the last frame on SizeChanged/Resized/Exposed/Maximized/Restored.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-27 11:10:53 +08:00
VallierDevandClaude Opus 5.5 2eece30287 Signaling: bound the WebSocket handshake so reconnect retries after a stall (#115)
After a network change the DNS/TCP/TLS/upgrade could stall forever after
room credentials were acquired; the reconnect loop never retried. The
handshake now fails after 20s and the existing 5s retry takes over.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-26 20:03:54 +08:00
VallierDevandClaude Opus 5.5 1e94175414 Release v0.2.33
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-26 19:02:33 +08:00
VallierDevandClaude Opus 5.5 cfe9601874 WebRTC: restart a promoted desktop's video after its stream ended (#114)
A tool peer promoted by capture_desktop stayed marked as the desktop after its
encoder exited on its own (Wayland capture failing while locked/DPMS off), so a
later capture_desktop on the same peer only logged and never restarted the
video. Treat a finished stream task as ended: capture_desktop asks for the
desktop again and promote() restarts the video on the existing input lease.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-26 18:02:56 +08:00
VallierDevandClaude Opus 5.5 ab5d0a656b Release v0.2.32
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-25 22:54:59 +08:00
VallierDevandClaude Opus 5.5 dcc67ed550 WebRTC: recompute the peer state from the real DTLS transport after ICE recovers
The ICE transport state callback was created before the DTLS transport and
captured the default placeholder, whose state never leaves New. Every later
ICE change therefore computed the peer state against a "New" DTLS: after a
brief ICE Disconnected -> Connected the PeerConnection settled on New instead
of Connected, so the idle room renewal treated the still-working
port-mapping peer as idle and tore the room down.

Wire the callback to the real DTLS transport through a weak slot filled right
after it is created.

Fixes #109

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-25 22:53:22 +08:00
liuyanghejerry bf7bd50062 viewer: forward mouse wheel events as mouse_scroll (#108)
SDL MouseWheel events had no arm in the event translator, so wheel input was dropped. Send one notch as 120 wire units (the Mac convention), use SDL's precise deltas for trackpads, honour the flipped direction for natural scrolling, and keep the existing focus and view-only gating.
2026-10-24 22:42:53 +08:00
liuyanghejerry 287b21a622 viewer: map pointer input to the content rectangle of the padded canvas (#107)
The CLI decoder pads every frame into a fixed 1920x1080 canvas so rawvideo frames have a known byte length. Input mapping and the SDL viewport treated that padded canvas as the picture, so non-16:9 hosts (official Macs are usually 16:10) had the pillarbox bars inside the 0..1 range: the remote pointer lagged inward and the error grew towards the screen edges.

Parse the coded picture size from ffmpeg's one-time "Video:" stream line, carry it on Frame.content, and render/map only the content sub-rectangle. 16:9 streams are unchanged; UU_VIEWER_SIZE keeps working.
2026-10-24 21:41:48 +08:00
Mr. ErrorandClaude Code bcde9f967c Signaling: keep heartbeat detection alive when delivery stalls (#104)
* Signaling: keep heartbeat detection alive when delivery stalls

The receive loop awaited event_sender.send() without a bound. When the main loop was parked in PeerConnection::close after a released peer, the 64-slot event queue filled and the receiver blocked inside the loop body, so the Engine.IO deadline in the same select! never ran. The host stayed online with a half-closed socket for hours.

- add a watchdog over the last inbound frame, independent of the receive loop
- bound event, pong and control sends with a timeout or try_send
- timeout PeerConnection::close so one dead peer cannot stall signaling
- regression test with a blocked event consumer

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

* Signaling: always report Disconnected when the receiver stops

The receive loop can break without enqueueing Disconnected: event delivery exceeded SEND_STALL_TIMEOUT, or the writer already stopped. receiver_done then lets the watchdog exit, while the main loop's rx_event stays open because the idle-renewal timer holds a sender. The host stays in a dead room until the 15-minute renewal, which is deferred while a peer is connected.

Hand a Disconnected off from a detached task after every loop exit. Duplicates are harmless: the main loop breaks on the first one and drops the old receiver.

The new test keeps the consumer blocked past SEND_STALL_TIMEOUT, then drains the queue and expects Disconnected.

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

---------

Co-authored-by: Claude Code <[email protected]>
2026-10-24 16:38:43 +08:00
VallierDevandClaude Opus 5.5 df9429495f Release v0.2.31
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-24 11:15:00 +08:00
VallierDevandClaude Opus 5.5 ba82bc432a nvenc: opt-in UU_NVENC_BUFFER_MS VBV buffer for high-resolution keyframes (#103)
The 100-500 kbit NVENC default squeezes a 1440p IDR into ~62 KB, so the
picture blurs and sharpens once per GOP. Share the VAAPI buffer parser so
UU_NVENC_BUFFER_MS (10-1000 ms of the bitrate cap) applies to the FFmpeg
pipeline and the in-process engine; default unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-24 10:44:59 +08:00
VallierDevandClaude Opus 5.5 648eeca03d Release v0.2.30
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-24 04:41:03 +08:00
VallierDevandClaude Opus 5.5 f97370782f Start the desktop on a tool connection when the viewer sends capture_desktop (#99) (#101)
When a port-mapping connection is already open, the Mac viewer opens the desktop by sending SimpleAction 4 (capture_desktop) on that connection's CONTROL channel instead of a new offer. The host now promotes that tool connection to the desktop: video, cursor, TEXT clipboard (with the capability echo replayed) and session counting follow a per-peer active flag. A later desktop demotes it without closing its port mappings. Stream tasks are fenced by an abort handle, and the X11 capture is rebuilt if the screen size changed.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 13:40:14 -07:00
Jeff Zhangandferstar 8792fb4eca vaapi: raise the in-process RC max_qp to 51 so capped presets reach the QP 51 floor (#102)
Co-authored-by: ferstar <[email protected]>
2026-10-23 11:24:15 -07:00
VallierDevandClaude Opus 5.5 c041160d6d Release v0.2.29
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 21:52:30 +08:00
VallierDevandClaude Opus 5.5 69aecf0269 X11: select one monitor with UU_X11_MULTISCREEN=1 (#100)
Opt-in X11 monitor selection for #98: RandR monitors from xrandr --listmonitors through the existing screen-switch path; x11grab reads display+x,y at the monitor size, absolute input adds the monitor offset, in-process engine and xrandr resize are skipped while a region is captured.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 06:51:42 -07:00
VallierDevandClaude Opus 5.5 979b62d271 Issue template: keep peer and port-mapping log lines, drop webrtc noise, mask IPv6/MAC
The WARN filter let webrtc_ice/dtls lines push the useful ones out of the
last 80 lines (#99). Also mask IPv6 and MAC addresses, and ask for the
graphical session terminal: doctor from SSH/tty reports no DISPLAY.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 21:20:42 +08:00
Jeff Zhangandferstar 6a3da14961 Switch the desktop encoder on SIGUSR2 without dropping the session (#96)
set-encoder / set-codec signal the running host (only when /proc/<pid>/exe is this exact binary); the live desktop stream re-plans its encoder at the next frame boundary, sends CaptureSettingSync when 4:4:4 falls back, and prints a note when no host was notified. Step 3 of #85.

Co-authored-by: ferstar <[email protected]>
2026-10-23 03:24:29 -07:00
VallierDevandClaude Opus 5.5 792408e6f5 Release v0.2.28
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 16:22:37 +08:00
VallierDevandClaude Opus 5.5 61c3f91e9e Install: install.sh installs FFmpeg; host notifies the desktop user when it is missing (#97)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 01:21:57 -07:00
VallierDevandClaude Opus 5.5 1bb43a9426 Release v0.2.27
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 15:25:54 +08:00
Jeff Zhang 9d3b3da3f5 Video: probe the auto encoder in the background (NVENC then CPU) (#93)
Refs #85 (step 2).
2026-10-23 00:24:31 -07:00
阿夜 1009bdeaf2 fix(video): keep streaming after display wake failures (#95)
Fixes #94.
2026-10-22 21:24:51 -07:00
212duoand212duo fa7606894f feat(viewer): secure type input that reuses the open desktop session (#70)
Co-authored-by: 212duo <[email protected]>
2026-10-22 20:24:18 -07:00
963875516a Video: encoder and codec selection settings (set-encoder / set-codec) (#92)
Step 1 of #85: unified encoder/codec selection (host_settings.json > UU_VIDEO_* > auto), set-encoder / set-codec subcommands with locked merge writes, per-connection selection snapshot, doctor shows sources.

Co-authored-by: ferstar <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-22 16:24:22 -07:00
VallierDevandClaude Opus 5.5 b6703b19df Release v0.2.26
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-22 23:54:56 +08:00
76a225a235 Tray: install the symbolic icon into the user hicolor theme (#90)
v0.2.25 showed KDE's unknown icon on Plasma 6.8 (#87). Plasma resolves
SNI icons theme by theme, trying dash-trimmed names in each theme before
the IconThemePath app theme, which comes last, so a cache-only icon is
easy to lose. Write it to $XDG_DATA_HOME/icons/hicolor (found by every
panel's default lookup; only when changed) and keep that as the theme
path. The new name "uuremote-tray-symbolic" cannot trim into the colored
"uu-remote-linux" app icon and avoids entries cached under the old name.

Checked with KIconLoader on Plasma 6.7 (Plasma's IconThemePath setup and
the global loader both resolve it, with the colored icon installed too).

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-22 08:54:23 -07:00
da99c1ceb4 NVENC: skip direct BGRA input when NVIDIA drives the display (#89)
#16: with display, capture and encode all on an RTX 5070 the packed-RGB
input path is 19% slower in the probe and 25% end to end than CPU
swscale, while on an iGPU-composited desktop it was neutral to faster.
Keep it on by default only when no connected DRM connector belongs to an
nvidia-bound card; UU_NVENC_RGB=1 forces it, =0 still disables it.

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-22 08:12:31 -07:00
VallierDevandClaude Opus 5.5 0fe9b979e5 Release v0.2.25
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-22 21:05:37 +08:00
cb4850d296 Tray: monochrome icon that follows light/dark panels (#88)
* Tray: monochrome icon that follows light/dark panels

The tray used the colored app icon (or the theme's "computer" when it was
not installed), which is hard to see on dark panels. Ship a 16px symbolic
icon embedded in the binary, write it to the user cache and pass that
directory as the indicator's icon theme path: GTK and the GNOME
AppIndicator extension recolor "-symbolic" names, KDE recolors the
ColorScheme-Text class. Fixes #87.

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

* AGENTS: config.json is parsed once, re-read only on LoginExpired

Reported in #85: the 60 s sleep is the room renewal poll, not a config reload.

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-22 06:04:54 -07:00
161 changed files with 24041 additions and 970 deletions

No files matched your search

+5 -4
View File
@@ -32,8 +32,8 @@ body:
attributes:
label: 诊断信息 / Diagnostics
description: |
先复现一次问题,然后在被控的 Linux 上运行下面的命令,把输出粘贴到这里(IP 会被自动抹掉,不包含密码、令牌或剪贴板内容)。
Reproduce the problem, then run this on the Linux host and paste the output (IPs are masked; no passwords, tokens or clipboard data).
先复现一次问题,然后在被控 Linux 的**图形桌面里打开的终端**中运行下面的命令(SSH 或 tty 里缺少桌面环境变量,doctor 结果不准),把输出粘贴到这里(IPv4/IPv6/MAC 地址会被自动抹掉,不包含密码、令牌或剪贴板内容)。
Reproduce the problem, then run this in a terminal **inside the Linux graphical session** (SSH/tty lacks the desktop environment, so doctor would be misleading) and paste the output (IPv4/IPv6/MAC addresses are masked; no passwords, tokens or clipboard data).
```sh
{
@@ -45,8 +45,9 @@ body:
echo "== 显卡"; lspci 2>/dev/null | grep -iE 'vga|3d'
echo "== FFmpeg"; ffmpeg -hide_banner -encoders 2>/dev/null | grep -E 'h264_nvenc|libx264'
echo "== 日志"; journalctl --user -u uuremote-native.service --since "-30min" --no-pager -o cat \
| grep -E 'Starting|backend|Selected capture|Desktop encoder|Capture setting request|Desktop video settings|Offer for connection|WARN|ERROR' | tail -n 80
} 2>&1 | sed -E 's/[0-9]{1,3}(\.[0-9]{1,3}){3}/x.x.x.x/g'
| grep -E 'Starting|backend|Selected capture|Desktop encoder|Capture setting request|Desktop video settings|Offer for connection|PeerConnection State|Remote controller disconnected|ICE path|Port mapping|WARN|ERROR' \
| grep -vE 'webrtc_ice|webrtc_dtls|webrtc::mux' | tail -n 120
} 2>&1 | sed -E 's/[0-9]{1,3}(\.[0-9]{1,3}){3}/x.x.x.x/g; s/([0-9a-fA-F]{1,4}:){4,7}[0-9a-fA-F]{1,4}|[0-9a-fA-F]{0,4}::[0-9a-fA-F:]*[0-9a-fA-F]/x:x::x/g'
```
render: text
validations:
+16 -1
View File
@@ -43,6 +43,21 @@ jobs:
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
# The tarball installer must bring FFmpeg back on a machine without it (no FFmpeg = no picture).
- name: Tarball install script
run: |
shellcheck packaging/tarball/install.sh
sudo apt-get remove -y ffmpeg || true
if command -v ffmpeg; then echo "ffmpeg still present"; exit 1; fi
pkg=$(mktemp -d)
cp target/debug/uuremote-server target/debug/libuu-wayland.so packaging/tarball/install.sh "$pkg/"
cp -r contrib "$pkg/"
home=$(mktemp -d)
HOME=$home XDG_CONFIG_HOME=$home/.config "$pkg/install.sh" --yes
ffmpeg -hide_banner -encoders | grep -qw libx264
test -x "$home/.local/bin/uuremote-server" && test -f "$home/.local/lib/uu-remote-linux/libuu-wayland.so"
grep -q '^ExecStart=%h/.local/bin/uuremote-server$' "$home/.config/systemd/user/uuremote-native.service"
HOME=$home XDG_CONFIG_HOME=$home/.config "$pkg/install.sh" --yes | grep -q 'Kept existing'
test-viewer:
runs-on: ubuntu-22.04
@@ -82,7 +97,7 @@ jobs:
ASAN_OPTIONS: detect_leaks=1
UBSAN_OPTIONS: halt_on_error=1
run: |
for source in tests/portal_engine.c tests/portal_input.c tests/portal_eis.c tests/desktop_power.c; do
for source in tests/portal_engine.c tests/portal_input.c tests/portal_eis.c tests/desktop_power.c tests/wayland_transform.c; do
target="/tmp/$(basename "$source" .c)"
cc -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \
-Wall -Wextra -Wno-unused-parameter "$source" -o "$target" \
+1 -1
View File
@@ -65,7 +65,7 @@ jobs:
name=uu-remote-linux-${GITHUB_REF_NAME}-${{ matrix.arch }}-linux
mkdir -p "$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/"
packaging/tarball/install.sh 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"
+30 -12
View File
@@ -29,7 +29,10 @@ This file is written for large language model agents (Claude Code, Codex, Cursor
the config file / environment. The only built-in default is the public client signing key in `src/auth.rs`.
6. **Don't break other tools.** The desktop, file-transfer, terminal and port-mapping tools each open their own
peer connection; a new offer must never close other peers.
7. Keep changes small and tested; match the surrounding code style (dense, comment only the non-obvious).
7. **UI text is bilingual.** Every user-facing string has Chinese and English: `L("中文", "English")` in C
(`c_engine/i18n.h`), `crate::i18n::s(..)` / `crate::tr!(..)` in Rust (`src/i18n.rs`; `UU_LANG`, saved choice, locale).
Logs stay English.
8. Keep changes small and tested; match the surrounding code style (dense, comment only the non-obvious).
## 3. Build and test
@@ -73,6 +76,9 @@ cargo build --release --features native-viewer,viewer-sdl --bin uuremote-viewer
X11 → default build. Hyprland → `--features wayland`. GNOME/KDE on Wayland → `--features wayland,portal`
(or advise the user to pick the "on Xorg" session at the login screen, which is the best-supported path).
2. Install dependencies and build (section 3). Copy the binary: `install -Dm755 target/release/uuremote-server ~/.local/bin/uuremote-server`.
From a release tarball run its `./install.sh` as the desktop user instead: it installs into `~/.local`, writes the user unit
(keeps an existing one) and installs FFmpeg with libx264 via sudo apt/pacman when missing (Fedora/openSUSE: prints the command).
The .deb depends on `ffmpeg`. Without FFmpeg the viewer waits on 正在传输画面; the host checks at startup and on each desktop offer, logs an error and tells the desktop user (freedesktop notification, else opens its window with a red line; `assist::show_problem`).
3. **Login (needs the human).** Run `uuremote-server login` inside the graphical session. A GTK window shows a QR
code; the user scans it with the UU Remote mobile app and confirms. Without a display use
`uuremote-server login --no-gui` (terminal QR). Credentials are written to `~/.config/uuremote/config.json`
@@ -114,25 +120,29 @@ viewer does not reconnect them automatically.
| Item | Meaning |
|---|---|
| `~/.config/uuremote/config.json` | user_id, device_id, client_id, system_id, machine_guid, token, csrf; optional `sign_key`, `ffmpeg_root`. `$UU_CONFIG` overrides the path |
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent |
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent; optional `video_encoder` (`auto`/`cpu`/`vaapi`/`nvenc`) and `video_codec` (`auto`/`h264`/`h265`), written by `set-encoder` / `set-codec` (0600, merge write). Non-`auto` beats `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`. `set-encoder` and `set-codec` both send `SIGUSR2` to the pid in `host.pid` (same binary). Live desktop streams restart the encoder (`EncoderTask::restart`, sequence kept, first frame IDR) without dropping the peer. Codec preference is logged and applies on the next desktop stream. `SIGUSR2` does not re-probe. Hand edits: `kill -USR2 $(cat ~/.config/uuremote/host.pid)` |
| `UU_DESKTOP_BACKEND` | `auto` (default) / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless: no display; desktop offers ignored; tool peers get a nominal 1920x1080 screen + Allow permissions, which the port-mapping viewer requires) |
| `UU_X11_MULTISCREEN=1`, `UU_X11_OUTPUT` | X11: advertise each RandR monitor (`xrandr --listmonitors`, read once at start; primary or `UU_X11_OUTPUT` is id 0) through the same screen-switch path as `UU_WAYLAND_MULTISCREEN` (`wayland::outputs`/`select`). x11grab reads `display+x,y` at the monitor size, XTest/uinput absolute input adds the monitor offset, the in-process engine and `desktop_mode` resize are skipped (分辨率 scales). Needs two or more monitors |
| `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends |
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
| `UU_TOUCH_INPUT` | Android/iOS controllers (connect header `controller_platform` 2/3) send a finger as a left-button drag at absolute positions. Default on the portal backend (gesture): per press, moving past 12 px within 450 ms scrolls (`NotifyPointerAxis` / EIS scroll, content follows the finger, `finish` on release), holding still selects with button 1 down, a short press clicks; needs no touchscreen consent. `touch`: replay as one finger on the portal touchscreen (`NotifyTouch*` / EIS touch; requested where `AvailableDeviceTypes` offers it; consents saved before touch support restore keyboard+pointer only, so the first mobile drag asks once per run in the background via `PortalSession::upgrade_touch`, swapped in only with the touchscreen granted for the same monitor; the saved consent is never removed first). `0`: plain mouse drags |
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
| `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset: NVENC→CPU only if `/proc/driver/nvidia/version` or `/dev/nvidia0` exists, else CPU (#10) |
| `UU_VIDEO_CODEC=h264` | force H.264 even when the viewer negotiated H.265 (default: H.265 when both sides support it) |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset/`auto`: background probe, one synthetic IDR per candidate, 3 s each. While #33 is open, auto is NVENC then CPU when `/proc/driver/nvidia/version` or `/dev/nvidia0` exists; with no NVIDIA the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the legacy rule (NVENC if NVIDIA is present, else CPU). On `--features inproc-av`, a process-only failure of NVENC when the native engine would try it first on X11 is `native_unprobed` and keeps that legacy NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence (`/proc/driver/nvidia/version` or `/dev/nvidia0`) matches the report. A later desktop connection whose presence differs treats the report as stale and starts one background re-probe (`warm_auto_probe`, non-blocking, one at a time) and still uses the cached encoder. A hardware-candidate failure (NVENC failed, chosen CPU) is cached for 10 minutes (`PROBE_FAILURE_TTL`); the next desktop connection after that starts the same re-probe and still uses the cached encoder. Explicit `cpu` / `vaapi` / `nvenc` (setting file or `UU_VIDEO_ENCODER`) does not start the probe. A later success selects NVENC again; another failure restarts the 10 minutes. `native_unprobed` is not a failure cache. Ignored when `host_settings.json` `video_encoder` is not `auto`. Explicit `vaapi` with 真彩 encodes 4:2:0 and reports that in CaptureSettingSync (field 3). VAAPI is not an auto candidate until #33 |
| `UU_VIDEO_CODEC=h264` | force H.264 even when the viewer negotiated H.265 (default: H.265 when both sides support it and the encoder is hardware). Same precedence as the encoder: setting file, then this variable, then auto |
| `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_USE_PROXY=1` | honor HTTP/HTTPS proxy env vars for REST and WebSocket signaling, and also gather TURN relays over TCP/TLS through that proxy (`vendor/webrtc-ice/PATCHES.md`; chain-verified, name mismatch tolerated for IP TURN URLs); 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
every 60 s.
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. `config.json` is parsed once
(`config::file()`); only a `LoginExpired` room answer re-reads it from disk (`config::read_fresh()`) before waiting
for a new QR login.
## 6. Code map
@@ -162,9 +172,10 @@ every 60 s.
| `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) |
| `src/viewer/hud.rs` | in-window chrome drawn on the SDL canvas: loading screen, control center (Ctrl+Alt+M; capture settings RPC 2 and SimpleActions 14/16/18/19 as the official viewer sends them), network-status panel (Ctrl+Alt+G); fontconfig font via ab_glyph |
| `src/viewer/thumbs.rs`, `src/viewer/host.rs` | launcher device previews (last picture, local 0600 cache); viewer sign-in keeps the local host user service running so the machine joins the account's device list |
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),
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoder and codec with source, sign-in/service state; booleans and names only), `set-encoder auto|cpu|vaapi|nvenc` and `set-codec auto|h264|h265` (both notify a running host with SIGUSR2; live encoder switch, negotiated codec unchanged, codec preference on the next desktop stream; illegal values exit 2), `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_CHROMA=444` 真彩; `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.
@@ -200,6 +211,11 @@ started a second full host server instead, so check that a subcommand exists in
- SystemMetrics (Message 13): GeneralMetric `2 system_sound_support` is an enum, **2 = supported** (1 = not
supported); SettingMetric 1 keep_mute, 2 mute_permanent, 3 auto_lock, 5 file_transfer_save_location,
8/9/10 permission states (2 = allow).
- 防窥 (privacy screen): RpcRequest 7 `PrivateScreenSettingRequest {1 enable, 2 privacy_type, 3 setting_source}` →
RpcResponse 3 `{1 error_code, 2 req_privacy_type, 3 cur_privacy_type}`; PrivateScreenType 1 NOT_SET, 2 NORMAL,
3 ENHANCED (wallpaper). Declared on X11 only: FeatureFlag `4 ff_private_screen=1`, `3 ff_system_metrics=3`;
SettingMetric 4 private_screen, 7 private_screen_type (`src/privacy_screen.rs`, xrandr brightness 0, saved
gamma restored on session end / SIGTERM / next start). Not yet accepted with an official viewer.
- Security menu: 静音运行 on → SimpleAction 14 + 18, off → 16. 远程结束后自动锁屏 → SimpleAction 19 with
`value` (field 5) **2 = on, 1 = off**. The viewer sends these only when toggled, so the host persists them.
- Auto unlock: host reports `SystemStateChange{1 SecureDesktopState{1 is_locked, 5 is_support_auto_logon}}`;
@@ -276,10 +292,12 @@ started a second full host server instead, so check that a subcommand exists in
- Update README.md / README.en.md when user-visible features or limitations change, and add
`docs/release-notes/<tag>.md` before tagging a release.
### VAAPI (opt-in / 显式启用)
### VAAPI
`UU_VIDEO_ENCODER=vaapi` selects Intel/AMD H.264 VAAPI; `UU_VAAPI_DEVICE` defaults to
`/dev/dri/renderD128` (render-node permissions required). No automatic VAAPI selection.
`UU_VIDEO_ENCODER=vaapi` or `set-encoder vaapi` selects Intel/AMD H.264 VAAPI explicitly.
`UU_VAAPI_DEVICE` defaults to `/dev/dri/renderD128` (render-node permissions required).
Auto is NVENC then CPU when an NVIDIA driver is present, otherwise CPU. VAAPI is not an
auto candidate until #33.
The FFmpeg process pipeline uploads NV12 frames to a VAAPI frame pool. With `--features inproc-av` on X11, VAAPI
H.264/HEVC Main runs in process: a DRI3 DMA-BUF of the root (XShm upload without DRI3) goes through VPP to NV12
and VCN, with SPS/PPS(/VPS) and slice headers packed by the host as radeonsi (Mesa 26) needs; parameters follow
Generated
+38 -3
View File
@@ -2,6 +2,22 @@
# It is not intended for manual editing.
version = 4
[[package]]
name = "ab_glyph"
version = "0.2.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2"
dependencies = [
"ab_glyph_rasterizer",
"owned_ttf_parser",
]
[[package]]
name = "ab_glyph_rasterizer"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
[[package]]
name = "adler2"
version = "2.0.1"
@@ -1440,6 +1456,15 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
[[package]]
name = "owned_ttf_parser"
version = "0.25.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b"
dependencies = [
"ttf-parser",
]
[[package]]
name = "p256"
version = "0.13.2"
@@ -2629,6 +2654,12 @@ version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
[[package]]
name = "ttf-parser"
version = "0.25.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
[[package]]
name = "tungstenite"
version = "0.23.0"
@@ -2741,8 +2772,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.2.24"
version = "0.2.41"
dependencies = [
"ab_glyph",
"async-trait",
"base64 0.22.1",
"bytes",
@@ -2758,12 +2790,14 @@ dependencies = [
"nix 0.29.0",
"qrcode",
"rand 0.8.8",
"rcgen",
"reqwest",
"sdl2",
"serde",
"serde_json",
"sha2",
"tokio",
"tokio-rustls",
"tokio-tungstenite",
"webrtc",
"x11rb",
@@ -3008,23 +3042,24 @@ dependencies = [
[[package]]
name = "webrtc-ice"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1bbd6b3dea22cc6e961e22b012e843d8869e2ac8e76b96e54d4a25e311857ad"
dependencies = [
"arc-swap",
"async-trait",
"crc",
"log",
"rand 0.8.8",
"rustls-native-certs",
"serde",
"serde_json",
"stun",
"thiserror 1.0.69",
"tokio",
"tokio-rustls",
"turn",
"url",
"uuid",
"waitgroup",
"webpki-roots 1.0.9",
"webrtc-mdns",
"webrtc-util",
]
+10 -2
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.2.24"
version = "0.2.41"
edition = "2021"
default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"]
@@ -23,7 +23,7 @@ required-features = ["native-viewer"]
default = []
native-viewer = []
viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"]
viewer-sdl = ["native-viewer", "dep:sdl2"]
viewer-sdl = ["native-viewer", "dep:sdl2", "dep:ab_glyph"]
wayland = []
# Experimental direct linear framebuffer capture; never enabled in release builds.
kms = []
@@ -59,6 +59,12 @@ ffmpeg-next = { version = "6.1", optional = true, default-features = false, feat
x11rb = { version = "0.13", features = ["damage", "shm", "allow-unsafe-code"], optional = true }
sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] }
ab_glyph = { version = "0.2", optional = true }
[dev-dependencies]
# Synthetic loopback WSS certificates only; both crates already occur in Cargo.lock.
rcgen = "0.11.3"
tokio-rustls = { version = "0.26.6", default-features = false, features = ["ring", "tls12"] }
[build-dependencies]
cc = "1.0"
@@ -69,6 +75,8 @@ webrtc-srtp = { path = "vendor/webrtc-srtp" }
webrtc-dtls = { path = "vendor/webrtc-dtls" }
# Larger data-channel receive buffer (see vendor/webrtc/src/data_channel/mod.rs).
webrtc = { path = "vendor/webrtc" }
# TURN over TCP/TLS through an HTTP CONNECT proxy (vendor/webrtc-ice/PATCHES.md).
webrtc-ice = { path = "vendor/webrtc-ice" }
[[bench]]
name = "nvenc_pipeline_bench"
+98 -18
View File
@@ -21,7 +21,23 @@
<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>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>
<p align="center"><sub>Linux host main window: remote assistance and account (device ID, code and account redacted). The UI is available in Chinese and English (see [Language](#language--语言)).</sub></p>
## Language / 语言
The language is picked once at start, in this order:
1. `UU_LANG=en` or `UU_LANG=zh`;
2. the choice saved in the viewer's **Settings → General → 语言 / Language**
or the host main window's 语言 / Language row; stored as `~/.config/uuremote/language`, applies after a restart);
3. the locale: `LC_ALL` / `LC_MESSAGES` / `LANG` starting with `zh` → Chinese, anything else → English.
```sh
UU_LANG=en uuremote-viewer ui
UU_LANG=zh uuremote-server
```
Protocol strings and messages that come from the UU servers are shown as the server sends them.
<!-- 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 +61,7 @@
| Mouse / keyboard | Absolute and relative motion, clicks, wheel, keys; no spurious key repeat on high-latency links; optional uinput virtual devices on Wayland (layout independent, see below) |
| Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) |
| Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
| Clipboard | Two-way text sync |
| Clipboard | Two-way text sync; Wayland mobile IME text inputs use clipboard paste fallback (see below) |
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder |
| Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
| File transfer | Upload, download (including folders), create folder, rename, delete |
@@ -73,7 +89,7 @@ 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` |
| niri | Wayland (native wlroots protocols) | 🧪 Experimental; capture, text input and portrait switching hardware-tested; other features pending (#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
@@ -84,6 +100,10 @@ plugins, permissions and encoders only, no account data, tokens or addresses) an
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.
**Touch from mobile viewers (GNOME)**: in touch mode the Android/iOS viewers send a finger as a left-button drag, which on a desktop selects text. On the portal backend the host decides per press: a finger that moves more than a few pixels within 0.45 s scrolls smoothly (`NotifyPointerAxis`; the content follows the finger, also in terminals, and the last event lets clients coast), one held still selects like a mouse drag, and a short press clicks. This needs no touchscreen consent. `UU_TOUCH_INPUT=touch` instead replays drags as one finger on the portal touchscreen, which the host requests where the portal offers it; a consent saved before touch support restores keyboard and pointer only, so the first drag then asks the host once more in the background (the GNOME share dialog, which the phone also sees; it closes after the consent timeout), and an approval for the same monitor switches to touch without reconnecting. The saved consent is never removed beforehand, and the host asks at most once per run. `UU_TOUCH_INPUT=0` keeps mouse drags.
**Mobile IME typing and clipboard on Wayland**: Mobile IME text (`text_input`) on Wayland is typed through spare keycodes on wlroots compositors. On GNOME (Portal) printable ASCII is typed as keysyms when the active input source is a Latin xkb layout (Mutter picks the key and Shift level); other text, KDE and compositors where keycodes are exhausted fall back to "system clipboard write + `Shift+Insert` (or `UU_WAYLAND_PASTE_KEY=ctrl_v`)". VTE terminals paste the PRIMARY selection on `Shift+Insert`, which is why ASCII is typed instead. **Note**: This fallback replaces the host's existing clipboard contents and may echo back to the viewer's clipboard via two-way sync; set `UU_WAYLAND_TEXT=0` to completely disable Wayland mobile text input and clipboard paste fallback.
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.
GNOME Portal CONTROL no longer waits for a consent dialog or the first video frame. It announces the selected desktop before reporting secure-desktop state and receiving the official viewer's “auto unlock host” request. The official Android viewer requires this desktop selection before entering its auto-unlock flow, so the notification must precede capture readiness; actual screen dimensions, codec information and capture permissions still follow their real readiness state. Enable auto unlock in the viewer and use the current Linux user's login password. The host verifies it with PAM, unlocks the existing GNOME session, requests display wake, and restores capture, input and clipboard through the shared Portal session. Initial consent or revoked permissions still require local approval. Reconnect if physical or logical dimensions change.
@@ -94,7 +114,7 @@ Existing screen-off and lock settings remain unchanged. Only capture recovery in
Locked black video requires FFmpeg's libx264/libx265 encoder for the negotiated H.264/H.265 codec; hardware encoding support alone does not satisfy this dependency. Encoder failures are logged explicitly. Synthetic video does not change capture permissions or advertised monitor dimensions. It pauses on unlock or unknown lock state, ends when capture is ready/rejected or the connection closes, and then hands the same video track to real capture. See [#29](../../issues/29) and [#34](../../pull/34) for the controlled experiment and validation scope.
The native Wayland backend needs `wlr-output-power-management` from the compositor to wake a turned-off screen; without it only wake is unavailable — capture and encoding are unaffected.
The native Wayland backend needs `wlr-output-power-management` from the compositor to wake a turned-off screen; without it only wake is unavailable — capture and encoding are unaffected. Display-wake failures at video startup or during streaming are logged and retried at the next interval without ending the video stream; capture, encoder and send errors retain their existing handling.
Native Wayland experiments: `UU_WAYLAND_PIPELINE=0` disables pipelining for comparison.
`UU_WAYLAND_DMABUF=1` explicitly tries dma-buf → GBM CPU mapping (off by default;
@@ -104,23 +124,27 @@ 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)
### 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.
X11 sessions send all monitors as one combined picture by default. With `UU_X11_MULTISCREEN=1` the host lists the monitors from `xrandr --listmonitors`; the viewer selects one, only that region is captured, and absolute pointer positions are offset to that monitor. The primary monitor is the default; `UU_X11_OUTPUT` picks another (e.g. `HDMI-1`). The layout is read when the host starts; restart the service after changing it. In this mode the viewer's resolution setting scales the stream instead of changing the display mode. Experimental: unit tests and Xvfb virtual monitors only, not yet accepted with the official clients.
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%.
On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/180/270-degree capture and pointer transforms are enabled only with `NIRI_SOCKET`; reflected transforms are excluded. Three-output switching, 90-degree portrait capture/click alignment, and mobile Chinese input into Codex were hardware-tested on CachyOS + niri. Other compositors retain their existing text path and reject rotated outputs. Restart after layout changes. The temporary printable-key text keyboard is niri-only; the Hyprland fast path and pristine-keymap restoration are unchanged.
## Not implemented / not supported
| Feature | Status |
|---|---|
| Switching between multiple monitors | Experimental on native Hyprland Wayland; see above |
| Switching between multiple monitors | Experimental on native niri / Hyprland Wayland and on X11 (`UU_X11_MULTISCREEN=1`); 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; `inproc-av` native NVENC encodes H.264 High 4:4:4 / HEVC FRExt; VAAPI stays 4:2:0 and reports that to the client |
| HDR | Not implemented |
| Super screen / virtual display | Not implemented |
| Privacy screen on the host | Not implemented |
| Privacy screen on the host | 🧪 Experimental, X11 only: output brightness (gamma) is set to 0 so the physical monitors go black while the remote picture stays normal; normal privacy (black) only, no wallpaper mode; not on Wayland. Restored when the session ends or the service stops/restarts. Overrides custom gamma such as night light; local mouse/keyboard stay active |
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) |
| 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 |
@@ -139,16 +163,21 @@ uuremote-server login # scan the QR code with
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).
The deb installs the binaries, plugins, a systemd user unit and menu entries, and pulls in FFmpeg as a dependency; 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:
**Other distributions**: download `uu-remote-linux-<version>-x86_64-linux.tar.gz` (ARM64: `aarch64-linux`) from [Releases](../../releases/latest), extract it, then run as your desktop user (not root):
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
install -Dm644 libuu-wayland.so libuu-portal.so -t ~/.local/lib/uu-remote-linux/
cd uu-remote-linux-<version>-x86_64-linux
./install.sh # --yes: don't ask; --no-ffmpeg: check only
```
The script installs the binaries and plugins under `~/.local`, writes the systemd user unit (an existing one is kept) and checks
FFmpeg with libx264 (without it the viewer stays on 正在传输画面). A missing FFmpeg is installed through sudo with apt or pacman;
Fedora needs RPM Fusion and openSUSE needs Packman first, and the script only prints the command instead of adding third-party repositories.
The host also checks FFmpeg at startup and on every desktop connection: when it is not runnable it logs an error and shows a desktop notification (without a notification daemon it opens its window with a red hint), at most every 5 minutes. Install it and reconnect; no restart is needed.
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.
@@ -203,6 +232,10 @@ Run inside your graphical session:
Scan the code with the **NetEase UU Remote mobile app** and confirm. Credentials are stored only on this
machine, in `~/.config/uuremote/config.json` (mode 0600).
A failed status query or the 60-second request timeout does not prove that the QR expired or that the phone confirmed login. The official-client refresh policy is unchanged: after a query error, click Refresh QR (Enter in a terminal; refresh after 60 seconds with neither a window nor a terminal). QR request diagnostics contain only the request phase, error category, elapsed time, HTTP/API status and last known scan state—not tickets, URLs or response content. A `connect` category alone does not identify a DNS, TLS or proxy cause.
The same file holds this machine's device identity (`device_id`, `client_id`, `system_id`), which reinstalls and new QR logins keep. **Do not copy `config.json` between machines or clone a second host from a snapshot/disk that includes the home directory**: two host instances with one identity, on the same or different machines, kick each other out of the room. The log then shows `Cloud room leave without peer identifier` every few seconds with reconnects, and viewers disconnect right after connecting. On a cloned or copied machine, stop the service, remove those three keys plus `token`, `csrf` and `user_id`, and run `uuremote-server login` to register a new device. A leftover instance on the same machine (for example an old `~/.local/bin/uuremote-server` started by hand) has the same effect; `uuremote-server doctor` warns when more than one host instance is running.
### 4. Run as a user service
`~/.config/systemd/user/uuremote-native.service`:
@@ -331,13 +364,17 @@ 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_DESKTOP_RESIZE=0` | on X11, keep the desktop resolution and only scale the encoded stream when the viewer picks a resolution |
| `UU_NVENC_RGB=0` / `=1` | NVENC encodes BGRA directly (saves CPU). Off by default when a monitor is connected to the NVIDIA card (slower when the desktop is composited on the same GPU); `0` forces off, `1` forces on |
| `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_X11_MULTISCREEN=1` | Select and capture X11 monitors separately (experimental, off by default, needs `xrandr`) |
| `UU_X11_OUTPUT` | Initial X11 monitor name (`xrandr --listmonitors`); default: the primary |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) |
| `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_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 |
| `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_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default is 100-500 kbit, set `1000` when high-resolution keyframes blur and flicker once per GOP (#103) |
| `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) |
@@ -345,10 +382,35 @@ Common environment variables:
| `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 |
| `UU_USE_PROXY=1` | Share environment HTTP/HTTPS proxy policy between REST and host/viewer WebSocket signaling; proxies are ignored by default |
`UU_USE_PROXY=1` uses only proxy settings already available to the current process. `HTTP_PROXY` / `HTTPS_PROXY` / `ALL_PROXY` (and lowercase forms) and `NO_PROXY` follow reqwest's standard selection, with uppercase taking precedence. Signaling rejects invalid/unsupported values in the selected variables (HTTP/HTTPS only, not SOCKS), proxy URLs with paths/queries/fragments, and CGI environments that would ignore proxies; this validation is intentionally stricter than silently ignoring bad values. No matching proxy or a `NO_PROXY` match still means direct access; a selected proxy failing does not trigger direct fallback. Certificate verification remains enabled and redirects are not followed, so room authentication is not forwarded to a redirect target.
With it the host also reaches the cloud TURN relays over TCP/TLS (CONNECT through the unauthenticated `http://` proxy in `HTTPS_PROXY`/`ALL_PROXY`, or directly without one), for hosts whose UDP cannot reach the TURN servers but whose TCP/proxy can. TURN certificates are chain-verified; a name mismatch is tolerated only when the cloud-supplied TURN address is an IP (media itself is end-to-end DTLS-SRTP). Without the setting only UDP relays are used, as before. **This creates no new network access**: login, signaling and media each still need an allowed network path. Connector errors expose only fixed categories/HTTP status; do not enable dependency TRACE logs that may record URLs or authentication information.
Host settings such as "lock after remote session" and "mute host" are stored in
`~/.config/uuremote/host_settings.json`.
`~/.config/uuremote/host_settings.json`. The same file stores `video_encoder`
(`auto`/`cpu`/`vaapi`/`nvenc`) and `video_codec` (`auto`/`h264`/`h265`), written by
`uuremote-server set-encoder` and `uuremote-server set-codec` (illegal arguments exit 2).
A value other than `auto` beats `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`; `auto` or a missing
field falls through to the environment, then to auto (NVENC then CPU when an NVIDIA driver
is loaded; CPU with no probe when it is not; codec stays H.265 on hardware and H.264 on CPU).
The probe runs in the background at startup and does not delay the first picture. A success
stays cached until the process exits, except when NVIDIA presence (`/proc/driver/nvidia/version`
or `/dev/nvidia0`) no longer matches the report: the next desktop connection then starts one
background re-probe (`warm_auto_probe`) and still uses the cached encoder until the new result
is stored. An NVENC failure is kept for 10 minutes, and the next desktop connection after that
starts the same background re-probe while still using the cached encoder. `set-encoder` and
`set-codec` both send `SIGUSR2` to the host in `host.pid` when that process is this program.
An encoder change switches each live desktop stream without disconnecting and keeps the codec
negotiated for that session. A failed start follows the existing fallback (in-process, then the
FFmpeg process, then CPU). After a hand edit, `kill -USR2 $(cat ~/.config/uuremote/host.pid)`
does the same. `SIGUSR2` does not re-probe. A codec change takes effect the next time a desktop
connection starts; the running host only logs it. Explicit `vaapi` with 真彩 stays on VAAPI,
encodes 4:2:0, and reports chroma 4:2:0 in CaptureSettingSync field 3. If the chosen encoder
cannot start, the stream falls back to CPU and logs a warning. VAAPI is not an auto candidate
until #33.
Custom bitrate follows the Mbps value selected in the client; for example, 1 Mbps sets an encoder cap of 1000 kbit/s.
@@ -426,10 +488,12 @@ AUD only at IRAPs and drops every other picture from the bitstream, so an AUD-ba
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 / 显式启用)
### VAAPI
`UU_VIDEO_ENCODER=vaapi` selects Intel/AMD H.264 VAAPI; `UU_VAAPI_DEVICE` defaults to
`/dev/dri/renderD128` (render-node permissions required). No automatic VAAPI selection.
`UU_VIDEO_ENCODER=vaapi` or `set-encoder vaapi` selects Intel/AMD H.264 VAAPI explicitly.
`UU_VAAPI_DEVICE` defaults to `/dev/dri/renderD128` (render-node permissions required).
`auto` is NVENC then CPU when an NVIDIA driver is present, and CPU otherwise. VAAPI is
selected only explicitly; putting it in auto waits on #33.
The FFmpeg process uploads NV12 frames to a VAAPI frame pool; a self-built `--features inproc-av`
binary instead runs VAAPI in process on X11 (a DRI3 DMA-BUF of the root window zero-copy, or XShm
upload without DRI3, then VPP to NV12 and VCN; H.264/HEVC).
@@ -525,7 +589,8 @@ terminal emulator (`TERMINAL` selects one). From source: `sudo apt install libsd
`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
On niri, data-control-capable `wl-clipboard` is used instead, so synchronization does not require window focus.
Other SDL backends synchronize only while that window is focused. The 30 KiB text limit applies. 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.
@@ -538,11 +603,26 @@ GNOME-to-official-Mac bidirectional clipboard synchronization is still unverifie
- 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`.
- **Secure `type` input** (inject keystrokes into an open desktop session — lock-screen PIN/password; never put secrets on argv):
```sh
# Preferred: open desktop via ui/connect first, then type (reuses the session; does not kick the live view)
UU_INPUT_ENV=UU_SECRET UU_SECRET='…' \
uuremote-viewer type DEVICE [--delay-ms 40] [--omit-last 1] [--snapshot /path/out.png]
# Or: printf '%s' '…' | uuremote-viewer type DEVICE
# Validate only, no network: uuremote-viewer type DEVICE --dry-run
# If no desktop viewer is running you must pass --new-session (opens a new peer and replaces any already-open desktop window; upstream #30)
```
Brace tokens: `{Enter}` `{Tab}` `{Esc}` `{Backspace}` `{Ctrl+Alt+Del}` …; `{{` is a literal `{`.
**Layout**: characters are mapped for **US QWERTY** only (non-US layouts may mistype symbols/letters).
**Windows numeric PIN**: Windows often submits automatically once enough digits are entered — usually no `{Enter}` needed. Use `--omit-last N` to omit the last N characters when you want to fill without signing in.
Logs and `--dry-run` report lengths/event counts only. When reusing a session, about one second after sending, a PNG frame is saved (default under `$XDG_RUNTIME_DIR/uu-viewer-type/`, mode 0600); the path is logged and printed as `snapshot=…`.
- 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.
- Frames are decoded at the host's native resolution and scaled to the window with linear filtering; a host resolution
change restarts the decoder. `UU_VIEWER_SIZE=WxH` forces a fixed letterboxed canvas instead.
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
+76 -20
View File
@@ -19,6 +19,21 @@
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Linux 主机主窗口:远程协助与账号"></p>
<p align="center"><sub>Linux 被控端主窗口:远程协助与账号(设备 ID、验证码和账号已打码)</sub></p>
## 语言 / Language
启动时按以下顺序确定界面语言:
1. `UU_LANG=zh` 或 `UU_LANG=en`;
2. 控制端 **设置 → 常规 → 语言 / Language** 或主机主窗口底部「语言 / Language」中保存的选择(保存在 `~/.config/uuremote/language`,重启后生效);
3. 系统区域设置:`LC_ALL` / `LC_MESSAGES` / `LANG` 以 `zh` 开头为中文,其余为英文。
```sh
UU_LANG=zh uuremote-viewer ui
UU_LANG=en uuremote-server
```
协议字段以及 UU 服务器返回的提示按服务器原文显示。
<!-- 截图占位:在官方客户端里远控 Linux 桌面的效果图。请自行截图并去掉账号、设备名等信息后放到
docs/images/remote-desktop.png,再取消下面这行的注释。注意不要截入网易的图标和品牌素材。 -->
<!-- <p align="center"><img src="docs/images/remote-desktop.png" width="720" alt="用官方 Mac 客户端远控 Linux 桌面"></p> -->
@@ -39,7 +54,7 @@
| 鼠标 / 键盘 | 绝对/相对移动、点击、滚轮、按键;修复了网络延迟导致的按键连发;Wayland 下可用 uinput 虚拟键鼠(不依赖键盘布局,见下文) |
| Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) |
| 鼠标指针样式 | 远端指针形状实时同步(X11) |
| 剪贴板 | 双向文本同步 |
| 剪贴板 | 双向文本同步;Wayland 手机输入法输入通过剪贴板兜底粘贴,见下文 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 |
@@ -65,7 +80,7 @@ Portal 仅作用于本服务获授权的会话。文件传输、终端等独立
| Xfce | X11 | ✅ 虚拟机测试通过 | 默认 |
| Cinnamon / MATE | X11 | ✅ 虚拟机测试通过 | 默认 |
| Hyprland | Wayland(wlroots 原生协议) | 🧪 实验性,虚拟机测试(部分功能受限,见下) | `--features wayland` |
| niri | Wayland(wlroots 原生协议) | 🧪 实验性,协议支持已按 niri 源码确认,尚未实机验收(#55) | `--features wayland` |
| niri | Wayland(wlroots 原生协议) | 🧪 实验性,采集、文字输入及竖屏切换已实机验收,其余待验证(#55) | `--features wayland` |
| GNOME / KDE Plasma | Wayland(xdg-desktop-portal) | 🧪 实验性,验证范围与限制见下 | `--features wayland,portal` |
最后一列是源码编译方式;Release 预编译包已包含全部后端,直接使用即可(见[安装](#0-直接用-release-预编译包推荐x86_64))。
@@ -75,6 +90,10 @@ GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/20
Wayland 下的限制:默认采集单屏,Hyprland 可按上文启用切屏;分辨率固定;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
**手机控制端触控(GNOME)**:Android/iOS 控制端在触控模式下把手指当作左键拖动发送,在桌面上会选中文字。Portal 后端下被控端按每次按下判断:0.45 秒内移动超过几个像素即平滑滚动(`NotifyPointerAxis`,内容跟随手指,终端里同样有效,最后一个事件让客户端可以惯性滑动);按住不动则像鼠标拖动一样选中;短按为点击。此模式无需触摸屏授权。`UU_TOUCH_INPUT=touch` 改为把拖动按单指触控在 Portal 触摸屏上重放,门户提供触摸屏设备类型时被控端会一并申请;此前保存的授权只恢复键盘和指针,因此第一次拖动时会在后台再申请一次(GNOME 共享对话框,手机画面中也能看到,授权超时后自动关闭),同意同一显示器后无需重连即切换为触控。不会预先删除已保存的授权,每次运行最多申请一次。`UU_TOUCH_INPUT=0` 保持鼠标拖动。
**Wayland 手机输入法打字与剪贴板**:Wayland 下手机端输入法提交的文字(`text_input`)优先通过虚拟键盘空闲键码上屏;GNOME(Portal)下,当前输入源为拉丁 xkb 布局时,可打印 ASCII 直接以 keysym 输入(由 Mutter 选择按键和 Shift 层级);其他文字、KDE 以及键码耗尽的环境自动通过「写系统剪贴板 + 触发 `Shift+Insert`(或 `UU_WAYLAND_PASTE_KEY=ctrl_v`)」兜底粘贴。VTE 终端的 `Shift+Insert` 粘贴的是 PRIMARY 选区,因此 ASCII 改为直接输入。**注意**:此兜底过程会覆盖被控端原有的剪贴板内容,且会被双向同步回传到控制端剪贴板;设置 `UU_WAYLAND_TEXT=0` 可完全关闭 Wayland 文字输入及该粘贴兜底。
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 逻辑尺寸仅用于本地输入映射。
GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通知客户端当前选择桌面,再上报锁屏状态、接收官方客户端的「自动解锁被控端」请求。官方 Android 客户端需要桌面目标通知才会进入自动解锁流程,因此该通知不能等待采集就绪;真实屏幕尺寸、编码信息及采集权限仍按实际就绪状态上报。请在客户端启用自动解锁,使用当前 Linux 用户的登录密码;主机通过 PAM 验证后解锁当前 GNOME 会话、请求点亮屏幕,并恢复同一 Portal 会话中的画面、键鼠和剪贴板。首次授权或权限被撤销时仍需本机确认。物理或逻辑分辨率变化后需要重连。
@@ -85,28 +104,32 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。
原生 Wayland 后端需要合成器提供 `wlr-output-power-management` 才能唤醒已关闭的屏幕;缺少该协议不影响采集和编码。
原生 Wayland 后端需要合成器提供 `wlr-output-power-management` 才能唤醒已关闭的屏幕;缺少该协议不影响采集和编码。视频启动及运行期间,屏幕保活失败仅记录警告并在下轮重试,不终止视频;实际采集、编码或发送错误仍按原逻辑处理。
原生 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%)双屏切换及点击。
X11 会话默认把所有显示器拼成一张画面。设置 `UU_X11_MULTISCREEN=1` 后,主机按 `xrandr --listmonitors` 列出各个显示器,控制端可选择其中一块,只采集该区域,绝对鼠标坐标加上该屏幕在桌面中的偏移;默认屏幕为主显示器,`UU_X11_OUTPUT` 可指定其他屏幕(如 `HDMI-1`)。显示器布局在主机启动时读取,改动后需重启服务。此模式下控制端的「分辨率」改为缩放画面,不再修改显示模式。实验性:目前只有单元测试与 Xvfb 虚拟显示器实测,尚未经官方客户端实机验收。
切屏复用同一条视频轨道,过渡期间暂停输入,发送新屏首帧后恢复;采集或编码失败、等待首帧超时会请求恢复原屏。Hyprland 通过 `hyprctl` 枚举未旋转的显示器,显示器插拔或布局变化后需重启服务。已在 Omarchy / Hyprland 上用官方手机客户端实测 2560×1440(125%)与 1920×1080(133.33%)双屏切换及点击。
niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通及 90°/180°/270° 旋转输出仅在 `NIRI_SOCKET` 存在时启用;镜像变换暂不支持。三屏切换、90° 竖屏画面与点击,以及手机向 Codex 输入中文已在 CachyOS + niri 实测。其他合成器继续拒绝旋转输出,保留原有文本输入路径。显示器布局变化后需重启服务。
## 尚未实现 / 不支持
| 功能 | 状态 |
|---|---|
| 多显示器切换 | Hyprland 原生 Wayland 后端实验性支持,见上文 |
| 多显示器切换 | niri / Hyprland 原生 Wayland 后端与 X11(`UU_X11_MULTISCREEN=1`)实验性支持,见上文 |
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;`inproc-av` 原生 NVENC 输出 H.264 High 4:4:4 / HEVC FRExt;VAAPI 管线仍为 4:2:0,并如实回报给客户端 |
| HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 |
| 被控端防窥模式 | 未实现 |
| 被控端防窥模式 | 🧪 实验性,仅 X11:把显示器输出的亮度(gamma)调为 0,物理屏幕变黑,远程画面照常;只支持「普通防窥」(黑屏),不支持壁纸防窥;Wayland 未实现。连接断开、服务退出或重启时恢复屏幕。会改写夜间模式等自定义 gamma,本地鼠标键盘不会被禁用 |
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
@@ -125,16 +148,20 @@ uuremote-server login # 用 UU 远程 App 扫
systemctl --user enable --now uuremote-native.service # 随图形会话启动
```
deb 会安装程序、插件、用户级 systemd 服务和应用菜单图标;uinput 权限不会自动开启(见第 5 步)。
deb 会安装程序、插件、用户级 systemd 服务和应用菜单图标,并通过依赖自动装上 FFmpeg;uinput 权限不会自动开启(见第 5 步)。
GNOME / KDE 会把显示环境自动传给服务;Xfce 等不传的桌面需按第 4 步补 `DISPLAY`。
**其他发行版**:从 [Releases](../../releases/latest) 下载 `uu-remote-linux-<版本>-x86_64-linux.tar.gz`(ARM64 选 `aarch64-linux`),解压后:
**其他发行版**:从 [Releases](../../releases/latest) 下载 `uu-remote-linux-<版本>-x86_64-linux.tar.gz`(ARM64 选 `aarch64-linux`),解压后用普通桌面用户(不要 root)运行:
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
install -Dm644 libuu-wayland.so libuu-portal.so -t ~/.local/lib/uu-remote-linux/
cd uu-remote-linux-<版本>-x86_64-linux
./install.sh # 加 --yes 不询问;--no-ffmpeg 只检查不安装
```
脚本把程序和插件装到 `~/.local`,写入用户级 systemd 服务(已有则保留),并检查 FFmpeg(需带 libx264,否则客户端会一直停在「正在传输画面」)。
缺 FFmpeg 时经 sudo 用 apt / pacman 安装;Fedora 需先启用 RPM Fusion,openSUSE 需 Packman 源,脚本只提示命令、不替你添加第三方源。
服务启动时和每次有人连接桌面时都会检查 FFmpeg:不可用就记 error,并弹桌面通知(没有通知服务时打开主窗口,顶部红字提示安装方法,最多每 5 分钟一次);装好后重新连接即可,不用重启服务。
同一个包支持 X11、Hyprland 等 wlroots 合成器和 GNOME/KDE Wayland:程序启动时按当前会话自动选择后端,只在 Wayland 会话里
才加载对应的 `libuu-*.so`,X11 用户不需要任何 Wayland 库。系统要求:
@@ -187,6 +214,10 @@ cargo build --release --features wayland,portal # + GNOME/KDE Wayland
用手机上的 **网易 UU 远程 App** 扫码并确认即可。登录信息只保存在本机的
`~/.config/uuremote/config.json`(权限 0600)里。
登录状态查询失败或达到 60 秒请求超时不代表二维码已过期,也不代表手机已经确认。程序保留官方客户端的刷新策略:查询出错后点击「刷新二维码」(终端按回车;无窗口且无终端时 60 秒后刷新)。二维码请求诊断只包含请求阶段、错误类别、耗时、HTTP/API 状态及最后已知扫码状态,不输出票据、URL 或响应内容;`connect` 类别本身不能确定是 DNS、TLS 还是代理问题。
这个文件里还有本机的设备身份(`device_id`、`client_id`、`system_id`),重装软件和重新扫码登录都会沿用它。**不要在机器之间拷贝 `config.json`,也不要从带着家目录的快照/数据盘克隆出第二台主机**:同一身份的两个主机实例(不论在同一台还是不同机器上)会互相把对方踢出房间,日志表现为每隔几秒出现 `Cloud room leave without peer identifier` 并反复重连,控制端一连就断。克隆或拷贝出来的机器先停掉服务,删掉配置里这三个键和 `token`、`csrf`、`user_id`,再运行 `uuremote-server login` 注册为新设备。同一台机器上残留的旧实例(例如以前手动启动的 `~/.local/bin/uuremote-server`)也会这样,`uuremote-server doctor` 发现多个主机实例时会提示。
### 4. 作为用户服务常驻
`~/.config/systemd/user/uuremote-native.service`:
@@ -300,13 +331,17 @@ systemctl --user restart uuremote-native.service
| `UU_CONFIG` | 配置文件路径(默认 `~/.config/uuremote/config.json`) |
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) |
| `UU_DESKTOP_RESIZE=0` | X11 下控制端切换分辨率时不改桌面分辨率,只缩放编码画面 |
| `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland 物理显示器切换(默认关闭) |
| `UU_NVENC_RGB=0` / `=1` | NVENC 直接编码 BGRA(省 CPU)。显示器接在 NVIDIA 卡上时默认关闭(同卡合成时直吃反而更慢),`0` 强制关,`1` 强制开 |
| `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland / niri 物理显示器切换(默认关闭) |
| `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` |
| `UU_X11_MULTISCREEN=1` | X11 下按显示器分别选择和采集(实验性,默认关闭,需要 `xrandr`) |
| `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) |
| `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_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto |
| `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 |
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认 100–500 kbit,1440p 等高分辨率下关键帧被压糊、按 GOP 周期闪烁时设 `1000`(#103) |
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
@@ -314,9 +349,14 @@ systemctl --user restart uuremote-native.service
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) |
| `UU_USE_PROXY=1` | 使用环境变量里的 HTTP/SOCKS 代理;默认忽略代理、直连网易服务器 |
| `UU_USE_PROXY=1` | REST API 与 host/viewer WebSocket 信令共用环境 HTTP/HTTPS 代理策略;默认忽略代理、直连 |
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。
`UU_USE_PROXY=1` 仅使用当前进程已有的代理配置;`HTTP_PROXY` / `HTTPS_PROXY` / `ALL_PROXY`(及小写形式)和 `NO_PROXY` 按 reqwest 的标准规则选择,大写优先。信令拒绝选定变量中的无效/不支持的代理 URL(仅 HTTP/HTTPS;不支持 SOCKS)、带路径/查询/片段的代理 URL,以及会忽略代理的 CGI 环境;此校验比 reqwest 默默忽略坏值更严格。未配置匹配代理或命中 `NO_PROXY` 时仍正常直连,选中代理后连接失败不会改为直连。信令保留 TLS 证书校验,不跟随重定向,也不转发认证头到重定向目标。
开启后主机还会经 TCP/TLS 连接云端 TURN 中继(使用 `HTTPS_PROXY`/`ALL_PROXY` 里的无认证 `http://` 代理做 CONNECT,没有代理则直连),适用于 UDP 到不了 TURN 服务器、只有 TCP/代理能出网的主机;TURN 证书按 CA 链校验,云端下发的 TURN 地址是 IP 时容忍名称不匹配(媒体本身由 DTLS-SRTP 端到端加密)。默认(不开代理)只用 UDP 中继,行为不变。**这不创建任何新的网络出口**:登录、信令和媒体仍需各自有允许使用的网络路径。连接器只返回固定错误类别/HTTP 状态;不要为诊断开启会记录 URL/认证信息的依赖库 TRACE 日志。
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。同一文件里的 `video_encoder`(`auto`/`cpu`/`vaapi`/`nvenc`)和 `video_codec`(`auto`/`h264`/`h265`)用 `uuremote-server set-encoder`、`uuremote-server set-codec` 写入(非法参数退出码 2)。非 `auto` 的值优先于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`;`auto` 或留空则落到环境变量,再落到 auto(有 NVIDIA 时 NVENC 优先,失败再 CPU;没有 NVIDIA 时就是 CPU,不探测;codec 仍是硬件优先 H.265、CPU 用 H.264)。探测在启动时后台进行,不挡住第一路出图。成功结果缓存到进程退出,但 NVIDIA 是否存在(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)与报告不一致时,下一次桌面连接会在后台再探测一次(`warm_auto_probe`),这一路仍用缓存的编码器,直到新结果写入。NVENC 失败只缓存 10 分钟,到期后的桌面连接同样在后台再探测一次,这一路仍用当前结果。`set-encoder` 和 `set-codec` 写完后若 `host.pid` 指向正在运行的本程序,都会发 `SIGUSR2`:编码器变化时进行中的桌面流立刻换编码器(不断开,沿用本会话已协商的 codec;新编码器起不来时按进程内 → FFmpeg 进程 → CPU 回退)。手改文件后可 `kill -USR2 $(cat ~/.config/uuremote/host.pid)`。`SIGUSR2` 不重新探测。codec 偏好仍在下次建立桌面连接时生效(运行中的 host 只记日志,不重开编码)。显式 `vaapi` 请求真彩时仍用 VAAPI、编码 4:2:0,并在 CaptureSettingSync 的 field 3 回报 4:2:0。所选编码器在本机不可用时,建流回退 CPU 并记 warning。VAAPI 进入 auto 要等 #33。
自定义码率按客户端选择的 Mbps 生效,例如 1 Mbps 对应 1000 kbit/s 的编码上限。
@@ -382,11 +422,12 @@ HEVC 的访问单元按 RFC 7798 的图片边界切分,不依赖 AUD:`hevc_v
画面从码流里丢掉,读取端按 AUD 切分就会把整个 GOP 当成一帧,再被 IRAP 门控全部拒绝——对外表现为连接停在
「正在传输画面」,而主机侧只有约 12 kbit/s。`UU_VIDEO_CODEC=h265` 可显式选中 H.265,便于对照排查。
### VAAPI 硬件编码(显式启用)
### VAAPI 硬件编码
设置 `UU_VIDEO_ENCODER=vaapi` 使用 Intel/AMD H.264 VAAPI;`UU_VAAPI_DEVICE` 默认
`/dev/dri/renderD128`,运行用户需要 render 节点权限。不会自动选择 VAAPI;设备或驱动初始化
失败会明确警告并回退 libx264。外部 FFmpeg 先转 NV12 再上传硬件帧。
`UU_VIDEO_ENCODER=vaapi` 或 `set-encoder vaapi` 显式选择 Intel/AMD H.264 VAAPI。
`UU_VAAPI_DEVICE` 默认 `/dev/dri/renderD128`,运行用户需要 render 节点权限。
`auto` 有 NVIDIA 驱动时是 NVENC → CPU,没有 NVIDIA 时是 CPU。VAAPI 只通过显式选择启用,进入 auto 要等 #33。
设备或驱动初始化失败会明确警告并回退 libx264。外部 FFmpeg 先转 NV12 再上传硬件帧。
VBR 使用控制端码率预设及 CQ 对应的最小 QP,无 B 帧、async depth=1,并保留现有 GOP/VFR 规则。
Intel 核显(UHD 770,iHD 驱动)已实机验收:默认的外部 FFmpeg 管线用官方 Mac 控制端测试了各档画质、帧率、缩放和重连,全程硬件编码、无回退,CPU 占用比 libx264 低约 40%(该数字为 FFmpeg 进程管线时代的测量)。AMD 核显已在**进程内原生引擎**上实机验收(`--features inproc-av`):官方 Mac 客户端的端到端会话在 HawkPoint(Mesa 26.2.3)与 Cezanne(Mesa 26.2.5)上通过验收(HEVC,含画质档、帧率、缩放);Cezanne 上另以探测验证了 H.264 与两条采集路径——XShm 上传(码流可解码、画面正确)与 DRI3 DMA-BUF 零拷贝导入。同机实测(1920×1200@60,Cezanne iGPU + RTX 3050 Ti 双显卡):进程内 VAAPI 每帧编码 CPU 约为 libx264(FFmpeg 管线 superfast)的 **1/12**、进程内 NVENC 的 **1/5**;外部 FFmpeg 进程管线(预编译包使用)在 AMD 上未单独验证。
@@ -473,7 +514,8 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
`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)。仅在桌面窗口获得焦点时同步,
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。niri 改用支持 data-control 的
`wl-clipboard`,不需要桌面窗口保持焦点;其他 SDL 后端仅在桌面窗口获得焦点时同步。
保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。
SDL2 同步读取选择内容,慢速的剪贴板提供者可能暂时阻塞窗口,桥接超时无法中断该原生调用。
GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不解决被控端兼容问题。
@@ -485,11 +527,25 @@ GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不
- 命令行:`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` 查看全部参数。
- **安全输入 `type`**(向已打开的桌面会话注入键盘,适合锁屏 PIN / 密码;文本永不进 argv):
```sh
# 推荐:先 ui/connect 打开桌面,再 type(复用会话,不顶掉当前画面)
UU_INPUT_ENV=UU_SECRET UU_SECRET='……' \
uuremote-viewer type DEVICE [--delay-ms 40] [--omit-last 1] [--snapshot /path/out.png]
# 或:printf '%s' '……' | uuremote-viewer type DEVICE
# 只检查、不连网:uuremote-viewer type DEVICE --dry-run
# 没有正在运行的桌面会话时必须显式:--new-session(会新开连接,并顶掉已打开的桌面窗口,见上游 #30)
```
特殊键用花括号:`{Enter}` `{Tab}` `{Esc}` `{Backspace}` `{Ctrl+Alt+Del}` 等;`{{` 表示字面 `{`。
**布局**:字符按 **US QWERTY** 物理键位映射(非美式布局的符号/字母可能对不上)。
**Windows 数字 PIN**:输满位数后系统常会自动提交,一般不必再发 `{Enter}`;若只想填入、不登录,用 `--omit-last N` 省略最后 N 个字符。
日志与 `--dry-run` 输出只含长度/事件数,不含明文。复用会话时,发送约 1 秒后会保存一帧 PNG(默认写在 `$XDG_RUNTIME_DIR/uu-viewer-type/`,权限 0600),路径打在日志并打印 `snapshot=…`。
- 桌面窗口中按 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 显示。
- 按被控端原始分辨率解码,窗口缩放使用线性过滤;被控端分辨率变化时自动重启解码器。`UU_VIEWER_SIZE=WxH` 可改为固定的留黑边画布。
Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。键盘按物理键位置转发,不自动把 Ctrl 改成 Command;
控制 Mac 时,PC 键盘的 Super / Win 键对应 Command。仅接受已验证的目标平台值 1(Windows / 本项目 Linux 主机)和 4(Mac),
+1
View File
@@ -1,4 +1,5 @@
fn main() {
println!("cargo:rerun-if-changed=c_engine/wayland_transform.h");
println!("cargo:rerun-if-changed=c_engine/portal_clipboard.inc");
println!("cargo:rerun-if-changed=c_engine/x11_engine.c");
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.c");
+161 -56
View File
@@ -8,6 +8,8 @@
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
#include "i18n.h"
static void on_language(GtkComboBox *c, gpointer note);
static const char *CSS =
"window { background-color: #f5f6f8; }\n"
@@ -57,6 +59,10 @@ static int suppress_tray;
static int cur_verify, cur_refresh, cur_has_custom;
static char current_id[64], current_code[64];
static int code_visible = 1, suppress_switch, start_hidden, close_hides;
// A problem only the person at the desktop can fix (e.g. FFmpeg missing): red line at the top.
static GtkWidget *problem_label;
static gchar *problem_text;
static pthread_mutex_t problem_lock = PTHREAD_MUTEX_INITIALIZER;
static GtkWidget *label(const char *text, const char *cls) {
GtkWidget *l = gtk_label_new(text);
@@ -92,9 +98,9 @@ static void on_custom_changed(GtkEditable *e, gpointer ok) {
// Returns 1 when a new custom code was entered and posted.
static int ask_custom_code(void) {
GtkWidget *d = gtk_dialog_new_with_buttons("设置自定义验证码", GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"取消", GTK_RESPONSE_CANCEL, NULL);
GtkWidget *ok = gtk_dialog_add_button(GTK_DIALOG(d), "确定", GTK_RESPONSE_OK);
GtkWidget *d = gtk_dialog_new_with_buttons(L("设置自定义验证码", "Set custom code"), GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
L("取消", "Cancel"), GTK_RESPONSE_CANCEL, NULL);
GtkWidget *ok = gtk_dialog_add_button(GTK_DIALOG(d), L("确定", "OK"), GTK_RESPONSE_OK);
gtk_widget_set_sensitive(ok, FALSE);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(d));
gtk_container_set_border_width(GTK_CONTAINER(area), 16);
@@ -102,10 +108,10 @@ static int ask_custom_code(void) {
GtkWidget *entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), 16);
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(entry), "请输入自定义验证码");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry), L("请输入自定义验证码", "Enter custom code"));
g_signal_connect(entry, "changed", G_CALLBACK(on_custom_changed), ok);
gtk_box_pack_start(GTK_BOX(area), entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(area), label("8-16 位,需同时包含字母和数字;不会自动刷新,请妥善保管", "note"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(area), label(L("8-16 位,需同时包含字母和数字;不会自动刷新,请妥善保管", "8-16 characters with both letters and digits; never refreshed automatically, keep it safe"), "note"), FALSE, FALSE, 0);
gtk_widget_show_all(d);
int done = 0;
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) {
@@ -136,12 +142,12 @@ static void on_refresh_item(GtkCheckMenuItem *item, gpointer data) {
}
static void on_refresh_now(GtkMenuItem *i, gpointer d) { (void)i; (void)d; post(CMD_RESET); }
static const char *REFRESH_NOTES[5] = { "每次远控结束刷新", "每小时自动刷新", "每 12 小时自动刷新", "每 24 小时自动刷新", "不自动刷新" };
static const char *refresh_note(int i) { const char *notes[5] = { L("每次远控结束刷新", "Refreshed after every remote session"), L("每小时自动刷新", "Refreshed every hour"), L("每 12 小时自动刷新", "Refreshed every 12 hours"), L("每 24 小时自动刷新", "Refreshed every 24 hours"), L("不自动刷新", "Never refreshed automatically") }; return notes[i >= 0 && i < 5 ? i : 0]; }
static void render_code(void) {
if (!code_label) return;
gtk_label_set_text(GTK_LABEL(code_label), current_code[0] ? (code_visible ? current_code : "********") : "--------");
gtk_button_set_label(GTK_BUTTON(eye_button), code_visible ? "隐藏" : "显示");
gtk_button_set_label(GTK_BUTTON(eye_button), code_visible ? L("隐藏", "Hide") : L("显示", "Show"));
}
static void copy_text(const char *text, const char *hint) {
@@ -155,19 +161,19 @@ static void on_copy_id(GtkButton *b, gpointer d) {
char digits[64]; size_t n = 0;
for (const char *p = current_id; *p && n + 1 < sizeof digits; p++) if (*p != ' ') digits[n++] = *p;
digits[n] = 0;
copy_text(digits, "已复制设备 ID");
copy_text(digits, L("已复制设备 ID", "Device ID copied"));
}
static void on_copy_code(GtkButton *b, gpointer d) { (void)b; (void)d; copy_text(current_code, "已复制验证码,请只发给信任的人"); }
static void on_copy_code(GtkButton *b, gpointer d) { (void)b; (void)d; copy_text(current_code, L("已复制验证码,请只发给信任的人", "Code copied. Only share it with people you trust")); }
static void on_eye(GtkButton *b, gpointer d) { (void)b; (void)d; code_visible = !code_visible; render_code(); }
static void on_share(GtkButton *b, gpointer d) {
(void)b; (void)d;
if (!current_id[0] || !current_code[0]) return;
char *text = g_strdup_printf("UU 远程协助\n设备 ID:%s\n验证码:%s", current_id, current_code);
char *text = g_strdup_printf(L("UU 远程协助\n设备 ID:%s\n验证码:%s", "UU Remote assistance\nDevice ID: %s\nCode: %s"), current_id, current_code);
gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), text, -1);
g_free(text);
gtk_label_set_text(GTK_LABEL(hint_label), "已复制设备 ID 和验证码,请只发给信任的人");
gtk_label_set_text(GTK_LABEL(hint_label), L("已复制设备 ID 和验证码,请只发给信任的人", "Device ID and code copied. Only share them with people you trust"));
}
static gboolean on_switch(GtkSwitch *s, gboolean state, gpointer d) {
@@ -209,10 +215,10 @@ static gboolean draw_avatar(GtkWidget *w, cairo_t *cr, gpointer d) {
static void on_logout(GtkButton *b, gpointer d) {
(void)b; (void)d;
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
"退出登录后,本机将从你的设备列表中下线,远程协助会改用访客身份。确定退出吗?");
L("退出登录后,本机将从你的设备列表中下线,远程协助会改用访客身份。确定退出吗?", "After signing out this computer leaves your device list and assistance switches to guest mode. Sign out?"));
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
post(CMD_LOGOUT);
gtk_label_set_text(GTK_LABEL(user_label), "正在退出登录…");
gtk_label_set_text(GTK_LABEL(user_label), L("正在退出登录…", "Signing out…"));
}
gtk_widget_destroy(dlg);
}
@@ -222,7 +228,7 @@ static GtkWidget *build_account_card(void) {
gtk_style_context_add_class(gtk_widget_get_style_context(card), "card");
GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(header), 20);
gtk_box_pack_start(GTK_BOX(header), label("账号", "heading"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), label(L("账号", "Account"), "heading"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
account_stack = gtk_stack_new();
@@ -239,21 +245,21 @@ static GtkWidget *build_account_card(void) {
GtkWidget *spinner = gtk_spinner_new();
gtk_spinner_start(GTK_SPINNER(spinner));
gtk_box_pack_start(GTK_BOX(loading), spinner, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(loading), label("正在获取二维码…", "note"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(loading), label(L("正在获取二维码…", "Loading QR code…"), "note"), FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(qr_stack), loading, "loading");
qr_image = gtk_image_new();
gtk_stack_add_named(GTK_STACK(qr_stack), qr_image, "qr");
gtk_box_pack_start(GTK_BOX(qr_page), qr_stack, FALSE, FALSE, 0);
GtkWidget *qr_text = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_valign(qr_text, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(qr_text), label("扫码登录", "heading"), FALSE, FALSE, 0);
GtkWidget *cap = label("请使用网易 UU 远程 App 扫一扫登录。\n登录后本机会出现在你的设备列表中,可直接远程控制;\n远程协助在登录前后都可以使用。", "hint");
gtk_box_pack_start(GTK_BOX(qr_text), label(L("扫码登录", "Scan to sign in"), "heading"), FALSE, FALSE, 0);
GtkWidget *cap = label(L("请使用网易 UU 远程 App 扫一扫登录。\n登录后本机会出现在你的设备列表中,可直接远程控制;\n远程协助在登录前后都可以使用。", "Scan with the NetEase UU Remote app to sign in.\nAfter sign-in this computer appears in your device list and can be controlled directly;\nremote assistance works whether you are signed in or not."), "hint");
gtk_label_set_xalign(GTK_LABEL(cap), 0);
gtk_box_pack_start(GTK_BOX(qr_text), cap, FALSE, FALSE, 0);
login_status = label("", "status");
gtk_label_set_line_wrap(GTK_LABEL(login_status), TRUE);
gtk_box_pack_start(GTK_BOX(qr_text), login_status, FALSE, FALSE, 0);
qr_refresh = gtk_button_new_with_label("刷新二维码");
qr_refresh = gtk_button_new_with_label(L("刷新二维码", "Refresh QR code"));
gtk_widget_set_halign(qr_refresh, GTK_ALIGN_START);
gtk_widget_set_no_show_all(qr_refresh, TRUE);
g_signal_connect(qr_refresh, "clicked", G_CALLBACK(on_qr_refresh), NULL);
@@ -273,9 +279,9 @@ static GtkWidget *build_account_card(void) {
gtk_widget_set_valign(user_text, GTK_ALIGN_CENTER);
user_label = label("", "user");
gtk_box_pack_start(GTK_BOX(user_text), user_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(user_text), label("已登录 · 本机已出现在你的设备列表中", "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(user_text), label(L("已登录 · 本机已出现在你的设备列表中", "Signed in · this computer is in your device list"), "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(user_page), user_text, TRUE, TRUE, 0);
GtkWidget *logout = gtk_button_new_with_label("退出登录");
GtkWidget *logout = gtk_button_new_with_label(L("退出登录", "Sign out"));
gtk_style_context_add_class(gtk_widget_get_style_context(logout), "share");
gtk_widget_set_valign(logout, GTK_ALIGN_CENTER);
g_signal_connect(logout, "clicked", G_CALLBACK(on_logout), NULL);
@@ -295,8 +301,8 @@ static void on_tray_allow(GtkCheckMenuItem *i, gpointer d) {
static void on_tray_quit(GtkMenuItem *i, gpointer d) {
(void)i; (void)d;
GtkWidget *dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
"退出后本机将下线:设备列表和远程协助都无法连接,直到再次启动。确定退出吗?");
gtk_window_set_title(GTK_WINDOW(dlg), "UU 远程 Linux 主机");
L("退出后本机将下线:设备列表和远程协助都无法连接,直到再次启动。确定退出吗?", "Quitting takes this computer offline: neither the device list nor remote assistance can connect until it starts again. Quit?"));
gtk_window_set_title(GTK_WINDOW(dlg), L("UU 远程 Linux 主机", "UU Remote Linux host"));
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) post(CMD_QUIT);
gtk_widget_destroy(dlg);
}
@@ -305,20 +311,49 @@ static void on_status_menu(GtkStatusIcon *i, guint button, guint time, gpointer
(void)i; (void)button; (void)time; (void)d;
gtk_menu_popup_at_pointer(GTK_MENU(tray_menu), NULL);
}
// Monochrome tray icon that follows light/dark panels: GTK and the GNOME AppIndicator extension
// recolor "-symbolic" names, KDE recolors the ColorScheme-Text class. Installed into the user's
// hicolor theme (found by every panel's default lookup) and also offered as the icon theme path,
// so it needs no package install. KDE tries dash-trimmed names ("uu-remote-linux") in each theme
// before the next one, so the name must not trim into the colored app icon (#87).
static const char TRAY_ICON_NAME[] = "uuremote-tray-symbolic";
static const char TRAY_ICON_SVG[] =
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\">"
"<style id=\"current-color-scheme\">.ColorScheme-Text{color:#232629}</style>"
"<path class=\"ColorScheme-Text\" fill=\"currentColor\" fill-rule=\"evenodd\" d=\"M2.5 2h11A1.5 1.5 0 0 1 15 3.5v7a1.5 1.5 0 0 1-1.5 1.5h-11"
"A1.5 1.5 0 0 1 1 10.5v-7A1.5 1.5 0 0 1 2.5 2zm0 1.5v7h11v-7z\"/>"
"<path class=\"ColorScheme-Text\" fill=\"currentColor\" d=\"M7.25 12h1.5v1.5H11a.75.75 0 0 1 0 1.5H5a.75.75 0 0 1 0-1.5h2.25z"
"M11.5 4.5v4l-1.35-1.35-3.1 3.1-1.2-1.2 3.1-3.1L7.5 4.5z\"/></svg>\n";
// Returns the icon theme root holding the icon ($XDG_DATA_HOME/icons), or NULL.
static gchar *write_tray_icon(void) {
gchar *root = g_build_filename(g_get_user_data_dir(), "icons", NULL);
gchar *apps = g_build_filename(root, "hicolor", "scalable", "apps", NULL);
gchar *file = g_strconcat(TRAY_ICON_NAME, ".svg", NULL);
gchar *path = g_build_filename(apps, file, NULL), *current = NULL;
// Rewriting an unchanged file would only make icon caches rescan.
int ok = g_file_get_contents(path, &current, NULL, NULL) && strcmp(current, TRAY_ICON_SVG) == 0;
if (!ok) ok = g_mkdir_with_parents(apps, 0755) == 0 && g_file_set_contents(path, TRAY_ICON_SVG, -1, NULL);
g_free(apps); g_free(file); g_free(path); g_free(current);
if (!ok) { g_free(root); return NULL; }
return root;
}
static void build_tray(void) {
tray_menu = gtk_menu_new();
GtkWidget *open = gtk_menu_item_new_with_label("打开主窗口");
GtkWidget *open = gtk_menu_item_new_with_label(L("打开主窗口", "Open main window"));
g_signal_connect(open, "activate", G_CALLBACK(on_tray_open), NULL);
tray_allow = gtk_check_menu_item_new_with_label("允许他人远程协助");
tray_allow = gtk_check_menu_item_new_with_label(L("允许他人远程协助", "Allow remote assistance"));
g_signal_connect(tray_allow, "toggled", G_CALLBACK(on_tray_allow), NULL);
GtkWidget *quit = gtk_menu_item_new_with_label("退出");
GtkWidget *quit = gtk_menu_item_new_with_label(L("退出", "Quit"));
g_signal_connect(quit, "activate", G_CALLBACK(on_tray_quit), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), open);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), tray_allow);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new());
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), quit);
gtk_widget_show_all(tray_menu);
const char *icon = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
gchar *icon_path = write_tray_icon();
if (icon_path) gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), icon_path);
const char *fallback = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
const char *icon = icon_path ? TRAY_ICON_NAME : fallback;
// StatusNotifierItem (GNOME AppIndicator extension, KDE): libayatana-appindicator3 / libappindicator3.
const char *libs[] = { "libayatana-appindicator3.so.1", "libappindicator3.so.1" };
@@ -329,9 +364,12 @@ static void build_tray(void) {
void (*set_status)(void *, int) = (void (*)(void *, int))dlsym(h, "app_indicator_set_status");
void (*set_menu)(void *, GtkMenu *) = (void (*)(void *, GtkMenu *))dlsym(h, "app_indicator_set_menu");
void (*set_title)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_title");
void (*set_theme_path)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_icon_theme_path");
if (ind_new && set_status && set_menu) {
void *ind = ind_new("uu-remote-linux", icon, 0 /* APPLICATION_STATUS */);
if (set_title) set_title(ind, "UU 远程 Linux 主机");
// Without a theme path the panel cannot find the cached icon; keep the installed one.
void *ind = ind_new("uu-remote-linux", set_theme_path ? icon : fallback, 0 /* APPLICATION_STATUS */);
if (icon_path && set_theme_path) set_theme_path(ind, icon_path);
if (set_title) set_title(ind, L("UU 远程 Linux 主机", "UU Remote Linux host"));
set_menu(ind, GTK_MENU(tray_menu));
set_status(ind, 1 /* ACTIVE */);
return; // keep the library loaded for the indicator's lifetime
@@ -341,8 +379,8 @@ static void build_tray(void) {
// XEmbed system tray (Xfce, Cinnamon, MATE...).
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
GtkStatusIcon *status = gtk_status_icon_new_from_icon_name(icon);
gtk_status_icon_set_tooltip_text(status, "UU 远程 Linux 主机");
gtk_status_icon_set_title(status, "UU 远程 Linux 主机");
gtk_status_icon_set_tooltip_text(status, L("UU 远程 Linux 主机", "UU Remote Linux host"));
gtk_status_icon_set_title(status, L("UU 远程 Linux 主机", "UU Remote Linux host"));
g_signal_connect(status, "activate", G_CALLBACK(on_status_activate), NULL);
g_signal_connect(status, "popup-menu", G_CALLBACK(on_status_menu), NULL);
G_GNUC_END_IGNORE_DEPRECATIONS
@@ -357,7 +395,7 @@ static void build_window(void) {
gtk_window_set_default_icon_name("uu-remote-linux"); // contrib/desktop icon, when installed
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "UU 远程 Linux 主机(非官方)");
gtk_window_set_title(GTK_WINDOW(window), L("UU 远程 Linux 主机(非官方)", "UU Remote Linux host (unofficial)"));
gtk_window_set_default_size(GTK_WINDOW(window), 760, -1);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
@@ -367,6 +405,11 @@ static void build_window(void) {
GtkWidget *root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(root), 24);
gtk_container_add(GTK_CONTAINER(window), root);
problem_label = label("", "status");
gtk_style_context_add_class(gtk_widget_get_style_context(problem_label), "error");
gtk_label_set_line_wrap(GTK_LABEL(problem_label), TRUE);
gtk_label_set_max_width_chars(GTK_LABEL(problem_label), 40);
gtk_box_pack_start(GTK_BOX(root), problem_label, FALSE, FALSE, 0);
GtkWidget *card = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_style_context_add_class(gtk_widget_get_style_context(card), "card");
@@ -376,12 +419,12 @@ static void build_window(void) {
// Header: 本设备 ... 允许他人远程协助 [switch]
GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(header), 20);
gtk_box_pack_start(GTK_BOX(header), label("本设备", "heading"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), label(L("本设备", "This device"), "heading"), FALSE, FALSE, 0);
allow_switch = gtk_switch_new();
gtk_widget_set_valign(allow_switch, GTK_ALIGN_CENTER);
g_signal_connect(allow_switch, "state-set", G_CALLBACK(on_switch), NULL);
gtk_box_pack_end(GTK_BOX(header), allow_switch, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(header), label("允许他人远程协助", "key"), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(header), label(L("允许他人远程协助", "Allow remote assistance"), "key"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
@@ -390,12 +433,12 @@ static void build_window(void) {
gtk_container_set_border_width(GTK_CONTAINER(body), 20);
gtk_grid_set_column_spacing(GTK_GRID(body), 48);
gtk_grid_set_row_spacing(GTK_GRID(body), 6);
gtk_grid_attach(GTK_GRID(body), label("本设备 ID", "key"), 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(body), label(L("本设备 ID", "This device's ID"), "key"), 0, 0, 1, 1);
GtkWidget *id_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
id_label = label("获取中…", "big");
id_label = label(L("获取中…", "Loading…"), "big");
gtk_label_set_selectable(GTK_LABEL(id_label), TRUE);
gtk_box_pack_start(GTK_BOX(id_row), id_label, FALSE, FALSE, 0);
GtkWidget *copy_id = gtk_button_new_with_label("复制");
GtkWidget *copy_id = gtk_button_new_with_label(L("复制", "Copy"));
gtk_style_context_add_class(gtk_widget_get_style_context(copy_id), "flat");
gtk_widget_set_valign(copy_id, GTK_ALIGN_CENTER);
g_signal_connect(copy_id, "clicked", G_CALLBACK(on_copy_id), NULL);
@@ -403,11 +446,11 @@ static void build_window(void) {
gtk_grid_attach(GTK_GRID(body), id_row, 0, 1, 1, 1);
GtkWidget *verify_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(verify_row), label("验证方式:", "key"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(verify_row), label(L("验证方式:", "Verification:"), "key"), FALSE, FALSE, 0);
verify_combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "仅使用临时验证码");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "仅使用自定义验证码");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "同时使用两种验证码");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), L("仅使用临时验证码", "Temporary code only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), L("仅使用自定义验证码", "Custom code only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), L("同时使用两种验证码", "Use both codes"));
gtk_combo_box_set_active(GTK_COMBO_BOX(verify_combo), 0);
g_signal_connect(verify_combo, "changed", G_CALLBACK(on_verify_changed), NULL);
gtk_box_pack_start(GTK_BOX(verify_row), verify_combo, FALSE, FALSE, 0);
@@ -415,17 +458,17 @@ static void build_window(void) {
GtkWidget *code_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
code_label = label("--------", "big");
gtk_box_pack_start(GTK_BOX(code_row), code_label, FALSE, FALSE, 0);
eye_button = gtk_button_new_with_label("隐藏");
eye_button = gtk_button_new_with_label(L("隐藏", "Hide"));
gtk_style_context_add_class(gtk_widget_get_style_context(eye_button), "flat");
g_signal_connect(eye_button, "clicked", G_CALLBACK(on_eye), NULL);
// Gear menu: 立即刷新 / 自动刷新 ▸ (每次远控结束, 每小时, 每 12 小时, 每 24 小时, 关闭) / 设置自定义验证码
GtkWidget *menu = gtk_menu_new();
GtkWidget *now = gtk_menu_item_new_with_label("立即刷新");
GtkWidget *now = gtk_menu_item_new_with_label(L("立即刷新", "Refresh now"));
g_signal_connect(now, "activate", G_CALLBACK(on_refresh_now), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), now);
GtkWidget *auto_item = gtk_menu_item_new_with_label("自动刷新");
GtkWidget *auto_item = gtk_menu_item_new_with_label(L("自动刷新", "Auto refresh"));
GtkWidget *sub = gtk_menu_new();
const char *names[5] = { "每次远控结束", "每小时", "每 12 小时", "每 24 小时", "关闭" };
const char *names[5] = { L("每次远控结束", "After every remote session"), L("每小时", "Every hour"), L("每 12 小时", "Every 12 hours"), L("每 24 小时", "Every 24 hours"), L("关闭", "Close") };
GSList *group = NULL;
for (int i = 0; i < 5; i++) {
refresh_items[i] = gtk_radio_menu_item_new_with_label(group, names[i]);
@@ -435,15 +478,15 @@ static void build_window(void) {
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(auto_item), sub);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), auto_item);
GtkWidget *custom_item = gtk_menu_item_new_with_label("设置自定义验证码…");
GtkWidget *custom_item = gtk_menu_item_new_with_label(L("设置自定义验证码…", "Set custom code…"));
g_signal_connect(custom_item, "activate", G_CALLBACK(on_set_custom), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), custom_item);
gtk_widget_show_all(menu);
GtkWidget *gear = gtk_menu_button_new();
gtk_button_set_image(GTK_BUTTON(gear), gtk_image_new_from_icon_name("emblem-system-symbolic", GTK_ICON_SIZE_BUTTON));
gtk_widget_set_tooltip_text(gear, "刷新设置");
gtk_widget_set_tooltip_text(gear, L("刷新设置", "Refresh settings"));
gtk_menu_button_set_popup(GTK_MENU_BUTTON(gear), menu);
GtkWidget *copy_code = gtk_button_new_with_label("复制");
GtkWidget *copy_code = gtk_button_new_with_label(L("复制", "Copy"));
gtk_style_context_add_class(gtk_widget_get_style_context(copy_code), "flat");
gtk_widget_set_valign(copy_code, GTK_ALIGN_CENTER);
g_signal_connect(copy_code, "clicked", G_CALLBACK(on_copy_code), NULL);
@@ -453,10 +496,10 @@ static void build_window(void) {
gtk_box_pack_start(GTK_BOX(code_row), eye_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(code_row), gear, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(body), code_row, 1, 1, 1, 1);
note_label = label(REFRESH_NOTES[0], "note");
note_label = label(refresh_note(0), "note");
gtk_grid_attach(GTK_GRID(body), note_label, 1, 2, 1, 1);
share_button = gtk_button_new_with_label("复制并分享");
share_button = gtk_button_new_with_label(L("复制并分享", "Copy and share"));
gtk_style_context_add_class(gtk_widget_get_style_context(share_button), "share");
gtk_widget_set_valign(share_button, GTK_ALIGN_CENTER);
g_signal_connect(share_button, "clicked", G_CALLBACK(on_share), NULL);
@@ -468,18 +511,36 @@ static void build_window(void) {
account_card = build_account_card();
gtk_widget_set_margin_top(account_card, 6);
gtk_box_pack_start(GTK_BOX(root), account_card, FALSE, FALSE, 0);
footer_label = label("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口即停止远程协助", "footer");
footer_label = label(L("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口即停止远程协助", "Open-source Linux host · not an official NetEase client · closing the window stops remote assistance"), "footer");
gtk_box_pack_end(GTK_BOX(root), footer_label, FALSE, FALSE, 0);
if (close_hides) gtk_label_set_text(GTK_LABEL(footer_label), "开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口后远程协助仍在后台运行");
GtkWidget *lang_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8), *lang_note = label("", "note");
GtkWidget *lang = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(lang), "中文"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(lang), "English");
gtk_combo_box_set_active(GTK_COMBO_BOX(lang), uu_i18n_english());
g_signal_connect(lang, "changed", G_CALLBACK(on_language), lang_note);
gtk_box_pack_start(GTK_BOX(lang_row), label("语言 / Language", "key"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lang_row), lang, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lang_row), lang_note, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(root), lang_row, FALSE, FALSE, 6);
if (close_hides) gtk_label_set_text(GTK_LABEL(footer_label), L("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口后远程协助仍在后台运行", "Open-source Linux host · not an official NetEase client · remote assistance keeps running after the window closes"));
render_code();
if (close_hides) build_tray();
gtk_widget_show_all(gtk_bin_get_child(GTK_BIN(window)));
gtk_widget_set_visible(assist_card, show_assist);
gtk_widget_set_visible(hint_label, show_assist);
gtk_widget_set_visible(account_card, show_account);
pthread_mutex_lock(&problem_lock);
gtk_label_set_text(GTK_LABEL(problem_label), problem_text ? problem_text : "");
gtk_widget_set_visible(problem_label, problem_text != NULL);
pthread_mutex_unlock(&problem_lock);
if (!start_hidden) gtk_widget_show(window);
}
static void on_language(GtkComboBox *c, gpointer note) {
int english = gtk_combo_box_get_active(c) == 1;
gtk_label_set_text(GTK_LABEL(note), english == uu_i18n_english() ? "" : !uu_i18n_save(english) ? L("无法保存语言设置", "Could not save the language")
: english ? "Restart uuremote-server to switch to English" : "重新启动 uuremote-server 后切换为中文");
}
static void *ui_main(void *arg) {
(void)arg;
int ok = gtk_init_check(NULL, NULL);
@@ -537,7 +598,7 @@ static gboolean apply_state(gpointer data) {
if (window) {
g_strlcpy(current_id, s->id, sizeof current_id);
g_strlcpy(current_code, s->code, sizeof current_code);
gtk_label_set_text(GTK_LABEL(id_label), current_id[0] ? current_id : "获取中…");
gtk_label_set_text(GTK_LABEL(id_label), current_id[0] ? current_id : L("获取中…", "Loading…"));
render_code();
suppress_switch = 1;
gtk_switch_set_active(GTK_SWITCH(allow_switch), s->allowed);
@@ -548,12 +609,12 @@ static gboolean apply_state(gpointer data) {
if (s->refresh >= 0 && s->refresh < 5) {
suppress_refresh = 1; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(refresh_items[s->refresh]), TRUE); suppress_refresh = 0;
}
gtk_label_set_text(GTK_LABEL(note_label), s->verify == VERIFY_CUSTOM ? "自定义验证码不会自动刷新"
: s->verify == VERIFY_BOTH ? "也可使用自定义验证码连接" : REFRESH_NOTES[s->refresh >= 0 && s->refresh < 5 ? s->refresh : 0]);
gtk_label_set_text(GTK_LABEL(note_label), s->verify == VERIFY_CUSTOM ? L("自定义验证码不会自动刷新", "Custom code is never refreshed automatically")
: s->verify == VERIFY_BOTH ? L("也可使用自定义验证码连接", "The custom code also works") : refresh_note(s->refresh));
gtk_widget_set_sensitive(share_button, current_id[0] && current_code[0]);
gtk_label_set_text(GTK_LABEL(hint_label), s->allowed
? "对方在 UU 远程「开始协助」中输入设备 ID 和验证码即可连接"
: "已关闭:他人暂时无法远程协助本机,打开右上角开关后才能连接");
? L("对方在 UU 远程「开始协助」中输入设备 ID 和验证码即可连接", "Your partner enters the device ID and code under \"Start assistance\" in UU Remote to connect")
: L("已关闭:他人暂时无法远程协助本机,打开右上角开关后才能连接", "Off: nobody can assist this computer until you turn on the switch at the top right"));
}
g_free(s->id); g_free(s->code); g_free(s);
return G_SOURCE_REMOVE;
@@ -659,6 +720,50 @@ void uu_login_ui_offer_refresh(int visible) {
g_idle_add(apply_qr_refresh, GINT_TO_POINTER(visible != 0));
}
int uu_login_ui_take_refresh(void) { return atomic_exchange(&qr_refresh_requested, 0); }
static gboolean apply_problem(gpointer data) {
(void)data;
if (window && problem_label) {
pthread_mutex_lock(&problem_lock);
gtk_label_set_text(GTK_LABEL(problem_label), problem_text ? problem_text : "");
gtk_widget_set_visible(problem_label, problem_text != NULL);
pthread_mutex_unlock(&problem_lock);
}
return G_SOURCE_REMOVE;
}
// Freedesktop notification through the session bus (no GTK main loop needed). Returns 0 when delivered.
static int notify_desktop(const char *summary, const char *body) {
GDBusConnection *bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!bus) return -1;
GVariantBuilder actions, hints;
g_variant_builder_init(&actions, G_VARIANT_TYPE("as"));
g_variant_builder_init(&hints, G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(&hints, "{sv}", "urgency", g_variant_new_byte(2)); // critical: stays until dismissed
GVariant *reply = g_dbus_connection_call_sync(bus, "org.freedesktop.Notifications", "/org/freedesktop/Notifications",
"org.freedesktop.Notifications", "Notify",
g_variant_new("(susssasa{sv}i)", L("UU 远程 Linux 主机", "UU Remote Linux host"), 0u, "uu-remote-linux", summary, body, &actions, &hints, -1),
G_VARIANT_TYPE("(u)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
g_object_unref(bus);
if (!reply) return -1;
g_variant_unref(reply);
return 0;
}
// text NULL clears the window line. notify: also tell the person now, by a desktop notification or,
// without a notification daemon (e.g. bare Xfce), by opening the host window that shows the line.
// Returns 0 notified, 1 window opened, -1 neither (no notify requested, or no daemon and no window).
int uu_ui_set_problem(const char *summary, const char *text, int notify) {
pthread_mutex_lock(&problem_lock);
g_free(problem_text);
problem_text = text ? g_strdup(text) : NULL;
pthread_mutex_unlock(&problem_lock);
int window_ready = ui_started && init_state == 1 && !atomic_load(&closed);
if (window_ready) g_idle_add(apply_problem, NULL);
if (!notify || !text) return -1;
if (notify_desktop(summary ? summary : "", text) == 0) return 0;
if (!window_ready) return -1;
uu_assist_ui_present();
return 1;
}
void uu_login_ui_set_done(const char *text) { uu_ui_set_user(text); }
int uu_login_ui_closed(void) { return atomic_load(&closed); }
void uu_login_ui_close(void) { uu_assist_ui_close(); }
+8
View File
@@ -0,0 +1,8 @@
// Chinese / English UI text. The language is decided once on the Rust side (src/i18n.rs: UU_LANG, the
// choice saved in settings, then the locale) so the GTK windows and Rust messages always agree.
#ifndef UU_I18N_H
#define UU_I18N_H
int uu_i18n_english(void);
int uu_i18n_save(int english);
#define L(zh, en) (uu_i18n_english() ? (en) : (zh))
#endif
+39 -3
View File
@@ -17,7 +17,7 @@ static int portal_eis_dispatch(struct uu_portal *p) {
case EI_EVENT_SEAT_ADDED:
ei_seat_bind_capabilities(ei_event_get_seat(event),
EI_DEVICE_CAP_POINTER, EI_DEVICE_CAP_POINTER_ABSOLUTE,
EI_DEVICE_CAP_BUTTON, EI_DEVICE_CAP_SCROLL, EI_DEVICE_CAP_KEYBOARD, NULL);
EI_DEVICE_CAP_BUTTON, EI_DEVICE_CAP_SCROLL, EI_DEVICE_CAP_KEYBOARD, EI_DEVICE_CAP_TOUCH, NULL);
break;
case EI_EVENT_DEVICE_RESUMED:
if (!g_list_find(p->ei_devices, device)) {
@@ -55,15 +55,19 @@ static struct ei_region *portal_eis_region(struct uu_portal *p, struct ei_device
ei_region_get_width(region) && ei_region_get_height(region)) return region;
}
}
static struct ei_device *portal_eis_absolute(struct uu_portal *p, struct ei_region **region) {
static struct ei_device *portal_eis_mapped(struct uu_portal *p, enum ei_device_capability capability, struct ei_region **region) {
for (GList *item = p->ei_devices; item; item = item->next) {
struct ei_device *device = item->data;
if (ei_device_has_capability(device, EI_DEVICE_CAP_POINTER_ABSOLUTE) &&
if (ei_device_has_capability(device, capability) &&
(*region = portal_eis_region(p, device))) return device;
}
return NULL;
}
static struct ei_device *portal_eis_absolute(struct uu_portal *p, struct ei_region **region) {
return portal_eis_mapped(p, EI_DEVICE_CAP_POINTER_ABSOLUTE, region);
}
static void portal_eis_close(struct uu_portal *p) {
if (p->ei_touch) p->ei_touch = ei_touch_unref(p->ei_touch);
for (GList *item = p->ei_devices; item; item = item->next) ei_device_unref(item->data);
g_list_free(p->ei_devices); p->ei_devices = NULL;
if (p->ei) p->ei = ei_unref(p->ei);
@@ -157,6 +161,38 @@ static int portal_eis_button(struct uu_portal *p, int button, int pressed) {
ei_device_button_button(device, code, !!pressed);
return portal_eis_frame(p, device);
}
static int portal_eis_scroll(struct uu_portal *p, double dx, double dy, int finish) {
if (portal_eis_available(p)) return 9;
struct ei_device *device = portal_eis_device(p, EI_DEVICE_CAP_SCROLL);
if (!device) return 9;
if (dx != 0 || dy != 0) ei_device_scroll_delta(device, dx, dy);
if (finish) ei_device_scroll_stop(device, true, true);
return portal_eis_frame(p, device);
}
static int portal_eis_touch(struct uu_portal *p, int phase, double x, double y) {
if (portal_eis_available(p)) return 9;
if (phase == 2) {
if (!p->ei_touch) return 0;
struct ei_device *device = ei_touch_get_device(p->ei_touch);
ei_touch_up(p->ei_touch);
p->ei_touch = ei_touch_unref(p->ei_touch);
return portal_eis_frame(p, device);
}
struct ei_region *region = NULL;
struct ei_device *device = portal_eis_mapped(p, EI_DEVICE_CAP_TOUCH, &region);
if (!device) return 9;
double target_x = ei_region_get_x(region) + x * ei_region_get_width(region) / p->width;
double target_y = ei_region_get_y(region) + y * ei_region_get_height(region) / p->height;
if (phase == 0) {
if (p->ei_touch) { ei_touch_up(p->ei_touch); p->ei_touch = ei_touch_unref(p->ei_touch); }
if (!(p->ei_touch = ei_device_touch_new(device))) return 9;
ei_touch_down(p->ei_touch, target_x, target_y);
} else {
if (!p->ei_touch) return 11;
ei_touch_motion(p->ei_touch, target_x, target_y);
}
return portal_eis_frame(p, device);
}
static int portal_eis_key(struct uu_portal *p, int code, int pressed) {
if (code < 0 || code > 0x2ff) return 11;
if (portal_eis_available(p)) return 9;
+109 -11
View File
@@ -56,10 +56,12 @@ struct uu_portal {
int format_valid, stream_started;
gint64 interrupted_at, display_changed_at;
uint32_t node, width, height;
int logical_width, logical_height;
int logical_width, logical_height, position_x, position_y, has_position;
int absolute_stream_pixels;
uint32_t devices, available;
struct ei *ei;
GList *ei_devices;
struct ei_touch *ei_touch;
char *mapping_id;
uint32_t ei_sequence;
atomic_int ei_failed;
@@ -81,6 +83,19 @@ static int open_cancelled(struct uu_portal *p) {
}
static int wait_for_first_frame(struct uu_portal *p);
#include "portal_eis.inc"
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes); 0 when unreadable. */
static guint remote_property(struct uu_portal *p, const char *name) {
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, name),
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
guint result = 0;
if (reply) {
GVariant *value; g_variant_get(reply, "(v)", &value);
if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) result = g_variant_get_uint32(value);
g_variant_unref(value); g_variant_unref(reply);
}
return result;
}
static void fail(struct uu_portal *p, int error) {
pthread_mutex_lock(&p->lock);
if (!p->error) p->error = error;
@@ -365,10 +380,12 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
if (!has_devices || (devices & 3) != 3 || !streams || g_variant_n_children(streams) != 1) {
error = 6;
} else {
p->devices = devices;
GVariant *entry = g_variant_get_child_value(streams, 0), *properties;
g_variant_get(entry, "(u@a{sv})", &p->node, &properties);
/* Optional 'size' is compositor logical coordinates, not frame pixels. */
g_variant_lookup(properties, "size", "(ii)", &p->logical_width, &p->logical_height);
p->has_position = g_variant_lookup(properties, "position", "(ii)", &p->position_x, &p->position_y);
const char *mapping_id = NULL;
if (g_variant_lookup(properties, "mapping_id", "&s", &mapping_id)) p->mapping_id = g_strdup(mapping_id);
g_variant_unref(properties); g_variant_unref(entry);
@@ -412,16 +429,10 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
p->closed_subscription = g_dbus_connection_signal_subscribe(p->bus, DEST, SESSION, "Closed", p->session,
NULL, G_DBUS_SIGNAL_FLAGS_NONE, session_closed, p, NULL);
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(3));
GVariant *version_reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, "version"),
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
guint version = 0;
if (version_reply) {
GVariant *value; g_variant_get(version_reply, "(v)", &value);
if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) version = g_variant_get_uint32(value);
g_variant_unref(value); g_variant_unref(version_reply);
}
/* Keyboard and pointer, plus the touchscreen (4) where the portal offers one (mobile viewers). */
p->available = remote_property(p, "AvailableDeviceTypes");
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(3 | (p->available & 4)));
guint version = remote_property(p, "version");
if (version >= 2) {
g_variant_builder_add(&options, "{sv}", "persist_mode", g_variant_new_uint32(2));
if (restore && *restore) g_variant_builder_add(&options, "{sv}", "restore_token", g_variant_new_string(restore));
@@ -669,9 +680,96 @@ int uu_portal_button(struct uu_portal *p, int button, int pressed) {
if (!code) return 11;
return notify(p, "NotifyPointerButton", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), code, (guint)!!pressed));
}
/* Smooth scroll in stream pixels (positive scrolls down/right, like a touchpad); `finish` ends the
* gesture so clients may coast. */
int uu_portal_scroll(struct uu_portal *p, double dx, double dy, int finish) {
if (!p || !isfinite(dx) || !isfinite(dy)) return 11;
if (p->logical_width <= 0 || p->logical_height <= 0 || !p->width || !p->height) return 11;
int result = prepare_input(p); if (result) return result;
double lx = dx * p->logical_width / p->width, ly = dy * p->logical_height / p->height;
if (p->ei) return portal_eis_scroll(p, lx, ly, finish);
GVariantBuilder options; g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
if (finish) g_variant_builder_add(&options, "{sv}", "finish", g_variant_new_boolean(TRUE));
return notify(p, "NotifyPointerAxis", g_variant_new("(oa{sv}dd)", p->session, &options, lx, ly));
}
/* One finger (slot 0) in stream pixels: phase 0 down, 1 motion, 2 up. */
int uu_portal_touch_supported(struct uu_portal *p) { return p && (p->devices & 4); }
/* The portal offers a touchscreen this session's consent did not grant (restored from before touch). */
int uu_portal_touch_available(struct uu_portal *p) { return p && (p->available & 4); }
int uu_portal_touch(struct uu_portal *p, int phase, double x, double y) {
if (!uu_portal_touch_supported(p) || phase < 0 || phase > 2) return 11;
if (phase != 2 && (!isfinite(x) || !isfinite(y) || p->logical_width <= 0 || p->logical_height <= 0 ||
!p->width || !p->height || x < 0 || y < 0 || x >= p->width || y >= p->height)) return 11;
int result = prepare_input(p); if (result) return result;
if (p->ei) return portal_eis_touch(p, phase, x, y);
if (phase == 2) return notify(p, "NotifyTouchUp", g_variant_new("(o@a{sv}u)", p->session, empty_options(), 0u));
return notify(p, phase ? "NotifyTouchMotion" : "NotifyTouchDown", g_variant_new("(o@a{sv}uudd)", p->session, empty_options(), p->node, 0u,
p->absolute_stream_pixels ? x : x * p->logical_width / p->width,
p->absolute_stream_pixels ? y : y * p->logical_height / p->height));
}
int uu_portal_key(struct uu_portal *p, uint32_t symbol, int keycode, int pressed) {
if (!p || !symbol || symbol > INT32_MAX) return 11;
int result = prepare_input(p); if (result) return result;
if (p->ei) return portal_eis_key(p, keycode, pressed);
return notify(p, "NotifyKeyboardKeysym", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), (gint)symbol, (guint)!!pressed));
}
/* Logical position of the granted monitor: matches a Mutter logical monitor. */
int uu_portal_stream_position(struct uu_portal *p, int32_t *x, int32_t *y) {
if (!p || !p->has_position) return 11;
*x = p->position_x; *y = p->position_y;
return 0;
}
/* Mutter's monitors as "connector\twidth\theight\tx\ty\tprimary\n" lines: current mode in
* pixels, logical position. Returns the count, or -1 without Mutter (KDE, no session bus). */
int uu_portal_monitors(char *out, size_t length) {
if (!out || !length) return -1;
out[0] = 0;
GDBusConnection *bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!bus) return -1;
GVariant *reply = g_dbus_connection_call_sync(bus, MUTTER_DISPLAY, MUTTER_DISPLAY_PATH, MUTTER_DISPLAY,
"GetCurrentState", NULL, G_VARIANT_TYPE("(ua((ssss)a(siiddada{sv})a{sv})a(iiduba(ssss)a{sv})a{sv})"),
G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
g_object_unref(bus);
if (!reply) return -1;
GVariant *monitors = g_variant_get_child_value(reply, 1), *logical = g_variant_get_child_value(reply, 2);
int count = 0; size_t used = 0;
for (gsize i = 0; i < g_variant_n_children(logical); i++) {
gint32 x, y; gdouble scale; guint32 transform; gboolean primary; GVariant *specs, *props;
g_variant_get_child(logical, i, "(iidub@a(ssss)@a{sv})", &x, &y, &scale, &transform, &primary, &specs, &props);
const gchar *connector = NULL;
if (g_variant_n_children(specs)) g_variant_get_child(specs, 0, "(&s&s&s&s)", &connector, NULL, NULL, NULL);
gint32 width = 0, height = 0;
for (gsize m = 0; connector && m < g_variant_n_children(monitors); m++) {
GVariant *monitor = g_variant_get_child_value(monitors, m), *spec = g_variant_get_child_value(monitor, 0),
*modes = g_variant_get_child_value(monitor, 1);
const gchar *name = NULL; g_variant_get_child(spec, 0, "&s", &name);
for (gsize k = 0; name && !strcmp(name, connector) && k < g_variant_n_children(modes); k++) {
GVariant *mode = g_variant_get_child_value(modes, k), *mode_props = g_variant_get_child_value(mode, 6);
gboolean current = FALSE;
if (g_variant_lookup(mode_props, "is-current", "b", &current) && current)
g_variant_get_child(mode, 1, "i", &width), g_variant_get_child(mode, 2, "i", &height);
g_variant_unref(mode_props); g_variant_unref(mode);
}
g_variant_unref(modes); g_variant_unref(spec); g_variant_unref(monitor);
}
if (transform % 2) { gint32 t = width; width = height; height = t; } /* 90/270, flipped or not */
if (connector && width > 0 && height > 0) {
int n = snprintf(out + used, length - used, "%s\t%d\t%d\t%d\t%d\t%d\n", connector, width, height, x, y, primary ? 1 : 0);
if (n > 0 && (size_t)n < length - used) { used += (size_t)n; count++; }
}
g_variant_unref(specs); g_variant_unref(props);
}
g_variant_unref(monitors); g_variant_unref(logical); g_variant_unref(reply);
return count;
}
/* End the compositor session now (screen-share indicator off) while the handle stays valid;
* captures then report a closed stream until the handle is replaced. */
void uu_portal_end(struct uu_portal *p) {
if (!p || atomic_exchange(&p->closed, 1)) return;
if (p->bus && p->session) {
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, p->session, SESSION, "Close",
NULL, NULL, G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
if (reply) g_variant_unref(reply);
}
}
+7
View File
@@ -25,5 +25,12 @@ int uu_portal_capture(struct uu_portal *portal, uint8_t *bgra, size_t length);
int uu_portal_capture_since(struct uu_portal *portal, uint8_t *bgra, size_t length, uint64_t *revision);
int uu_portal_move(struct uu_portal *portal, double x, double y, int relative);
int uu_portal_button(struct uu_portal *portal, int button, int pressed);
int uu_portal_scroll(struct uu_portal *portal, double dx, double dy, int finish);
int uu_portal_touch_supported(struct uu_portal *portal);
int uu_portal_touch_available(struct uu_portal *portal);
int uu_portal_touch(struct uu_portal *portal, int phase, double x, double y);
int uu_portal_key(struct uu_portal *portal, uint32_t keysym, int keycode, int pressed);
int uu_portal_stream_position(struct uu_portal *portal, int32_t *x, int32_t *y);
int uu_portal_monitors(char *out, size_t length);
void uu_portal_end(struct uu_portal *portal);
#endif
+3 -1
View File
@@ -732,7 +732,9 @@ int vaapi_encode_frame(
rc.window_size = 1000;
rc.initial_qp = 28;
rc.min_qp = 16;
rc.max_qp = 44;
// The driver's VBR raises QP only up to max_qp; 44 blocked the capped presets from reaching
// the QP 51 hardware floor on hard content (2560x1600 testsrc2: 4.16 -> 2.60 Mbps, #33)
rc.max_qp = 51;
rc.rc_flags.bits.disable_frame_skip = 1; // a remote desktop must not drop frames silently
b.misc[b.misc_n++] = vaapi_create_misc_buffer(engine, VAEncMiscParameterTypeRateControl, &rc, sizeof(rc));
+50 -49
View File
@@ -9,6 +9,7 @@
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include "i18n.h"
#define QSIZE 64
static char queue[QSIZE][4096];
@@ -97,9 +98,9 @@ static void format_size(guint64 size, int kind, char *out, size_t len) {
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);
strftime(out, len, L("%Y年%m月%d日", "%Y-%m-%d"), &tm);
}
static const char *kind_name(int kind) { return kind == 4 ? "文件" : kind == 3 ? "磁盘" : "文件夹"; }
static const char *kind_name(int kind) { return kind == 4 ? L("文件", "File") : kind == 3 ? L("磁盘", "Disk") : L("文件夹", "Folder"); }
/* ---------------- file transfer ---------------- */
enum { C_NAME, C_TIME, C_TYPE, C_SIZE, C_PATH, C_KIND, C_N };
@@ -111,7 +112,7 @@ 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; }
if (!d) { show_toast(L("无法打开本机目录", "Cannot open local folder")); 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);
@@ -150,7 +151,7 @@ static void on_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewCo
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 *dlg = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_MODAL, L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("确定", "OK"), 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);
@@ -158,21 +159,21 @@ static char *ask_name(const char *title) {
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("名称无效");
if (*t && !strchr(t, '/') && strcmp(t, ".") && strcmp(t, "..")) name = g_strdup(t); else if (*t) show_toast(L("名称无效", "Invalid name"));
}
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;
(void)b; (void)d; char *name = ask_name(L("新建文件夹", "New folder")); if (!name) return;
char *full = g_build_filename(local_dir, name, NULL);
if (mkdir(full, 0755) != 0) show_toast("无法创建文件夹"); else load_local(local_dir);
if (mkdir(full, 0755) != 0) show_toast(L("无法创建文件夹", "Cannot create folder")); 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;
if (!strcmp(remote_dir, ":/")) { show_toast(L("请先进入一个文件夹", "Open a folder first")); return; }
char *name = ask_name(L("新建文件夹", "New folder")); 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);
}
@@ -181,8 +182,8 @@ static void on_remote_mkdir(GtkButton *b, gpointer d) {
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; }
if (!rows) { show_toast(L("请先选择要发送的文件", "Select the files to send first")); return; }
if (upload && !strcmp(remote_dir, ":/")) { show_toast(L("请先在远端进入目标文件夹", "Open the destination folder on the remote side first")); 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;
@@ -199,7 +200,7 @@ static void on_send(GtkButton *b, gpointer upload) {
g_free(full); g_free(name);
}
g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free);
if (skipped) show_toast(upload ? "暂不支持上传文件夹,已跳过" : "不能下载整个磁盘,已跳过");
if (skipped) show_toast(upload ? L("暂不支持上传文件夹,已跳过", "Uploading folders is not supported yet; skipped") : L("不能下载整个磁盘,已跳过", "Cannot download a whole disk; skipped"));
}
static void on_cancel_all(GtkButton *b, gpointer d) { (void)b; (void)d; push("cancel"); }
static void on_clear_done(GtkButton *b, gpointer d) {
@@ -209,13 +210,13 @@ static void on_clear_done(GtkButton *b, gpointer d) {
}
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, "刷新");
GtkWidget *bar = hbox(6), *up = button("↑", NULL), *refresh = button(L("刷新", "Refresh"), NULL), *mk = button(L("新建文件夹", "New folder"), NULL), *path = gtk_entry_new();
gtk_widget_set_tooltip_text(up, L("上一级", "Up")); gtk_widget_set_tooltip_text(refresh, L("刷新", "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);
add_column(view, L("名称", "Name"), C_NAME, 1); add_column(view, L("修改日期", "Date modified"), C_TIME, 0); add_column(view, L("类型", "Type"), C_TYPE, 0); add_column(view, L("大小", "Size"), 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);
@@ -229,13 +230,13 @@ static GtkWidget *pane(int remote) {
return card;
}
static void build_files(void) {
GtkWidget *content; frame("文件传输", &content);
GtkWidget *content; frame(L("文件传输", "File transfer"), &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);
char host[256]; if (gethostname(host, sizeof host) != 0) snprintf(host, sizeof host, L("本机", "This device")); host[sizeof host - 1] = 0;
GtkWidget *tag_l = label(L("本机", "This device"), "tag"), *tag_r = label(L("远端", "Remote"), "tag"); add_class(tag_r, "remote");
GtkWidget *send_r = button(L("发送 →", "Send →"), NULL), *send_l = button(L("← 发送", "← Send"), 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);
@@ -247,25 +248,25 @@ static void build_files(void) {
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);
GtkWidget *tbar = hbox(8), *cancel = button(L("全部取消", "Cancel all"), NULL), *clear = button(L("清除完结任务", "Clear finished"), 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_start(GTK_BOX(tbar), label(L("传输列表", "Transfers"), "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);
add_column(tview, L("名称", "Name"), T_NAME, 1); add_column(tview, L("状态", "Status"), T_STATUS, 0); add_column(tview, L("大小", "Size"), T_SIZE, 0);
add_column(tview, L("发送路径", "From"), T_FROM, 1); add_column(tview, L("接收路径", "To"), 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), "此电脑");
gtk_entry_set_text(GTK_ENTRY(remote_path), L("此电脑", "This PC"));
}
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_entry_set_text(GTK_ENTRY(remote_path), strcmp(remote_dir, ":/") ? remote_dir : L("此电脑", "This PC"));
gtk_list_store_clear(remote_store);
char **lines = g_strsplit(l->rows, "\n", -1);
for (char **line = lines; *line; line++) {
@@ -312,10 +313,10 @@ 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 *dlg = gtk_dialog_new_with_buttons(L("添加映射规则", "Add mapping rule"), GTK_WINDOW(window), GTK_DIALOG_MODAL, L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("保存后立即启用", "Save and enable"), 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[] = {"名称", "请输入端口", "", "请输入端口"};
const char *labels[] = {L("名称", "Name"), L("本地端口", "Local port"), L("目标地址", "Target address"), L("目标端口", "Target port")}, *hints[] = {L("名称", "Name"), L("请输入端口", "Enter port"), "", L("请输入端口", "Enter port")};
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);
@@ -328,7 +329,7 @@ static void on_add_rule(GtkButton *b, gpointer d) {
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; }
if (!*name || strchr(name, '\t') || !*host || strchr(host, '\t') || bad_local || bad_port) { show_toast(L("请填写名称、有效端口和目标地址", "Enter a name, valid ports and a target address")); continue; }
char cmd[1024]; snprintf(cmd, sizeof cmd, "add\t%s\t%ld\t%s\t%ld", name, local, host, port); push(cmd);
break;
}
@@ -336,27 +337,27 @@ static void on_add_rule(GtkButton *b, gpointer d) {
}
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; }
if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(view), &m, &it)) { show_toast(L("请先选择一条规则", "Select a rule first")); 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);
GtkWidget *content; frame(L("端口映射", "Port mapping"), &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");
GtkWidget *head = hbox(12), *add = button(L("添加规则", "Add rule"), "primary"), *del = button(L("删除", "Remove"), NULL);
GtkWidget *dot = label(L("● 已连接", "● Connected"), "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);
add_column(view, L("名称", "Name"), P_NAME, 1); add_column(view, L("本地地址", "Local address"), P_LOCAL, 0); add_column(view, L("目标地址", "Target address"), P_TARGET, 1); add_column(view, L("状态", "Status"), P_STATUS, 0);
rule_stack = gtk_stack_new();
GtkWidget *empty = label("当前没有端口映射规则,点击「添加规则」把远端端口映射到本机", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
GtkWidget *empty = label(L("当前没有端口映射规则,点击「添加规则」把远端端口映射到本机", "No port mapping rules. Click \"Add rule\" to map a remote port to this computer"), "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);
gtk_box_pack_start(GTK_BOX(content), label(L("本地端口只监听 127.0.0.1;本地端口填 0 时自动分配。", "Local ports listen on 127.0.0.1 only; enter 0 to pick a free port."), "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);
}
@@ -394,36 +395,36 @@ static void on_open_session(GtkTreeView *v, GtkTreePath *path, GtkTreeViewColumn
}
static void on_kill_session(GtkButton *b, gpointer d) {
(void)b; (void)d; guint id = selected_session();
if (!id) { show_toast("请先选择一个会话"); return; }
if (!id) { show_toast(L("请先选择一个会话", "Select a session first")); 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_MESSAGE_WARNING, GTK_BUTTONS_NONE, L("确定结束会话 %u?", "End session %u?"), id);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dlg), L("会话内正在运行的程序将被终止。", "Programs running in the session will be terminated."));
gtk_dialog_add_buttons(GTK_DIALOG(dlg), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("结束会话", "End session"), 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);
GtkWidget *content; frame(L("终端远控", "Remote terminal"), &content); gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
GtkWidget *head = hbox(12); session_dot = label(L("● 正在读取会话", "● Loading sessions"), "online");
session_create = button(L("创建会话", "New session"), "primary"); session_kill = button(L("结束会话", "End session"), 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);
add_column(session_view, L("会话 ID", "Session ID"), S_ID, 0); add_column(session_view, "Shell", S_SHELL, 1);
add_column(session_view, L("创建时间", "Created"), S_TIME, 0); add_column(session_view, L("状态", "Status"), S_STATE, 0);
session_stack = gtk_stack_new();
GtkWidget *empty = label("当前无正在运行的终端会话", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
GtkWidget *empty = label(L("当前无正在运行的终端会话", "No running terminal sessions"), "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), label(L("正在读取会话…", "Loading sessions…"), "empty"), "loading");
gtk_stack_add_named(GTK_STACK(session_stack), label(L("连接已断开,请关闭窗口后重试", "Disconnected. Close the window and try again"), "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_box_pack_start(GTK_BOX(content), label(L("双击接回会话;创建会话将在本机终端程序中打开。", "Double-click to reattach; new sessions open in a local terminal."), "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);
@@ -449,7 +450,7 @@ static gboolean sessions_idle(gpointer d) {
g_strfreev(f);
}
g_strfreev(lines);
gtk_label_set_text(GTK_LABEL(session_dot), s->connected ? "● 已连接" : "● 已断开");
gtk_label_set_text(GTK_LABEL(session_dot), s->connected ? L("● 已连接", "● Connected") : L("● 已断开", "● Disconnected"));
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");
+196 -120
View File
@@ -9,6 +9,8 @@
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/stat.h>
#include "i18n.h"
static const char *CSS =
"window { background-color: #ffffff; }\n"
@@ -49,7 +51,7 @@ static const char *CSS =
".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;
typedef struct { char id[64]; char name[128]; int platform, online, current; char thumb[512]; } Device;
static Device devices[64];
static int device_count;
static char queue[16][200];
@@ -93,7 +95,7 @@ static GtkWidget *platform_icon(int platform, int online) {
}
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 unsupported(GtkButton *b, gpointer what) { (void)b; char t[128]; snprintf(t, sizeof t, L("%s:暂未支持", "%s: not supported yet"), (const char *)what); show_toast(t); }
static void connect_kind(const char *kind) {
if (selected < 0) return;
@@ -102,7 +104,7 @@ static void connect_kind(const char *kind) {
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("正在连接…");
if (!strcmp(kind, "desktop") || !strcmp(kind, "watch")) show_toast(L("正在连接…", "Connecting…"));
}
static void on_tool(GtkButton *b, gpointer kind);
static void more_item(GtkButton *b, gpointer kind) {
@@ -110,32 +112,32 @@ static void more_item(GtkButton *b, gpointer kind) {
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);
!strcmp(k, "reboot") ? L("确定要重启被控电脑吗?", "Restart the remote computer?") : L("确定要关闭被控电脑吗?", "Shut down the remote computer?"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), L("远程会话会断开。", "The remote session will be disconnected."));
gtk_dialog_add_buttons(GTK_DIALOG(d), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("确认", "Confirm"), 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("正在发送电源指令…"); }
if (ok) { connect_kind(k); show_toast(L("正在发送电源指令…", "Sending power command…")); }
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);
L("确定要从账号中删除该设备吗?", "Remove this device from your account?"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), L("删除后需要在该设备上重新登录才能再次远控。", "After removal you must sign in on that device again before you can control it."));
gtk_dialog_add_buttons(GTK_DIALOG(d), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("删除", "Remove"), 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("正在删除设备…"); }
if (ok) { gtk_widget_destroy(dialog); connect_kind(k); show_toast(L("正在删除设备…", "Removing device…")); }
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);
GtkWidget *dialog = gtk_dialog_new_with_buttons(L("更多工具", "More tools"), 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[] = {"🗂 文件传输", "▶ 观看模式", "⌨ 终端", "⇄ 端口映射", "⏻ 远程开机", "↻ 重启", "⏻ 关机", "🗑 删除设备"};
gtk_box_pack_start(GTK_BOX(box), label(L("更多工具", "More tools"), "h2"), FALSE, FALSE, 6);
const char *names[] = {L("🗂 文件传输", "🗂 File transfer"), L("▶ 观看模式", "▶ Watch mode"), L("⌨ 终端", "⌨ Terminal"), L("⇄ 端口映射", "⇄ Port mapping"), L("⏻ 远程开机", "⏻ Wake on LAN"), L("↻ 重启", "↻ Restart"), L("⏻ 关机", "⏻ Shut down"), L("🗑 删除设备", "🗑 Remove device")};
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");
@@ -146,8 +148,8 @@ static void open_more(void) {
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), "调整顺序");
GtkWidget *foot = hbox(10), *order = button(L("调整顺序", "Reorder"), "secondary"), *close = button(L("关闭", "Close"), "secondary");
g_signal_connect(order, "clicked", G_CALLBACK(unsupported), L("调整顺序", "Reorder"));
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);
@@ -159,10 +161,10 @@ 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") ? "重启" : "关机"));
unsupported(NULL, (gpointer)(!strcmp(kind, "wol") ? L("远程开机", "Wake on LAN") : !strcmp(kind, "reboot") ? L("重启", "Restart") : L("关机", "Shut down")));
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 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), L("登录", "Sign in")); }
static void set_header(const char *title, int device_page) {
gtk_label_set_text(GTK_LABEL(title_label), title);
@@ -170,19 +172,52 @@ static void set_header(const char *title, int 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; }
if (!logged_in && need_login) { set_header(L("全部设备", "All devices"), 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);
}
// ---- device preview: the last remote picture saved by the desktop window (src/viewer/thumbs.rs) ----
static GtkWidget *preview_bg;
static GdkPixbuf *thumb_pixbuf;
static char thumb_loaded[512];
static gint64 thumb_mtime;
static void load_thumb(const char *path) {
struct stat st; gint64 mtime = path[0] && stat(path, &st) == 0 ? (gint64)st.st_mtime : 0;
if (!strcmp(path, thumb_loaded) && mtime == thumb_mtime) return;
if (thumb_pixbuf) { g_object_unref(thumb_pixbuf); thumb_pixbuf = NULL; }
snprintf(thumb_loaded, sizeof thumb_loaded, "%s", path); thumb_mtime = mtime;
if (mtime) thumb_pixbuf = gdk_pixbuf_new_from_file(path, NULL);
if (preview_bg) gtk_widget_queue_draw(preview_bg);
}
static gboolean draw_preview(GtkWidget *w, cairo_t *cr, gpointer d) {
(void)d; if (!thumb_pixbuf) return FALSE;
double W = gtk_widget_get_allocated_width(w), H = gtk_widget_get_allocated_height(w), r = 12;
double pw = gdk_pixbuf_get_width(thumb_pixbuf), ph = gdk_pixbuf_get_height(thumb_pixbuf);
double scale = W / pw > H / ph ? W / pw : H / ph; // cover, centered
cairo_save(cr);
cairo_new_path(cr); cairo_arc(cr, r, r, r, G_PI, 1.5 * G_PI); cairo_arc(cr, W - r, r, r, 1.5 * G_PI, 2 * G_PI);
cairo_line_to(cr, W, H); cairo_line_to(cr, 0, H); cairo_close_path(cr); cairo_clip(cr);
cairo_translate(cr, (W - pw * scale) / 2, (H - ph * scale) / 2); cairo_scale(cr, scale, scale);
gdk_cairo_set_source_pixbuf(cr, thumb_pixbuf, 0, 0);
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_GOOD); cairo_paint(cr);
cairo_restore(cr);
// Soft shade at the bottom keeps the "Open desktop" button readable on bright desktops.
cairo_pattern_t *g = cairo_pattern_create_linear(0, H * 0.55, 0, H);
cairo_pattern_add_color_stop_rgba(g, 0, 0, 0, 0, 0); cairo_pattern_add_color_stop_rgba(g, 1, 0, 0, 0, 0.35);
cairo_rectangle(cr, 0, 0, W, H); cairo_set_source(cr, g); cairo_fill(cr); cairo_pattern_destroy(g);
return FALSE;
}
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;
char thumb[512]; snprintf(thumb, sizeof thumb, "%s", devices[index].thumb);
pthread_mutex_unlock(&d_lock);
load_thumb(thumb);
set_header(name, 1);
gtk_label_set_markup(GTK_LABEL(badge), online ? "<span foreground='#22c55e'>●</span> 在线" : "离线");
gtk_label_set_markup(GTK_LABEL(badge), online ? L("<span foreground='#22c55e'>●</span> 在线", "<span foreground='#22c55e'>●</span> Online") : L("离线", "Offline"));
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");
@@ -194,9 +229,9 @@ static void on_row(GtkListBox *box, GtkListBoxRow *row, gpointer d) {
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", "收藏设备");
if (!strcmp(kind, "all")) show_page("all", L("全部设备", "All devices"));
else if (!strcmp(kind, "assist")) show_page("assist", L("远程协助", "Remote assistance"));
else if (!strcmp(kind, "favorite")) show_page("favorite", L("收藏设备", "Favorites"));
}
static void on_card(GtkButton *b, gpointer index) { (void)b; show_device(GPOINTER_TO_INT(index)); }
@@ -220,18 +255,18 @@ static void on_info(GtkButton *b, gpointer index) {
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 *dialog = gtk_dialog_new_with_buttons(L("设备信息", "Device info"), GTK_WINDOW(window), GTK_DIALOG_MODAL, L("完成", "Done"), 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);
GtkWidget *r = hbox(8); gtk_box_pack_start(GTK_BOX(r), label(L("名称", "Name"), "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), "重命名");
GtkWidget *rename = button(L("重命名", "Rename"), "secondary"); gtk_widget_set_halign(rename, GTK_ALIGN_END);
g_signal_connect(rename, "clicked", G_CALLBACK(unsupported), L("重命名", "Rename"));
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[] = {"处理器", "网卡", "总内存", "系统版本", "显卡"};
const char *rows[] = {L("处理器", "Processor"), L("网卡", "Network adapter"), L("总内存", "Total memory"), L("系统版本", "OS version"), L("显卡", "Graphics")};
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);
@@ -239,7 +274,7 @@ static void on_info(GtkButton *b, gpointer index) {
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_box_pack_start(GTK_BOX(box), label(L("硬件信息暂未获取。", "Hardware info not available yet."), "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);
}
@@ -249,8 +284,9 @@ static gboolean apply_devices(gpointer d) {
(void)d;
clear(device_list); clear(all_box);
pthread_mutex_lock(&d_lock);
if (selected >= 0 && selected < device_count) load_thumb(devices[selected].thumb);
if (!banner_closed) gtk_widget_show_all(banner);
char group[64]; snprintf(group, sizeof group, "⌄ 电脑 %d", device_count);
char group[64]; snprintf(group, sizeof group, L("⌄ 电脑 %d", "⌄ Computers %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);
@@ -266,7 +302,7 @@ static gboolean apply_devices(gpointer d) {
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);
if (devices[i].current) gtk_box_pack_start(GTK_BOX(card), label(L("本机", "This device"), "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); }
@@ -275,12 +311,20 @@ static gboolean apply_devices(gpointer d) {
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_list_box_insert(GTK_LIST_BOX(device_list), nav_row("◼", L("全部设备", "All devices"), "all"), -1);
gtk_widget_show_all(device_list); gtk_widget_show_all(all_box);
return G_SOURCE_REMOVE;
}
static GtkWidget *account_who, *account_out;
/* The settings window is built once and kept; refresh its account card on every login change. */
static void refresh_account(void) {
if (!account_who) return;
gtk_label_set_text(GTK_LABEL(account_who), logged_in ? (user_text[0] ? user_text : L("已登录", "Signed in")) : L("未登录", "Not signed in"));
gtk_widget_set_sensitive(account_out, logged_in);
}
static gboolean apply_login(gpointer d) {
(void)d;
refresh_account();
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);
@@ -288,9 +332,9 @@ static gboolean apply_login(gpointer d) {
} 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); }
if (logged_in && (!strcmp(page, "login") || !strcmp(page, "welcome"))) show_page("all", L("全部设备", "All devices"));
if (!logged_in && strcmp(page, "login") && strcmp(page, "assist")) show_page("welcome", L("全部设备", "All devices"));
if (!logged_in && qr_path[0]) { gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); set_header(L("登录", "Sign in"), 0); }
return G_SOURCE_REMOVE;
}
@@ -299,28 +343,28 @@ 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);
GtkWidget *t = label(L("随时访问个人设备,可用于办公、游戏、文件传输。", "Access your devices anytime for work, gaming and file transfer."), "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);
GtkWidget *b = button(L("立即登录", "Sign in now"), "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);
GtkWidget *brand = label(L("UU 远程 Linux 控制端(非官方)", "UU Remote Linux viewer (unofficial)"), "h2"); gtk_widget_set_halign(brand, GTK_ALIGN_CENTER);
GtkWidget *t = label(L("扫码登录", "Scan to sign in"), "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);
GtkWidget *h = label(L("请使用网易 UU 远程 App 扫一扫\n可快速登录", "Scan with the NetEase UU Remote app\nto sign in quickly"), "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);
GtkWidget *again = button(L("刷新二维码", "Refresh QR code"), "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;
@@ -328,14 +372,15 @@ static GtkWidget *build_login(void) {
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);
preview_bg = bg; g_signal_connect_after(bg, "draw", G_CALLBACK(draw_preview), NULL);
gtk_container_add(GTK_CONTAINER(preview), bg);
GtkWidget *enter = button("进入桌面 →", "enter");
GtkWidget *enter = button(L("进入桌面 →", "Open desktop →"), "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"};
const char *names[] = {L("🗂 文件传输", "🗂 File transfer"), L("▶ 观看模式", "▶ Watch mode"), L("⌨ 终端", "⌨ Terminal"), L("⇄ 端口映射", "⇄ Port mapping"), "▦"}, *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]);
@@ -343,11 +388,11 @@ static GtkWidget *build_device(void) {
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);
gtk_box_pack_start(GTK_BOX(page), label(L("快速启动", "Quick launch"), "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);
g_signal_connect(add, "clicked", G_CALLBACK(unsupported), L("快速启动", "Quick launch"));
GtkWidget *al = label(L("添加", "Add"), "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;
@@ -357,8 +402,8 @@ 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(text), label(L("ⓘ 添加你的其他设备", "ⓘ Add your other devices"), "group"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(text), label(L("在其他电脑上安装 UU 远程官方客户端或本项目主机端,登录同一账号后即可在这里远程访问。", "Install the official UU Remote client or this project's host on another computer and sign in with the same account to access it here."), "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);
@@ -372,51 +417,51 @@ static GtkWidget *build_all(void) {
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; }
if (!id[0]) { show_toast(L("请输入伙伴的设备 ID", "Enter your partner's device 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; }
if (!code[0]) { show_toast(L("请输入伙伴的设备验证码", "Enter your partner's verification code")); return; }
if (strpbrk(id, "\t\r\n") || strpbrk(code, "\t\r\n")) { show_toast(L("设备 ID 和验证码不能包含换行或制表符", "Device ID and code cannot contain line breaks or tabs")); 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; }
if (n < 0 || (size_t)n >= sizeof cmd) { show_toast(L("设备 ID 或验证码过长", "Device ID or code is too long")); return; }
int accepted = push(cmd);
memset(cmd, 0, sizeof cmd);
if (!accepted) { show_toast("连接请求过多,请稍后重试"); return; }
if (!accepted) { show_toast(L("连接请求过多,请稍后重试", "Too many connection requests, try again later")); return; }
gtk_entry_set_text(GTK_ENTRY(code_entry), "");
show_toast("正在连接…");
show_toast(L("正在连接…", "Connecting…"));
}
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 *top = hbox(10); gtk_box_pack_start(GTK_BOX(top), label(L("本设备", "This device"), "h2"), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(top), label(L("允许他人远程协助", "Allow remote assistance"), "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(L("本设备 ID", "This device's 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(L("验证方式:仅使用临时验证码", "Verification: temporary code only"), "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(c2), label(L("每次远控结束刷新", "Refreshed after every remote session"), "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(mine), label(L("本机被协助由 uuremote-server 主机端提供(uuremote-server assist)。", "Assistance for this computer is provided by the uuremote-server host (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), label(L("远控伙伴设备", "Control a partner's device"), "h2"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), label(L("通过其他设备的【设备 ID】及【设备验证码】启动远程控制", "Start remote control with another device's [Device ID] and [Verification code]"), "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_box_pack_start(GTK_BOX(peer), label(L("伙伴的设备 ID", "Partner's device ID"), "devname"), FALSE, FALSE, 0);
GtkWidget *row = hbox(20), *entry = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entry), L("请输入设备 ID", "Enter device ID")); gtk_widget_set_size_request(entry, 320, -1);
GtkWidget *code = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(code), L("请输入设备验证码", "Enter verification 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);
GtkWidget *go = button(L("连接", "Connect"), "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);
@@ -424,10 +469,10 @@ static GtkWidget *build_assist(void) {
}
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 *dialog = gtk_dialog_new_with_buttons(L("添加收藏设备", "Add favorite device"), GTK_WINDOW(window), GTK_DIALOG_MODAL, L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("添加", "Add"), 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", "请输入设备验证码", "请输入名称"};
const char *names[] = {L("伙伴的设备 ID", "Partner's device ID"), L("设备验证码(可选)", "Verification code (optional)"), L("备注名称(可选)", "Nickname (optional)")}, *hints[] = {L("请输入设备 ID", "Enter device ID"), L("请输入设备验证码", "Enter verification code"), L("请输入名称", "Enter a name")};
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);
@@ -440,17 +485,17 @@ static void on_add_favorite(GtkButton *b, gpointer d) {
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");
if (response == GTK_RESPONSE_OK) show_toast(has_id ? L("收藏设备:暂未支持", "Favorite devices: not supported yet") : L("请输入伙伴的设备 ID", "Enter your partner's device 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);
GtkWidget *add = button(L("添加收藏设备", "Add favorite device"), "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);
GtkWidget *t = label(L("暂无收藏", "No favorites yet"), "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);
@@ -478,7 +523,7 @@ static GtkWidget *settings_card(GtkWidget **rows, int n) {
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 GtkWidget *edit_button(const char *what) { GtkWidget *b = button(L("编辑", "Edit"), "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).
@@ -488,15 +533,31 @@ static void own_titlebar(GtkWidget *w, const char *title) {
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(w), bar);
}
static atomic_int host_active;
static GtkWidget *host_switch;
static gboolean host_idle(gpointer d) { (void)d; if (host_switch) gtk_switch_set_active(GTK_SWITCH(host_switch), atomic_load(&host_active)); return G_SOURCE_REMOVE; }
void uu_viewer_ui_set_host(int active) { atomic_store(&host_active, active != 0); g_idle_add(host_idle, NULL); }
static void on_host(GObject *o, GParamSpec *p, gpointer d) {
(void)p; (void)d; int on = gtk_switch_get_active(GTK_SWITCH(o));
if (on != atomic_load(&host_active)) { atomic_store(&host_active, on); push(on ? "host\ton" : "host\toff"); }
}
static void on_language(GtkComboBox *c, gpointer d) {
(void)d; int english = gtk_combo_box_get_active(c) == 1;
if (english == uu_i18n_english()) return;
if (!uu_i18n_save(english)) show_toast(L("无法保存语言设置", "Could not save the language"));
else push("relaunch");
}
static void confirm_logout(void);
static void on_sign_out(GtkButton *b, gpointer d) { (void)b; (void)d; if (logged_in) confirm_logout(); }
static void open_settings(void) {
if (settings_window) { gtk_window_present(GTK_WINDOW(settings_window)); return; }
if (settings_window) { refresh_account(); 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_title(GTK_WINDOW(settings_window), L("设置", "Settings"));
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, "设置");
own_titlebar(settings_window, L("设置", "Settings"));
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);
@@ -504,60 +565,74 @@ static void open_settings(void) {
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)) };
GtkWidget *acct = hbox(12), *acct_text = vbox(2);
gtk_box_pack_start(GTK_BOX(acct_text), label(L("账号", "Account"), "devname"), FALSE, FALSE, 0);
account_who = label("", "hint"); gtk_box_pack_start(GTK_BOX(acct_text), account_who, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(acct), acct_text, TRUE, TRUE, 0);
account_out = button(L("退出登录", "Sign out"), "secondary"); gtk_widget_set_valign(account_out, GTK_ALIGN_CENTER);
g_signal_connect(account_out, "clicked", G_CALLBACK(on_sign_out), NULL); gtk_box_pack_end(GTK_BOX(acct), account_out, FALSE, FALSE, 0);
GtkWidget *g0[] = { acct };
gtk_box_pack_start(GTK_BOX(general), settings_card(g0, 1), FALSE, FALSE, 0);
refresh_account();
const char *wake[] = {L("永不", "Never"), L("接通电源时", "When plugged in"), L("始终", "Always")}, *close_opts[] = {L("最小化", "Minimize"), L("退出程序", "Quit")};
GtkWidget *g1[] = { setting_row(L("开机自启动", "Start at login"), NULL, gtk_switch_new()),
setting_row(L("保持唤醒状态", "Stay awake"), L("防止电脑进入睡眠状态,导致无法远程访问。", "Keep the computer from sleeping so it stays reachable."), combo(wake, 3)),
setting_row(L("关闭窗口时", "When closing the window"), 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), "打开文件夹");
GtkWidget *path = hbox(8); GtkWidget *change = button(L("修改路径", "Change path"), "secondary"), *open = button(L("打开文件夹", "Open folder"), "secondary");
g_signal_connect(change, "clicked", G_CALLBACK(unsupported), L("修改路径", "Change path")); g_signal_connect(open, "clicked", G_CALLBACK(unsupported), L("打开文件夹", "Open folder"));
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) };
GtkWidget *g2[] = { setting_row(L("传输文件存储路径", "Received files folder"), "~/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) };
GtkWidget *real = button(L("在手机 App 中查看", "View in the mobile app"), "secondary"); gtk_widget_set_sensitive(real, FALSE);
GtkWidget *g3[] = { setting_row(L("实名认证", "Identity verification"), 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", "⚙ 常规");
const char *languages[] = {"中文", "English"}; GtkWidget *language = combo(languages, 2);
gtk_combo_box_set_active(GTK_COMBO_BOX(language), uu_i18n_english()); g_signal_connect(language, "changed", G_CALLBACK(on_language), NULL);
GtkWidget *g4[] = { setting_row("语言 / Language", NULL, language) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g4, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), general, "general", L("⚙ 常规", "⚙ 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()) };
const char *verify[] = {L("仅使用临时验证码", "Temporary code only"), L("仅使用自定义验证码", "Custom code only"), L("临时与自定义验证码", "Temporary and custom codes")};
host_switch = gtk_switch_new(); gtk_switch_set_active(GTK_SWITCH(host_switch), atomic_load(&host_active));
g_signal_connect(host_switch, "notify::active", G_CALLBACK(on_host), NULL);
GtkWidget *s1[] = { setting_row(L("允许同账号控制本设备", "Allow the same account to control this device"), L("默认关闭。开启后本机会出现在你的设备列表中,可被远程控制(uuremote-server 用户服务)", "Off by default. When on, this computer appears in your device list and can be controlled (uuremote-server user service)"), host_switch), setting_row(L("允许他人远程协助", "Allow remote assistance"), NULL, gtk_switch_new()) };
GtkWidget *s2[] = { setting_row(L("远程协助连接本设备的验证方式", "Verification for remote assistance"), NULL, combo(verify, 3)) };
GtkWidget *s3[] = { setting_row(L("客户端锁定", "Lock client"), L("防止客户端设置被修改,保障数据与使用安全。", "Prevents client settings from being changed, keeping data and usage safe."), 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", "🔒 安全");
gtk_stack_add_titled(GTK_STACK(tabs), security, "security", L("🔒 安全", "🔒 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), label(L("仅控制端响应的快捷键", "Viewer-only shortcuts"), "h2"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(keys), label(L("远控时按下以下快捷键,仅在控制端本地响应,不会发送到被控端。", "These shortcuts are handled locally on the viewer and are not sent to the remote device."), "hint"), FALSE, FALSE, 0);
GtkWidget *addk = button(L("添加控制端快捷键", "Add viewer shortcut"), "secondary"); g_signal_connect(addk, "clicked", G_CALLBACK(unsupported), L("添加快捷键", "Add shortcut"));
GtkWidget *k1[] = { setting_row(L("当前暂无设置", "Nothing set yet"), 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 组合键"};
gtk_box_pack_start(GTK_BOX(keys), label(L("功能快捷键", "Function shortcuts"), "h2"), FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(keys), label(L("按下以下快捷键时,仅在本地触发对应功能,不会发送到被控端。", "These shortcuts trigger local functions only and are not sent to the remote device."), "hint"), FALSE, FALSE, 0);
const char *fns[] = {L("使用被控端鼠标/解锁鼠标", "Use remote mouse / release mouse"), L("被控时解除防窥模式", "Turn off privacy screen while controlled"), L("切换上一个屏幕", "Previous screen"), L("切换下一个屏幕", "Next screen"), L("显示/隐藏悬浮球", "Show/hide floating ball"), L("静音/取消静音", "Mute/unmute"), L("老板键(隐藏/显示所有客户端窗口)", "Boss key (hide/show all client windows)"), L("发送 Ctrl+Alt+Delete 组合键", "Send 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", "⌨ 键盘");
gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", L("⌨ 键盘", "⌨ Keyboard"));
// 网络
GtkWidget *network = settings_page();
const char *proxy[] = {"使用系统环境代理", "不使用代理"};
GtkWidget *n1[] = { setting_row("代理设置", NULL, combo(proxy, 2)) };
const char *proxy[] = {L("使用系统环境代理", "Use system proxy"), L("不使用代理", "No proxy")};
GtkWidget *n1[] = { setting_row(L("代理设置", "Proxy"), 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_stack_add_titled(GTK_STACK(tabs), network, "network", L("🌐 网络", "🌐 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);
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, L("确定要退出登录吗?", "Sign out?"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), L("退出登录会中断正在进行中的连接,你的设备也将从本账户删除。请谨慎操作!", "Signing out ends active connections and removes your device from this account. Be careful!"));
gtk_dialog_add_buttons(GTK_DIALOG(d), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("确认", "Confirm"), GTK_RESPONSE_OK, NULL);
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) push("logout");
gtk_widget_destroy(d);
}
@@ -571,15 +646,15 @@ static void on_menu(GtkMenuItem *item, gpointer what) {
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);
GtkWidget *who = gtk_menu_item_new_with_label(logged_in ? (user_text[0] ? user_text : L("已登录", "Signed in")) : L("未登录", "Not signed in")); 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");
GtkWidget *out = gtk_menu_item_new_with_label(L("退出登录", "Sign out")); 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);
GtkWidget *none = gtk_menu_item_new_with_label(L("暂无通知", "No notifications")); gtk_widget_set_sensitive(none, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), none);
} else {
const char *labels[] = {"刷新设备列表", "设置", "退出程序"}, *whats[] = {"refresh", "settings", "quit"};
const char *labels[] = {L("刷新设备列表", "Refresh device list"), L("设置", "Settings"), L("退出程序", "Quit")}, *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);
@@ -598,27 +673,27 @@ static void *run(void *arg) {
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_title(GTK_WINDOW(window), L("UU 远程 Linux 控制端(非官方)", "UU Remote Linux viewer (unofficial)"));
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 控制端(非官方)");
own_titlebar(window, L("UU 远程 Linux 控制端(非官方)", "UU Remote Linux viewer (unofficial)"));
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(mh), label(L("⧉ 我的设备", "⧉ My devices"), "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);
GtkWidget *ah = label(L("⧉ 远程协助", "⧉ Remote assistance"), "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_list_box_insert(GTK_LIST_BOX(assist), nav_row("◧", L("开始协助", "Start assistance"), "assist"), -1);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("★", L("收藏设备", "Favorites"), "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;
@@ -628,7 +703,7 @@ static void *run(void *arg) {
// 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");
title_label = label(L("全部设备", "All devices"), "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);
@@ -676,12 +751,13 @@ void uu_viewer_ui_set_devices(const char *tsv) {
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;
char *f[6] = {0}, *s2 = NULL; int n = 0;
for (char *p = strtok_r(line, "\t", &s2); p && n < 6; 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]);
snprintf(d->thumb, sizeof d->thumb, "%s", n > 5 && f[5][0] == '/' ? f[5] : "");
}
free(copy);
selected = -1;
@@ -715,8 +791,8 @@ 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);
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, L("打开后将断开当前与该设备的连接,继续吗?", "Opening this disconnects your current connection to this device. Continue?"));
gtk_dialog_add_buttons(GTK_DIALOG(dialog), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("继续", "Continue"), 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);
+57 -16
View File
@@ -1,5 +1,6 @@
/* Native Hyprland/wlroots desktop bridge. Protocol XMLs retain upstream licenses. */
#define _GNU_SOURCE
#include "wayland_transform.h"
#include <wayland-client.h>
#include <xkbcommon/xkbcommon.h>
#include <pthread.h>
@@ -60,7 +61,7 @@ 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. */
and printable codes on a separate text keyboard carry each batch. Never logs the text. */
#define UU_TEXT_SPARE 32
static char *keymap_text;
static size_t keymap_text_len, keymap_insert;
@@ -187,6 +188,14 @@ static xkb_keycode_t existing_keycode(xkb_keysym_t symbol) {
}
return 0;
}
static unsigned find_niri_text_codes(xkb_keycode_t *out,unsigned limit) {
/* Printable physical keys work in Chromium; reserved evdev codes can be discarded. */
static const xkb_keycode_t text_codes[]={24,25,26,27,28,29,30,31,32,33,38,39,40,41,42,43,44,45,46,52,53,54,55,56,57,58};
unsigned count=0;
for(unsigned i=0;i<sizeof(text_codes)/sizeof(text_codes[0]) && count<limit;i++)
if(xkb_keymap_key_get_name(keymap,text_codes[i])) out[count++]=text_codes[i];
return count;
}
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);
@@ -207,7 +216,8 @@ static void release_held_keys_locked(void) {
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;
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);}
else if(rekey_keyboard()!=0) return -1;
size_t at=keymap_insert;
memcpy(buffer,keymap_text,at);
for(unsigned i=0;i<count;i++) {
@@ -217,8 +227,11 @@ static int flush_batch(char *buffer,size_t capacity,const char names[][64],const
}
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(getenv("NIRI_SOCKET")) zwp_virtual_keyboard_v1_modifiers(keyboard,0,0,0,0);
if(sync_display()!=0) return -1;
if(getenv("NIRI_SOCKET")) usleep(8000);
for(unsigned i=0;i<count;i++) { press_keycode(codes[i]); (*typed)++; }
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);}
return 0;
}
/* Type UTF-8 like xdotool type does on X11, but on Wayland: characters the session keymap already
@@ -247,14 +260,14 @@ static int type_utf8_locked(const char *text) {
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);
xkb_keycode_t existing=getenv("NIRI_SOCKET")?0: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(count==(getenv("NIRI_SOCKET")?spare_count:UU_TEXT_SPARE)) {
if(flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; }
count=0;
}
@@ -266,13 +279,23 @@ static int type_utf8_locked(const char *text) {
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;
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);}
else 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(initialized && text && keymap_text && keymap_insert && spare_count) {
if(getenv("NIRI_SOCKET")) {
/* Only niri uses printable codes on a separate text device; preserve the Hyprland path. */
release_held_keys_locked();
struct zwp_virtual_keyboard_v1 *saved=keyboard;
keyboard=zwp_virtual_keyboard_manager_v1_create_virtual_keyboard(keyboard_manager,seat);
if(keyboard) {typed=type_utf8_locked(text);sync_display();usleep(8000);if(keyboard) zwp_virtual_keyboard_v1_destroy(keyboard);}
keyboard=saved;
} else typed=type_utf8_locked(text);
}
if(typed>=0 && wl_display_flush(display)<0) typed=-1;
pthread_mutex_unlock(&lock); return typed;
}
@@ -544,9 +567,9 @@ int uu_wl_init(int32_t *w,int32_t *h) {
for(selected=0;selected<output_count;selected++) if(!strcmp(outputs[selected].name,name)) break;
if(selected==output_count) goto end;
}
/* Rotated output coordinate mapping needs separate acceptance. */
if(outputs[selected].transform!=WL_OUTPUT_TRANSFORM_NORMAL) goto end;
if(!uu_output_transform_supported(outputs[selected].transform,getenv("NIRI_SOCKET")!=NULL)) goto end;
width=outputs[selected].width; height=outputs[selected].height;
if(outputs[selected].transform&1) {uint32_t t=width;width=height;height=t;}
if(!width || !height || width>16384 || height>16384 || (uint64_t)width*height*4>256*1024*1024) goto end;
if(power_manager) {
power=zwlr_output_power_manager_v1_get_output_power(power_manager,outputs[selected].handle);
@@ -574,7 +597,7 @@ int uu_wl_init(int32_t *w,int32_t *h) {
/* 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]));
spare_count=getenv("NIRI_SOCKET")?find_niri_text_codes(spare_codes,UU_TEXT_SPARE):find_spare_codes(spare_codes,UU_TEXT_SPARE);
}
initialized=1; *w=width; *h=height; result=0;
end:
@@ -588,8 +611,9 @@ int uu_wl_select_output(const char *name,uint32_t expected_w,uint32_t expected_h
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;
if(target==output_count || !uu_output_transform_supported(outputs[target].transform,getenv("NIRI_SOCKET")!=NULL)) goto end;
uint32_t w=outputs[target].width,h=outputs[target].height;
if(outputs[target].transform&1) {uint32_t t=w;w=h;h=t;}
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=NULL;
if(pointer_manager) {
@@ -640,7 +664,7 @@ retry:;
for(unsigned i=0;i<2;i++) { frame_clear(&frames[i]); dma_clear(&frames[i]); }
pending=0; goto retry;
}
if(frame->failed || !frame->pixels || frame->width!=width || frame->height!=height) goto end;
if(frame->failed || !frame->pixels || frame->width!=outputs[selected].width || frame->height!=outputs[selected].height) goto end;
zwlr_screencopy_frame_v1_destroy(frame->handle); frame->handle=NULL;
const char *pipeline=getenv("UU_WAYLAND_PIPELINE");
if(!pipeline || strcmp(pipeline,"0")) {
@@ -651,11 +675,22 @@ retry:;
}
{
for(uint32_t y=0;y<height;y++) {
uint32_t source=(frame->flags&ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT)?height-y-1:y;
uint8_t *row=out+(size_t)y*width*4;
memcpy(row,(uint8_t*)frame->pixels+(size_t)source*frame->stride,width*4);
if(frame->format==WL_SHM_FORMAT_XBGR8888 || frame->format==WL_SHM_FORMAT_ABGR8888) {
for(uint32_t x=0;x<width;x++) { uint8_t red=row[x*4]; row[x*4]=row[x*4+2]; row[x*4+2]=red; }
if(outputs[selected].transform==WL_OUTPUT_TRANSFORM_NORMAL &&
frame->format!=WL_SHM_FORMAT_XBGR8888 && frame->format!=WL_SHM_FORMAT_ABGR8888) {
uint32_t sy=(frame->flags&ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT)?height-1-y:y;
memcpy(row,(uint8_t*)frame->pixels+(size_t)sy*frame->stride,width*4);
continue;
}
for(uint32_t x=0;x<width;x++) {
uint32_t sx=x,sy=y,sw=frame->width,sh=frame->height;
uu_source_pixel(outputs[selected].transform,sw,sh,x,y,&sx,&sy);
if(frame->flags&ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT) sy=sh-1-sy;
const uint8_t *pixel=(uint8_t*)frame->pixels+(size_t)sy*frame->stride+sx*4;
memcpy(row+x*4,pixel,4);
if(frame->format==WL_SHM_FORMAT_XBGR8888 || frame->format==WL_SHM_FORMAT_ABGR8888) {
row[x*4]=pixel[2];row[x*4+2]=pixel[0];
}
}
}
result=0;
@@ -675,7 +710,13 @@ int uu_wl_move(int32_t x,int32_t y,int relative) {
double scale=outputs[selected].scale;
zwlr_virtual_pointer_v1_motion(pointer,timestamp(),wl_fixed_from_double(x/scale),wl_fixed_from_double(y/scale));
}
else if(x>=0 && y>=0 && x<(int32_t)width && y<(int32_t)height) zwlr_virtual_pointer_v1_motion_absolute(pointer,timestamp(),x,y,width,height);
else if(x>=0 && y>=0 && x<(int32_t)width && y<(int32_t)height) {
uint32_t sx,sy,sw=outputs[selected].width,sh=outputs[selected].height;
/* niri/Smithay applies the output transform to absolute device coordinates. */
if(getenv("NIRI_SOCKET")) uu_source_pixel(outputs[selected].transform,sw,sh,x,y,&sx,&sy);
else {sx=x;sy=y;sw=width;sh=height;}
zwlr_virtual_pointer_v1_motion_absolute(pointer,timestamp(),sx,sy,sw,sh);
}
else goto end;
zwlr_virtual_pointer_v1_frame(pointer); result=wl_display_flush(display)<0?-1:0;
}
+14
View File
@@ -0,0 +1,14 @@
#include <stdint.h>
/* Map upright output pixels to untransformed capture/device coordinates (Smithay Transform). */
static inline void uu_source_pixel(int transform,uint32_t w,uint32_t h,uint32_t x,uint32_t y,uint32_t *sx,uint32_t *sy) {
*sx=x;*sy=y;
switch(transform) {
case 1:*sx=y;*sy=h-1-x;break;
case 2:*sx=w-1-x;*sy=h-1-y;break;
case 3:*sx=w-1-y;*sy=x;break;
}
}
/* Rotated capture and pointer mapping have hardware acceptance only on niri. */
static inline int uu_output_transform_supported(int transform,int niri) {
return transform==0 || (niri && transform>=1 && transform<=3);
}
+17 -2
View File
@@ -56,6 +56,15 @@ static void track_injected_key(int keycode, int is_press) {
}
}
/* XShmAttach fails asynchronously (BadAccess when the X server cannot reach our segment, e.g. a
* server in another container); Xlib's default handler would exit the process before the XGetImage fallback. */
static volatile int g_shm_attach_failed = 0;
static int shm_attach_error(Display *display, XErrorEvent *event) {
(void)display; (void)event;
g_shm_attach_failed = 1;
return 0;
}
static void shm_open_image(void) {
g_use_shm = 0;
if (!XShmQueryExtension(g_display)) return;
@@ -66,9 +75,15 @@ static void shm_open_image(void) {
if (g_shminfo.shmid == -1) return;
g_shminfo.shmaddr = g_shm_image->data = (char *)shmat(g_shminfo.shmid, 0, 0);
g_shminfo.readOnly = False;
if (g_shminfo.shmaddr != (char *)-1 && XShmAttach(g_display, &g_shminfo)) {
if (g_shminfo.shmaddr != (char *)-1) {
XSync(g_display, False);
g_use_shm = 1;
g_shm_attach_failed = 0;
int (*previous)(Display *, XErrorEvent *) = XSetErrorHandler(shm_attach_error);
Status attached = XShmAttach(g_display, &g_shminfo);
XSync(g_display, False);
XSetErrorHandler(previous);
if (attached && !g_shm_attach_failed) g_use_shm = 1;
else fprintf(stderr, "X11 shared-memory capture unavailable; using XGetImage\n");
}
shmctl(g_shminfo.shmid, IPC_RMID, 0); // 标记删除,进程退出时自动回收;失败时也不遗留段
}
+12
View File
@@ -0,0 +1,12 @@
托盘图标随深色/浅色模式自动变色。/ The tray icon now follows light and dark panels.
### 修复 / Fixed
- **深色模式下托盘图标看不清**(#87):托盘改用内置单色符号图标,GNOME(AppIndicator 扩展)和 KDE 会按面板主题自动着色,
tarball 安装也不用另装图标。旧版 AppIndicator 库或缓存目录不可写时沿用原图标。目前只经过 CI 编译,尚未在 KDE / GNOME 面板上实机确认。
- The tray uses a built-in monochrome symbolic icon (written to the user cache and offered as the indicator's icon theme
path) that GNOME's AppIndicator extension and KDE recolor for the panel theme. Built in CI; not yet checked on a real panel.
### 下载 / Download
`uu-remote-linux_0.2.25_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.25-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.25`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
修复 KDE 托盘图标显示为未知图标;显示器接在 NVIDIA 卡上时默认不再让 NVENC 直接编码 BGRA。/ Fixes the KDE tray icon; NVENC skips direct BGRA input when NVIDIA drives the display.
### 修复 / Fixed
- **KDE 托盘显示成未知(空白页)图标**(#87,v0.2.25 引入):单色托盘图标改名为 `uuremote-tray-symbolic`,写到 `~/.local/share/icons/hicolor`,
各家面板的默认图标查找都能找到,仍会随深色/浅色面板着色。已在 Plasma 6.7 / KF6 上用 KIconLoader 按 Plasma 的查找方式验证,Plasma 6.8 面板待报告者确认。
v0.2.25 留下的 `~/.cache/uu-remote-linux/icons` 不再使用,可以删除。
- **同一张 NVIDIA 卡负责显示时编码变慢**(#16):显示、采集、编码都在同一张 NVIDIA 卡上时,NVENC 直接编码 BGRA 反而比 CPU 转换慢
(RTX 5070 4K:探针 82.6 vs 98 fps)。现在只要有显示器接在 NVIDIA 卡上就改用 CPU 转换;核显接显示器的机器不变。`UU_NVENC_RGB=1` 强制直接编码,`=0` 强制 CPU 转换。
- The tray icon is installed as `uuremote-tray-symbolic` in the user hicolor theme, so KDE's default lookup finds it
(v0.2.25 showed the unknown icon on Plasma 6.8). NVENC no longer takes packed BGRA when a connected monitor hangs off
an NVIDIA card (slower when the desktop is composited on the encoding GPU); `UU_NVENC_RGB=1` forces it.
### 下载 / Download
`uu-remote-linux_0.2.26_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.26-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.26`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+26
View File
@@ -0,0 +1,26 @@
可手动选择视频编码器和 codec,auto 改为后台探测;Wayland 屏幕保活失败不再中断画面;viewer 新增安全输入 `type`。/ Encoder and codec settings, background auto probe, display-wake failures no longer stop video, and a secure `type` command in the viewer.
### 新增 / Added
- **编码器与 codec 设置**(#85 第①②步,#92、#93,感谢 @ferstar):`uuremote-server set-encoder auto|cpu|vaapi|nvenc`、
`uuremote-server set-codec auto|h264|h265` 写入 `~/.config/uuremote/host_settings.json`,优先级高于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`,
下次建立桌面连接时生效;`doctor` 显示来源和最终 codec。auto 在启动时后台探测(每个候选编码一帧合成画面,限时 3 秒,不挡第一路出图):
有 NVIDIA 时 NVENC → CPU,没有 NVIDIA 时直接用 CPU 不探测。NVENC 探测失败只缓存 10 分钟,之后的桌面连接会在后台重探;
NVIDIA 驱动或设备中途出现/消失也会重探。显式指定编码器时不探测。VAAPI 要等 #33 解决后才进入 auto。
- **viewer 安全输入 `uuremote-viewer type`**(#70,感谢 @212duo):向已打开的桌面会话注入键盘(锁屏 PIN / 密码),文本不进 argv,
日志只记长度;按 US QWERTY 键位映射。本机 IPC 用私有目录和对端 uid 校验。
- `set-encoder` / `set-codec` write the video settings to `host_settings.json`; auto now probes NVENC then CPU in the background
(CPU only without NVIDIA, NVENC failures retried after 10 minutes). The viewer gains `type`, a secure key-injection command that
reuses the open desktop session.
### 修复 / Fixed
- **Wayland 运行中屏幕保活失败会停掉视频**(#94、#95,感谢 @AYssu):启动时和每 30 秒的屏幕保活改为尽力而为,失败只记警告、下轮重试,
画面继续发送;采集、编码、发送错误仍按原逻辑处理。
- A failed display wake at stream start or during the 30-second refresh is logged and retried instead of ending the video.
### 验证范围 / Validation
单元测试与 CI(x86_64、arm64、Wayland、inproc-av、viewer)通过;以上改动尚未在报告者现场或 NVIDIA 机器上实机验收。
### 下载 / Download
`uu-remote-linux_0.2.27_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.27-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.27`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
tar 包新增 `install.sh`,缺 FFmpeg 时自动安装;宿主缺 FFmpeg 时弹桌面提示,不再让客户端一直停在「正在传输画面」。/ The tarball gains `install.sh`, which installs FFmpeg when missing; the host tells the desktop user when FFmpeg is missing.
### 新增 / Added
- **tar 包安装脚本 `install.sh`**:解压后用普通桌面用户运行 `./install.sh`。程序和插件装到 `~/.local`,写入用户级 systemd 服务(已有则保留),
并检查 FFmpeg(需带 libx264)。缺失时询问后经 sudo 用 apt / pacman 安装(`--yes` 不询问,`--no-ffmpeg` 只检查);Fedora 需先启用 RPM Fusion,
openSUSE 需 Packman 源,脚本只打印命令、不替你添加第三方源。.deb 包本来就依赖 `ffmpeg`,不受影响。
- **缺 FFmpeg 时的桌面提示**:宿主在启动时和每次有人连接桌面时检查 FFmpeg。不可用时记 error,弹出「无法传输远程画面」桌面通知并给出安装命令;
没有通知服务的桌面(如精简 Xfce)改为打开宿主窗口,顶部红字提示。最多每 5 分钟一次;装好后重新连接即可,不用重启服务。
- `install.sh` installs into `~/.local`, writes the systemd user unit and installs FFmpeg with libx264 through apt or pacman when missing.
The host checks FFmpeg at startup and on every desktop connection and shows a desktop notification (or opens its window) when it is missing.
### 验证范围 / Validation
`install.sh` 在 Debian 13(Xfce)上实测:卸掉 FFmpeg 后 `--yes` 自动装回;CI 在 Ubuntu 22.04 上做同样的测试。通知和窗口红字用测试程序在 Xfce 上实测
(有/无通知服务两种情况);宿主内的完整流程只有编译与 CI 覆盖。
### 下载 / Download
`uu-remote-linux_0.2.28_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.28-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.28`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+22
View File
@@ -0,0 +1,22 @@
运行中切换编码器不再断开连接;X11 双屏/多屏可以只看其中一块屏幕(实验性)。/ Switch the encoder without dropping the session; select one monitor on X11 (experimental).
### 新增 / Added
- **运行中切换编码器(#85 第③步,#96,感谢 @ferstar)**:`uuremote-server set-encoder auto|cpu|vaapi|nvenc` 和 `set-codec` 写入设置后会通知正在运行的宿主(`SIGUSR2`),
已连接的桌面在下一帧边界换用新编码器,不用断开重连;VAAPI 不支持真彩 4:4:4 时自动降为 4:2:0 并通知客户端。只通知完整路径相同的宿主程序,
避免误杀旧版本宿主;没有通知到宿主时会打印提示(下次连接或重启服务后生效)。编码格式(H.264/H.265)偏好仍在下次连接时生效。
- **X11 单屏选择(#98,实验性)**:设置 `UU_X11_MULTISCREEN=1` 后,主机按 `xrandr --listmonitors` 列出各显示器,控制端可选择其中一块,只采集该区域,
鼠标绝对坐标加上该屏幕的偏移;默认主显示器,`UU_X11_OUTPUT` 可指定其他屏幕。显示器布局在启动时读取,改动后需重启服务;此模式下「分辨率」改为缩放画面。默认关闭,单屏用户不受影响。
- `set-encoder` / `set-codec` now switch a live desktop stream's encoder via `SIGUSR2` (same binary only) without reconnecting.
`UU_X11_MULTISCREEN=1` lets the viewer pick one X11 monitor (RandR monitors; capture and absolute input follow the selected monitor).
### 其他 / Other
- Issue 模板的诊断命令:保留连接状态和端口映射日志、过滤 WebRTC 内部噪音,并抹掉 IPv6 和 MAC 地址。
### 验证范围 / Validation
运行中切换编码器:单元测试与 CI,官方客户端下的切换时序尚未实机验证。X11 单屏选择:单元测试;在 Debian 13 上用两块 RandR 虚拟显示器实测,
鼠标落点与按区域采集正确;官方客户端在真实双屏上的切换尚未实机验证,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.29_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.29-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.29`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
先开端口映射再打开桌面时不再黑屏;VAAPI 低码率档能压到更低码率。/ Opening the desktop after a port mapping no longer shows a black screen; VAAPI low-bitrate presets go lower.
### 修复 / Fixed
- **端口映射后打开桌面黑屏(#99)**:已有端口映射连接时,Mac 控制端打开桌面不会新建连接,而是在原连接上发送 `capture_desktop`。
宿主现在会把这条连接转为桌面:画面、光标、剪贴板和会话计数都会启动,剪贴板能力也会重新通告。之后再打开新的桌面时,旧连接只停掉桌面,
端口映射照常可用。若此前 X11 分辨率有变化,会按新尺寸重建采集。限制:Wayland Portal 后端暂不支持这种方式;这条连接上没有声音。
- **VAAPI 低档码率(#33,#102,感谢 @ferstar)**:in-process VAAPI 编码的最大 QP 从 44 放宽到 51,复杂画面下低档可降到硬件能达到的最低码率;中高档不受影响。
- A viewer that opens the desktop on an existing port-mapping connection (`capture_desktop`) now gets video, cursor, clipboard and session handling on that connection;
a later desktop stops it without closing the port mappings. In-process VAAPI `max_qp` raised from 44 to 51.
### 验证范围 / Validation
#99:根因由报告者日志证实;修复只有单元测试与 CI,官方 Mac 控制端下尚未实机验证,欢迎反馈。#102:贡献者在 AMD 核显上实测(2560×1600 复杂画面最低档 4.16→2.60 Mbps,
中高档输出一致),我们这边仅 CI。
### 下载 / Download
`uu-remote-linux_0.2.30_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.30-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.30`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
NVENC 新增可选 VBV 缓冲开关,缓解高分辨率下关键帧按 GOP 周期闪烁。/ Opt-in NVENC VBV buffer for high-resolution keyframe pulsing.
### 新增 / Added
- **`UU_NVENC_BUFFER_MS`(#103,感谢 @zhl-HFUT 的分析)**:NVENC 的 VBV 缓冲(10–1000 ms,缓冲 = 码率上限 × 毫秒 / 1000),FFmpeg 进程管线和进程内引擎都生效。
默认缓冲(100–500 kbit)在 1440p 等高分辨率下会把关键帧压糊,画面按 GOP 周期“糊一下再变清”;遇到时可设 `UU_NVENC_BUFFER_MS=1000`。默认行为不变。
- New `UU_NVENC_BUFFER_MS` (10–1000 ms of the bitrate cap) for NVENC, applied to both the FFmpeg pipeline and the in-process engine. Default unchanged.
### 验证范围 / Validation
仅单元测试与 CI,尚未在 NVENC 实机上验证,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.31_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.31-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.31`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
修复端口映射在 ICE 瞬断恢复后被续房拆掉、信令卡死后长时间假在线,以及查看器 CLI 的指针偏移与滚轮。/ Fixes port-mapping teardown after ICE recovery, stalled signaling, and viewer CLI pointer/wheel input.
### 修复 / Fixed
- **ICE 瞬断恢复后连接被拆(#109,感谢 @sinoyster 的细致分析)**:WebRTC 的 ICE 状态回调读到的是占位 DTLS 对象,ICE `Disconnected → Connected` 恢复后 PeerConnection 停在 `New`,15 分钟续房把仍在使用的端口映射当成空闲,拆房并断开所有映射 TCP 流。现在恢复后会回到 `Connected`。
After a brief ICE drop the peer state settled on `New` instead of `Connected`, so the idle room renewal tore down live port-mapping streams.
- **信令投递卡住时心跳检测失效(#104,感谢 @RiverOnVenus)**:事件队列阻塞时 Engine.IO 超时不再执行,主机可能带着半关闭的连接“在线”数小时。现在有独立看门狗、发送超时和关闭超时。
Heartbeat detection keeps running when event delivery stalls; the host reconnects instead of staying half-online.
- **查看器 CLI**:16:10 等非 16:9 主机的指针按内容区域映射,不再内偏(#107,感谢 @liuyanghejerry);鼠标滚轮/触控板转发为滚动(#108,感谢 @liuyanghejerry)。
Viewer CLI: pointer mapped to the content rectangle of the padded canvas; mouse wheel forwarded.
### 验证范围 / Validation
单元测试与 CI;#109 的 ICE 恢复场景尚未实机复现,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.32_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.32-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.32`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
修复 Wayland 锁屏或熄屏后,由工具连接(端口映射)升级的桌面视频结束后无法再次打开。/ Fixes a promoted tool connection whose desktop video could not be reopened after the screen locked or blanked.
### 修复 / Fixed
- **锁屏/熄屏后桌面无法重新打开(#114,感谢 @sinoyster 的完整报告)**:通过 capture_desktop 升级为桌面的工具连接上,若 Wayland 采集因锁屏或 DPMS 关闭而结束,再次 capture_desktop 不会重建视频,查看器只剩黑屏。现在会重新请求桌面并在原连接上重启视频,保留原输入租约。
On a tool connection promoted with capture_desktop, a desktop stream that ended (e.g. Wayland capture failing on lock/DPMS) is now restarted on the next capture_desktop, keeping the original input lease.
### 验证范围 / Validation
单元测试与 CI;#114 的锁屏场景尚未实机复现,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.33_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.33-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.33`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
修复网络波动后信令重连卡住,以及 Linux 控制端在平铺窗口管理器下画面空白。/ Fixes signaling reconnect stalling after a network hiccup, and the Linux viewer showing a blank window under tiling compositors.
### 修复 / Fixed
- **网络异常后停在 Acquired room signaling credentials(#115,感谢 @Changxi-M)**:信令 WebSocket 握手没有超时,网络半断时会无限等待,重连不再重试。现在握手限时 20 秒,超时后按原有退避重试。
The signaling WebSocket handshake is now bounded to 20 s, so a stalled handshake falls back to the normal reconnect retry instead of hanging forever.
- **控制端窗口平铺后画面空白(#118,感谢 @shao-zhijie)**:Linux 控制端只在收到新解码帧时绘制,合成器调整窗口尺寸后静止画面不会重绘;在尚未收到首帧时,Wayland 也不会映射没有提交缓冲的窗口。现在窗口尺寸变化/重新显示时用最后一帧重绘,无帧时先画黑底。
The Linux viewer now repaints the last frame after a compositor resize/expose, and paints a black frame before the first decoded frame so Wayland maps the window.
### 验证范围 / Validation
单元测试与 CI;#115、#118 的场景尚未实机复现,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.34_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.34-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.34`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+21
View File
@@ -0,0 +1,21 @@
信令可走 HTTP 代理、二维码登录错误分类、重复主机实例诊断,以及 Wayland 手机端文字输入兜底。/ Signaling through an opt-in HTTP proxy, clearer QR login errors, duplicate-host diagnostics, and a Wayland fallback for mobile text input.
### 新增 / Added
- **信令遵循 `UU_USE_PROXY=1`(#123)**:主机和 Linux 控制端的 WebSocket 信令改用与 REST 接口相同的 HTTP 客户端,开启 `UU_USE_PROXY=1` 后也走环境里的 HTTP/HTTPS 代理(不支持 SOCKS;选中的代理失败不会改为直连;不跟随重定向)。不代理 ICE/WebRTC 媒体。默认(不开代理)行为不变。
Host and viewer signaling now use the same HTTP client as the REST API, so `UU_USE_PROXY=1` applies to signaling too (HTTP/HTTPS proxies only, no direct fallback, no redirects). Media is not proxied; the default is unchanged.
- **Wayland/Portal 手机端文字输入兜底(#119,感谢 @shofukantkts)**:没有空闲键码的合成器和 Portal 后端上,手机端输入的文字经剪贴板 + Shift+Insert 粘贴;`UU_WAYLAND_TEXT=0` 可关闭。
Mobile text input on Portal and compositors without spare keycodes is pasted via the clipboard and Shift+Insert; `UU_WAYLAND_TEXT=0` disables it.
### 修复 / Fixed
- **二维码登录错误分类(#121)**:状态查询失败不再一律提示「网络超时」,区分超时、连接失败、响应异常与二维码过期;诊断只含阶段、类别、耗时和状态码,不输出票据、URL 或服务器内容。
QR polling failures are no longer all reported as a network timeout; timeouts, connection failures, bad responses and expiry are distinguished, with diagnostics that never include tickets, URLs or server content.
- **重复主机实例(#122)**:同一身份的两个主机实例(拷贝了 `config.json`,或残留的旧手动实例)会互相把对方踢出房间,表现为控制端一连就断。`doctor` 现在能数到重新执行后进程名为 `exe` 的实例并给出提示;README 说明不要在机器之间拷贝 `config.json`;日志会记录无 peer id 的 leave 事件结构(仅键名/类型/长度)。
Two host instances sharing one identity kick each other out of the room. `doctor` now counts re-executed instances and warns about extras, the README explains not to copy `config.json` between machines, and leave events without a peer id log their shape (keys/types/lengths only).
### 验证范围 / Validation
单元测试与 CI。#123 在真实 Linux X11 主机上实测不开代理时信令与 iPhone 桌面连接正常;经真实代理的信令尚未实测。#122 的修复在报告环境实机验证。
### 下载 / Download
`uu-remote-linux_0.2.35_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.35-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.35`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
修复 X11 共享内存被拒时主机直接退出,以及 Linux 控制端加入已有会话时可能永久黑屏。/ Fixes the host exiting when X11 refuses shared memory, and a possible black screen when the Linux viewer joins a host that already streams to another session.
### 修复 / Fixed
- **X11 MIT-SHM 被拒时直接退出**:X 服务器无法访问本程序的共享内存段时(例如 X 服务器在另一个容器里),`XShmAttach` 返回 BadAccess,Xlib 默认错误处理直接结束了进程,原有的 `XGetImage` 退路没有机会执行。现在捕获该错误并改用 `XGetImage` 抓屏。
When `XShmAttach` is refused (BadAccess, e.g. an X server in another container), the host now falls back to `XGetImage` instead of being terminated by Xlib's default error handler.
- **控制端加入已有会话时黑屏(#124,感谢 @shao-zhijie)**:Linux 控制端过去只在丢包或解码出错时请求关键帧;加入一条已在推流的干净 H.264 流时永远等不到 IDR。现在首帧显示前每 30 个访问单元请求一次关键帧(PLI),300 个仍无画面时日志给出提示。
The Linux viewer now requests key frames (PLI) every 30 access units until the first frame is shown, and logs a warning after 300.
### 验证范围 / Validation
单元测试与 CI。共享内存退路尚待在报告环境实机确认;#124 中官方 Mac 主机是否响应 PLI 尚未实测。
### 下载 / Download
`uu-remote-linux_0.2.36_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.36-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.36`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
`UU_USE_PROXY=1` 时经 TCP/TLS(可走 HTTP 代理)连接 TURN 中继,供 UDP 到不了中继服务器的主机使用。/ With `UU_USE_PROXY=1`, TURN relays are also reached over TCP/TLS (optionally through the HTTP proxy) for hosts whose UDP cannot reach the relay servers.
### 新增 / Added
- **TURN over TCP/TLS**:云端在强制中继的会话里也会下发 `turns:<IP>:<端口>?transport=tcp`,原来使用的 webrtc-ice 只支持 UDP 中继,UDP 被限制、只能经 HTTP 代理出网的主机因此拿不到任何中继候选,控制端一直"正在尝试重连"。现在开启 `UU_USE_PROXY=1` 后,主机会经 `HTTPS_PROXY`/`ALL_PROXY` 中的无认证 `http://` 代理(没有则直连)建立 TCP/TLS 中继连接。TURN 证书按 CA 链校验,仅在云端下发的地址为 IP 时容忍名称不匹配;媒体仍由 DTLS-SRTP 端到端加密。未开启时只用 UDP 中继,行为不变(`vendor/webrtc-ice/PATCHES.md`)。
With `UU_USE_PROXY=1` the host also opens TURN relays over TCP/TLS through the unauthenticated `http://` proxy (or directly), chain-verifying certificates and tolerating a name mismatch only for IP TURN URLs. The default stays UDP-only.
### 验证范围 / Validation
单元测试(经模拟代理的 CONNECT 与 STUN/ChannelData 分帧)与 CI;与真实 TURN 服务器的 TCP/TLS 分配尚待在报告环境实机确认。
### 下载 / Download
`uu-remote-linux_0.2.37_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.37-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.37`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
TURN over TLS 改为同时信任系统证书库。/ TURN over TLS now also trusts the system certificate store.
### 修复 / Fixed
- **TURN over TLS 报 UnknownIssuer**:v0.2.37 的 TCP/TLS 中继只信任内置的 Mozilla 根证书;在会检查 TLS 的 HTTP 代理后面,中继证书由主机管理员装在系统证书库里的 CA 重新签发,OpenSSL 能通过、我们却报 `UnknownIssuer`。现在同时信任系统证书库(与 OpenSSL 一致)和内置根证书。仅影响 `UU_USE_PROXY=1` 时的 TCP/TLS 中继。
TCP/TLS relays (only with `UU_USE_PROXY=1`) now trust the system certificate store as well as the bundled Mozilla roots, so CAs added for TLS-inspecting proxies are honoured.
### 验证范围 / Validation
单元测试与 CI;报告环境实机验证进行中。
### 下载 / Download
`uu-remote-linux_0.2.38_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.38-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.38`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
Linux 控制端像官方控制端一样请求桌面视频轨道,修复第二个会话永久黑屏。/ The Linux viewer now requests the desktop video track like the official viewer, fixing a permanently black second session.
### 修复 / Fixed
- **第二个会话黑屏(#124,感谢 @shao-zhijie 的码流取证)**:被控端已在给别的控制端推流时,Linux 控制端只会接上那条流的中段,没有 SPS/PPS/IDR,永远无法解码;官方主机也不响应 RTCP PLI。官方 iPhone 控制端在 CONTROL 通道打开后会立即发 RPC 15 `SendVideoTrackReq`(无字段);Linux 控制端现在桌面会话里也发这一条。
Desktop sessions now send RpcRequest case 15 `SendVideoTrackReq` (no fields) right after CONTROL opens, as the official iPhone viewer does, so the host starts a track for this session instead of the viewer joining another session's stream mid-GOP.
### 验证范围 / Validation
单元测试与 CI;官方 iPhone 控制端发送该 RPC 的行为来自本项目主机日志(`response_field=11 value=None`)。与官方 macOS 主机的第二会话场景尚待报告者实测。
### 下载 / Download
`uu-remote-linux_0.2.39_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.39-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.39`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+23
View File
@@ -0,0 +1,23 @@
GNOME 多显示器与精确触控、niri 适配、控制端控制中心与中英文界面,以及登录设备注册修复。/ GNOME multi-monitor and precise touch, niri support, a viewer control center with Chinese/English UI, and a login device-registration fix.
### 新增 / Added
- **GNOME(Wayland / Portal)多显示器切换(#128,感谢 @spixyy7)**:逐块显示器公布并各自保存 Portal 授权,首次在主机上授权一次,之后静默恢复;最后一个控制端断开后立即停止屏幕共享。
GNOME Portal: per-monitor sources with per-monitor saved grants (asked once, restored silently); screen sharing stops when the last viewer leaves.
- **niri 支持(#71,感谢 @WALKERKILLER)**:`UU_WAYLAND_MULTISCREEN=1` 下的显示器枚举与切换、旋转输出的正向采集与指针映射、手机端中文输入。其他合成器行为不变。
niri: output enumeration/switching, upright capture and pointer mapping for rotated outputs, and mobile text input; other compositors unchanged.
- **原生控制端(#129,感谢 @spixyy7)**:按被控端原始分辨率解码、中英文界面(`UU_LANG` 或设置)、控制中心(`Ctrl+Alt+M`)、网络状态面板(`Ctrl+Alt+G`,显示实测 RTT)、连接加载画面。控制端登录不会开启本机被控服务(默认关闭)。
Native viewer: native-resolution decode, Chinese/English UI, control center, network panel with measured RTT, connection screen. Viewer login does not enable the local host service (off by default).
### 修复 / Fixed
- **GNOME 触控偏移(#128)**:绝对移动与点击改走当前 Portal 流,不再映射到整个多屏桌面。/ Absolute pointer goes through the current Portal stream.
- **账号下出现永远离线的“幽灵”设备(#127,感谢 @spixyy7)**:主机与控制端同时登录时,设备注册在配置文件锁下串行进行并复用已注册的设备。/ Device registration is serialized under a config lock.
- **控制端**:控制中心卡顿与随后的花屏、Wayland 下关闭文件传输窗口崩溃(#129)。/ Viewer menu stalls and resulting corruption; crash closing the file-transfer window on Wayland.
- **TURN over TCP/TLS 经检查型代理**:代理返回 HTTP 时给出明确错误(代理在检查 TLS 内容,TURN 无法通过),不再报含糊的解析错误。/ A clear error when an inspecting proxy answers with HTTP inside the relay stream.
### 验证范围 / Validation
单元测试与 CI。GNOME 多显示器/触控由贡献者在 Fedora 44 / GNOME 50.6 双屏实机验证;niri 与控制端改动由各自贡献者实机验证(控制端 RTT 补丁实测仅覆盖 Android 控制端场景)。
### 下载 / Download
`uu-remote-linux_0.2.40_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.40-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.40`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
修复原生控制端连 Mac 无画面,GNOME 手机控制端新增手势滚动,控制端记住画质设置。/ Fixes the native viewer showing no picture from Mac hosts, adds gesture scrolling for phone viewers on GNOME, and remembers viewer quality settings.
### 修复 / Fixed
- **原生控制端连 Mac 被控端一直“连接中”、无画面(#136,感谢 @coolxll 二分定位)**:v0.2.40 在本地重置后只等 IDR,Mac 对 PLI 不回 IDR 时会一直丢帧。现在 H.264 I 片和恢复点 SEI 也可作为重启点,最多等待 1.5 秒后照常解码。
Native viewer: after a local reset it accepted only IDR frames, so a Mac host that answers PLI without one stayed blank. I slices and recovery-point SEI now count, and the wait is capped at 1.5 s.
### 新增 / Added
- **GNOME(Portal)手机控制端手势(#134、#131,感谢 @spixyy7)**:触控模式下拖动即平滑滚动(终端里也能滚),按住 0.45 秒后拖动为选中,短按为点击;默认不再需要触摸屏授权。`UU_TOUCH_INPUT=touch` 改用真触控,`=0` 保持鼠标拖动。输入法 ASCII 直接按键输入。
GNOME Portal phone viewers: drag scrolls smoothly (also in terminals), hold-then-drag selects, tap clicks, with no touchscreen consent by default; `UU_TOUCH_INPUT=touch` / `=0` select real touch or mouse drags.
- **控制端跨会话记住画质、帧率和真彩设置(#133,感谢 @spixyy7)**。/ The viewer remembers quality, frame rate and true-color choices.
### 验证范围 / Validation
单元测试与 CI。手机手势由贡献者在 Fedora 44 / GNOME 50.6 + 官方 Android 控制端实机验证;#136 的修复尚未连真实 Mac 被控端验证。
### 下载 / Download
`uu-remote-linux_0.2.41_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.41-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.41`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+131
View File
@@ -0,0 +1,131 @@
#!/bin/sh
# Install uu-remote-linux from the release tarball for the current desktop user, and install FFmpeg
# (needed for desktop video) through the system package manager when it is missing.
# usage: ./install.sh [--yes] [--no-ffmpeg]
# --yes install FFmpeg without asking
# --no-ffmpeg only check FFmpeg, never install it
set -eu
assume_yes=0 ffmpeg_install=1
for arg in "$@"; do
case $arg in
-y|--yes) assume_yes=1 ;;
--no-ffmpeg) ffmpeg_install=0 ;;
-h|--help) sed -n '2,6p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
*) echo "unknown option: $arg (see --help)" >&2; exit 2 ;;
esac
done
if [ "$(id -u)" = 0 ]; then
echo "Run this as your desktop user, not root: the host is a per-user service. It asks for sudo only to install FFmpeg." >&2
exit 1
fi
src=$(cd "$(dirname "$0")" && pwd)
bin=$HOME/.local/bin lib=$HOME/.local/lib/uu-remote-linux share=$HOME/.local/share
unit_dir=${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user
# A running binary cannot be overwritten in place ("text file busy"): copy, then rename.
put() { install -Dm"$1" "$2" "$3.new" && mv -f "$3.new" "$3"; }
[ -f "$src/uuremote-server" ] || { echo "uuremote-server not found next to install.sh" >&2; exit 1; }
put 755 "$src/uuremote-server" "$bin/uuremote-server"
[ -f "$src/uuremote-viewer" ] && put 755 "$src/uuremote-viewer" "$bin/uuremote-viewer"
for so in libuu-wayland.so libuu-portal.so; do
[ -f "$src/$so" ] && put 644 "$src/$so" "$lib/$so"
done
if [ -d "$src/contrib/desktop" ]; then
put 644 "$src/contrib/desktop/uu-remote-linux.svg" "$share/icons/hicolor/scalable/apps/uu-remote-linux.svg"
put 644 "$src/contrib/desktop/uu-remote-linux.desktop" "$share/applications/uu-remote-linux.desktop"
[ -f "$bin/uuremote-viewer" ] && put 644 "$src/contrib/desktop/uu-remote-linux-viewer.desktop" "$share/applications/uu-remote-linux-viewer.desktop"
fi
echo "Installed uuremote-server to $bin"
# Same unit as the .deb, pointing at ~/.local/bin. An existing unit is the user's: leave it alone.
if [ -f "$unit_dir/uuremote-native.service" ]; then
echo "Kept existing $unit_dir/uuremote-native.service"
else
mkdir -p "$unit_dir"
cat > "$unit_dir/uuremote-native.service" <<'UNIT'
[Unit]
Description=UU Remote Linux host (unofficial)
After=graphical-session.target
PartOf=graphical-session.target
[Service]
Environment=RUST_LOG=info
ExecStart=%h/.local/bin/uuremote-server
Restart=always
RestartSec=5
[Install]
WantedBy=graphical-session.target
UNIT
echo "Created $unit_dir/uuremote-native.service"
fi
if command -v systemctl >/dev/null 2>&1; then systemctl --user daemon-reload 2>/dev/null || true; fi
# FFmpeg with libx264 is required: without it the viewer waits on 正在传输画面 forever.
ffmpeg_ok() { command -v ffmpeg >/dev/null 2>&1 && ffmpeg -hide_banner -encoders 2>/dev/null | grep -qw libx264; }
ffmpeg_cmd=""
ffmpeg_note=""
if command -v apt-get >/dev/null 2>&1; then
ffmpeg_cmd="apt-get update && apt-get install -y ffmpeg"
elif command -v pacman >/dev/null 2>&1; then
ffmpeg_cmd="pacman -S --needed --noconfirm ffmpeg"
elif command -v dnf >/dev/null 2>&1; then
# Fedora's own ffmpeg-free has no libx264; the full build is in RPM Fusion, which we do not enable for you.
if dnf repolist --enabled 2>/dev/null | grep -qi rpmfusion-free; then
ffmpeg_cmd="dnf install -y --allowerasing ffmpeg"
else
ffmpeg_note="Enable RPM Fusion (https://rpmfusion.org/Configuration), then: sudo dnf install --allowerasing ffmpeg"
fi
elif command -v zypper >/dev/null 2>&1; then
ffmpeg_note="openSUSE's ffmpeg has no libx264; add the Packman repository, then: sudo zypper install ffmpeg"
else
ffmpeg_note="Install FFmpeg with libx264 from your distribution, or set \"ffmpeg_root\" in ~/.config/uuremote/config.json"
fi
ffmpeg_ready=1
if ffmpeg_ok; then
echo "FFmpeg with libx264: found"
else
if command -v ffmpeg >/dev/null 2>&1; then echo "FFmpeg is installed but has no libx264."; else echo "FFmpeg is not installed."; fi
if [ "$ffmpeg_install" = 1 ] && [ -n "$ffmpeg_cmd" ]; then
answer=n
if [ "$assume_yes" = 1 ]; then
answer=y
elif [ -t 0 ]; then
printf 'Install it now with: sudo sh -c "%s"? [Y/n] ' "$ffmpeg_cmd"
read -r answer || answer=n
case $answer in ""|y|Y|yes|YES) answer=y ;; esac
fi
if [ "$answer" = y ]; then
if [ "$(id -u)" != 0 ] && ! command -v sudo >/dev/null 2>&1; then
echo "sudo is not available; run as root: $ffmpeg_cmd" >&2
else
sudo sh -c "$ffmpeg_cmd" || echo "FFmpeg installation failed." >&2
fi
fi
fi
if ffmpeg_ok; then
echo "FFmpeg with libx264: installed"
else
ffmpeg_ready=0
if [ -n "$ffmpeg_cmd" ]; then echo "Install it with: sudo sh -c \"$ffmpeg_cmd\""; else echo "$ffmpeg_note"; fi
fi
fi
case ":$PATH:" in *":$bin:"*) ;; *) echo "Note: $bin is not on PATH; add it or call $bin/uuremote-server directly." ;; esac
cat <<NEXT
Next steps (as this user, inside the graphical session):
uuremote-server login # scan the QR code with the UU Remote app
systemctl --user enable --now uuremote-native.service # start with the graphical session
Desktops that do not export DISPLAY to systemd (e.g. Xfce) need a drop-in; see README step 4.
NEXT
if [ "$ffmpeg_ready" = 0 ]; then
echo "WARNING: desktop video will not start until FFmpeg with libx264 is installed." >&2
exit 1
fi
+14
View File
@@ -78,6 +78,20 @@ extern "C" {
fn uu_assist_ui_set(id: *const libc::c_char, code: *const libc::c_char, allowed: libc::c_int, verify: libc::c_int, refresh: libc::c_int, has_custom: libc::c_int);
fn uu_assist_ui_take_command(arg: *mut libc::c_char, len: libc::size_t) -> libc::c_int;
fn uu_assist_ui_close();
fn uu_ui_set_problem(summary: *const libc::c_char, text: *const libc::c_char, notify: libc::c_int) -> libc::c_int;
}
/// A problem only the person at the desktop can fix: a red line in the host window (`None` clears it)
/// and, with `notify`, a desktop notification, or the host window opened when no notification daemon
/// answers. Returns whether the person was told now.
pub fn show_problem(summary: &str, text: Option<&str>, notify: bool) -> bool {
#[cfg(uu_gtk)] {
let summary = std::ffi::CString::new(summary).unwrap_or_default();
let text = text.map(|t| std::ffi::CString::new(t).unwrap_or_default());
let text = text.as_ref().map_or(std::ptr::null(), |t| t.as_ptr());
unsafe { uu_ui_set_problem(summary.as_ptr(), text, i32::from(notify)) >= 0 }
}
#[cfg(not(uu_gtk))] { let _ = (summary, text, notify); false }
}
/// "243829726" -> "243 829 726", as the official client shows device IDs.
+109 -9
View File
@@ -91,6 +91,48 @@ pub struct UUAuthClient {
guest_id: Option<String>,
}
/// QR failures are safe to display: never retain a URL, source error or response body.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QrRequestErrorKind { Timeout, Connect, Decode, Body, Request }
impl QrRequestErrorKind {
fn from_reqwest(error: &reqwest::Error) -> Self {
if error.is_timeout() { Self::Timeout }
else if error.is_connect() { Self::Connect }
else if error.is_decode() { Self::Decode }
else if error.is_body() { Self::Body }
else { Self::Request }
}
fn label(self) -> &'static str {
match self { Self::Timeout => "timeout", Self::Connect => "connect", Self::Decode => "decode",
Self::Body => "body", Self::Request => "request" }
}
}
#[derive(Debug)]
pub struct QrRequestError {
pub kind: QrRequestErrorKind,
phase: &'static str,
elapsed_ms: u128,
http_status: Option<u16>,
}
impl std::fmt::Display for QrRequestError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "phase={} kind={} elapsed_ms={} http_status={:?}",
self.phase, self.kind.label(), self.elapsed_ms, self.http_status)
}
}
impl QrRequestError {
pub fn response_received(&self) -> bool { self.http_status.is_some() }
fn new(kind: QrRequestErrorKind, phase: &'static str, started: std::time::Instant, http_status: Option<u16>) -> Self {
Self { kind, phase, elapsed_ms: started.elapsed().as_millis(), http_status }
}
}
async fn send_qr_request(request: reqwest::RequestBuilder, started: std::time::Instant) -> Result<(u16, serde_json::Value), QrRequestError> {
let resp = request.send().await.map_err(|e| QrRequestError::new(QrRequestErrorKind::from_reqwest(&e), "send", started, None))?;
let status = resp.status().as_u16();
let value = resp.json().await.map_err(|e| QrRequestError::new(QrRequestErrorKind::from_reqwest(&e), "response", started, Some(status)))?;
Ok((status, value))
}
/// Transport failures name only the outer request; the cause (certificate, proxy, DNS,
/// timeout) lives in the source chain. URL user-info (proxy credentials) and query
/// strings are removed before the chain is shown.
@@ -121,17 +163,20 @@ fn redact_urls(text: &str) -> String {
out
}
/// Cloud API clients ignore ambient HTTP/SOCKS proxy settings by default: a local
/// Cloud API and signaling clients ignore ambient HTTP/HTTPS 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) {
if proxy_enabled() {
builder
} else {
builder.no_proxy()
}
}
pub(crate) fn proxy_enabled() -> bool {
std::env::var("UU_USE_PROXY").ok().as_deref().is_some_and(proxy_requested)
}
fn proxy_requested(value: &str) -> bool {
matches!(value.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on")
}
@@ -253,13 +298,13 @@ impl UUAuthClient {
/// Signed POST with an optional JSON body (None = empty body, like Moya `requestPlain`) and an
/// explicit timeout. The official clients long-poll the QR status with a 60 s request timeout.
pub async fn post_with_timeout(&self, path: &str, body: Option<&serde_json::Value>, timeout: std::time::Duration) -> Result<(u16, serde_json::Value), String> {
let body_str = body.map(serde_json::to_string).transpose().map_err(|e| e.to_string())?.unwrap_or_default();
let resp = self.http.post(format!("{}{}", BASE_URL, path)).timeout(timeout)
.headers(self.build_headers("POST", path, &body_str)).body(body_str)
.send().await.map_err(|e| format!("HTTP post {path} failed: {}", transport_error(&e)))?;
let status = resp.status().as_u16();
Ok((status, resp.json().await.unwrap_or(serde_json::Value::Null)))
pub async fn post_with_timeout(&self, path: &str, body: Option<&serde_json::Value>, timeout: std::time::Duration) -> Result<(u16, serde_json::Value), QrRequestError> {
let started = std::time::Instant::now();
let body_str = body.map(serde_json::to_string).transpose()
.map_err(|_| QrRequestError::new(QrRequestErrorKind::Request, "encode", started, None))?.unwrap_or_default();
let request = self.http.post(format!("{}{}", BASE_URL, path)).timeout(timeout)
.headers(self.build_headers("POST", path, &body_str)).body(body_str);
send_qr_request(request, started).await
}
/// Signed JSON POST to another API host (the signature covers the path only).
@@ -389,3 +434,58 @@ mod guest_tests {
for value in ["", "0", "false", "no", "off", "2"] { assert!(!super::proxy_requested(value)); }
}
}
#[cfg(test)]
mod qr_request_tests {
use super::*;
use std::time::{Duration, Instant};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
// Synthetic, loopback-only responses: no account, device, proxy or live login API.
async fn response(reply: &'static [u8], stall: bool) -> QrRequestError {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut request = [0u8; 4096];
let _ = socket.read(&mut request).await.unwrap();
socket.write_all(reply).await.unwrap();
if stall { std::future::pending::<()>().await; }
});
let request = reqwest::Client::builder().no_proxy().build().unwrap()
.post(format!("http://fixture-user:fixture-password@{addr}/fixture-path?token=fixture-ticket"))
.timeout(Duration::from_secs(2));
let error = send_qr_request(request, Instant::now()).await.unwrap_err();
server.abort();
let output = format!("{error} {error:?}");
for secret in ["fixture-user", "fixture-password", "fixture-path", "fixture-ticket", "fixture-body", "127.0.0.1", "http://"] {
assert!(!output.contains(secret));
}
error
}
#[tokio::test]
async fn qr_request_distinguishes_send_timeout_body_timeout_and_bad_json_without_secrets() {
let error = response(b"", true).await;
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Timeout, "send", None));
assert!(!error.response_received());
let error = response(b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n", true).await;
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Timeout, "response", Some(200)));
assert!(error.response_received());
let error = response(b"HTTP/1.1 502 Bad Gateway\r\nContent-Length: 12\r\n\r\nfixture-body", false).await;
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Decode, "response", Some(502)));
assert!(error.response_received());
}
#[tokio::test]
async fn qr_connection_failure_is_not_a_timeout() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
drop(listener);
let request = reqwest::Client::builder().no_proxy().build().unwrap()
.post(format!("http://{addr}/fixture-ticket")).timeout(Duration::from_secs(2));
let error = send_qr_request(request, Instant::now()).await.unwrap_err();
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Connect, "send", None));
assert!(!format!("{error} {error:?}").contains("fixture-ticket"));
}
}
+9 -1
View File
@@ -56,6 +56,12 @@ pub fn x11_size() -> Option<(u32, u32)> {
}
/// The root size from the last refresh, without an X round trip (pointer mapping).
/// Display the X11 engine opened, once a capture has initialized it.
pub fn x11_display() -> Option<String> {
let name = unsafe { x11_display_name() };
if name.is_null() { None } else { Some(unsafe { std::ffi::CStr::from_ptr(name) }.to_string_lossy().into_owned()) }
}
pub fn x11_last_size() -> Option<(u32, u32)> {
let (mut w, mut h): (libc::c_int, libc::c_int) = (0, 0);
if unsafe { x11_get_dimensions(&mut w, &mut h) } != 0 || w <= 0 || h <= 0 { return None; }
@@ -76,8 +82,10 @@ pub struct ScreenCapture {
impl ScreenCapture {
pub fn open_portal(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, crate::portal::PortalError> {
let session = std::sync::Arc::new(crate::portal::PortalSession::open_cancellable(cancelled)?);
crate::portal::register(&session);
let (width, height) = session.size();
Ok(Self { backend: crate::desktop_backend::DesktopBackend::Portal, init_error: None,
display: "wayland:portal".into(), width: session.width, height: session.height,
display: "wayland:portal".into(), width, height,
portal: Some(session), kms: None, buffer: Mutex::new(Vec::new()) })
}
pub fn new() -> Result<Self, String> {
+61 -10
View File
@@ -120,6 +120,7 @@ fn custom_bitrate_bps(value: u64) -> u32 {
bps.min(u64::from(u32::MAX)) as u32
}
#[cfg(test)]
pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32)) -> Option<Vec<u8>> {
handle_rpc_with_codecs(rpc, settings, native, true, false)
}
@@ -128,17 +129,32 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
/// 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 = 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)
#[cfg(test)]
fn test_selection() -> crate::video_select::Selection {
crate::video_select::resolve_pair(Some("auto"), None, Some("auto"), None, false, None)
}
fn pick_codec(h264: bool, h265: bool, forced: Option<&str>, hardware: bool) -> VideoCodec {
#[cfg(test)]
pub fn preferred_codec(h264: bool, h265: bool) -> VideoCodec {
preferred_codec_for(h264, h265, test_selection())
}
pub fn preferred_codec_for(h264: bool, h265: bool, selection: crate::video_select::Selection) -> VideoCodec {
pick_codec(h264, h265, crate::video_select::codec_force(selection.codec_pref), crate::video_select::hardware(selection.encoder))
}
pub(crate) 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 }
}
#[cfg(test)]
pub fn handle_rpc_with_codecs(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool) -> Option<Vec<u8>> {
apply_rpc(rpc, settings, native, h264, h265, crate::video::full_chroma_available())
handle_rpc_for(rpc, settings, native, h264, h265, test_selection())
}
pub fn handle_rpc_for(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool, selection: crate::video_select::Selection) -> Option<Vec<u8>> {
apply_rpc(rpc, settings, native, h264, h265, crate::video::full_chroma_for(selection.encoder), crate::video_select::codec_force(selection.codec_pref))
}
/// The resolution a capture/resolution RPC asks for, parsed like apply_rpc: X11 hosts apply it
@@ -156,7 +172,7 @@ pub fn requested_resolution(rpc: &[WireField]) -> Option<crate::desktop_mode::Re
} else { None }
}
fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool, full_chroma: bool) -> Option<Vec<u8>> {
fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), _h264: bool, h265: bool, full_chroma: bool, forced: Option<&str>) -> Option<Vec<u8>> {
let header = message(rpc, 1).unwrap_or(&[]);
let mut next = *settings.borrow();
if let Some(request) = message(rpc, 2) {
@@ -167,7 +183,9 @@ fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native:
// codec_type 13 (1 H264, 2 H265): like the official host (negotiateCodec), the host picks the
// codec from both capability lists; the Mac viewer sends its current codec (1 while receiving
// H.264), so only an explicit H.265 request switches, never one absent from the m-line.
if number(&fields, 13) == Some(2) && h265 { next.codec = VideoCodec::H265; }
// A forced codec (host_settings video_codec or UU_VIDEO_CODEC) wins over that switch, same
// rule as pick_codec at stream start: h264 stays H.264; auto/h265 still follow the request.
if number(&fields, 13) == Some(2) && h265 && forced != Some("h264") { next.codec = VideoCodec::H265; }
// Field 1 is the viewer's fps option index (1 = 30, 2 = 60, ...); 18 fpsCount is the frame rate.
if let Some(fps) = number(&fields, 18).filter(|v| *v > 0).or_else(|| number(&fields, 1).and_then(fps_from_option)) { next.fps = fps as u32; }
if let Some(quality) = number(&fields, 2).filter(|v| *v > 0) { next.quality = quality; }
@@ -333,12 +351,12 @@ mod tests {
let (tx, rx) = watch::channel(VideoSettings::default());
// Observed Mac viewer request with 真彩 on: field 7 = 3.
let request = rpc(5, 2, &[8, 2, 16, 4, 56, 3, 144, 1, 60]);
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, false).unwrap();
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, false, None).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_420);
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, true).unwrap();
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, true, None).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_444);
assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_444));
apply_rpc(&decode_wire(&rpc(6, 2, &[56, 1])).unwrap(), &tx, (1920, 1080), true, false, true).unwrap();
apply_rpc(&decode_wire(&rpc(6, 2, &[56, 1])).unwrap(), &tx, (1920, 1080), true, false, true, None).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_420);
}
@@ -570,6 +588,39 @@ mod codec_tests {
assert_eq!(pick_codec(false, true, None, false), VideoCodec::H265);
assert_eq!(pick_codec(true, false, Some("h265"), true), VideoCodec::H264);
}
#[test]
fn forced_h264_ignores_later_h265_capture_request() {
let (tx, rx) = watch::channel(VideoSettings::default());
// Field 13 = 2 on a peer that negotiated both codecs.
let request = decode_wire(&[18, 2, 104, 2]).unwrap();
apply_rpc(&request, &tx, (1920, 1080), true, true, false, Some("h264")).unwrap();
assert_eq!(rx.borrow().codec, VideoCodec::H264);
apply_rpc(&request, &tx, (1920, 1080), true, true, false, None).unwrap();
assert_eq!(rx.borrow().codec, VideoCodec::H265);
let (tx, rx) = watch::channel(VideoSettings::default());
apply_rpc(&request, &tx, (1920, 1080), true, true, false, Some("h265")).unwrap();
assert_eq!(rx.borrow().codec, VideoCodec::H265);
}
#[test]
fn true_color_keeps_codec_and_vaapi_reports_420() {
// Field 7 = 3 (真彩). full_chroma false is the VAAPI 4:2:0 drop; true encodes 4:4:4.
let request = decode_wire(&[18, 2, 56, 3]).unwrap();
let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() });
apply_rpc(&request, &tx, (1920, 1080), true, true, true, None).unwrap();
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265));
// NVENC session (full chroma) that already chose H.265 stays H.265 when 真彩 is requested.
let nvenc = crate::video_select::resolve_pair(None, None, None, None, true, None);
assert_eq!(nvenc.encoder, crate::video::Encoder::Nvenc);
let (tx, rx) = watch::channel(VideoSettings { codec: preferred_codec_for(true, true, nvenc), ..VideoSettings::default() });
assert_eq!(rx.borrow().codec, VideoCodec::H265);
handle_rpc_for(&request, &tx, (1920, 1080), true, true, nvenc).unwrap();
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265));
let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() });
apply_rpc(&request, &tx, (1920, 1080), true, true, false, None).unwrap();
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_420, VideoCodec::H265));
assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_420));
assert!(decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap().iter().all(|f| f.number != 13));
}
}
#[cfg(test)]
+7
View File
@@ -5,6 +5,13 @@
use std::path::PathBuf;
use std::sync::OnceLock;
/// Tests that point UU_CONFIG at a temp file must take this, or they race.
#[cfg(test)]
pub(crate) fn test_env_lock() -> &'static std::sync::Mutex<()> {
static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
&LOCK
}
pub fn path() -> PathBuf {
if let Some(p) = std::env::var_os("UU_CONFIG") { return PathBuf::from(p); }
let base = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from)
+5 -2
View File
@@ -180,8 +180,11 @@ pub fn encode_echo_response_with_clipboard(seq: u64, timestamp: u64, request_seq
// FeatureFlag: 1 ff_capture_setting = CUSTOM_BITRATE (fps/quality/bitrate RPCs),
// 2 ff_simple_action = AUTO_LOCK (mute + lock after session), 3 ff_system_metrics = SETTING_AUTO_LOCK,
// 6 ff_file_transfer_ftp = LIST_COMPRESS (zlib dir_data), 8 ff_clipboard = SUPPORT_TEXT_CHANGE.
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8,
16, crate::system_actions::FF_SIMPLE_ACTION, 24, crate::system_actions::FF_SYSTEM_METRICS, 48, 2];
// On X11: 3 ff_system_metrics = SETTING_PRIVATE_SCREEN (3), 4 ff_private_screen = INIT_VERION (normal privacy).
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8, 16, crate::system_actions::FF_SIMPLE_ACTION];
if crate::privacy_screen::supported() { flags.extend_from_slice(&[24, 3, 32, crate::privacy_screen::FF_PRIVATE_SCREEN]); }
else { flags.extend_from_slice(&[24, crate::system_actions::FF_SYSTEM_METRICS]); }
flags.extend_from_slice(&[48, 2]);
if clipboard { flags.extend_from_slice(&[64, 3]); }
action.push(34);
action.push(flags.len() as u8);
+53
View File
@@ -215,3 +215,56 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
drop(lock);
}).await.expect("locked bootstrap/tool regression exceeded deadline");
}
#[tokio::test]
async fn capture_desktop_on_a_port_mapping_peer_promotes_it_once() {
tokio::time::timeout(Duration::from_secs(25), async {
let input = Arc::new(InputInjector::without_desktop());
let (host, mut viewer) = connect(input.clone(), false, None, &["CONTROL_DATA_CHANNEL", "FILE_DATA_CHANNEL"]).await;
let (requests, mut requested) = mpsc::unbounded_channel();
host.on_desktop_request(move || { let _ = requests.send(()); });
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
assert!(!host.role.is_desktop() && host.role.input().is_none());
// The Mac viewer opens the desktop on its existing port-mapping peer (#99).
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(5, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop());
assert!(host.role.input().is_some_and(|session| session.is_current()));
// CONTROL repeats the desktop initialization for the same viewer.
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
// The port-mapping session on this peer still answers.
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"still mapped")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
// A repeated capture_desktop does not ask again, and a later promote is a no-op.
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(6, 0, 3, &[8, 4])).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(7, 0, 3, &[8, 0])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
assert!(requested.try_recv().is_err());
let lease = host.role.input().unwrap();
host.promote(None);
assert!(lease.is_current());
// Its video ended on its own (capture failed while locked, #114): capture_desktop restarts it
// on the same input lease.
let ended = tokio::spawn(async {});
*host.role.stream_task.lock().unwrap() = Some(ended.abort_handle());
ended.await.unwrap();
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(9, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop() && !host.role.stream_ended() && lease.is_current());
// A newer desktop demotes it; the port mapping stays, and capture_desktop promotes it again.
host.demote();
assert!(!host.role.is_desktop() && host.role.input().is_none());
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"after demotion")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(8, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop() && host.role.input().is_some_and(|session| session.is_current()));
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
host.pc.close().await.unwrap();
viewer.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("capture_desktop promotion exceeded deadline");
}
+8
View File
@@ -123,6 +123,14 @@ impl PortalDesktop {
|| state.screen.portal.as_ref().is_some_and(|portal| !portal.is_alive()));
}
pub fn snapshot(&self) -> State { self.state.borrow().clone() }
/// No desktop controller left: stop sharing the screen. begin() then sees the dead
/// session and the next controller's maintain() reopens it with the saved consent.
pub fn end_idle(&self) {
if let Some(portal) = self.snapshot().screen.portal.as_ref().filter(|portal| portal.is_alive()) {
portal.end();
log::info!("Portal screen sharing ended: no desktop controller");
}
}
pub fn subscribe(&self) -> watch::Receiver<State> { self.state.subscribe() }
pub fn lock_state(&self) -> watch::Receiver<Option<bool>> { self.locked.clone() }
#[cfg(test)]
+75 -15
View File
@@ -16,6 +16,13 @@ fn env_state(name: &str) -> String {
fn line(key: &str, value: impl std::fmt::Display) { println!("{key:<22} {}", redact(&value.to_string())); }
fn format_probe(probe: &crate::video_select::ProbeReport) -> String {
let body = probe.order.iter().zip(probe.outcomes.iter())
.map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label()))
.collect::<Vec<_>>().join(" ");
if probe.expires_at.is_some() { format!("{body} (failure result, retried after 10 min)") } else { body }
}
fn glibc() -> String {
#[cfg(all(target_os = "linux", target_env = "gnu"))]
{
@@ -92,19 +99,24 @@ pub async fn run() -> Result<(), String> {
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 selection = crate::video_select::selection();
let env_enc = std::env::var("UU_VIDEO_ENCODER").unwrap_or_else(|_| "unset".into());
let codec = match selection.codec_pref { crate::video_select::CodecPref::Auto => "auto", crate::video_select::CodecPref::H264 => "h264", crate::video_select::CodecPref::H265 => "h265" };
let probe_text = if selection.encoder_source == crate::video_select::Source::Auto {
format_probe(&crate::video::run_auto_probe().await)
} else {
crate::video_select::cached_probe().as_ref().map(format_probe).unwrap_or_else(|| "not yet run".to_owned())
};
let selection = if selection.encoder_source == crate::video_select::Source::Auto { crate::video_select::selection() } else { selection };
line("encoder probe", probe_text);
line("encoder", format!("{:?} (source={}; UU_VIDEO_ENCODER={env_enc})", selection.encoder, crate::video_select::encoder_source_label(selection.encoder_source)));
line("codec", format!("{codec} (source={})", crate::video_select::source_label(selection.codec_source)));
// Both codecs offered: hardware prefers H.265, CPU stays H.264 unless the preference forces one.
let resolved = crate::capture_setting::pick_codec(true, true, crate::video_select::codec_force(selection.codec_pref), crate::video_select::hardware(selection.encoder));
line("resolved codec", format!("{resolved:?}"));
match crate::video::ffmpeg_encoders().await {
Some(found) => line("ffmpeg encoders", if found.is_empty() { "none of libx264/libx265/nvenc/vaapi".to_owned() } else { found.join(", ") }),
None => 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);
@@ -135,11 +147,39 @@ pub async fn run() -> Result<(), String> {
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)"));
let running = host_processes();
line("uuremote-server procs", format!("{} (including this one; more than 2 means duplicates)", running.map_or_else(|| "unknown".into(), |n| n.to_string())));
if running.is_some_and(|n| n > 2) {
println!(" ! another host instance is running (check `pgrep -af uuremote`); stop the extra one, e.g. an old copy started by hand");
println!(" instances sharing one identity, on this or another machine, kick each other out of the room: never copy config.json between machines");
}
Ok(())
}
/// Hosts re-exec through /proc/self/exe (comm "exe"), so match the executable's file name, not the process name.
/// Helpers a host spawns (Wayland capture, login window) are its children and are not separate instances.
fn host_processes() -> Option<usize> {
let hosts: Vec<(u32, u32)> = std::fs::read_dir("/proc").ok()?.flatten()
.filter_map(|entry| Some((entry.file_name().to_str()?.parse::<u32>().ok()?, entry.path())))
.filter(|(_, dir)| std::fs::read_link(dir.join("exe")).is_ok_and(|exe| is_host_executable(&exe)))
.filter_map(|(pid, dir)| Some((pid, parent_pid(&std::fs::read_to_string(dir.join("stat")).ok()?)?)))
.collect();
Some(top_level(&hosts))
}
/// Field 4 of /proc/<pid>/stat; the command name in field 2 may contain spaces and parentheses.
fn parent_pid(stat: &str) -> Option<u32> {
stat.rsplit_once(')')?.1.split_whitespace().nth(1)?.parse().ok()
}
fn top_level(hosts: &[(u32, u32)]) -> usize {
hosts.iter().filter(|(_, parent)| !hosts.iter().any(|(pid, _)| pid == parent)).count()
}
fn is_host_executable(exe: &std::path::Path) -> bool {
exe.file_name().and_then(|name| name.to_str()).is_some_and(|name| name.trim_end_matches(" (deleted)") == "uuremote-server")
}
#[cfg(test)]
mod tests {
#[test]
@@ -162,4 +202,24 @@ mod tests {
assert!(!super::missing_display(DesktopBackend::Wayland, false, None, None));
assert!(!super::missing_display(DesktopBackend::X11, true, None, None));
}
#[test]
fn host_processes_match_the_executable_even_after_reexec() {
use std::path::Path;
for exe in ["/usr/bin/uuremote-server", "/home/u/.local/bin/uuremote-server", "/usr/bin/uuremote-server (deleted)"] {
assert!(super::is_host_executable(Path::new(exe)));
}
for exe in ["/usr/bin/uuremote-viewer", "/usr/bin/bash", "/usr/bin/uuremote-server-old"] {
assert!(!super::is_host_executable(Path::new(exe)));
}
}
#[test]
fn host_helpers_are_not_counted_as_instances() {
assert_eq!(super::parent_pid("8943 (exe) S 1699 8943 1699 0 -1"), Some(1699));
assert_eq!(super::parent_pid("12 (a) b (c) R 7 12"), Some(7));
// service 10 with a login window 11, a stale copy 20, doctor 30
assert_eq!(super::top_level(&[(10, 1), (11, 10), (20, 5), (30, 9)]), 3);
assert_eq!(super::top_level(&[(10, 1), (11, 10), (30, 9)]), 2);
}
}
+1
View File
@@ -87,6 +87,7 @@ pub use native::symbol;
pub trait Missing { fn missing() -> Self; }
impl Missing for () { fn missing() -> Self {} }
impl Missing for i32 { fn missing() -> Self { -1 } }
impl Missing for usize { fn missing() -> Self { 0 } }
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
+57
View File
@@ -0,0 +1,57 @@
//! UI language: Chinese (the official clients' wording) or English.
//! `UU_LANG=zh|en`, else the choice saved from the settings window (`language` next to config.json),
//! else the locale (`LC_ALL` / `LC_MESSAGES` / `LANG` starting with `zh` → Chinese, anything else → English).
use std::sync::OnceLock;
static ENGLISH: OnceLock<bool> = OnceLock::new();
fn parse(value: &str) -> Option<bool> {
let value = value.trim().to_ascii_lowercase();
if value.starts_with("zh") { Some(false) } else if value.starts_with("en") { Some(true) } else { None }
}
fn saved_path() -> std::path::PathBuf {
crate::config::path().parent().map_or_else(|| "language".into(), |dir| dir.join("language"))
}
fn detect() -> bool {
if let Some(english) = std::env::var("UU_LANG").ok().as_deref().and_then(parse) { return english; }
if let Some(english) = std::fs::read_to_string(saved_path()).ok().as_deref().and_then(parse) { return english; }
let locale = ["LC_ALL", "LC_MESSAGES", "LANG"].iter()
.find_map(|name| std::env::var(name).ok().filter(|v| !v.is_empty()));
!locale.is_some_and(|v| v.to_ascii_lowercase().starts_with("zh"))
}
pub fn english() -> bool { *ENGLISH.get_or_init(detect) }
/// Pick the text for the current language.
pub fn s(zh: &'static str, en: &'static str) -> &'static str { if english() { en } else { zh } }
/// Saves the settings-window choice; it applies on the next start.
pub fn save(english: bool) -> std::io::Result<()> {
let path = saved_path();
if let Some(dir) = path.parent() { std::fs::create_dir_all(dir)?; }
std::fs::write(path, if english { "en\n" } else { "zh\n" })
}
/// `tr!("连接失败:{e}", "Connection failed: {e}")` formats the string for the current language.
#[macro_export]
macro_rules! tr {
($zh:literal, $en:literal $(, $arg:expr)* $(,)?) => {
if $crate::i18n::english() { format!($en $(, $arg)*) } else { format!($zh $(, $arg)*) }
};
}
// The GTK windows (c_engine/i18n.h) ask the same question so both halves always agree.
#[no_mangle] pub extern "C" fn uu_i18n_english() -> std::os::raw::c_int { english().into() }
#[no_mangle] pub extern "C" fn uu_i18n_save(english: std::os::raw::c_int) -> std::os::raw::c_int {
save(english != 0).is_ok().into()
}
#[cfg(test)] mod tests {
#[test] fn language_values_are_parsed(){
assert_eq!(super::parse("zh_CN.UTF-8"),Some(false));
assert_eq!(super::parse("EN\n"),Some(true));
assert_eq!(super::parse("sr_RS"),None);
}
}
+450 -13
View File
@@ -46,12 +46,60 @@ struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collecti
/// Held modifier VKs (bit 0 Ctrl, 1 Shift, 2 Alt, 3 Win) and keys that got a synthetic Shift.
#[derive(Default)]
struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> }
/// Mobile viewers in touch mode send a finger as a left-button drag at absolute positions (observed:
/// Android sends press, a stream of mouse_move_absolute, release), which on a desktop selects text
/// instead of scrolling. By default (`Gesture`) the host decides per press: moving past `SLOP` before
/// `HOLD` scrolls smoothly (content follows the finger, also in terminals), holding still selects
/// like a mouse drag, and a short press is a click. `UU_TOUCH_INPUT=touch` replays drags as one finger
/// on the portal touchscreen instead; `=0` keeps mouse buttons. `at` is the last absolute position;
/// relative motion (the viewers' trackpad mode) clears it and keeps mouse buttons.
#[derive(Default)]
struct TouchDrag { mode: TouchMode, at: Option<(i32,i32)>, down: bool, finger: Finger }
#[derive(Clone, Copy, Debug, Default, PartialEq)]
enum TouchMode { #[default] Mouse, Gesture, Touch }
/// A mobile left press in gesture mode: not decided yet, scrolling, or selecting with button 1 down.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
enum Finger { #[default] Up, Pending { start: (i32,i32), at: std::time::Instant }, Scroll { last: (i32,i32) }, Select }
/// Pixels a finger may wander before a press becomes a scroll, and how long it holds still to select.
const SLOP: i32 = 12;
const HOLD: std::time::Duration = std::time::Duration::from_millis(450);
/// What an absolute position does to the finger: the next state and a scroll from→to or a pointer move.
#[derive(Debug, PartialEq)]
enum FingerStep { Scroll((i32,i32),(i32,i32)), Move(i32,i32), Stay }
fn finger_motion(finger: Finger, to: (i32,i32)) -> (Finger, FingerStep) {
match finger {
Finger::Pending { start, .. } if (to.0-start.0).abs().max((to.1-start.1).abs()) > SLOP => (Finger::Scroll { last: to }, FingerStep::Scroll(start, to)),
Finger::Pending { .. } => (finger, FingerStep::Stay),
Finger::Scroll { last } => (Finger::Scroll { last: to }, FingerStep::Scroll(last, to)),
Finger::Select | Finger::Up => (finger, FingerStep::Move(to.0, to.1)),
}
}
/// A pending press held still for `HOLD`: where the selection starts.
fn finger_held(finger: Finger, now: std::time::Instant) -> Option<(i32,i32)> {
match finger { Finger::Pending { start, at } if now.duration_since(at) >= HOLD => Some(start), _ => None }
}
/// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android,
/// 3 ios, 4 macos, 5 tv).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Controller { #[default] Other, Mac, Mobile }
impl Controller {
pub fn from_platform(platform: Option<&serde_json::Value>) -> Self {
let Some(v) = platform else { return Self::Other };
let text = v.as_str().map(str::to_ascii_lowercase);
match v.as_i64().or_else(|| text.as_deref().and_then(|s| s.parse().ok())) {
Some(4) => Self::Mac,
Some(2 | 3) => Self::Mobile,
_ if text.is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac,
_ => Self::Other,
}
}
}
/// Mac viewer with 「使用 macOS 快捷键」 off sends Cmd as VK_LWIN (verified: Cmd 0x5B, Option 0xA4,
/// Ctrl 0xA2). Cmd is held back until we know whether it starts a Mac shortcut.
#[derive(Default)]
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput> }
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput>, touch: std::sync::Mutex<TouchDrag> }
impl InputInjector {
pub fn new() -> Self {
@@ -62,7 +110,7 @@ impl InputInjector {
Err(e) => { log::warn!("uinput unavailable ({}); using the desktop input path. See README for the udev rule.", e.kind()); None }
}
} else { None };
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()) }
}
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
@@ -114,8 +162,29 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap();
let motion = std::mem::take(&mut *pending);
pending.scroll = (motion.scroll.0 % 120, motion.scroll.1 % 120);
if let Some((x,y)) = motion.absolute { self.inject_move(x,y,false); }
if motion.relative != (0,0) { self.inject_move(motion.relative.0 as i32,motion.relative.1 as i32,true); }
let mut touch = self.touch.lock().unwrap();
if let Some((x,y)) = motion.absolute {
if touch.down { self.inject_touch(1,x,y); } else {
let (finger, step) = finger_motion(touch.finger, (x,y));
touch.finger = finger;
match step {
FingerStep::Scroll(from,to) => { self.inject_scroll(from,to,false); },
FingerStep::Move(x,y) => { self.inject_move(x,y,false); },
FingerStep::Stay => {},
}
}
touch.at = Some((x,y));
}
// Held still: select from where the finger went down, like a mouse drag.
if let Some((x,y)) = finger_held(touch.finger, std::time::Instant::now()) {
self.inject_move(x,y,false);
touch.finger = if self.inject_button(1,true) == 0 { Finger::Select } else { Finger::Up };
}
drop(touch);
if motion.relative != (0,0) {
self.touch.lock().unwrap().at = None;
self.inject_move(motion.relative.0 as i32,motion.relative.1 as i32,true);
}
for (value, positive, negative) in [(motion.scroll.1,4,5),(motion.scroll.0,7,6)] {
let count = value / 120;
let button = if count > 0 { positive } else { negative };
@@ -136,6 +205,7 @@ impl InputInjector {
pub fn mouse_button(&self, button: i32, is_press: bool) {
let _serial=self.serial.lock().unwrap();
self.flush_pointer_locked();
if button == 1 && self.touch_button(is_press) { return; }
let result = self.inject_button(button,is_press);
if result == 0 {
let mut held = self.held.lock().unwrap();
@@ -174,10 +244,92 @@ impl InputInjector {
shift
}
/// The current desktop controller is the macOS viewer (connect header controller_platform).
pub fn set_mac_controller(&self, mac: bool) {
self.mac_controller.store(mac, std::sync::atomic::Ordering::Relaxed);
/// The current desktop controller's platform (connect header controller_platform).
/// Mobile drags follow `UU_TOUCH_INPUT`: unset = gesture, `touch` = portal touchscreen, `0` = mouse.
pub fn set_controller(&self, controller: Controller) {
self.mac_controller.store(controller == Controller::Mac, std::sync::atomic::Ordering::Relaxed);
*self.cmd.lock().unwrap() = CmdState::default();
let mut touch = self.touch.lock().unwrap();
self.lift_finger(&mut touch);
let mode = if controller != Controller::Mobile { TouchMode::Mouse } else {
match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture }
};
*touch = TouchDrag { mode, ..TouchDrag::default() };
}
/// Ends whatever a finger holds: the touch point, a selection's button, a scroll gesture.
fn lift_finger(&self, touch: &mut TouchDrag) {
if std::mem::take(&mut touch.down) { self.inject_touch(2,0,0); }
match std::mem::take(&mut touch.finger) {
Finger::Select => { self.inject_button(1,false); },
Finger::Scroll { last } => { self.inject_scroll(last,last,true); },
Finger::Pending { .. } | Finger::Up => {},
}
}
/// Left button of a mobile controller: a finger down at the last absolute position, or up.
/// False leaves the button to the mouse path (no touchscreen, trackpad mode, other viewers).
fn touch_button(&self, pressed: bool) -> bool {
let mut touch = self.touch.lock().unwrap();
if touch.mode == TouchMode::Gesture { return self.gesture_button(&mut touch, pressed) }
if !pressed {
if !touch.down { return false; }
touch.down = false;
self.inject_touch(2,0,0);
return true;
}
if touch.down { return true; }
let Some((x,y)) = touch.at.filter(|_| touch.mode == TouchMode::Touch) else { return false };
let supported = self.backend == crate::desktop_backend::DesktopBackend::Portal
&& self.portal.lock().unwrap().as_ref().is_some_and(|portal| portal.touch_supported());
static REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
if !REPORTED.swap(true, std::sync::atomic::Ordering::Relaxed) {
log::info!("Mobile controller drag input: touchscreen={supported}");
}
if !supported { self.offer_touch_consent(); }
touch.down = supported && self.inject_touch(0,x,y) == 0;
touch.down
}
/// Gesture mode (portal only, for its smooth scroll): a press waits for `finger_motion`/`finger_held`
/// to decide; releasing an undecided press is a click.
fn gesture_button(&self, touch: &mut TouchDrag, pressed: bool) -> bool {
if !pressed {
return match std::mem::take(&mut touch.finger) {
Finger::Up => false,
Finger::Pending { start, .. } => {
self.inject_move(start.0,start.1,false);
if self.inject_button(1,true) == 0 { self.inject_button(1,false); }
true
},
finger => { touch.finger = finger; self.lift_finger(touch); true },
};
}
if touch.finger != Finger::Up { return true }
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some();
let Some(start) = touch.at.filter(|_| bound) else { return false };
static REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
if !REPORTED.swap(true, std::sync::atomic::Ordering::Relaxed) { log::info!("Mobile controller drag input: gesture (drag scrolls, hold selects)"); }
touch.finger = Finger::Pending { start, at: std::time::Instant::now() };
true
}
/// Content follows the finger: moving it up scrolls down.
fn inject_scroll(&self, from: (i32,i32), to: (i32,i32), finish: bool) -> i32 {
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
self.portal_result("scroll", portal.scroll(f64::from(from.0 - to.0), f64::from(from.1 - to.1), finish))
}
/// The portal offers a touchscreen the restored consent lacks: ask the host once per run, in the
/// background (GNOME's share dialog, visible to the phone too); drags stay mouse drags meanwhile.
fn offer_touch_consent(&self) {
static ASKED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
let Some(portal) = self.portal.lock().unwrap().clone() else { return };
if ASKED.swap(true, std::sync::atomic::Ordering::Relaxed) { return }
std::thread::spawn(move || match portal.upgrade_touch() {
Ok(true) => log::info!("Touch consent upgraded: mobile drags are touch from now on"),
Ok(false) => log::info!("Touch consent upgrade not needed or not offered by the portal"),
Err(reason) => log::info!("Touch consent upgrade not granted: {reason}"),
});
}
fn inject_touch(&self, phase: i32, x: i32, y: i32) -> i32 {
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y)))
}
fn terminal_focused(&self) -> bool {
@@ -269,6 +421,7 @@ impl InputInjector {
pub fn release_held(&self) {
let _serial=self.serial.lock().unwrap();
self.discard_pointer();
{ let mut touch=self.touch.lock().unwrap(); self.lift_finger(&mut touch); }
let mut held=self.held.lock().unwrap();
if let Some(uinput)=&self.uinput {
Self::uinput_result(uinput.release_all());
@@ -334,9 +487,17 @@ impl InputInjector {
let result=crate::wayland::move_pointer(x,y,false);
if result!=-2 { return result; }
}
// Portal (GNOME/KDE): absolute motion is addressed to the shared stream, i.e. the captured
// monitor; a uinput tablet would stretch the point across every monitor of the desktop.
if !relative && self.backend==crate::desktop_backend::DesktopBackend::Portal {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("motion", portal.move_pointer(f64::from(x),f64::from(y),false)); }
}
// X11 multi-screen: the point is inside the selected monitor; XTest and uinput span the root.
let placement=if relative || self.backend!=crate::desktop_backend::DesktopBackend::X11 {None} else {crate::wayland::x11_placement()};
let (x,y)=placement.map_or((x,y),|(ox,oy)|(x+ox,y+oy));
if let Some(uinput)=&self.uinput {
if relative { return Self::uinput_result(uinput.move_relative(x,y)); }
let (w,h)=*self.screen.lock().unwrap();
let (w,h)=placement.and_then(|_|crate::capture::x11_last_size()).unwrap_or(*self.screen.lock().unwrap());
if w > 1 && h > 1 {
let scale = |v: i32, extent: u32| (i64::from(v) * i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
return Self::uinput_result(uinput.move_absolute(scale(x,w),scale(y,h)));
@@ -349,6 +510,11 @@ impl InputInjector {
else if relative { unsafe { x11_mouse_relative(x,y) } } else { unsafe { x11_mouse_move(x,y) } }
}
fn inject_button(&self,button:i32,pressed:bool)->i32 {
// Portal: clicks follow absolute motion on the same session, so a tap cannot land
// before the compositor has moved the pointer there (uinput is a separate queue).
if self.backend==crate::desktop_backend::DesktopBackend::Portal {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); }
}
if let Some(uinput)=&self.uinput {
if let Some((v,h))=crate::uinput::wheel_step(button) { return if pressed { Self::uinput_result(uinput.wheel(v,h)) } else { 0 }; }
if let Some(code)=crate::uinput::button_code(button) { return Self::uinput_result(uinput.button(code,pressed)); }
@@ -369,8 +535,93 @@ 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)) } }
}
/// Set clipboard content for text injection on Wayland / Portal.
/// Tries Portal RemoteDesktop.SetSelection first, then wl-copy as fallback.
fn set_clipboard_text(&self, text: &str) -> bool {
if text.is_empty() || text.len() > crate::clipboard::MAX_TEXT {
return false;
}
// In unit tests, never invoke external clipboard binaries (wl-copy)
// or alter the system clipboard to prevent side effects on developer desktops.
#[cfg(test)]
{
let _ = text;
false
}
#[cfg(not(test))]
{
// 1. Try Portal clipboard if session is bound and active
if let Some(portal) = self.portal.lock().unwrap().as_ref() {
if portal.clipboard_set(text).is_ok() {
return true;
}
}
// 2. Try wl-copy in Wayland session
if std::env::var_os("WAYLAND_DISPLAY").is_some() {
if let Ok(mut child) = std::process::Command::new("wl-copy")
.args(["--type", "text/plain;charset=utf-8"])
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.spawn()
{
if let Some(mut stdin) = child.stdin.take() {
use std::io::Write;
let _ = stdin.write_all(text.as_bytes());
}
if let Ok(status) = child.wait() {
if status.success() {
return true;
}
}
}
}
false
}
}
/// Injects text by copying it to the clipboard and simulating a paste shortcut.
/// Uses Shift+Insert by default (broadest Linux compatibility across GUI apps and terminals),
/// or Ctrl+V if configured via UU_WAYLAND_PASTE_KEY=ctrl_v.
fn paste_text_via_clipboard(&self, text: &str) -> bool {
if !self.set_clipboard_text(text) {
return false;
}
// Give the clipboard daemon / compositor a brief moment to register the selection.
std::thread::sleep(std::time::Duration::from_millis(25));
let use_ctrl_v = std::env::var("UU_WAYLAND_PASTE_KEY")
.is_ok_and(|v| v.eq_ignore_ascii_case("ctrl_v") || v.eq_ignore_ascii_case("ctrl+v"));
if use_ctrl_v {
// Control_L (0xffe3) + 'v' (0x76)
self.inject_key(0xffe3, true);
std::thread::sleep(std::time::Duration::from_millis(15));
self.inject_key(0x76, true);
std::thread::sleep(std::time::Duration::from_millis(20));
self.inject_key(0x76, false);
std::thread::sleep(std::time::Duration::from_millis(15));
self.inject_key(0xffe3, false);
} else {
// Shift_L (0xffe1) + Insert (0xff63)
self.inject_key(0xffe1, true);
std::thread::sleep(std::time::Duration::from_millis(15));
self.inject_key(0xff63, true);
std::thread::sleep(std::time::Duration::from_millis(20));
self.inject_key(0xff63, false);
std::thread::sleep(std::time::Duration::from_millis(15));
self.inject_key(0xffe1, false);
}
// Brief delay allowing the target application to consume the paste event
std::thread::sleep(std::time::Duration::from_millis(25));
true
}
/// 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.
/// keycode in the virtual keyboard's keymap. Portal and other Wayland environments inject
/// via clipboard paste (Shift+Insert). Set UU_WAYLAND_TEXT=0 to disable Wayland text injection.
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 };
@@ -378,17 +629,39 @@ impl InputInjector {
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.
// Escape hatch: disable Wayland text typing/pasting entirely 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.
// Fallback to clipboard paste if keymap has no spare keycodes or native typing failed
if self.paste_text_via_clipboard(text) {
log::info!("Desktop text input (Wayland clipboard paste fallback): chars={} result=ok", text.chars().count());
return;
}
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)");
log::warn!("Mobile text input unavailable on the Wayland backend (native and clipboard fallback failed)");
}
} else if self.backend==crate::desktop_backend::DesktopBackend::Portal {
if std::env::var("UU_WAYLAND_TEXT").is_ok_and(|v|v=="0") { return; }
// Shift+Insert pastes the PRIMARY selection in VTE terminals, not the clipboard just set:
// type what the active layout has as keys and paste only the rest.
let typed=self.type_portal_keysyms(text);
if typed==text.chars().count() {
log::info!("Desktop text input (Portal keysyms): chars={typed}");
return;
}
let rest:String=text.chars().skip(typed).collect();
if self.paste_text_via_clipboard(&rest) {
log::info!("Desktop text input (Portal clipboard paste): chars={} typed={typed} result=ok", text.chars().count());
return;
}
static WARNED:std::sync::atomic::AtomicBool=std::sync::atomic::AtomicBool::new(false);
if !WARNED.swap(true,std::sync::atomic::Ordering::Relaxed) {
log::warn!("Portal clipboard text paste failed: ensure clipboard permission or wl-copy is available");
}
} else {
static WARNED:std::sync::atomic::AtomicBool=std::sync::atomic::AtomicBool::new(false);
@@ -397,6 +670,14 @@ impl InputInjector {
}
}
}
/// Types `text` as portal keysyms when it is all printable ASCII (or newline/tab) and GNOME's
/// active input source is a Latin xkb layout; returns how many characters were typed.
fn type_portal_keysyms(&self, text: &str) -> usize {
let Some(symbols)=ascii_keysyms(text) else { return 0 };
if !gnome_layout_types_ascii() { return 0; }
let Some(portal)=self.portal.lock().unwrap().clone() else { return 0 };
symbols.iter().take_while(|&&symbol| portal.type_keysym(symbol).is_ok()).count()
}
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; }
@@ -533,7 +814,107 @@ impl InputInjector {
uinput:None, screen:std::sync::Mutex::new((0,0)), portal_failures:std::sync::atomic::AtomicUsize::new(0),
portal_outcomes:std::array::from_fn(|_|std::sync::atomic::AtomicUsize::new(0)),
portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::DesktopBackend::Portal,
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()),
touch:std::sync::Mutex::new(TouchDrag::default()) }
}
}
/// Keysyms for mobile IME text: printable ASCII is its own keysym, newline is Return, tab is Tab.
fn ascii_keysyms(text: &str) -> Option<Vec<u32>> {
text.chars().map(|c| match c { '\n' => Some(0xff0d), '\t' => Some(0xff09), ' '..='~' => Some(c as u32), _ => None }).collect()
}
/// Whether an `org.gnome.desktop.input-sources` source list starts with an xkb layout that has
/// printable ASCII in its first group. Mutter drops keysyms the active layout lacks, and an IBus
/// engine (pinyin, ...) would compose the keys instead.
fn first_source_types_ascii(sources: &str) -> bool {
let Some(start)=sources.find('(') else { return false };
let Some(end)=sources[start..].find(')') else { return false };
let fields:Vec<&str>=sources[start+1..start+end].split(',').map(|f| f.trim().trim_matches('\'')).collect();
let [kind, layout]=fields[..] else { return false };
let (base, variant)=layout.split_once('+').unwrap_or((layout, ""));
const NON_LATIN: &[&str]=&["af","am","ara","bd","bg","bt","by","eg","et","ge","gr","il","in","iq","ir","kg","kh","kz","la","lk","mk","mm","mn","mv","np","ru","sy","th","tj","ua"];
kind=="xkb" && !NON_LATIN.contains(&base) && !variant.contains("cyrillic") && (base!="rs" || variant.contains("latin"))
}
/// GNOME's active input source is the first of `mru-sources` (else of `sources`). Cached for 2 s.
fn gnome_layout_types_ascii() -> bool {
#[cfg(test)]
{ false }
#[cfg(not(test))]
{
static CACHE: std::sync::Mutex<Option<(std::time::Instant,bool)>> = std::sync::Mutex::new(None);
let mut cache=CACHE.lock().unwrap();
if let Some((at,value))=*cache { if at.elapsed()<std::time::Duration::from_secs(2) { return value; } }
let read=|key: &str| std::process::Command::new("gsettings").args(["get","org.gnome.desktop.input-sources",key])
.stderr(std::process::Stdio::null()).output().ok().filter(|o| o.status.success())
.map(|o| String::from_utf8_lossy(&o.stdout).into_owned()).filter(|s| s.contains('('));
let value=read("mru-sources").or_else(|| read("sources")).is_some_and(|s| first_source_types_ascii(&s));
*cache=Some((std::time::Instant::now(),value));
value
}
}
#[cfg(test)]
mod text_keysym_tests {
use super::*;
#[test]
fn ascii_text_becomes_keysyms_and_other_text_does_not() {
assert_eq!(ascii_keysyms("Hi!\n\t~"), Some(vec![0x48,0x69,0x21,0xff0d,0xff09,0x7e]));
assert_eq!(ascii_keysyms("čaj"), None);
assert_eq!(ascii_keysyms("测试"), None);
}
#[test]
fn only_latin_xkb_layouts_type_ascii() {
assert!(first_source_types_ascii("[('xkb', 'us'), ('ibus', 'libpinyin'), ('xkb', 'rs+latin')]"));
assert!(first_source_types_ascii("[('xkb', 'rs+latin')]"));
assert!(first_source_types_ascii("[('xkb', 'de+nodeadkeys')]"));
assert!(!first_source_types_ascii("[('ibus', 'libpinyin'), ('xkb', 'us')]"));
assert!(!first_source_types_ascii("[('xkb', 'rs')]"));
assert!(!first_source_types_ascii("[('xkb', 'ru')]"));
assert!(first_source_types_ascii("[('xkb', 'ba+unicodeus')]"));
assert!(!first_source_types_ascii("[('xkb', 'me+cyrillic')]"));
assert!(!first_source_types_ascii("@a(ss) []"));
}
}
#[cfg(test)]
mod touch_tests {
use super::*;
#[test]
fn controller_from_platform_numbers_and_mac_strings() {
use serde_json::json;
assert_eq!(Controller::from_platform(Some(&json!(2))), Controller::Mobile);
assert_eq!(Controller::from_platform(Some(&json!("3"))), Controller::Mobile);
assert_eq!(Controller::from_platform(Some(&json!(4))), Controller::Mac);
assert_eq!(Controller::from_platform(Some(&json!("MacOS"))), Controller::Mac);
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Other);
assert_eq!(Controller::from_platform(None), Controller::Other);
}
#[test]
fn a_press_scrolls_past_the_slop_and_selects_when_held() {
let t0=std::time::Instant::now();
let pending=Finger::Pending{start:(100,100),at:t0};
// Small wander stays undecided; past SLOP the content follows the finger from the start.
assert_eq!(finger_motion(pending,(105,110)),(pending,FingerStep::Stay));
assert_eq!(finger_motion(pending,(100,100+SLOP+1)),(Finger::Scroll{last:(100,113)},FingerStep::Scroll((100,100),(100,113))));
assert_eq!(finger_motion(Finger::Scroll{last:(100,113)},(100,90)),(Finger::Scroll{last:(100,90)},FingerStep::Scroll((100,113),(100,90))));
assert_eq!(finger_motion(Finger::Select,(7,8)),(Finger::Select,FingerStep::Move(7,8)));
assert_eq!(finger_motion(Finger::Up,(7,8)),(Finger::Up,FingerStep::Move(7,8)));
assert_eq!(finger_held(pending,t0+HOLD-std::time::Duration::from_millis(1)),None);
assert_eq!(finger_held(pending,t0+HOLD),Some((100,100)));
assert_eq!(finger_held(Finger::Scroll{last:(1,1)},t0+HOLD*4),None);
}
#[test]
fn mobile_drag_without_touchscreen_stays_a_mouse_button() {
let input=InputInjector::without_desktop();
input.set_controller(Controller::Mobile);
input.mouse_absolute_normalized(0.5,0.5,(100,100)); input.flush_pointer();
assert!(input.touch.lock().unwrap().at.is_some());
assert!(!input.touch_button(true) && !input.touch.lock().unwrap().down);
assert!(!input.touch_button(false));
input.mouse_relative(1,1); input.flush_pointer();
assert!(input.touch.lock().unwrap().at.is_none());
input.set_controller(Controller::Other);
assert_eq!(input.touch.lock().unwrap().mode,TouchMode::Mouse);
}
}
@@ -700,3 +1081,59 @@ mod output_pointer_tests {
}
}
}
#[cfg(all(test,target_os="linux"))]
mod x11_monitor_pointer_tests {
use super::*;
#[test]
#[ignore="requires an X11 display with two or more RandR monitors and UU_X11_MULTISCREEN=1; moves pointer only"]
fn absolute_pointer_lands_on_the_selected_x11_monitor() {
let _capture=crate::capture::ScreenCapture::new().unwrap();
let input=InputInjector::new();
assert_eq!(input.backend,crate::desktop_backend::DesktopBackend::X11);
let outputs=crate::wayland::outputs();assert!(crate::wayland::x11_multiscreen() && outputs.len()>=2,"needs two X11 monitors");
for (id,output) in outputs.iter().enumerate().chain(outputs.iter().enumerate().rev()) {
crate::wayland::select(id).unwrap();
for (x,y) in [(0.0,0.0),(0.5,0.5),(0.999,0.999),(0.1,0.9)] {
let size=(output.width,output.height);
let pixels=crate::input_mapping::normalized_pointer(x,y,size.0,size.1).unwrap();
input.mouse_absolute_normalized(x,y,size);input.flush_pointer();
let (mut ax,mut ay,mut mask)=(0,0,0);
assert_eq!(unsafe {x11_pointer_state(&mut ax,&mut ay,&mut mask)},0);
assert_eq!((ax,ay),(output.x+pixels.0,output.y+pixels.1),"monitor={} normalized=({x},{y})",output.name);
}
}
crate::wayland::select(0).unwrap();
}
}
#[cfg(test)]
mod clipboard_paste_text_tests {
use super::*;
#[test]
fn rejects_empty_and_oversized_text() {
let input = InputInjector::new();
assert!(!input.set_clipboard_text(""));
let oversized = "a".repeat(crate::clipboard::MAX_TEXT + 1);
assert!(!input.set_clipboard_text(&oversized));
}
#[test]
fn text_input_handles_portal_backend_safely_without_side_effects() {
let mut input = InputInjector::new();
input.backend = crate::desktop_backend::DesktopBackend::Portal;
// In unit tests, set_clipboard_text avoids external commands so this
// will not mutate the host's actual clipboard.
input.text_input("测试输入法文字");
}
#[test]
fn text_input_respects_disable_env() {
let mut input = InputInjector::new();
input.backend = crate::desktop_backend::DesktopBackend::Portal;
std::env::set_var("UU_WAYLAND_TEXT", "0");
input.text_input("测试输入法文字");
std::env::remove_var("UU_WAYLAND_TEXT");
}
}
+5 -5
View File
@@ -25,11 +25,11 @@ async fn black_frame(codec: VideoCodec) -> Result<Bytes, String> {
Ok(output.stdout.into())
}
pub async fn run(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop) -> Result<(), String> {
run_with_encoder(pc, track, desktop, black_frame).await
pub async fn run(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop, selection: crate::video_select::Selection) -> Result<(), String> {
run_with_encoder(pc, track, desktop, selection, black_frame).await
}
async fn run_with_encoder<F, Fut>(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop, mut encode: F) -> Result<(), String>
async fn run_with_encoder<F, Fut>(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop, selection: crate::video_select::Selection, mut encode: F) -> Result<(), String>
where F: FnMut(VideoCodec) -> Fut, Fut: std::future::Future<Output = Result<Bytes, String>> {
// #29: iPhone 4.42.0 cold ON/OFF/ON tests only sent action15 after black video.
// Keep CONTROL permissions truthful and use the existing video track until real capture is ready.
@@ -55,8 +55,8 @@ where F: FnMut(VideoCodec) -> Fut, Fut: std::future::Future<Output = Result<Byte
if !updates.borrow().waiting || *locked.borrow() != Some(true)
|| pc.connection_state() != RTCPeerConnectionState::Connected { continue; }
if frame.is_none() {
let codec = crate::capture_setting::preferred_codec(
track.supports(VideoCodec::H264), track.supports(VideoCodec::H265));
let codec = crate::capture_setting::preferred_codec_for(
track.supports(VideoCodec::H264), track.supports(VideoCodec::H265), selection);
let encoded = tokio::select! {
biased;
_ = updates.changed() => continue,
+4 -4
View File
@@ -206,7 +206,7 @@ async fn exercise_locked_video(codec: VideoCodec) {
let run_host = peers.host.clone();
let run_track = peers.track.clone();
let run_desktop = desktop.clone();
let task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop).await });
let task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop, crate::video_select::selection()).await });
assert_ne!(peers.host.connection_state(), RTCPeerConnectionState::Connected);
assert_no_rtp(&mut peers.packets, Duration::from_millis(150)).await;
@@ -273,7 +273,7 @@ async fn locked_video_rechecks_state_when_encoding_finishes() {
let (encoded_tx, mut encoded_rx) = mpsc::unbounded_channel();
let revision = peers.track.revision();
let task = tokio::spawn(async move {
run_with_encoder(&run_host, &run_track, &run_desktop, |_| {
run_with_encoder(&run_host, &run_track, &run_desktop, crate::video_select::selection(), |_| {
let desktop = run_desktop.clone();
let lock_tx = lock_tx.clone();
let encoded_tx = encoded_tx.clone();
@@ -317,7 +317,7 @@ async fn locked_video_stops_on_capture_rejection_and_terminal_peer_close() {
let run_host = peers.host.clone();
let run_track = peers.track.clone();
let run_desktop = rejected_desktop.clone();
let rejection_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop).await });
let rejection_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop, crate::video_select::selection()).await });
rejected_desktop.publish_test_screen(
Arc::new(ScreenCapture::unavailable("synthetic capture rejection".into())),
);
@@ -335,7 +335,7 @@ async fn locked_video_stops_on_capture_rejection_and_terminal_peer_close() {
let run_host = peers.host.clone();
let run_track = peers.track.clone();
let run_desktop = pending_desktop;
let close_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop).await });
let close_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop, crate::video_select::selection()).await });
peers.host.close().await.unwrap();
tokio::time::timeout(Duration::from_secs(2), close_task).await
.expect("locked video task did not stop after terminal peer close")
+141 -29
View File
@@ -8,7 +8,7 @@
//! (analysis/tools-fix-20261013/viewer-fieldmd.json). Results are written to the private
//! config file (chmod 600). Tokens and tickets are never printed or logged.
use crate::auth::{Credentials, UUAuthClient};
use crate::auth::{Credentials, QrRequestErrorKind, UUAuthClient};
use crate::login_ui::{LoginUi, Tone};
use serde_json::{json, Value};
use std::time::Duration;
@@ -127,6 +127,35 @@ fn render_qr(content: &str) -> Result<String, String> {
/// API code for an expired login QR code.
const QR_EXPIRED: i64 = 1190;
/// QR API errors must not echo server messages/validation fields: they may contain credentials.
fn qr_data<'a>(stage: &str, status: u16, body: &'a Value) -> Result<&'a Value, String> {
let code = body.get("code").and_then(Value::as_i64);
if status == 200 && code == Some(0) { return Ok(body.get("data").unwrap_or(&Value::Null)); }
Err(format!("{stage}: http_status={status} api_code={code:?}"))
}
#[derive(Debug, PartialEq, Eq)]
enum QrPollAction { Wait(i64), Scanned, Confirmed, Refresh(Duration), Failed(&'static str) }
/// Preserve the official refresh policy; a failed query says nothing about QR expiry.
fn qr_poll_action(last_status: i64, http_status: u16, body: &Value) -> QrPollAction {
if body.get("code").and_then(Value::as_i64) == Some(QR_EXPIRED) {
return QrPollAction::Failed(crate::i18n::s("二维码已失效","QR code expired"));
}
let Ok(data) = qr_data("qrcode status", http_status, body) else {
return QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed"));
};
match data.get("status").and_then(Value::as_i64) {
Some(1) => QrPollAction::Wait(1),
Some(2) if last_status != 2 => QrPollAction::Scanned,
Some(2) => QrPollAction::Wait(2),
Some(0) => QrPollAction::Refresh(Duration::from_millis(350)),
Some(3) => QrPollAction::Refresh(Duration::ZERO),
Some(4) => QrPollAction::Confirmed,
_ => QrPollAction::Failed(crate::i18n::s("二维码状态响应异常","Unexpected QR status response")),
}
}
/// QR modules as RGBA pixels: `scale` pixels per module, `quiet` light modules around the code.
fn qr_rgba(content: &str, scale: usize, quiet: usize) -> Result<(Vec<u8>, usize), String> {
let code = qrcode::QrCode::new(content.as_bytes()).map_err(|e| format!("QR encode failed: {e}"))?;
@@ -218,10 +247,10 @@ pub async fn run(gui: bool) -> Result<(), String> {
};
match &result {
Ok(name) => {
ui.done(&format!("登录成功\n{name}"));
ui.status("登录信息已保存到本机配置,可以关闭此窗口", Tone::Ok);
ui.done(&crate::tr!("登录成功\n{name}","Signed in\n{name}"));
ui.status(crate::i18n::s("登录信息已保存到本机配置,可以关闭此窗口","Sign-in saved to the local config; you can close this window"), Tone::Ok);
}
Err(e) => { eprintln!("login failed: {e}"); ui.status(&format!("登录失败:{e}"), Tone::Error); }
Err(e) => { eprintln!("login failed: {e}"); ui.status(&crate::tr!("登录失败:{e}","Sign-in failed: {e}"), Tone::Error); }
}
if ui.shown() { ui.wait_closed().await; }
result.map(|_| ())
@@ -243,7 +272,26 @@ pub fn prepare_identity() -> Result<(Value, Credentials), String> {
Ok((cfg, creds))
}
/// Holds an exclusive lock beside config.json while a device identity is created: the host's own QR
/// window and the viewer's sign-in can run at once, and two `device/windows/init` calls would leave the
/// account bound to one device while config.json keeps the other (the host then shows as offline).
struct IdentityLock(std::fs::File);
impl IdentityLock {
fn acquire() -> Result<Self, String> {
use std::os::unix::io::AsRawFd;
let path = crate::config::path().with_extension("lock");
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
let file = std::fs::OpenOptions::new().create(true).truncate(false).write(true).open(&path).map_err(|_| "Cannot open the identity lock")?;
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX) } != 0 { return Err("Cannot lock the device identity".into()) }
Ok(Self(file))
}
}
impl Drop for IdentityLock { fn drop(&mut self) { use std::os::unix::io::AsRawFd; unsafe { libc::flock(self.0.as_raw_fd(), libc::LOCK_UN); } } }
pub async fn prepare_device() -> Result<(Value, Credentials), String> {
// Read the configuration only after taking the lock, so a waiting process sees the device the
// first one registered instead of creating its own.
let _lock = tokio::task::spawn_blocking(IdentityLock::acquire).await.map_err(|_| "Identity lock task failed")??;
let (mut cfg, mut creds) = prepare_identity()?;
let get = |cfg: &Value, k: &str| std::env::var(format!("UU_{}", k.to_uppercase())).ok().filter(|v| !v.is_empty())
.or_else(|| cfg.get(k).and_then(|v| v.as_str()).map(str::to_owned)).unwrap_or_default();
@@ -276,10 +324,18 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
// every QR within seconds (#68).
let timeout = Duration::from_secs(60);
loop {
let (status, resp) = client.post_with_timeout("/api/v1/qrcode/gen/login", None, timeout).await?;
let d = match data("qrcode gen", status, &resp) {
let (status, resp) = match client.post_with_timeout("/api/v1/qrcode/gen/login", None, timeout).await {
Ok(r) => r,
Err(e) if e.response_received() => {
eprintln!("QR generation response failed: {e}");
wait_for_refresh(ui, crate::i18n::s("二维码加载失败","QR code failed to load")).await;
continue;
}
Err(e) => return Err(format!("QR generation failed: {e}")),
};
let d = match qr_data("qrcode gen", status, &resp) {
Ok(d) => d.clone(),
Err(e) => { println!("QR code could not be loaded ({e})"); wait_for_refresh(ui, "二维码加载失败").await; continue; }
Err(e) => { println!("QR code could not be loaded ({e})"); wait_for_refresh(ui, crate::i18n::s("二维码加载失败","QR code failed to load")).await; continue; }
};
let url = d.get("qrcode_jump_url").and_then(|v| v.as_str()).ok_or("qrcode gen returned no qrcode_jump_url")?.to_string();
let ticket = qr_ticket(&d).ok_or("qrcode gen returned no status ticket")?.to_string();
@@ -288,7 +344,7 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
let modules = qrcode::QrCode::new(url.as_bytes()).map_err(|e| e.to_string())?.width() + 2;
let (rgba, edge) = qr_rgba(&url, (224 / modules).max(2), 1)?;
ui.qr(&rgba, edge);
ui.status("等待扫码…", Tone::Info);
ui.status(crate::i18n::s("等待扫码…","Waiting for scan…"), Tone::Info);
}
if let Some(path)=std::env::var_os("UU_LOGIN_QR_PNG") {
use std::io::Write;
@@ -303,26 +359,44 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
let query = json!({"token": ticket, "qrcode_jump_url": url, "login_status": login_status});
let (status, resp) = match client.post_with_timeout("/api/v1/qrcode/login/status", Some(&query), timeout).await {
Ok(r) => r,
Err(_) => break "网络超时,二维码已停止刷新",
Err(e) => {
eprintln!("QR status query failed: {e}; last_status={login_status}");
break match e.kind {
QrRequestErrorKind::Timeout => crate::i18n::s("二维码状态查询超时(不代表二维码已失效)","QR status check timed out (the QR code may still be valid)"),
_ => crate::i18n::s("二维码状态查询失败(不代表二维码已失效)","QR status check failed (the QR code may still be valid)"),
};
}
};
let code = resp.get("code").and_then(|c| c.as_i64());
if code == Some(QR_EXPIRED) { break "二维码已失效"; }
let Ok(d) = data("qrcode status", status, &resp) else { break "二维码状态查询失败"; };
let st = d.get("status").and_then(|v| v.as_i64()).unwrap_or(login_status);
match st {
1 => {}
2 => if login_status != 2 {
match qr_poll_action(login_status, status, &resp) {
QrPollAction::Wait(st) => {
if st == 1 && login_status != 1 { ui.status(crate::i18n::s("等待扫码…","Waiting for scan…"), Tone::Info); }
login_status = st;
}
QrPollAction::Scanned => {
login_status = 2;
println!("已扫码,请在手机上确认 (scanned, confirm on the phone)");
ui.status("已扫码,请在手机上确认登录", Tone::Ok);
},
3 => { println!("QR code expired; generating a new one"); break ""; }
0 => { tokio::time::sleep(Duration::from_millis(350)).await; break ""; }
4 => {
ui.status(crate::i18n::s("已扫码,请在手机上确认登录","Scanned, confirm the sign-in on your phone"), Tone::Ok);
}
QrPollAction::Refresh(delay) => {
if delay.is_zero() { println!("QR code expired; generating a new one"); }
else { tokio::time::sleep(delay).await; }
break "";
}
QrPollAction::Confirmed => {
println!("已确认,正在完成登录 (confirmed, completing login)");
ui.status(crate::i18n::s("已确认,正在完成登录…","Confirmed, finishing sign-in…"), Tone::Info);
let body = json!({"token": ticket, "qrcode_jump_url": url});
let (status, resp) = client.post_with_timeout("/api/v1/login/by_qrcode", Some(&body), timeout).await?;
let d = match data("qrcode login", status, &resp) {
let (status, resp) = match client.post_with_timeout("/api/v1/login/by_qrcode", Some(&body), timeout).await {
Ok(r) => r,
Err(e) if e.response_received() => {
eprintln!("QR login exchange response failed: {e}");
break crate::i18n::s("登录失败","Sign-in failed");
}
Err(e) => return Err(format!("QR login exchange failed: {e}")),
};
let d = match qr_data("qrcode login", status, &resp) {
Ok(d) => d,
Err(e) => { println!("QR login not granted ({e})"); break "登录失败"; }
Err(e) => { println!("QR login not granted ({e})"); break crate::i18n::s("登录失败","Sign-in failed"); }
};
let token = d.get("token").and_then(|v| v.as_str()).ok_or("login returned no token")?;
let user = d.get("user_id").and_then(|v| v.as_str()).ok_or("login returned no user_id")?;
@@ -339,9 +413,12 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
println!("Logged in as {} ({}); saved to {}", nickname, user, path.display());
return Ok(if nickname.is_empty() { user.to_string() } else { nickname.to_string() });
}
other => { println!("QR status: {other}"); break "二维码已失效"; }
QrPollAction::Failed(reason) => {
eprintln!("QR status query stopped: http_status={status} api_code={:?} status={:?} last_status={login_status}",
resp.get("code").and_then(Value::as_i64), resp.get("data").and_then(|d| d.get("status")).and_then(Value::as_i64));
break reason;
}
}
login_status = st;
};
if !failure.is_empty() { wait_for_refresh(ui, failure).await; }
}
@@ -357,7 +434,7 @@ fn qr_ticket(gen: &Value) -> Option<&str> {
/// or (no window and no terminal, e.g. a service) one minute.
async fn wait_for_refresh(ui: &LoginUi, reason: &str) {
use std::io::IsTerminal;
ui.status(&format!("{reason},请点击「刷新二维码」"), Tone::Error);
ui.status(&crate::tr!("{reason},请点击「刷新二维码」","{reason}. Click \"Refresh QR code\"."), Tone::Error);
ui.offer_refresh(true);
let terminal = !ui.quiet() && std::io::stdin().is_terminal();
if terminal { println!("{reason}. Press Enter to show a new QR code (按回车刷新二维码)"); }
@@ -376,14 +453,48 @@ async fn wait_for_refresh(ui: &LoginUi, reason: &str) {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn qr_poll_keeps_waiting_scanned_and_confirmed_distinct() {
let reply = |status| json!({"code": 0, "data": {"status": status}});
assert_eq!(qr_poll_action(1, 200, &reply(1)), QrPollAction::Wait(1));
assert_eq!(qr_poll_action(1, 200, &reply(2)), QrPollAction::Scanned);
assert_eq!(qr_poll_action(2, 200, &reply(2)), QrPollAction::Wait(2));
assert_eq!(qr_poll_action(2, 200, &reply(4)), QrPollAction::Confirmed);
assert_eq!(qr_poll_action(1, 200, &reply(0)), QrPollAction::Refresh(Duration::from_millis(350)));
assert_eq!(qr_poll_action(2, 200, &reply(3)), QrPollAction::Refresh(Duration::ZERO));
assert_eq!(qr_poll_action(2, 400, &json!({"code": 1190})), QrPollAction::Failed(crate::i18n::s("二维码已失效","QR code expired")));
}
#[test]
fn qr_poll_failures_do_not_imply_expiry_or_confirmation() {
for last in [1, 2] {
for body in [json!(null), json!({"code": 1}), json!({"code": 0, "data": {"status": 4}})] {
assert_eq!(qr_poll_action(last, 503, &body), QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed")));
}
assert_eq!(qr_poll_action(last, 200, &json!({"code": 1})), QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed")));
for data in [json!(null), json!({}), json!({"status": "4"}), json!({"status": 99}), json!({"status": -1})] {
assert_eq!(qr_poll_action(last, 200, &json!({"code": 0, "data": data})), QrPollAction::Failed(crate::i18n::s("二维码状态响应异常","Unexpected QR status response")));
}
}
}
#[test]
fn qr_api_errors_do_not_echo_server_content() {
let body = json!({"code": 1001, "msg": "fixture-token", "data": [{"loc": "fixture-ticket"}]});
assert_eq!(qr_data("qrcode gen", 400, &body).unwrap_err(), "qrcode gen: http_status=400 api_code=Some(1001)");
}
#[test]
fn status_ticket_prefers_status_query_ticket() {
assert_eq!(qr_ticket(&json!({"token": "old", "status_query_ticket": "new"})), Some("new"));
assert_eq!(qr_ticket(&json!({"token": "old"})), Some("old"));
assert_eq!(qr_ticket(&json!({"status_query_ticket": ""})), None);
}
#[tokio::test]
async fn service_waits_until_a_new_token_is_saved() {
#[test]
fn service_waits_until_a_new_token_is_saved() {
let _env = crate::config::test_env_lock().lock().unwrap();
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let dir = std::env::temp_dir().join(format!("uu-login-wait-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
@@ -399,6 +510,7 @@ mod tests {
let got = tokio::time::timeout(Duration::from_secs(10), wait_for_credentials(Some("old".into()))).await.unwrap();
assert_eq!(got.token, "new"); // the expired token in the file is not accepted
let _ = std::fs::remove_dir_all(&dir);
});
}
#[test]
+288 -28
View File
@@ -1,6 +1,7 @@
//! UU Remote Pure Native Linux Server (Rust Edition)
//! Zero-Wine, Zero-Python, Single-Binary, 5 Native Tools Integrated
mod ws_transport;
mod engine_plugin;
mod doctor;
mod wol;
@@ -15,6 +16,7 @@ mod wayland;
mod auth;
mod assist;
mod config;
mod i18n;
mod login;
mod login_ui;
mod session_lock;
@@ -30,6 +32,7 @@ mod signaling;
mod terminal;
mod webrtc;
mod video;
mod video_select;
mod video_track;
mod locked_video;
#[cfg(test)]
@@ -43,6 +46,7 @@ mod capture_setting;
mod audio;
mod virtual_audio;
mod system_actions;
mod privacy_screen;
mod capability;
mod protocol;
mod control_protocol;
@@ -68,10 +72,20 @@ use webrtc::WebRtcSession;
/// Set before a normal return when the host must come back in the other mode (signed in / out).
static RESTART: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
struct AbortOnDrop(tokio::task::AbortHandle);
impl Drop for AbortOnDrop { fn drop(&mut self) { self.0.abort(); } }
fn superseded_peer_ids(sessions: &HashMap<String, WebRtcSession>, ice: &str, desktop: bool) -> Vec<String> {
sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop))
.map(|(id, _)| id.clone()).collect()
}
/// A peer whose transport is already broken can leave `PeerConnection::close`
/// waiting indefinitely; signaling must keep flowing without it.
async fn close_peer(pc: &::webrtc::peer_connection::RTCPeerConnection) {
if tokio::time::timeout(std::time::Duration::from_secs(5), pc.close()).await.is_err() {
log::warn!("Peer connection close timed out; continuing");
}
}
fn released_peer_ids<T>(sessions: &HashMap<String, T>, ice: Option<&serde_json::Value>) -> Vec<String> {
let ice = ice.map(|id| id.as_str().map(str::to_owned).unwrap_or_else(|| id.to_string()));
sessions.keys().filter(|id| ice.as_deref().map_or(true, |ice| id.as_str() == ice)).cloned().collect()
@@ -127,12 +141,179 @@ fn systemd_unit() -> Option<String> {
cgroup.lines().find_map(|l| l.rsplit('/').next().filter(|u| u.ends_with(".service")).map(str::to_owned))
}
fn display_present() -> bool { std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some() }
fn set_video_pref() -> Result<(), Box<dyn std::error::Error>> {
let which = std::env::args().nth(1).unwrap_or_default();
let stored = std::env::args().nth(2).unwrap_or_default().trim().to_ascii_lowercase();
let stored = if stored == "hevc" { "h265".to_owned() } else { stored };
if let Err(e) = system_actions::merge_save(|settings| {
if which == "set-encoder" { settings.video_encoder = Some(stored.clone()); }
else { settings.video_codec = Some(stored.clone()); }
}) {
// Exit 2 is reserved for bad CLI input; a settings file that cannot be merged is exit 1.
eprintln!("{which}: {e}");
std::process::exit(1);
}
let selection = video_select::selection();
let codec = match selection.codec_pref { video_select::CodecPref::Auto => "auto", video_select::CodecPref::H264 => "h264", video_select::CodecPref::H265 => "h265" };
println!("encoder={:?} source={} codec_pref={codec} source={}", selection.encoder, video_select::encoder_source_label(selection.encoder_source), video_select::source_label(selection.codec_source));
// Both subcommands wake the host. Encoder changes restart live desktop streams; codec changes are logged only.
match notify_host(libc::SIGUSR2) {
Ok(()) => println!("notified the running host"),
Err(_) => println!(
"host not running, or the running host is not this binary: takes effect the next time a desktop connection starts, or after restarting the service"
),
}
if which == "set-codec" {
println!("takes effect the next time a desktop connection starts");
}
Ok(())
}
/// Signal the host recorded in host.pid only when `/proc/<pid>/exe` is exactly
/// `canonicalize(current_exe())`. A filename match is not enough: an older host
/// has no SIGUSR2 handler, and the default action terminates the process.
/// A replaced binary reads back as `… (deleted)` and does not match.
fn notify_host(signal: i32) -> Result<(), ()> {
let pid = std::fs::read_to_string(host_pid_path())
.ok()
.and_then(|s| s.trim().parse::<i32>().ok())
.filter(|p| *p > 1)
.ok_or(())?;
let exe = std::fs::read_link(format!("/proc/{pid}/exe")).map_err(|_| ())?;
let own = std::fs::canonicalize(std::env::current_exe().map_err(|_| ())?).map_err(|_| ())?;
if !same_host_binary(&exe, &own) {
return Err(());
}
if unsafe { libc::kill(pid, signal) } == 0 {
Ok(())
} else {
Err(())
}
}
/// `/proc/<pid>/exe` must equal the canonical path of this binary. A trailing ` (deleted)` does not match.
fn same_host_binary(proc_exe: &std::path::Path, own: &std::path::Path) -> bool {
proc_exe == own
}
/// Explicit command words for set-encoder / set-codec. Empty and whitespace are illegal.
pub(crate) fn cli_pref_ok(which: &str, value: &str) -> bool {
let value = value.trim();
if value.is_empty() { return false; }
let value = value.to_ascii_lowercase();
match which {
"set-encoder" => matches!(value.as_str(), "auto" | "cpu" | "vaapi" | "nvenc"),
"set-codec" => matches!(value.as_str(), "auto" | "h264" | "h265" | "hevc"),
_ => false,
}
}
const SUBCOMMANDS: [&str; 17] = ["doctor", "show", "assist", "set-encoder", "set-codec", "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"];
/// Unknown arguments and illegal set-encoder / set-codec values exit 2 (never start a second host).
/// help / -h / --help exit 0 so main prints usage instead of starting the host.
pub(crate) fn reject_cli(arg: Option<&str>, argc: usize, value_ok: bool) -> Option<i32> {
if matches!(arg, Some("help" | "-h" | "--help")) { return Some(0); }
if arg.is_some_and(|a| !SUBCOMMANDS.contains(&a)) { return Some(2); }
if matches!(arg, Some("set-encoder" | "set-codec")) && (argc != 3 || !value_ok) { return Some(2); }
None
}
#[cfg(test)]
mod cli_exit_tests {
#[test]
fn unknown_and_illegal_subcommand_exit_2() {
assert_eq!(super::reject_cli(Some("not-a-command"), 2, true), Some(2));
assert_eq!(super::reject_cli(Some("set-encoder"), 3, false), Some(2));
assert_eq!(super::reject_cli(Some("set-encoder"), 2, true), Some(2));
assert_eq!(super::reject_cli(Some("set-codec"), 4, true), Some(2));
assert_eq!(super::reject_cli(Some("set-encoder"), 3, true), None);
assert_eq!(super::reject_cli(Some("set-codec"), 3, true), None);
assert_eq!(super::reject_cli(Some("help"), 2, true), Some(0));
assert_eq!(super::reject_cli(Some("-h"), 2, true), Some(0));
assert_eq!(super::reject_cli(Some("--help"), 2, true), Some(0));
assert_eq!(super::reject_cli(None, 1, true), None);
assert!(!super::cli_pref_ok("set-encoder", ""));
assert!(!super::cli_pref_ok("set-encoder", " "));
assert!(!super::cli_pref_ok("set-codec", ""));
assert!(!super::cli_pref_ok("set-codec", "\t"));
assert!(!super::cli_pref_ok("set-encoder", "bogus"));
assert!(super::cli_pref_ok("set-encoder", " NVENC "));
assert!(super::cli_pref_ok("set-codec", "hevc"));
assert_eq!(super::reject_cli(Some("set-encoder"), 3, super::cli_pref_ok("set-encoder", "")), Some(2));
assert_eq!(super::reject_cli(Some("set-codec"), 3, super::cli_pref_ok("set-codec", " ")), Some(2));
}
/// SIGUSR1 and SIGUSR2 are installed with no assist UI. `host.pid` is written only after both exist.
#[test]
fn signal_handlers_install_without_assist() {
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let _guard = crate::config::test_env_lock().lock().unwrap();
let dir =
std::env::temp_dir().join(format!("uuremote-signal-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::env::set_var("UU_CONFIG", dir.join("config.json"));
assert!(super::install_host_signals(None));
let pid = std::fs::read_to_string(super::host_pid_path()).unwrap();
assert_eq!(pid.trim(), std::process::id().to_string());
std::env::remove_var("UU_CONFIG");
let _ = std::fs::remove_dir_all(&dir);
});
}
#[test]
fn sigusr2_requires_the_same_canonical_binary() {
let own = std::path::Path::new("/home/user/.local/bin/uuremote-server");
assert!(super::same_host_binary(own, own));
assert!(!super::same_host_binary(
std::path::Path::new("/tmp/unpack/uuremote-server"),
own
));
assert!(!super::same_host_binary(
std::path::Path::new("/home/user/.local/bin/uuremote-server (deleted)"),
own
));
}
}
/// SIGUSR1 (`uuremote-server show`) opens the host window.
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
// Install the handler before publishing the pid: SIGUSR1's default action terminates the process.
let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) else { return };
/// SIGUSR2 (set-encoder, set-codec, or `kill -USR2`) re-reads host_settings. Encoder changes switch live desktop streams; codec changes are logged for the next connection.
/// The default action of either signal terminates the process, so both handlers are installed before `host.pid` is written.
/// SIGUSR2 is independent of remote assistance: `UU_REMOTE_ASSIST=0` and a failed assist setup still switch live encoders.
/// SIGUSR1 is installed first as a no-op so `show` cannot terminate a host that has no assist window yet.
fn install_host_signals(ui: Option<std::sync::Arc<assist::LocalUi>>) -> bool {
static USR1: std::sync::Once = std::sync::Once::new();
static USR2: std::sync::Once = std::sync::Once::new();
let mut usr1_ok = true;
USR1.call_once(|| {
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) {
Ok(mut usr1) => { tokio::spawn(async move { while usr1.recv().await.is_some() {} }); }
Err(_) => usr1_ok = false,
}
});
if !usr1_ok { return false; }
let mut usr2_ok = true;
USR2.call_once(|| {
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined2()) {
Ok(mut usr2) => { tokio::spawn(async move { while usr2.recv().await.is_some() { crate::video_select::publish_reload(); } }); }
Err(_) => usr2_ok = false,
}
});
if !usr2_ok { return false; }
// Assist attaches later and replaces the no-op with the window. A second registration replaces the first.
if let Some(ui) = ui {
if let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) {
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
}
}
write_host_pid();
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
true
}
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
let _ = install_host_signals(Some(ui));
}
fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.pid") }
@@ -140,7 +321,9 @@ fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.p
fn write_host_pid() {
use std::os::unix::fs::OpenOptionsExt;
use std::io::Write;
if let Ok(mut f) = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(host_pid_path()) {
let path = host_pid_path();
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
if let Ok(mut f) = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(path) {
let _ = write!(f, "{}", std::process::id());
}
}
@@ -226,16 +409,20 @@ 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; 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 arg1 = std::env::args().nth(1);
let value_ok = match arg1.as_deref() {
Some(which @ ("set-encoder" | "set-codec")) => cli_pref_ok(which, &std::env::args().nth(2).unwrap_or_default()),
_ => true,
};
if let Some(code) = reject_cli(arg1.as_deref(), std::env::args().len(), value_ok) {
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(()); }
if code == 0 { println!("{usage}"); return Ok(()); }
eprintln!("unknown argument\n{usage}");
std::process::exit(2);
std::process::exit(code);
}
if std::env::args().nth(1).as_deref() == Some("show") { return show_running_host(); }
if matches!(std::env::args().nth(1).as_deref(), Some("set-encoder") | Some("set-codec")) { return set_video_pref(); }
if assist_enabled && !unified {
if std::env::args().len() > 2 { return Err("assist accepts no additional arguments; configure it with a private UU_CONFIG".into()); }
assist::configure()?;
@@ -447,6 +634,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
session_ice::configure_relay_transport();
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
let _ = install_host_signals(None);
video::warm_auto_probe();
video::check_ffmpeg_usable();
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).
@@ -465,6 +657,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let input = Arc::new(InputInjector::new());
input.bind_portal(capture.portal.clone());
input.release_held(); // recover stale input before accepting any peer
privacy_screen::recover(); // monitors a previous run left black
let _pointer_worker = input.start_pointer_worker();
let (shutdown_tx, mut shutdown) = tokio::sync::watch::channel(false);
let shutdown_input = input.clone();
@@ -477,6 +670,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
}
#[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await;
let _ = tokio::task::spawn_blocking(privacy_screen::disable).await;
if !assist_enabled { shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
let _ = signal_tx.send(true);
});
@@ -507,7 +701,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if let Some(task) = command_task { task.abort(); }
// One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { let _ = old.pc.close().await; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
@@ -525,6 +719,21 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
assist: &mut Option<assist::Assist>, commands: &mut mpsc::Receiver<assist::Command>, webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>>) -> Result<(), Box<dyn std::error::Error>> {
let portal_desktop = (capture.backend == desktop_backend::DesktopBackend::Portal && !desktop_backend::headless())
.then(|| Arc::new(desktop_session::PortalDesktop::new(capture.clone())));
// Stop sharing the screen once no desktop controller is left. Viewers send stop_capture
// before leaving and phones reconnect within seconds, so require two idle checks in a row.
let idle_watch = portal_desktop.clone().map(|portal| {
let sessions = webrtc_sessions.clone();
tokio::spawn(async move {
let mut idle = 0u8;
loop {
tokio::time::sleep(std::time::Duration::from_secs(2)).await;
if sessions.lock().await.values().any(|s| s.role.is_desktop()) { idle = 0; continue; }
idle = idle.saturating_add(1);
if idle >= 2 { portal.end_idle(); }
}
})
});
let _idle_watch = idle_watch.map(|task| AbortOnDrop(task.abort_handle()));
let mut auth = if let Some(session) = assist.as_ref() { session.client.clone() } else {
let creds = match config::file().and_then(Credentials::load) {
Ok(creds) => creds,
@@ -557,8 +766,10 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id.
let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
let mut mac_by_ice: HashMap<String, bool> = HashMap::new();
let mut next_mac = false;
let mut controller_by_ice: HashMap<String, crate::input::Controller> = HashMap::new();
let mut next_controller = crate::input::Controller::Other;
// Tool peers ask here to become the desktop (capture_desktop on an existing connection, #99).
let (desktop_requests, mut desktop_requested) = mpsc::unbounded_channel::<String>();
loop {
if *shutdown.borrow() {
@@ -643,6 +854,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
_ = shutdown.changed() => Some(SignalingEvent::Stop),
command = commands.recv(), if assist.is_some() => Some(SignalingEvent::AssistCommand(command.unwrap_or(assist::Command::Stop))),
_ = assist_tick.tick(), if assist.is_some() => Some(SignalingEvent::AssistTick),
Some(ice) = desktop_requested.recv() => Some(SignalingEvent::DesktopRequested(ice)),
event = rx_event.recv() => event,
};
let Some(evt) = event else { break; };
@@ -677,8 +889,10 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(id, _)| id.clone()).collect();
let mut desktop_ended = false;
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.desktop; let _ = s.pc.close().await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.role.is_desktop(); close_peer(&s.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
// The controller left: stop sharing now; reconnecting reopens silently with the saved consent.
if !sessions.values().any(|s| s.role.is_desktop()) { if let Some(portal) = &portal_desktop { portal.end_idle(); } }
if let Some(s) = assist.as_mut() { s.tick()?; }
}
SignalingEvent::Connected => {
@@ -740,9 +954,9 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
.and_then(|s| s.as_str())
);
}
SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller_mac } => {
if mac_by_ice.len()>=32 { mac_by_ice.clear(); }
match ice_id.clone() { Some(id) => { mac_by_ice.insert(id, controller_mac); } None => next_mac = controller_mac }
SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller } => {
if controller_by_ice.len()>=32 { controller_by_ice.clear(); }
match ice_id.clone() { Some(id) => { controller_by_ice.insert(id, controller); } None => next_controller = controller }
// Pending cloud credentials live only within this room; cap
// requests that never receive an offer rather than retain them.
if capture_types.len()>=32 { capture_types.clear(); }
@@ -765,21 +979,25 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(k, _)| k.clone()).collect();
let mut desktop_ended = false;
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.desktop; let _ = old.pc.close().await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.role.is_desktop(); close_peer(&old.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
if soac.msg_type == "offer" {
let (capture_type,transport) = capture_types.remove(&ice).or_else(|| next_capture_type.take()).unwrap_or((1,crate::session_ice::SessionIce::default()));
// CaptureType: 0 unknown, 1 desktop, 2 window; 5 file transfer, 8 terminal, 9 port mapping.
let desktop = capture_type <= 2;
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac);
if desktop { input.set_mac_controller(controller_mac); }
let controller = controller_by_ice.remove(&ice).unwrap_or(next_controller);
if desktop { input.set_controller(controller); }
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
// An expired NVENC failure is re-probed in the background. This offer keeps the cached encoder.
if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); }
// Replace only this ICE id or a previous desktop, never tool peers.
for id in superseded_peer_ids(&sessions, &ice, desktop) {
if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; }
if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; }
}
// A tool peer promoted by capture_desktop stops its desktop but keeps its tools.
if desktop { for old in sessions.values() { old.demote(); } }
if desktop && desktop_backend::headless() {
log::info!("Desktop connection ignored: headless mode (terminal, file transfer and port mapping remain available)");
continue;
@@ -801,7 +1019,12 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
if desktop { if let Some(portal) = &portal_desktop { portal.begin(); } }
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport,
if desktop { portal_desktop.clone() } else { None }).await {
Ok(sess) => {
Ok(mut sess) => {
sess.controller = controller;
if !desktop {
let (requests, peer) = (desktop_requests.clone(), ice.clone());
sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); });
}
// Register before awaiting SDP: shutdown can always close
// a peer whose answer may already be queued to the viewer.
sessions.insert(ice.clone(), sess);
@@ -824,7 +1047,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
}
Err(_) => {
log::error!("Failed to handle offer (details omitted)");
if let Some(session) = sessions.remove(&ice) { let _ = session.pc.close().await; }
if let Some(session) = sessions.remove(&ice) { close_peer(&session.pc).await; }
}
}},
Err(_) => log::error!("Create peer failed (details omitted)"),
@@ -846,13 +1069,50 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let mut desktop_ended = false;
for k in targets {
if let Some(old) = sessions.remove(&k) {
desktop_ended |= old.desktop;
if let Err(e) = old.pc.close().await { log::warn!("Close released peer failed: {}", e); }
desktop_ended |= old.role.is_desktop();
close_peer(&old.pc).await;
}
}
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
}
SignalingEvent::DesktopRequested(ice) => {
let mut sessions = webrtc_sessions.lock().await;
let Some(peer) = sessions.get(&ice).filter(|peer| !peer.role.is_desktop()) else { continue; };
if desktop_backend::headless() {
log::info!("Desktop request on a tool connection ignored: headless mode");
continue;
}
if portal_desktop.is_some() {
log::info!("Desktop request on a tool connection not supported with the Portal backend; open the desktop before port mapping");
continue;
}
let controller = peer.controller;
let current = peer.desktop_capture();
// Same recovery as a desktop offer: the display may have come up or been resized after this peer.
let resized = current.init_error.is_none() && current.backend == desktop_backend::DesktopBackend::X11
&& tokio::task::spawn_blocking(crate::capture::x11_size).await.ok().flatten().is_some_and(|size| size != (current.width, current.height));
if resized { log::info!("Desktop geometry changed since this connection opened; reinitializing capture"); }
let screen = if current.init_error.is_some() || resized {
match tokio::task::spawn_blocking(ScreenCapture::new).await {
Ok(Ok(screen)) => { capture = Arc::new(screen); Some(capture.clone()) },
Ok(Err(error)) => { log::info!("Desktop request on a tool connection ignored: {error}"); continue; },
Err(_) => { log::warn!("Desktop initialization worker failed"); continue; },
}
} else { None };
video::warm_auto_probe(); video::check_ffmpeg_usable();
input.set_controller(controller);
input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone()));
// One desktop at a time, as for a new desktop offer. Peers offered as desktops
// close; a promoted tool peer only stops its desktop and keeps its tools.
let superseded: Vec<String> = sessions.iter().filter(|(id, old)| id.as_str() != ice && old.role.is_desktop())
.map(|(id, _)| id.clone()).collect();
for id in superseded {
if sessions[&id].desktop { if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; } }
else { sessions[&id].demote(); }
}
if let Some(peer) = sessions.get(&ice) { peer.promote(screen); }
}
SignalingEvent::Disconnected => {
capture_types.clear();
next_capture_type=None;
+178 -19
View File
@@ -38,8 +38,16 @@ mod native {
fn uu_portal_move(portal: *mut c_void, x: f64, y: f64, relative: i32) -> i32;
fn uu_portal_button(portal: *mut c_void, button: i32, pressed: i32) -> i32;
fn uu_portal_key(portal: *mut c_void, keysym: u32, keycode: i32, pressed: i32) -> i32;
fn uu_portal_scroll(portal: *mut c_void, dx: f64, dy: f64, finish: i32) -> i32;
fn uu_portal_touch_supported(portal: *mut c_void) -> i32;
fn uu_portal_touch_available(portal: *mut c_void) -> i32;
fn uu_portal_touch(portal: *mut c_void, phase: i32, x: f64, y: f64) -> i32;
fn uu_portal_stream_position(portal: *mut c_void, x: *mut i32, y: *mut i32) -> i32;
fn uu_portal_monitors(out: *mut libc::c_char, length: usize) -> i32;
fn uu_portal_end(portal: *mut c_void);
}
struct Handle(NonNull<c_void>);
fn pack(width: u32, height: u32) -> u64 { (u64::from(width) << 32) | u64::from(height) }
// The engine owns callback threads; public calls are serialized by Mutex.
unsafe impl Send for Handle {}
impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } }
@@ -84,7 +92,7 @@ mod native {
was_locked.store(false, std::sync::atomic::Ordering::Release);
}
}
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, pub width: u32, pub height: u32 }
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>> }
impl Session {
fn take_lock_observation(&self) -> Result<bool, String> {
// A recovery in progress must see the lock even if another capture
@@ -99,7 +107,7 @@ mod native {
fn check_geometry(&self, replacement: &Self) -> Result<(), super::PortalError> {
// Encoder buffers use frame pixels. Logical geometry and EIS regions
// belong to the replacement handle and may change with scaling (#25).
if (self.width, self.height) != (replacement.width, replacement.height) {
if self.size() != replacement.size() {
Err(super::PortalError { code: 14 })
} else {
Ok(())
@@ -108,7 +116,10 @@ mod native {
pub fn is_alive(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
}
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>) -> Result<Self, super::PortalError> {
/// Opens a session for `monitor` (a Mutter connector) with that monitor's saved consent;
/// None means the screen currently selected, or the only monitor.
/// `fresh` asks the host again instead of restoring the saved consent (which stays saved).
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>, fresh: bool) -> Result<Self, super::PortalError> {
extern "C" fn is_cancelled(data: *mut c_void) -> i32 {
let cancelled = unsafe { &*(data as *const std::sync::atomic::AtomicBool) };
i32::from(cancelled.load(std::sync::atomic::Ordering::Acquire))
@@ -121,16 +132,19 @@ mod native {
let (mut error, mut width, mut height) = (0, 0, 0);
let directory = super::permissions::directory();
let key = super::permissions::desktop_key();
let token = directory.as_deref().and_then(|dir| super::permissions::take(dir, key))
.and_then(|value| std::ffi::CString::new(value).ok());
let mut cache = (directory, key);
let wanted = monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor);
// Each monitor has its own consent; the desktop-wide key is the single-monitor one.
let token = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
wanted.as_deref().and_then(|name| super::permissions::take(dir, &super::permissions::monitor_key(name)))
.or_else(|| super::permissions::take(dir, key))
}).and_then(|value| std::ffi::CString::new(value).ok());
// The new token is saved once the granted monitor is known (after open).
let mut cache: Option<String> = None;
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
// Callback is synchronous during open; cache lives through the call.
let result = std::panic::catch_unwind(|| unsafe {
let cache = &*(data as *const (Option<std::path::PathBuf>, &'static str));
if let (Some(dir), Ok(value)) = (cache.0.as_deref(), std::ffi::CStr::from_ptr(token).to_str()) {
if super::permissions::save(dir, cache.1, value).is_err() { log::warn!("Portal permission cache could not be saved"); }
}
let cache = &mut *(data as *mut Option<String>);
*cache = std::ffi::CStr::from_ptr(token).to_str().ok().map(str::to_owned);
});
if result.is_err() { log::warn!("Portal permission cache callback failed"); }
}
@@ -147,16 +161,77 @@ mod native {
}
};
let handle = NonNull::new(pointer).ok_or(super::PortalError { code: error })?;
let (mut x, mut y) = (0, 0);
let granted = (unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
.then(|| crate::wayland::portal_monitor_at(x, y)).flatten();
if let (Some(dir), Some(token)) = (directory.as_deref(), cache.take()) {
let saved = match &granted {
Some(name) => super::permissions::monitor_key(name),
None => key.to_owned(),
};
if super::permissions::save(dir, &saved, &token).is_err() { log::warn!("Portal permission cache could not be saved"); }
}
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
// A freshly opened session holds no lock-screen frame: only an observed lock (or a
// closed stream) must discard the cached frame. Starting "locked" cleared the first
// valid frame, and a static desktop sends no new one, so the viewer stayed black (#2).
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), width, height })
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted) })
}
/// Frame pixels of the monitor the stream currently follows.
pub fn size(&self) -> (u32, u32) {
let packed = self.size.load(std::sync::atomic::Ordering::Acquire);
((packed >> 32) as u32, packed as u32)
}
/// End the compositor session (screen-share indicator off); the next desktop
/// connection reopens it with the saved consent.
pub fn end(&self) {
if let Ok(handle) = self.handle.lock() { unsafe { uu_portal_end(handle.0.as_ptr()) }; }
}
/// Mutter connector of the monitor this session captures, when several are advertised.
pub fn monitor(&self) -> Option<String> { self.monitor.lock().ok().and_then(|m| m.clone()) }
/// Capture another monitor: open its own session (silently with saved consent; the first
/// time GNOME asks on the host) and swap it in, so every holder of this Arc follows.
pub fn switch_to(&self, connector: &str) -> Result<(), String> {
if self.monitor().as_deref() == Some(connector) { return Ok(()); }
let replacement = Self::open_inner(None, Some(connector), false).map_err(|error| error.to_string())?;
if replacement.monitor().as_deref() != Some(connector) {
return Err("Another monitor was shared; choose this monitor in the host dialog".into());
}
let size = replacement.size();
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
let previous = {
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
std::mem::replace(&mut *handle, next)
};
if let Ok(mut monitor) = self.monitor.lock() { *monitor = Some(connector.to_owned()); }
drop(previous);
Ok(())
}
pub fn open() -> Result<Self, String> {
Self::open_inner(None).map_err(|error| error.to_string())
Self::open_inner(None, None, false).map_err(|error| error.to_string())
}
/// A consent saved before touch support restores keyboard and pointer only. Ask the host once
/// more (GNOME shows its share dialog; the consent timeout closes it) and swap the new session
/// in when it grants the touchscreen for this monitor at this size; until then, and on any
/// refusal, this session and its saved consent stay as they are. Ok(false): nothing to do.
pub fn upgrade_touch(&self) -> Result<bool, String> {
let available = self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_touch_available(handle.0.as_ptr()) } != 0);
if !available || self.touch_supported() { return Ok(false); }
log::info!("Portal touch consent: asking the host again for the touchscreen");
let monitor = self.monitor();
let replacement = Self::open_inner(None, monitor.as_deref(), true).map_err(|error| error.to_string())?;
// The new consent is saved for whichever monitor was granted, so a later connection uses it.
if replacement.monitor() != monitor { return Err("another monitor was shared".into()); }
if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); }
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
let previous = std::mem::replace(&mut *self.handle.lock().map_err(|_| "Portal session lock poisoned")?, next);
drop(previous);
Ok(true)
}
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
Self::open_inner(Some(cancelled))
Self::open_inner(Some(cancelled), None, false)
}
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, super::PortalError> {
use std::sync::atomic::Ordering;
@@ -211,7 +286,9 @@ mod native {
self.capture_changed(frame, &mut None).map(|_| ())
}
pub fn capture_changed(&self, frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> Result<bool, String> {
if frame.len() != self.width as usize * self.height as usize * 4 { return Err(super::error(11)); }
let (width, height) = self.size();
// A buffer sized for the previous monitor belongs to an encoder that a switch is replacing.
if frame.len() != width as usize * height as usize * 4 { return Ok(blank_changed(frame, version)); }
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
// Drain EIS even on a static desktop so pause/disconnect and sync
// events are processed without waiting for remote input.
@@ -252,7 +329,7 @@ mod native {
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
false
}) { return Ok(None); }
let replacement = match Self::open_inner(None) {
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false) {
Ok(value) => value,
Err(error) => {
log::warn!("Portal capture recovery deferred: {error}");
@@ -319,6 +396,30 @@ mod native {
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_button(handle.0.as_ptr(), button, i32::from(pressed)) })
}
/// Press and release a keysym through Notify*: the compositor picks the key and level of
/// the active layout. Under EIS (keycodes only) it fails before typing anything.
pub fn type_keysym(&self, symbol: u32) -> Result<(), String> {
if *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, -1, 1) })?;
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, -1, 0) })
}
/// Smooth scroll in stream pixels (positive scrolls down/right); `finish` ends the gesture.
pub fn scroll(&self, dx: f64, dy: f64, finish: bool) -> Result<(), String> {
if *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_scroll(handle.0.as_ptr(), dx, dy, i32::from(finish)) })
}
/// The portal granted the touchscreen device type (requested where available).
pub fn touch_supported(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_touch_supported(handle.0.as_ptr()) } != 0)
}
/// One finger in stream pixels: phase 0 down, 1 motion, 2 up.
pub fn touch(&self, phase: i32, x: f64, y: f64) -> Result<(), String> {
if phase != 2 && *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_touch(handle.0.as_ptr(), phase, x, y) })
}
pub fn key(&self, symbol: u64, pressed: bool) -> Result<(), String> {
if pressed && *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let symbol = u32::try_from(symbol).map_err(|_| "Invalid Portal keysym")?;
@@ -328,6 +429,14 @@ mod native {
}
}
/// Mutter's monitors (GNOME); empty elsewhere.
pub fn monitors() -> Vec<super::Monitor> {
if crate::engine_plugin::load(crate::engine_plugin::Engine::Portal).is_err() { return Vec::new(); }
let mut text = vec![0u8; 8192];
if unsafe { uu_portal_monitors(text.as_mut_ptr() as *mut libc::c_char, text.len()) } <= 0 { return Vec::new(); }
let end = text.iter().position(|&b| b == 0).unwrap_or(text.len());
super::parse_monitors(&String::from_utf8_lossy(&text[..end]))
}
#[cfg(test)]
mod tests {
use super::*;
@@ -342,8 +451,8 @@ mod native {
locked,
was_locked: std::sync::atomic::AtomicBool::new(false),
recovery: Mutex::new(Recovery::default()),
width: physical.0,
height: physical.1,
size: pack(physical.0, physical.1).into(),
monitor: Mutex::new(None),
}))
}
@@ -605,6 +714,13 @@ pub use native::Session as PortalSession;
#[cfg(not(all(target_os = "linux", feature = "portal")))]
pub struct PortalSession { pub width: u32, pub height: u32 }
#[cfg(not(all(target_os = "linux", feature = "portal")))]
impl PortalSession {
pub fn size(&self) -> (u32, u32) { (self.width, self.height) }
pub fn monitor(&self) -> Option<String> { None }
pub fn end(&self) {}
pub fn switch_to(&self, _: &str) -> Result<(), String> { Err(error(15)) }
}
#[cfg(not(all(target_os = "linux", feature = "portal")))]
impl PortalSession {
pub fn clipboard_supported(&self) -> bool { false }
pub fn clipboard_ready(&self) -> bool { false }
@@ -625,13 +741,48 @@ impl PortalSession {
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 touch_supported(&self) -> bool { false }
pub fn scroll(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn upgrade_touch(&self) -> Result<bool, String> { Err(error(15)) }
pub fn type_keysym(&self, _: u32) -> Result<(), String> { Err(error(15)) }
pub fn touch(&self, _: i32, _: f64, _: f64) -> Result<(), String> { Err(error(15)) }
pub fn key(&self, _: u64, _: bool) -> Result<(), String> { Err(error(15)) }
}
/// The portal session that monitor switches act on: one per host, reused by reconnects.
static ACTIVE: std::sync::Mutex<Option<std::sync::Weak<PortalSession>>> = std::sync::Mutex::new(None);
pub fn permissions_directory() -> Option<std::path::PathBuf> { permissions::directory() }
pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connector) }
pub fn register(session: &Arc<PortalSession>) {
*ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session));
}
pub fn switch_active(connector: &str) -> Result<(), String> {
let session = ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade)
.ok_or("Portal desktop unavailable")?;
session.switch_to(connector)
}
pub struct Monitor { pub connector: String, pub width: u32, pub height: u32, pub x: i32, pub y: i32, pub primary: bool }
#[cfg(all(target_os = "linux", feature = "portal"))]
pub use native::monitors;
#[cfg(not(all(target_os = "linux", feature = "portal")))]
pub fn monitors() -> Vec<Monitor> { Vec::new() }
/// `connector\twidth\theight\tx\ty\tprimary` lines from the engine.
fn parse_monitors(text: &str) -> Vec<Monitor> {
text.lines().filter_map(|line| {
let mut f = line.split('\t');
let connector = f.next()?.to_owned();
let (width, height) = (f.next()?.parse().ok()?, f.next()?.parse().ok()?);
let (x, y, primary) = (f.next()?.parse().ok()?, f.next()?.parse().ok()?, f.next()? == "1");
(!connector.is_empty() && connector.len() <= 64 && connector.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_'))
.then_some(Monitor { connector, width, height, x, y, primary })
}).collect()
}
/// Forward frames in-process into encoder stdin. Cancellation drops the Arc;
/// the caller keeps one owning Arc for all subsequent desktop reconnects.
pub fn write_frames(session: Arc<PortalSession>, mut output: impl std::io::Write, cancelled: &std::sync::atomic::AtomicBool) -> Result<(), String> {
let length = (session.width as usize).checked_mul(session.height as usize).and_then(|n| n.checked_mul(4)).ok_or("Portal frame too large")?;
let (width, height) = session.size();
let length = (width as usize).checked_mul(height as usize).and_then(|n| n.checked_mul(4)).ok_or("Portal frame too large")?;
let mut frame = vec![0; length];
let interval = std::time::Duration::from_nanos(1_000_000_000 / crate::video::FPS);
while !cancelled.load(std::sync::atomic::Ordering::Acquire) {
@@ -645,13 +796,21 @@ pub fn write_frames(session: Arc<PortalSession>, mut output: impl std::io::Write
#[cfg(test)]
mod tests {
#[test]
fn monitor_lines_parse_and_reject_unsafe_connectors() {
let m = super::parse_monitors("eDP-1\t2880\t1800\t0\t0\t1\nHDMI-1\t2560\t1440\t1920\t0\t0\n../x\t1\t1\t0\t0\t0\n");
assert_eq!(m.len(), 2);
assert!(m[0].primary && m[0].connector == "eDP-1" && (m[1].width, m[1].x) == (2560, 1920));
}
#[test]
fn locked_frames_hide_old_content() { let mut frame = [42; 8]; super::blank(&mut frame); assert_eq!(frame, [0,0,0,255,0,0,0,255]); }
#[test]
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"));
// Portal builds name the missing runtime engine; other builds say how to get one.
let unavailable = super::check(15).unwrap_err();
assert!(unavailable.contains("--features wayland,portal") || (cfg!(feature = "portal") && unavailable.contains("engine unavailable")));
}
#[test]
fn portal_error_display_is_fixed_and_sanitized() {
+3
View File
@@ -23,6 +23,9 @@ pub fn desktop_key() -> &'static str {
if desktop.split(':').any(|v| v == "kde") { "kde" } else { "gnome" }
}
/// Consent for one monitor (Mutter connector); connectors are checked to be file-name safe.
pub fn monitor_key(connector: &str) -> String { format!("{}@{}", desktop_key(), connector) }
pub fn take(dir: &Path, key: &str) -> Option<String> {
let path = dir.join(key);
let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?;
+228
View File
@@ -0,0 +1,228 @@
//! 防窥模式 (privacy screen) on X11: the physical monitors go black while the stream keeps
//! showing the desktop. Official protocol (Mac UURemoteServer / Windows GameViewerServer maps):
//! Message 21 RpcRequest field 7 PrivateScreenSettingRequest { 1 enable, 2 privacy_type, 3 setting_source }
//! -> Message 22 RpcResponse field 3 PrivateScreenSettingResponse { 1 error_code, 2 req_privacy_type,
//! 3 cur_privacy_type }; PrivateScreenType 1 NOT_SET, 2 NORMAL_PRIVACY, 3 ENHANCED_PRIVACY (wallpaper).
//! Declared through FeatureFlag 4 ff_private_screen = INIT_VERION (1, normal privacy only) and
//! ff_system_metrics = SETTING_PRIVATE_SCREEN (3); SettingMetric 4 private_screen, 7 private_screen_type.
//! The official host answers cur_privacy_type from its saved type (NORMAL/ENHANCED, else NOT_SET).
//!
//! Linux has no capture-excluded overlay window, so the CRTC gamma ramps are zeroed instead
//! (`xrandr --brightness 0`): scanout turns black, the framebuffer the capture reads is unchanged.
//! The previous gamma/brightness is saved to a file first, so a restart restores a screen a crash left black.
use std::process::Command;
use std::sync::Mutex;
pub const FF_PRIVATE_SCREEN: u8 = 1;
pub const PS_NOT_SET: u64 = 1;
pub const PS_NORMAL: u64 = 2;
const PS_ENHANCED: u64 = 3;
const ERROR_FAILED: u64 = 1;
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
struct Output { name: String, gamma: String, brightness: String }
#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
struct Saved { display: String, outputs: Vec<Output> }
static ACTIVE: Mutex<Option<Saved>> = Mutex::new(None);
fn saved_path() -> std::path::PathBuf { crate::config::path().with_file_name("privacy_screen.json") }
/// Only the X11 engine can black out scanout without blacking out the capture.
pub fn supported() -> bool {
!cfg!(test) && !crate::desktop_backend::headless()
&& matches!(crate::desktop_backend::detect(), Ok(crate::desktop_backend::DesktopBackend::X11))
&& crate::capture::x11_display().is_some()
}
pub fn active() -> bool { ACTIVE.lock().map(|a| a.is_some()).unwrap_or(false) }
/// The saved type the viewer shows: NORMAL once privacy was used or chosen, else NOT_SET.
pub fn current_type() -> u64 {
if crate::system_actions::load_settings().privacy_screen_type == PS_NORMAL { PS_NORMAL } else { PS_NOT_SET }
}
fn xrandr(display: &str, args: &[String]) -> Result<String, String> {
let output = Command::new("xrandr").arg("--display").arg(display).args(args).output()
.map_err(|e| format!("xrandr unavailable: {}", e.kind()))?;
if !output.status.success() { return Err(format!("xrandr exited with {}", output.status)); }
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
/// Connected outputs that drive a CRTC (geometry WxH+X+Y on the header line), with their gamma.
fn parse_outputs(verbose: &str) -> Vec<Output> {
let mut outputs: Vec<Output> = Vec::new();
let mut current: Option<usize> = None;
for line in verbose.lines() {
if !line.starts_with([' ', '\t']) {
current = None;
let mut words = line.split_whitespace();
let (Some(name), Some("connected")) = (words.next(), words.next()) else { continue };
if words.take(2).any(|w| w.contains('x') && w.contains('+')) {
outputs.push(Output { name: name.into(), gamma: "1.0:1.0:1.0".into(), brightness: "1.0".into() });
current = Some(outputs.len() - 1);
}
} else if let Some(i) = current {
let line = line.trim();
if let Some(v) = line.strip_prefix("Gamma:") { outputs[i].gamma = v.trim().into(); }
if let Some(v) = line.strip_prefix("Brightness:") { outputs[i].brightness = v.trim().into(); }
}
}
// A black screen saved by a crashed run must not become the value restored later.
for output in &mut outputs {
if output.brightness.parse::<f64>().map_or(true, |b| !(b > 0.0)) { output.brightness = "1.0".into(); }
}
outputs
}
fn black_args(outputs: &[Output]) -> Vec<String> {
outputs.iter().flat_map(|o| ["--output".into(), o.name.clone(), "--brightness".into(), "0".into()]).collect()
}
fn restore_args(outputs: &[Output]) -> Vec<String> {
outputs.iter().flat_map(|o| ["--output".into(), o.name.clone(), "--gamma".into(), o.gamma.clone(),
"--brightness".into(), o.brightness.clone()]).collect()
}
fn turn_on() -> Result<(), String> {
let mut active = ACTIVE.lock().map_err(|_| "privacy state poisoned")?;
if active.is_some() { return Ok(()); }
let display = crate::capture::x11_display().ok_or("X11 display not open")?;
let outputs = parse_outputs(&xrandr(&display, &["--verbose".into()])?);
if outputs.is_empty() { return Err("no active output".into()); }
let saved = Saved { display, outputs };
std::fs::write(saved_path(), serde_json::to_vec(&saved).map_err(|e| e.to_string())?).map_err(|e| e.kind().to_string())?;
if let Err(e) = xrandr(&saved.display, &black_args(&saved.outputs)) {
let _ = xrandr(&saved.display, &restore_args(&saved.outputs));
let _ = std::fs::remove_file(saved_path());
return Err(e);
}
log::info!("Privacy screen on: outputs={}", saved.outputs.len());
*active = Some(saved);
Ok(())
}
/// Restores the monitors; also used on session end and shutdown. Blocking.
pub fn disable() {
let Ok(mut active) = ACTIVE.lock() else { return };
let Some(saved) = active.take() else { return };
match xrandr(&saved.display, &restore_args(&saved.outputs)) {
Ok(_) => { let _ = std::fs::remove_file(saved_path()); log::info!("Privacy screen off"); }
Err(e) => log::warn!("Privacy screen restore failed: {e}"),
}
}
/// At startup: a previous run that ended while private left the monitors black.
pub fn recover() {
let Ok(bytes) = std::fs::read(saved_path()) else { return };
match serde_json::from_slice::<Saved>(&bytes) {
Ok(saved) => match xrandr(&saved.display, &restore_args(&saved.outputs)) {
Ok(_) => { let _ = std::fs::remove_file(saved_path()); log::info!("Privacy screen left by a previous run restored"); }
Err(e) => log::warn!("Privacy screen left by a previous run not restored: {e}"),
},
Err(_) => { let _ = std::fs::remove_file(saved_path()); }
}
}
/// RpcRequest field 7 -> RpcResponse { 1 header, 3 PrivateScreenSettingResponse }. Blocking (xrandr).
pub fn rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
use crate::protocol::{decode_wire, WireValue};
let body = |n: u32| rpc.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Bytes(b)) if x == n => Some(*b), _ => None });
let request = decode_wire(body(7)?).ok()?;
let varint = |n: u32| request.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Varint(v)) if x == n => Some(*v), _ => None });
let (enable, requested) = (varint(1).unwrap_or(0) != 0, varint(2).unwrap_or(0));
let result = if requested == PS_ENHANCED {
Err("enhanced privacy (wallpaper) is not supported".to_owned())
} else if !supported() {
Err("privacy screen needs the X11 desktop".to_owned())
} else {
if requested == PS_NORMAL || enable {
if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_screen_type = PS_NORMAL) { log::warn!("Privacy type not saved: {e}"); }
}
if enable { turn_on() } else { disable(); Ok(()) }
};
let error = match result {
Ok(()) => 0,
Err(e) => { log::warn!("Privacy screen request failed: enable={enable} type={requested}: {e}"); ERROR_FAILED }
};
log::info!("Privacy screen request: enable={} type={} source={:?} error={}", enable, requested, varint(3), error);
let mut payload = Vec::new();
if error != 0 { payload.extend_from_slice(&[8, error as u8]); }
if requested != 0 { payload.push(16); varint_into(requested, &mut payload); }
payload.push(24); varint_into(current_type(), &mut payload);
let header = body(1).unwrap_or(&[]);
let mut out = vec![10];
varint_into(header.len() as u64, &mut out);
out.extend_from_slice(header);
out.push(26);
varint_into(payload.len() as u64, &mut out);
out.extend_from_slice(&payload);
Some(out)
}
pub fn is_request(rpc: &[crate::protocol::WireField]) -> bool { rpc.iter().any(|f| f.number == 7) }
fn varint_into(mut v: u64, out: &mut Vec<u8>) {
while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; }
out.push(v as u8);
}
#[cfg(test)]
mod tests {
use super::*;
const VERBOSE: &str = "Screen 0: minimum 8 x 8, current 4480 x 1440, maximum 32767 x 32767
HDMI-1 connected primary 2560x1440+0+0 (0x46) normal (normal left inverted right x axis y axis) 597mm x 336mm
\tIdentifier: 0x42
\tGamma: 1.0:1.0:1.0
\tBrightness: 1.0
2560x1440 (0x46) 241.500MHz +HSync -VSync *current +preferred
DP-1 connected 1920x1080+2560+0 (0x50) normal (normal left inverted right x axis y axis) 527mm x 296mm
\tGamma: 1.0:0.9:0.8
\tBrightness: 0.0
DP-2 connected (normal left inverted right x axis y axis)
\tGamma: 1.0:1.0:1.0
HDMI-2 disconnected (normal left inverted right x axis y axis)
";
#[test]
fn active_outputs_keep_gamma_and_a_black_brightness_is_not_saved() {
let outputs = parse_outputs(VERBOSE);
assert_eq!(outputs, vec![
Output { name: "HDMI-1".into(), gamma: "1.0:1.0:1.0".into(), brightness: "1.0".into() },
Output { name: "DP-1".into(), gamma: "1.0:0.9:0.8".into(), brightness: "1.0".into() },
]);
assert_eq!(black_args(&outputs[..1]), ["--output", "HDMI-1", "--brightness", "0"]);
assert_eq!(restore_args(&outputs[1..]), ["--output", "DP-1", "--gamma", "1.0:0.9:0.8", "--brightness", "1.0"]);
}
#[test]
fn settings_report_private_screen_on_and_its_type() {
use crate::system_metrics::{payload_with_settings, Permission::Allow, Settings};
let on = payload_with_settings(Allow, Allow, Allow, "", &Settings { private_screen: Some((true, PS_NORMAL)), ..Default::default() });
assert!(on.ends_with(&[34, 10, 32, 1, 56, 2, 64, 2, 72, 2, 80, 2]));
let unset = payload_with_settings(Allow, Allow, Allow, "", &Settings { private_screen: Some((false, PS_NOT_SET)), ..Default::default() });
assert!(unset.ends_with(&[34, 8, 56, 1, 64, 2, 72, 2, 80, 2]));
}
#[test]
fn unsupported_request_answers_failure_with_the_header() {
use crate::protocol::{decode_wire, WireValue};
// RpcRequest { 1 header{1:5}, 7 { 1 enable, 2 NORMAL, 3 source 1 } }
let rpc = [10, 2, 8, 5, 58, 6, 8, 1, 16, 2, 24, 1];
let fields = decode_wire(&rpc).unwrap();
assert!(is_request(&fields));
let out = rpc_response(&fields).unwrap();
let outer = decode_wire(&out).unwrap();
assert_eq!(outer[0].value, WireValue::Bytes(&[8, 5]));
let WireValue::Bytes(payload) = outer[1].value else { panic!("payload") };
assert_eq!(outer[1].number, 3);
let payload = decode_wire(payload).unwrap();
assert_eq!(payload[0].value, WireValue::Varint(ERROR_FAILED));
assert_eq!(payload[1].value, WireValue::Varint(PS_NORMAL));
assert_eq!(payload[2].number, 3);
assert!(!active());
}
}
+77
View File
@@ -56,6 +56,31 @@ impl SessionIce {
}
}
/// With `UU_USE_PROXY=1`, also gather TURN relays over TCP/TLS (through the HTTP proxy when
/// one is configured); hosts whose UDP cannot reach the TURN servers then still get a relay.
pub fn configure_relay_transport() {
if !crate::auth::proxy_enabled() { return; }
let value = ["HTTPS_PROXY", "https_proxy", "ALL_PROXY", "all_proxy"].iter().find_map(|name| std::env::var(name).ok()).filter(|v| !v.is_empty());
let proxy = match value.as_deref().map(relay_proxy) {
Some(Ok(proxy)) => Some(proxy),
Some(Err(reason)) => { log::warn!("TURN over TCP/TLS disabled: {reason}"); return; }
None => None,
};
log::info!("TURN over TCP/TLS enabled: via_http_proxy={}", proxy.is_some());
webrtc::ice::agent::turn_tcp::set_relay_transport(webrtc::ice::agent::turn_tcp::RelayTransport { http_proxy: proxy });
}
/// `host:port` of an unauthenticated HTTP proxy URL; never echoes the value.
fn relay_proxy(value: &str) -> Result<String, &'static str> {
let url = reqwest::Url::parse(&if value.contains("://") { value.to_owned() } else { format!("http://{value}") })
.map_err(|_| "invalid proxy URL")?;
if url.scheme() != "http" { return Err("only http:// proxies are supported for TURN"); }
if !url.username().is_empty() || url.password().is_some() { return Err("proxy authentication is not supported for TURN"); }
let host = url.host_str().ok_or("invalid proxy URL")?;
let port = url.port_or_known_default().ok_or("invalid proxy URL")?;
Ok(format!("{host}:{port}")) // host_str() keeps IPv6 brackets
}
#[cfg(test)]
mod tests {
use super::*;
@@ -74,4 +99,56 @@ mod tests {
assert_eq!(config.ice_servers.len(),1);
assert!(config.ice_servers[0].urls.iter().all(|s|s.starts_with("stun:")));
}
#[test]
fn relay_proxy_accepts_plain_http_only() {
assert_eq!(super::relay_proxy("http://proxy.invalid:8889").unwrap(), "proxy.invalid:8889");
assert_eq!(super::relay_proxy("proxy.invalid:8889/").unwrap(), "proxy.invalid:8889");
assert_eq!(super::relay_proxy("http://[::1]:3128").unwrap(), "[::1]:3128");
for bad in ["socks5://proxy.invalid:1080", "https://proxy.invalid:443", "http://user:[email protected]:8889", "::"] {
assert!(super::relay_proxy(bad).is_err());
}
}
#[test]
fn turn_tcp_frames_stun_and_padded_channel_data() {
use webrtc::ice::agent::turn_tcp::frame_len;
assert_eq!(frame_len([0x01, 0x01, 0x00, 0x08]), Some(28));
assert_eq!(frame_len([0x40, 0x00, 0x00, 0x05]), Some(12));
assert_eq!(frame_len([0x40, 0x00, 0x00, 0x08]), Some(12));
assert_eq!(frame_len([0x80, 0x00, 0x00, 0x00]), None);
assert!(webrtc::ice::agent::turn_tcp::is_http_reply(*b"HTTP"));
assert!(!webrtc::ice::agent::turn_tcp::is_http_reply([0x40, 0x00, 0x00, 0x05]));
}
#[tokio::test]
async fn turn_tcp_connects_through_the_proxy_and_frames_the_stream() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use webrtc::ice::agent::turn_tcp::{dial, set_relay_transport, RelayTransport};
use webrtc::util::Conn;
let proxy = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let proxy_addr = proxy.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut socket, _) = proxy.accept().await.unwrap();
let mut head = Vec::new();
while !head.ends_with(b"\r\n\r\n") { let mut b = [0u8; 1]; socket.read_exact(&mut b).await.unwrap(); head.push(b[0]); }
assert!(String::from_utf8_lossy(&head).starts_with("CONNECT 192.0.2.1:2483 HTTP/1.1\r\n"));
socket.write_all(b"HTTP/1.1 200 Connection established\r\n\r\n").await.unwrap();
let mut frames = [0u8; 20 + 12];
socket.read_exact(&mut frames).await.unwrap();
socket.write_all(&frames).await.unwrap();
});
set_relay_transport(RelayTransport { http_proxy: Some(proxy_addr.to_string()) });
let target: std::net::SocketAddr = "192.0.2.1:2483".parse().unwrap();
let conn = dial("192.0.2.1", 2483, target, false).await.unwrap();
let mut stun = [0u8; 20]; stun[1] = 0x01;
let channel = [0x40, 0x00, 0x00, 0x05, 1, 2, 3, 4, 5, 0, 0, 0];
conn.send_to(&stun, target).await.unwrap();
conn.send_to(&channel, target).await.unwrap();
let mut buf = [0u8; 64];
assert_eq!(conn.recv_from(&mut buf).await.unwrap(), (20, target));
assert_eq!(conn.recv_from(&mut buf).await.unwrap(), (12, target));
assert_eq!(&buf[..12], &channel);
server.await.unwrap();
}
}
+196 -45
View File
@@ -3,12 +3,22 @@
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::mpsc;
use tokio_tungstenite::connect_async;
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::Message;
/// A peer that stops reading must not park the heartbeat loop on a full queue.
/// Kept below the Engine.IO window so the protocol deadline still fires.
const SEND_STALL_TIMEOUT: Duration = Duration::from_secs(10);
// DNS/TCP/TLS/WebSocket upgrade must finish in bounded time: after a network
// change the handshake can stall forever and the reconnect loop never retries.
const CONNECT_TIMEOUT: Duration = Duration::from_secs(20);
/// How often the watchdog checks the last inbound frame.
const WATCHDOG_TICK: Duration = Duration::from_secs(1);
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoacMessage {
#[serde(rename = "type")]
@@ -41,11 +51,13 @@ pub enum SignalingEvent {
BeControlled(Value),
/// be-controlled with its binary app_data (ConnectOptions): capture type and the
/// ice_id it announces, when present.
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce, controller_mac: bool },
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce, controller: crate::input::Controller },
Soac(SoacMessage),
Released(Value),
Left(Value),
Disconnected,
/// capture_desktop on this tool peer (ice_id); raised by the peer, not by signaling.
DesktopRequested(String),
}
pub struct SignalingClient {
@@ -68,6 +80,11 @@ fn refreshed_key(ack:&Value)->Option<String> {
(!key.is_empty() && key.len()<=16384).then(||key.to_owned())
}
/// Deliver an event without letting a stalled consumer hide a dead socket.
async fn send_event(sender: &mpsc::Sender<SignalingEvent>, event: SignalingEvent) -> bool {
matches!(tokio::time::timeout(SEND_STALL_TIMEOUT, sender.send(event)).await, Ok(Ok(())))
}
#[cfg(test)]
mod refresh_tests {
use super::refreshed_key;
@@ -126,6 +143,95 @@ mod refresh_tests {
assert!(disconnected.is_ok(),"a socket without pings must be reported dead");
drop(hold_tx);
}
#[tokio::test]
async fn blocked_event_consumer_does_not_hide_a_dead_socket() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
let (closed_tx,closed_rx)=tokio::sync::oneshot::channel::<()>();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// Shortest accepted window (clamped to 5 s); never ping, only events.
sink.send(Message::Text(r#"0{"pingInterval":1000,"pingTimeout":1000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>match r {
None|Some(Err(_))|Some(Ok(Message::Close(_)))=>{let _=closed_tx.send(());return;}
_=>{}
},
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err() {
let _=closed_tx.send(());return;
}
}
}
}
});
// Capacity 1 and no reader: the first event fills the queue, so the
// receive loop would park inside `send().await` without the watchdog.
let (sender,_events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
let closed=tokio::time::timeout(std::time::Duration::from_secs(15),closed_rx).await;
assert!(closed.is_ok(),"a blocked consumer must not keep a dead signaling socket open");
}
#[tokio::test]
async fn stalled_handshake_times_out() {
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
// Accepts TCP but never answers the upgrade, like a stalled path after a network change.
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
tokio::spawn(async move {
let (_tcp,_)=listener.accept().await.unwrap();
tokio::time::sleep(std::time::Duration::from_secs(30)).await;
});
let req=format!("ws://{address}/socket.io/").into_client_request().unwrap();
let result=tokio::time::timeout(std::time::Duration::from_secs(5),super::open_socket(req,std::time::Duration::from_secs(1))).await;
assert!(matches!(result,Ok(Err(_))),"a stalled handshake must fail within the connect timeout");
}
#[tokio::test]
async fn stalled_event_delivery_still_reports_disconnected() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// A long window: the send stall must fire before the heartbeat deadline.
sink.send(Message::Text(r#"0{"pingInterval":30000,"pingTimeout":30000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>{ if matches!(r,None|Some(Err(_))|Some(Ok(Message::Close(_)))){return} }
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err(){return}
}
}
}
});
let (sender,mut events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
// Let SEND_STALL_TIMEOUT expire while nothing drains the queue.
tokio::time::sleep(std::time::Duration::from_secs(12)).await;
assert!(matches!(events.recv().await,Some(super::SignalingEvent::Connected)));
let disconnected=tokio::time::timeout(std::time::Duration::from_secs(5),events.recv()).await;
assert!(matches!(disconnected,Ok(Some(super::SignalingEvent::Disconnected))),"a stalled delivery must still report Disconnected");
}
}
async fn open_socket(
req: tokio_tungstenite::tungstenite::handshake::client::Request,
limit: Duration,
) -> Result<crate::ws_transport::Socket, String> {
crate::ws_transport::connect(req, limit).await
}
impl SignalingClient {
@@ -149,24 +255,30 @@ impl SignalingClient {
room_token.parse().map_err(|_| "Invalid token header")?,
);
let (ws_stream, _) = connect_async(req)
.await
.map_err(|e| format!("WS connect failed: {}", e))?;
let ws_stream = open_socket(req, CONNECT_TIMEOUT).await?;
log::info!("Connected to Engine.IO / Socket.IO");
let (mut write, mut read) = ws_stream.split();
let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<String>(32);
let started = Instant::now();
let last_rx = Arc::new(AtomicU64::new(0));
let ping_window_ms = Arc::new(AtomicU64::new(45_000));
let receiver_done = Arc::new(AtomicBool::new(false));
// 发送协程
let writer=tokio::spawn(async move {
while let Some(msg) = rx_outgoing.recv().await {
if let Err(e) = write.send(Message::Text(msg)).await {
let _ = e;
log::warn!("WS send failed (details omitted)");
break;
match tokio::time::timeout(SEND_STALL_TIMEOUT, write.send(Message::Text(msg))).await {
Ok(Ok(())) => {}
Ok(Err(_)) | Err(_) => {
// A peer that stopped reading must not park every producer.
log::warn!("WS send failed or stalled (details omitted)");
break;
}
}
}
});
let writer_abort = writer.abort_handle();
let tx_out_clone = tx_outgoing.clone();
static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
@@ -175,9 +287,12 @@ impl SignalingClient {
let refreshed=reconnect_key.clone();
// 接收与状态机协程
tokio::spawn(async move {
let watchdog_events = event_sender.clone();
let watchdog_last_rx = last_rx.clone();
let watchdog_ping_window_ms = ping_window_ms.clone();
let watchdog_done = receiver_done.clone();
let receiver = tokio::spawn(async move {
let mut req_counter = 10;
let started=std::time::Instant::now();
let mut last_ping=started;
let mut pings=0u64;
let mut pong_queued=0u64;
@@ -200,7 +315,7 @@ impl SignalingClient {
_=event_sender.closed()=>break,
_=tokio::time::sleep_until(ping_deadline) => {
log::warn!("Signaling heartbeat lost: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
},
// Official ControlledSession RefreshSignalTokenLoop: first
@@ -211,8 +326,8 @@ impl SignalingClient {
refresh_acks.push_back(req_counter);
if refresh_acks.len()>16 { refresh_acks.pop_front(); }
let packet=format!("42{}[\"refresh_reconnect_key\"]",req_counter);
if tx_out_clone.send(packet).await.is_err() {
let _=event_sender.send(SignalingEvent::Disconnected).await;break;
if tx_out_clone.try_send(packet).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(30);
log::info!("Signaling reconnect-key refresh requested: generation={} age_s={}",generation,started.elapsed().as_secs());
@@ -220,9 +335,14 @@ impl SignalingClient {
},
msg=read.next()=>match msg {
Some(msg)=>msg,
None=>{let _=event_sender.send(SignalingEvent::Disconnected).await;break;}
None=>{let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;}
},
};
// Any inbound frame proves the socket is alive. A reader parked on
// event delivery stops updating this, which the watchdog catches.
if msg_res.is_ok() {
last_rx.store(started.elapsed().as_millis() as u64, Ordering::Relaxed);
}
match msg_res {
Ok(Message::Text(txt)) => {
// Engine.IO 报文处理
@@ -231,16 +351,20 @@ impl SignalingClient {
log::info!("Signaling heartbeat config: generation={} ping_interval_ms={:?} ping_timeout_ms={:?}",generation,open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64));
if let (Some(interval),Some(timeout))=(open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64)) {
ping_window=std::time::Duration::from_millis(interval.saturating_add(timeout).clamp(5_000,300_000));
ping_window_ms.store(ping_window.as_millis() as u64, Ordering::Relaxed);
ping_deadline=tokio::time::Instant::now()+ping_window;
}
}
// Open packet -> 发送 Socket.IO connect
let _ = tx_out_clone.send("40".into()).await;
if tx_out_clone.try_send("40".into()).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
} else if txt == "2" {
// Ping -> 回复 Pong
let gap=last_ping.elapsed().as_secs();last_ping=std::time::Instant::now();pings+=1;
ping_deadline=tokio::time::Instant::now()+ping_window;
if tx_out_clone.send("3".into()).await.is_ok() { pong_queued+=1; }
if tx_out_clone.try_send("3".into()).is_ok() { pong_queued+=1; }
else { let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break; }
if pings==1 || pings%12==0 {
log::info!("Signaling heartbeat progress: generation={} age_s={} pings={} pong_queued={} gap_s={}",generation,started.elapsed().as_secs(),pings,pong_queued,gap);
}
@@ -250,8 +374,10 @@ impl SignalingClient {
// Socket.IO connected -> 发送 room_info 请求
req_counter += 1;
let room_req = format!("42{}[\"room_info\"]", req_counter);
let _ = tx_out_clone.send(room_req).await;
let _ = event_sender.send(SignalingEvent::Connected).await;
if tx_out_clone.try_send(room_req).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
if !send_event(&event_sender, SignalingEvent::Connected).await { break; }
} else if txt.starts_with("43") {
// Socket.IO ack 回调
let begin=txt.find('[').unwrap_or(2);
@@ -270,7 +396,7 @@ impl SignalingClient {
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(300);
}
log::info!("Signaling reconnect-key refresh acknowledged: generation={} age_s={} success={}",generation,started.elapsed().as_secs(),success);
} else { let _ = event_sender.send(SignalingEvent::RoomInfoAck(v)).await; }
} else if !send_event(&event_sender, SignalingEvent::RoomInfoAck(v)).await { break; }
}
} else if txt.starts_with("45") || txt.starts_with("46") {
// Socket.IO binary event/ack: header text, attachments follow as binary frames.
@@ -294,14 +420,10 @@ impl SignalingClient {
match event_name {
"bmsg_push" => {
let _ = event_sender
.send(SignalingEvent::DeviceInfoChanged(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::DeviceInfoChanged(data.clone())).await { break; }
}
"be-controlled" => {
let _ = event_sender
.send(SignalingEvent::BeControlled(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::BeControlled(data.clone())).await { break; }
}
"soac" => {
// Offers only: structure (keys, types, lengths), never SDP text or ids.
@@ -324,9 +446,7 @@ impl SignalingClient {
if soac.client_id.is_none() {
soac.client_id = client_id_opt;
}
let _ = event_sender
.send(SignalingEvent::Soac(soac))
.await;
if !send_event(&event_sender, SignalingEvent::Soac(soac)).await { break; }
}
Err(e) => {
let _ = e;
@@ -336,20 +456,17 @@ impl SignalingClient {
}
"released" => {
log::info!("Cloud peer event: generation={} event=released age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let _ = event_sender
.send(SignalingEvent::Released(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::Released(data.clone())).await { break; }
}
"left" | "leave" => {
log::info!("Cloud peer event: generation={} event={} age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,event_name,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let ice_id = data.get("ice_id").and_then(|v| v.as_str()).unwrap_or("");
if ice_id.is_empty() {
log::info!("Cloud room leave shape: {}", crate::protocol::json_shape(data, 3));
log::warn!("Cloud room leave without peer identifier; renewing signaling (expiry cause unknown)");
let _ = event_sender.send(SignalingEvent::Disconnected).await;
if !send_event(&event_sender, SignalingEvent::Disconnected).await { break; }
} else {
let _ = event_sender
.send(SignalingEvent::Left(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::Left(data.clone())).await { break; }
}
}
_ => {
@@ -396,31 +513,62 @@ impl SignalingClient {
if !caps.is_empty() { log::info!("Viewer decoder caps (fps,codec,w,h,chroma fields): {:?}", caps); }
// Viewer platform (website enum: 1 windows, 2 android, 3 ios, 4 macos, 5 tv).
let platform = header.get("controller_platform").or_else(|| header.get("data").and_then(|d| d.get("controller_platform")));
let controller_mac = platform.is_some_and(|v| v.as_i64() == Some(4)
|| v.as_str().is_some_and(|s| s == "4" || s.to_ascii_lowercase().contains("mac") || s.to_ascii_lowercase().contains("darwin")));
log::info!("Controller platform: {} mac={}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller_mac);
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await;
let controller = crate::input::Controller::from_platform(platform);
log::info!("Controller platform: {} controller={:?}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller);
if !send_event(&event_sender, SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller }).await { break; }
}
}
}
Ok(Message::Close(frame)) => {
log::warn!("Signaling socket closed: generation={} age_s={} close_code={:?} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),frame.map(|f|u16::from(f.code)),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
}
Err(_) => {
log::warn!("Signaling socket receive failed: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
}
_ => {}
}
}
// A stalled event queue or a writer that already stopped can end this
// loop without a delivered Disconnected. Hand one off from a detached
// task so the main loop always learns the room is dead; duplicates are
// harmless because it breaks on the first one.
let events = event_sender.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_done.store(true, Ordering::Relaxed);
log::info!("Signaling receiver stopped: generation={} age_s={}",generation,started.elapsed().as_secs());
// Live peer callbacks can retain the old SignalingClient sender.
// Explicitly drop its write half too when this room stops reading.
writer.abort();
});
let receiver_abort = receiver.abort_handle();
// Independent of the receive loop: a consumer that stops draining events
// parks the loop inside an `.await`, where the ping deadline can no longer
// be observed. The watchdog closes the socket anyway.
tokio::spawn(async move {
let mut tick = tokio::time::interval(WATCHDOG_TICK);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
tick.tick().await;
if watchdog_done.load(Ordering::Relaxed) || watchdog_events.is_closed() { return; }
let window_ms = watchdog_ping_window_ms.load(Ordering::Relaxed);
let idle_ms = (started.elapsed().as_millis() as u64)
.saturating_sub(watchdog_last_rx.load(Ordering::Relaxed));
if idle_ms <= window_ms { continue; }
log::warn!("Signaling heartbeat lost (watchdog): idle_s={} window_ms={}", idle_ms/1000, window_ms);
// Deliver from a detached task: the receiver may be the one parked
// on a full queue, and the main loop still needs this event.
let events = watchdog_events.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_abort.abort();
writer_abort.abort();
return;
}
});
Ok(Self { tx_outgoing, _reconnect_key:reconnect_key })
}
@@ -428,7 +576,10 @@ impl SignalingClient {
pub async fn emit_event(&self, event: &str, payload: serde_json::Value) -> Result<(), String> {
let packet = format!("42{}", serde_json::json!([event, payload]));
log::info!("Emitting signaling event: {}", event);
self.tx_outgoing.send(packet).await.map_err(|e| e.to_string())
tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(packet))
.await
.map_err(|_| "signaling send stalled".to_string())?
.map_err(|e| e.to_string())
}
/// 发送 SOAC 消息(Answer 或 Candidate)
@@ -443,9 +594,9 @@ impl SignalingClient {
};
let msg = format!("42[\"soac\",{}]", payload);
log::info!("Emitting soac packet: type={}", soac.msg_type);
self.tx_outgoing
.send(msg)
tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(msg))
.await
.map_err(|_| "Send soac timed out".to_string())?
.map_err(|e| format!("Send soac error: {}", e))
}
}
+165 -12
View File
@@ -12,6 +12,8 @@ pub const FF_SIMPLE_ACTION: u8 = 2;
pub const FF_SYSTEM_METRICS: u8 = 2;
pub const SHOW_DESKTOP: u64 = 2;
/// Opens the desktop on an existing connection (the viewer's port mapping reuses its peer, #99).
pub const CAPTURE_DESKTOP: u64 = 4;
pub const REBOOT_SYSTEM: u64 = 9;
pub const LOCK_SYSTEM: u64 = 10;
pub const SHUTDOWN_SYSTEM: u64 = 12;
@@ -25,11 +27,29 @@ pub const SET_AUTO_LOCK: u64 = 19;
/// Host settings from the viewer's 安全 menu. The viewer sends them only when a switch is toggled
/// and shows what SystemMetrics reports, so they are host-wide and persisted (like the official
/// host), not per connection: a reconnect must still lock / mute.
#[derive(Debug, Default, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
struct Settings {
#[derive(Debug, Default, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub(crate) struct Settings {
#[serde(default)] auto_lock: bool,
#[serde(default)] keep_mute: bool,
#[serde(default)] mute_permanent: bool,
/// 防窥 type the viewer chose (privacy_screen::PS_NORMAL), 0 = never set.
#[serde(default)] pub(crate) privacy_screen_type: u64,
/// "auto" or absent does not override the environment. A non-string value becomes None so a bad
/// video field cannot drop auto_lock / mute when the document is loaded.
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_encoder: Option<String>,
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option<String>,
}
fn lenient_string<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Option<String>, D::Error> {
use serde::Deserialize;
match Option::<serde_json::Value>::deserialize(deserializer)? {
Some(serde_json::Value::String(s)) => Ok(Some(s)),
Some(_) => {
log::warn!("Ignoring non-string video_encoder/video_codec in host settings");
Ok(None)
}
None => Ok(None),
}
}
struct HostState {
@@ -39,22 +59,83 @@ struct HostState {
desktop_sessions: usize,
}
fn settings_path() -> std::path::PathBuf { crate::config::path().with_file_name("host_settings.json") }
pub(crate) fn settings_path() -> std::path::PathBuf { crate::config::path().with_file_name("host_settings.json") }
pub(crate) fn load_settings() -> Settings {
std::fs::read(settings_path()).ok().and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default()
}
/// Re-read, apply `patch`, write via a temp file and rename (mode 0600).
pub(crate) fn merge_save(patch: impl FnOnce(&mut Settings)) -> Result<Settings, String> {
merge_write(patch)?;
let settings = load_settings();
if let Ok(mut guard) = state().lock() { guard.settings = settings.clone(); }
Ok(settings)
}
fn state() -> &'static Mutex<HostState> {
static STATE: std::sync::OnceLock<Mutex<HostState>> = std::sync::OnceLock::new();
STATE.get_or_init(|| {
let settings = std::fs::read(settings_path()).ok()
.and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default();
let settings = load_settings();
Mutex::new(HostState { settings, restore: None, desktop_sessions: 0 })
})
}
fn save(settings: &Settings) {
/// Re-read, copy only the security switches from `settings`, keep video_* from disk.
fn save(settings: &Settings) -> Result<(), String> {
merge_write(|disk| {
disk.auto_lock = settings.auto_lock;
disk.keep_mute = settings.keep_mute;
disk.mute_permanent = settings.mute_permanent;
})
}
/// Held across read-patch-write-rename so set-* and a security-toggle save cannot clobber each other.
struct SettingsLock { file: std::fs::File }
impl SettingsLock {
fn acquire(path: &std::path::Path) -> Result<Self, String> {
use std::os::unix::fs::OpenOptionsExt;
let lock_path = path.with_file_name("host_settings.json.lock");
let file = std::fs::OpenOptions::new().read(true).write(true).create(true).mode(0o600).open(&lock_path).map_err(|e| e.kind().to_string())?;
let rc = unsafe { libc::flock(std::os::unix::io::AsRawFd::as_raw_fd(&file), libc::LOCK_EX) };
if rc != 0 { return Err(std::io::Error::last_os_error().kind().to_string()); }
Ok(Self { file })
}
}
impl Drop for SettingsLock {
fn drop(&mut self) {
unsafe { libc::flock(std::os::unix::io::AsRawFd::as_raw_fd(&self.file), libc::LOCK_UN); }
}
}
/// NotFound starts from defaults. Any other read or parse error leaves the file untouched:
/// a bad document must not be rewritten with security switches forced off.
fn read_for_merge(path: &std::path::Path) -> Result<Settings, String> {
match std::fs::read(path) {
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Settings::default()),
Err(e) => Err(format!("host settings unreadable: {}", e.kind())),
// serde_json::Error's Display quotes the offending value; the journal and set-* must not.
Ok(bytes) => serde_json::from_slice(&bytes).map_err(|e| match (e.line(), e.column()) {
(0, 0) => "host_settings.json is not valid".to_owned(),
(line, column) => format!("host_settings.json is not valid (line {line}, column {column})"),
}),
}
}
fn merge_write(patch: impl FnOnce(&mut Settings)) -> Result<(), String> {
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
let path = settings_path();
let result = serde_json::to_vec_pretty(settings).map_err(|e| e.to_string())
.and_then(|json| std::fs::write(&path, json).map_err(|e| e.to_string()));
if let Err(e) = result { log::warn!("Host settings not saved: {}", e); }
if let Some(dir) = path.parent() { std::fs::create_dir_all(dir).map_err(|e| e.kind().to_string())?; }
let _lock = SettingsLock::acquire(&path)?;
let mut disk = read_for_merge(&path)?;
patch(&mut disk);
let json = serde_json::to_vec_pretty(&disk).map_err(|e| e.to_string())?;
let tmp = path.with_extension(format!("json.{}.tmp", std::process::id()));
let mut file = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(&tmp).map_err(|e| e.kind().to_string())?;
file.write_all(&json).map_err(|e| e.kind().to_string())?;
std::fs::rename(&tmp, &path).map_err(|e| e.kind().to_string())?;
Ok(())
}
/// Handle for one desktop connection (system actions are host-wide).
@@ -142,7 +223,7 @@ impl PeerActions {
_ => {}
}
let mut state = state().lock().unwrap();
let before = state.settings;
let before = state.settings.clone();
match action {
// 静音运行 on: the viewer sends MUTE_SYSTEM + MUTE_TEMPORARY (observed), off: MUTE_RESTORE.
MUTE_SYSTEM | MUTE_TEMPORARY => {
@@ -172,7 +253,7 @@ impl PeerActions {
}
_ => return false,
}
if state.settings != before { save(&state.settings); }
if state.settings != before { if let Err(e) = save(&state.settings) { log::warn!("Host settings not saved: {e}"); } }
true
}
@@ -194,6 +275,7 @@ impl PeerActions {
let mut state = state().lock().unwrap();
state.desktop_sessions = state.desktop_sessions.saturating_sub(1);
if state.desktop_sessions > 0 { return; }
crate::privacy_screen::disable();
crate::virtual_audio::disable();
if !state.settings.mute_permanent { restore_mute(&mut state); }
if state.settings.auto_lock {
@@ -205,9 +287,10 @@ impl PeerActions {
pub fn metrics_payload(&self, sound: bool, desktop: crate::system_metrics::Permission) -> Vec<u8> {
use crate::system_metrics::payload_with_settings;
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
let current = state().lock().unwrap().settings;
let current = state().lock().unwrap().settings.clone();
payload_with_settings(desktop, desktop, desktop, &home, &crate::system_metrics::Settings {
sound, keep_mute: current.keep_mute, mute_permanent: current.mute_permanent, auto_lock: current.auto_lock,
private_screen: crate::privacy_screen::supported().then(|| (crate::privacy_screen::active(), crate::privacy_screen::current_type())),
})
}
}
@@ -274,6 +357,76 @@ mod tests {
assert!(plugin_response(&decode_wire(&[10, 2, 8, 9]).unwrap()).is_none());
}
#[test]
fn merge_save_keeps_security_fields_and_mode() {
let _guard = crate::config::test_env_lock().lock().unwrap();
let dir = std::env::temp_dir().join(format!("uu-settings-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let cfg = dir.join("config.json");
std::env::set_var("UU_CONFIG", &cfg);
let path = settings_path();
std::fs::write(&path, br#"{"auto_lock":true,"keep_mute":true,"mute_permanent":false}"#).unwrap();
let saved = merge_save(|s| s.video_encoder = Some("vaapi".into())).unwrap();
assert!(saved.auto_lock && saved.keep_mute && !saved.mute_permanent);
assert_eq!(saved.video_encoder.as_deref(), Some("vaapi"));
let again = merge_save(|s| s.video_codec = Some("h264".into())).unwrap();
assert_eq!(again.video_encoder.as_deref(), Some("vaapi"));
assert_eq!(again.video_codec.as_deref(), Some("h264"));
assert!(again.auto_lock);
let mode = { use std::os::unix::fs::PermissionsExt; std::fs::metadata(&path).unwrap().permissions().mode() & 0o777 };
assert_eq!(mode, 0o600);
// A mute/lock save must not drop video_* written after the in-memory copy was taken.
let mut memory = load_settings();
std::fs::write(&path, br#"{"auto_lock":true,"keep_mute":true,"mute_permanent":false,"video_encoder":"nvenc","video_codec":"h265"}"#).unwrap();
memory.keep_mute = false;
save(&memory).unwrap();
let disk: serde_json::Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
assert_eq!(disk["video_encoder"], "nvenc");
assert_eq!(disk["video_codec"], "h265");
assert_eq!(disk["keep_mute"], false);
assert_eq!(disk["auto_lock"], true);
// A non-string video field must not fail the whole document (security switches survive).
std::fs::write(&path, br#"{"auto_lock":true,"keep_mute":false,"mute_permanent":true,"video_encoder":1,"video_codec":{"x":1}}"#).unwrap();
let loaded = load_settings();
assert!(loaded.auto_lock && !loaded.keep_mute && loaded.mute_permanent);
assert!(loaded.video_encoder.is_none() && loaded.video_codec.is_none());
merge_save(|s| s.video_encoder = Some("cpu".into())).unwrap();
let disk: serde_json::Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
assert_eq!(disk["auto_lock"], true);
assert_eq!(disk["mute_permanent"], true);
assert_eq!(disk["video_encoder"], "cpu");
let _ = std::fs::remove_dir_all(&dir);
std::env::remove_var("UU_CONFIG");
}
#[test]
fn merge_write_refuses_malformed_or_unreadable_settings() {
let _guard = crate::config::test_env_lock().lock().unwrap();
let dir = std::env::temp_dir().join(format!("uu-settings-bad-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::env::set_var("UU_CONFIG", dir.join("config.json"));
let path = settings_path();
let malformed = br#"{"auto_lock":true, "keep_mute":"#;
std::fs::write(&path, malformed).unwrap();
let err = merge_write(|s| s.video_encoder = Some("cpu".into())).unwrap_err();
assert!(err.contains("not valid"), "{err}");
assert_eq!(std::fs::read(&path).unwrap(), malformed);
let bad_type = br#"{"auto_lock":"yes","keep_mute":false,"mute_permanent":false}"#;
std::fs::write(&path, bad_type).unwrap();
let err = merge_write(|s| s.video_codec = Some("h265".into())).unwrap_err();
assert!(err.contains("not valid"), "{err}");
assert!(err.contains("line ") && err.contains("column "), "{err}");
assert!(!err.contains("yes"), "{err}");
assert_eq!(std::fs::read(&path).unwrap(), bad_type);
std::fs::remove_file(&path).unwrap();
std::fs::create_dir(&path).unwrap();
let err = merge_write(|s| s.video_encoder = Some("cpu".into())).unwrap_err();
assert!(err.contains("unreadable"), "{err}");
assert!(path.is_dir());
let _ = std::fs::remove_dir_all(&dir);
std::env::remove_var("UU_CONFIG");
}
#[test]
fn args_shape_never_contains_values() {
let shape = args_shape(br#"{"enable":true,"secret":"abc"}"#);
assert!(shape.contains("enable") && !shape.contains("abc"));
+6 -3
View File
@@ -25,20 +25,23 @@ pub fn payload_with_location(capture: Permission, operation: Permission, control
}
/// Optional host settings the viewer shows in 声音 / 安全 (SettingMetric 1 keep_mute,
/// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support).
/// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support), and 防窥 when the host
/// supports it (SettingMetric 4 private_screen on, 7 private_screen_type).
#[derive(Debug, Default, Clone, Copy)]
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool }
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool, pub private_screen: Option<(bool, u64)> }
pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec<u8> {
let mut setting = Vec::new();
for (field, on) in [(1u8, settings.keep_mute), (2, settings.mute_permanent), (3, settings.auto_lock)] {
if on { setting.push(field << 3); setting.push(1); }
}
if let Some((true, _)) = settings.private_screen { setting.extend_from_slice(&[4 << 3, 1]); }
if !location.is_empty() {
setting.push(5 << 3 | 2);
varint(location.len() as u64, &mut setting);
setting.extend_from_slice(location.as_bytes());
}
if let Some((_, kind)) = settings.private_screen { setting.push(7 << 3); varint(kind, &mut setting); }
for (field, state) in [(8u8, capture), (9u8, operation), (10u8, control)] {
if state != Permission::Unknown {
setting.push(field << 3);
@@ -48,7 +51,7 @@ pub fn payload_with_settings(capture: Permission, operation: Permission, control
// SystemMetrics.general: system_sound_support = SS_SUPPORT (2) when desktop audio is streamed
// (GvPb_SystemSoundSupport: 0 unknown, 1 nonsupport, 2 support).
let mut out = if settings.sound { vec![26, 2, 16, 2] } else { vec![26, 0] };
// No support_touch, sound capability, win_os_ver, private-screen, virtual
// No support_touch, sound capability, win_os_ver, virtual
// mouse, auto-lock, file path or optional feature claims are fabricated.
out.push(34); // SystemMetrics.setting field 4
varint(setting.len() as u64, &mut out);
+449 -104
View File
@@ -1,8 +1,12 @@
#[cfg(test)]
#[path = "video_wake_tests.rs"]
mod wake_tests;
use std::collections::HashMap;
use std::ffi::OsString;
use std::path::PathBuf;
use std::sync::{Arc, Mutex, OnceLock};
use std::sync::atomic::AtomicBool;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::time::{Duration, Instant};
use tokio::io::AsyncReadExt;
use tokio::process::Command;
@@ -177,16 +181,9 @@ impl CompleteFrame {
const RTP_CLOCK: u64 = 90_000;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub(crate) enum Encoder { Cpu, Nvenc, Vaapi }
impl Encoder {
pub(crate) fn requested() -> Self { Self::from_setting(std::env::var("UU_VIDEO_ENCODER").ok().as_deref(), nvidia_present()) }
/// Unset/auto tries NVENC only with an NVIDIA driver loaded: `ffmpeg -encoders` lists h264_nvenc
/// on any machine, so without this every stream start first ran a doomed NVENC process (#10).
fn from_setting(value: Option<&str>, nvidia: bool) -> Self {
match value { Some("cpu") => Self::Cpu, Some("vaapi") => Self::Vaapi, Some("nvenc") => Self::Nvenc,
_ => if nvidia { Self::Nvenc } else { Self::Cpu } }
}
pub(crate) fn name_for(self, codec: VideoCodec) -> &'static str {
match (self, codec) {
(Self::Cpu, VideoCodec::H264) => "libx264", (Self::Cpu, VideoCodec::H265) => "libx265",
@@ -195,14 +192,12 @@ impl Encoder {
}
}
}
fn nvidia_present() -> bool {
pub(crate) fn nvidia_present() -> bool {
std::path::Path::new("/proc/driver/nvidia/version").exists() || std::path::Path::new("/dev/nvidia0").exists()
}
/// 真彩 (4:4:4): NVENC (in-process or FFmpeg) and libx264; h264_vaapi is 4:2:0 only.
/// A GPU without 4:4:4 NVENC falls back to libx264, which keeps 4:4:4.
pub fn full_chroma_available() -> bool {
Encoder::requested() != Encoder::Vaapi
}
pub(crate) fn full_chroma_for(encoder: Encoder) -> bool { encoder != Encoder::Vaapi }
/// (-profile:v, -pix_fmt) for NVENC / libx264 / libx265: 4:4:4 (真彩) needs a 4:4:4 profile.
fn chroma_args(settings: &VideoSettings, encoder: Encoder) -> (&'static str, &'static str) {
@@ -262,10 +257,29 @@ fn cpu_hevc_options(settings: &VideoSettings, gop: &str) -> Vec<String> {
/// NVENC converts packed RGB on the GPU (BT.601 limited range, tagged bt470bg like the swscale default;
/// compared on the 3090), so 4:2:0 without scaling skips the CPU BGRA→YUV pass (#16: ~2 cores at 4K).
/// `input` is the source pixel format; `UU_NVENC_RGB=0` restores CPU conversion.
/// When the desktop is composited on the NVIDIA card itself, the packed-RGB path is slower than CPU
/// conversion (#16: RTX 5070 at 4K, 82.6 vs 98 fps), so it stays off unless `UU_NVENC_RGB=1`.
/// `input` is the source pixel format; `UU_NVENC_RGB=0` always restores CPU conversion.
fn nvenc_rgb_input(settings: &VideoSettings, encoder: Encoder, input: &'static str) -> Option<&'static str> {
(encoder == Encoder::Nvenc && settings.chroma != crate::capture_setting::CHROMA_444 && settings.output.is_none()
&& std::env::var("UU_NVENC_RGB").as_deref() != Ok("0")).then_some(input)
let wanted = match std::env::var("UU_NVENC_RGB").as_deref() {
Ok("0") => false,
Ok("1") => true,
_ => !nvidia_drives_display(std::path::Path::new("/sys/class/drm")),
};
(encoder == Encoder::Nvenc && settings.chroma != crate::capture_setting::CHROMA_444 && settings.output.is_none() && wanted)
.then_some(input)
}
/// A connected DRM connector (`cardN-HDMI-A-1/status`) on a card bound to the nvidia driver.
/// Only visible with nvidia-drm modeset, which Wayland compositors require.
fn nvidia_drives_display(drm: &std::path::Path) -> bool {
std::fs::read_dir(drm).into_iter().flatten().flatten().any(|entry| {
let name = entry.file_name().to_string_lossy().into_owned();
let Some((card, _)) = name.split_once('-') else { return false; };
card.starts_with("card")
&& std::fs::read_to_string(entry.path().join("status")).is_ok_and(|s| s.trim() == "connected")
&& std::fs::read_link(drm.join(card).join("device/driver")).is_ok_and(|p| p.file_name().is_some_and(|n| n == "nvidia"))
})
}
fn encoder_options(settings: &VideoSettings, encoder: Encoder, gop: &str, rgb: Option<&'static str>) -> Vec<String> {
@@ -344,6 +358,52 @@ fn ffmpeg_spec() -> FfmpegSpec {
pub(crate) fn ffmpeg_command() -> Command { ffmpeg_spec().command() }
/// Encoders of interest that the configured FFmpeg lists; `None` when it cannot run (bounded to 5 s).
pub async fn ffmpeg_encoders() -> Option<Vec<&'static str>> {
let mut ffmpeg = ffmpeg_command();
ffmpeg.args(["-hide_banner", "-encoders"]).kill_on_drop(true);
let output = tokio::time::timeout(Duration::from_secs(5), ffmpeg.output()).await.ok()?.ok()?;
let text = String::from_utf8_lossy(&output.stdout);
Some(["libx264", "libx265", "h264_nvenc", "hevc_nvenc", "h264_vaapi", "hevc_vaapi"].into_iter()
.filter(|name| text.split_whitespace().any(|word| word == *name)).collect())
}
/// Without FFmpeg the desktop stream fails after the viewer connects and it waits on
/// 正在传输画面 with no message of its own. Checked at startup and on each desktop offer:
/// logged, shown in the host window, and sent as a desktop notification (at most every 5 minutes).
/// Installing FFmpeg clears the window line on the next check; no restart is needed.
pub fn check_ffmpeg_usable() {
if crate::desktop_backend::headless() { return; }
tokio::spawn(async {
static LAST_NOTICE: std::sync::Mutex<Option<Instant>> = std::sync::Mutex::new(None);
let summary = crate::i18n::s("无法传输远程画面","Cannot stream the remote desktop");
match ffmpeg_encoders().await {
None => {
log::error!("FFmpeg is not runnable: desktop video cannot start and viewers stay on 正在传输画面. Install ffmpeg (Debian/Ubuntu: sudo apt install ffmpeg; Arch: sudo pacman -S ffmpeg; Fedora: ffmpeg from RPM Fusion), or set ffmpeg_root, then check `uuremote-server doctor`");
let text = crate::i18n::s("未找到可运行的 FFmpeg,客户端会一直停在「正在传输画面」。\n请安装后重新连接:sudo apt install ffmpeg(Arch:sudo pacman -S ffmpeg;Fedora 需先启用 RPM Fusion)","No runnable FFmpeg found; viewers stay on the loading screen.\nInstall it and reconnect: sudo apt install ffmpeg (Arch: sudo pacman -S ffmpeg; Fedora: enable RPM Fusion first)");
let previous = {
let mut last = LAST_NOTICE.lock().unwrap_or_else(|e| e.into_inner());
let previous = *last;
let due = previous.is_none_or(|at| at.elapsed() >= Duration::from_secs(300));
if due { *last = Some(Instant::now()); }
due.then_some(previous)
};
// The notification is a blocking D-Bus call (bounded to 3 s).
let told = tokio::task::spawn_blocking(move || crate::assist::show_problem(summary, Some(text), previous.is_some())).await.unwrap_or(false);
// Only a notice that reached the person starts the 5-minute quiet period.
if let (Some(previous), false) = (previous, told) {
*LAST_NOTICE.lock().unwrap_or_else(|e| e.into_inner()) = previous;
log::warn!("Missing FFmpeg: no desktop notification daemon and no host window to show it");
}
}
Some(found) => {
if !found.contains(&"libx264") { log::warn!("FFmpeg has no libx264: CPU encoding and the fallback after a hardware encoder failure are unavailable. Install a full ffmpeg build"); }
tokio::task::spawn_blocking(move || crate::assist::show_problem(summary, None, false));
}
}
});
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum FfmpegTimingMode { Modern, Legacy }
@@ -411,33 +471,153 @@ async fn ffmpeg_timing_mode(spec: &FfmpegSpec) -> FfmpegTimingMode {
*cell.get_or_init(|| probe_timing_mode(spec)).await
}
type HevcCache = Mutex<HashMap<(FfmpegSpec, Encoder), Arc<tokio::sync::OnceCell<bool>>>>;
fn hevc_cache() -> &'static HevcCache {
static CACHE: OnceLock<HevcCache> = OnceLock::new();
CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}
fn hevc_cell(cache: &HevcCache, spec: &FfmpegSpec, encoder: Encoder) -> Arc<tokio::sync::OnceCell<bool>> {
let mut cache = cache.lock().expect("HEVC probe cache poisoned");
cache.entry((spec.clone(), encoder)).or_insert_with(|| Arc::new(tokio::sync::OnceCell::const_new())).clone()
}
/// A compiled-in encoder name does not prove that its driver can initialize.
/// Probe one synthetic 4:2:0 frame once per process before advertising HEVC.
pub async fn hevc_available() -> bool {
static AVAILABLE: tokio::sync::OnceCell<bool> = tokio::sync::OnceCell::const_new();
*AVAILABLE.get_or_init(|| async {
let requested = Encoder::requested();
let mut candidates = vec![requested];
if requested != Encoder::Cpu { candidates.push(Encoder::Cpu); }
for encoder in candidates {
let settings = VideoSettings { codec: VideoCodec::H265, ..Default::default() };
let mut command = ffmpeg_command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
command.args(["-f", "lavfi", "-i", "color=black:size=256x256:rate=1", "-frames:v", "1", "-an"]);
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
command.args(encoder_options(&settings, encoder, "30", None));
command.args(["-f", "hevc", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
if let Ok(Ok(output)) = tokio::time::timeout(Duration::from_secs(5), command.output()).await {
if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H265) {
log::info!("HEVC encoder probe: {} ok", encoder.name_for(VideoCodec::H265));
return true;
}
/// Probe one synthetic 4:2:0 frame per resolved encoder and FFmpeg spec. The caller
/// passes the session's encoder so capability matches that snapshot. set-encoder
/// changes the snapshot for the next session, so a process-wide bool would keep advertising
/// the first session's result.
const AUTO_PROBE_BUDGET: Duration = Duration::from_secs(3);
/// One synthetic H.264 IDR. Failure reasons stay enum values: stderr and device paths are not logged.
pub(crate) async fn probe_encoder_idr(encoder: Encoder) -> crate::video_select::ProbeOutcome {
use crate::video_select::{ProbeFail, ProbeOutcome};
let settings = VideoSettings { codec: VideoCodec::H264, ..Default::default() };
let mut command = ffmpeg_command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
command.args(["-f", "lavfi", "-i", "color=c=black:s=256x256:r=1", "-frames:v", "1", "-an"]);
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
command.args(encoder_options(&settings, encoder, "30", None));
command.args(["-f", "h264", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
let process = match tokio::time::timeout(AUTO_PROBE_BUDGET, command.output()).await {
Ok(Ok(output)) if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H264) => ProbeOutcome::Ok,
Ok(Ok(output)) if output.status.success() => ProbeOutcome::Fail(ProbeFail::NoIdr),
Ok(Ok(_)) => ProbeOutcome::Fail(ProbeFail::Exit),
Ok(Err(_)) => ProbeOutcome::Fail(ProbeFail::Spawn),
Err(_) => ProbeOutcome::Fail(ProbeFail::Timeout),
};
// The native engine opens against a real X display, so a synthetic lavfi frame cannot
// exercise it. When this build would try that engine first, a process-only failure must
// not drop the candidate (NativeUnprobed → legacy auto for it).
crate::video_select::outcome_for_candidate(process, native_engine_would_run(encoder))
}
/// True when `read_encoder_with` would open the in-process engine for this candidate
/// on the selected desktop backend (X11 only; not Wayland, portal, KMS, or headless).
fn native_engine_would_run(encoder: Encoder) -> bool {
native_engine_eligible(encoder, native_display_kind())
}
fn native_display_kind() -> NativeDisplayKind {
if crate::desktop_backend::headless() { return NativeDisplayKind::None; }
match crate::desktop_backend::detect() {
Ok(crate::desktop_backend::DesktopBackend::Wayland) => NativeDisplayKind::Wayland,
Ok(crate::desktop_backend::DesktopBackend::Kms) => NativeDisplayKind::Kms,
Ok(crate::desktop_backend::DesktopBackend::Portal) => NativeDisplayKind::Portal,
_ => NativeDisplayKind::X11,
}
}
fn auto_probe_flight() -> &'static tokio::sync::Mutex<()> {
static FLIGHT: std::sync::OnceLock<tokio::sync::Mutex<()>> = std::sync::OnceLock::new();
FLIGHT.get_or_init(|| tokio::sync::Mutex::new(()))
}
/// Start the auto probe when auto is selected and the cache is empty or stale
/// (TTL, or NVIDIA presence changed since the report). Returns immediately.
/// One probe runs at a time; an in-flight probe is left alone.
/// Explicit encoder (setting or `UU_VIDEO_ENCODER`) does not spawn a probe.
pub fn warm_auto_probe() {
if !crate::video_select::should_warm_auto_probe(crate::video_select::selection().encoder_source) { return; }
if !crate::video_select::probe_needs_run(std::time::Instant::now(), nvidia_present()) { return; }
tokio::spawn(async { let _ = run_auto_probe().await; });
}
/// Diagnostics that encode must see the same auto choice as a warmed-up host.
/// An explicit encoder (setting or env) skips the probe.
pub async fn ensure_auto_probed() {
if crate::video_select::selection().encoder_source == crate::video_select::Source::Auto {
let _ = run_auto_probe().await;
}
}
/// Run the probe to completion (doctor, or the background warm-up).
/// A success or a CPU-only skip stays cached. A hardware failure expires after
/// `PROBE_FAILURE_TTL`; the next `warm_auto_probe` starts one background retry.
pub async fn run_auto_probe() -> crate::video_select::ProbeReport {
let now = std::time::Instant::now();
let nvidia = nvidia_present();
if let Some(cached) = crate::video_select::cached_probe() {
if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; }
}
let _flight = auto_probe_flight().lock().await;
let now = std::time::Instant::now();
let nvidia = nvidia_present();
if let Some(cached) = crate::video_select::cached_probe() {
if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; }
}
let reason = crate::video_select::reprobe_reason(crate::video_select::cached_probe().as_ref(), nvidia);
let nvidia = nvidia_present();
let order = crate::video_select::auto_order(nvidia);
// One candidate (CPU, no NVIDIA) has nothing to choose; skip the synthetic IDR.
let mut outcomes = Vec::with_capacity(order.len());
if order.len() == 1 {
outcomes.push(crate::video_select::ProbeOutcome::NotProbed);
} else {
for encoder in &order { outcomes.push(probe_encoder_idr(*encoder).await); }
}
let probed = crate::video_select::choose_from_probe(&order, &outcomes);
let chosen = crate::video_select::chosen_after_native(nvidia, &order, &outcomes, probed);
let report = crate::video_select::ProbeReport::fresh(order, outcomes, chosen, now, nvidia);
let parts: Vec<String> = report.order.iter().zip(report.outcomes.iter()).map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label())).collect();
if let Some(reason) = reason {
log::info!("Encoder probe: {reason} {}", parts.join(" "));
} else {
log::info!("Encoder probe: {}", parts.join(" "));
}
crate::video_select::store_probe(report.clone());
report
}
pub async fn hevc_available(requested: Encoder) -> bool {
let spec = ffmpeg_spec();
let cell = hevc_cell(hevc_cache(), &spec, requested);
*cell.get_or_init(|| probe_hevc(spec, requested)).await
}
async fn probe_hevc(spec: FfmpegSpec, requested: Encoder) -> bool {
let mut candidates = vec![requested];
if requested != Encoder::Cpu { candidates.push(Encoder::Cpu); }
for encoder in candidates {
let settings = VideoSettings { codec: VideoCodec::H265, ..Default::default() };
let mut command = spec.command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
command.args(["-f", "lavfi", "-i", "color=black:size=256x256:rate=1", "-frames:v", "1", "-an"]);
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
command.args(encoder_options(&settings, encoder, "30", None));
command.args(["-f", "hevc", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
if let Ok(Ok(output)) = tokio::time::timeout(Duration::from_secs(5), command.output()).await {
if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H265) {
log::info!("HEVC encoder probe: {} ok", encoder.name_for(VideoCodec::H265));
return true;
}
}
log::info!("HEVC encoder probe: unavailable");
false
}).await
}
log::info!("HEVC encoder probe: unavailable");
false
}
/// Round UP (+1ns float guard) so webrtc's floor(duration*90000) yields exactly `ticks`.
@@ -500,26 +680,34 @@ impl Drop for StopOnDrop { fn drop(&mut self) { self.0.store(true, std::sync::at
async fn read_encoder(
size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
latest: mpsc::Sender<Arc<CompleteFrame>>,
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
mut settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
selection: crate::video_select::Selection,
) -> Result<(), String> {
#[cfg(test)]
if display == wake_tests::DISPLAY { return wake_tests::encode(latest, settings, sequence, budget).await; }
// The sequence is shared so a CPU fallback or settings restart continues it (skip statistics stay correct).
let encoder = Encoder::requested();
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget).await; }
// `selection` is fixed for this desktop connection (taken where the codec is negotiated).
let encoder = selection.encoder;
if settings.chroma == crate::capture_setting::CHROMA_444 && !full_chroma_for(encoder) {
settings.chroma = crate::capture_setting::CHROMA_420;
log::info!("Chroma 4:4:4 requested; encoder={} source={} encodes 4:2:0", format!("{encoder:?}").to_ascii_lowercase(), crate::video_select::encoder_source_label(selection.encoder_source));
}
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await; }
#[cfg_attr(not(feature = "inproc-av"), allow(unused_mut))]
let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone()).await;
let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await;
// A failed native NVENC session (old driver, unsupported mode) still leaves FFmpeg's NVENC process pipeline.
#[cfg(feature = "inproc-av")]
if let Err(error) = &result {
if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) && x11_resized(&display, portal.is_some(), size).is_none() {
log::warn!("In-process {} stream unavailable; switching to the FFmpeg process pipeline: {}",encoder.name_for(settings.codec),error);
result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,false,sequence.clone(),settings,idr.clone(),budget.clone()).await;
result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,false,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await;
}
}
match result {
Ok(())=>Ok(()),
Err(error) if !latest.is_closed() && x11_resized(&display, portal.is_some(), size).is_none()=>{
log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name_for(settings.codec),error);
read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget).await
read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await
},
Err(error)=>Err(error),
}
@@ -532,10 +720,29 @@ fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u3
crate::capture::x11_size().filter(|current| *current != size)
}
/// Same predicate `native_inproc` uses: X11 only, and the in-process engine is selected.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum NativeDisplayKind { X11, Wayland, Portal, Kms, None }
pub(crate) fn native_engine_eligible(encoder: Encoder, kind: NativeDisplayKind) -> bool {
#[cfg(feature = "inproc-av")]
{ kind == NativeDisplayKind::X11 && crate::inproc_encoder::selected(encoder) }
#[cfg(not(feature = "inproc-av"))]
{ let _ = (encoder, kind); false }
}
/// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session).
#[cfg(feature = "inproc-av")]
fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool {
!display.starts_with("wayland:") && !display.starts_with("kms:") && !portal && crate::inproc_encoder::selected(encoder)
native_engine_eligible(encoder, display_kind(display, portal))
}
#[cfg(feature = "inproc-av")]
fn display_kind(display: &str, portal: bool) -> NativeDisplayKind {
if portal { NativeDisplayKind::Portal }
else if display.starts_with("wayland:") { NativeDisplayKind::Wayland }
else if display.starts_with("kms:") { NativeDisplayKind::Kms }
else { NativeDisplayKind::X11 }
}
/// Capture and encode inside this process; each packet is one access unit.
@@ -573,19 +780,20 @@ 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 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) }
let env = match encoder {
Encoder::Cpu => return max_kbps.clamp(500, 8000),
Encoder::Vaapi => "UU_VAAPI_BUFFER_MS",
Encoder::Nvenc => "UU_NVENC_BUFFER_MS",
};
let requested = std::env::var(env).ok();
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or((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).
/// Opt-in hardware VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
/// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With the 100-500 kbit default the encoder quantizes a
/// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42 VAAPI, #103 NVENC).
/// Unset, out of range or unparsable values keep the default buffer.
fn vaapi_buffer_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> {
fn buffer_ms_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))
}
@@ -605,11 +813,15 @@ async fn read_encoder_with(
size: (u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,latest:mpsc::Sender<Arc<CompleteFrame>>,encoder:Encoder,
#[cfg_attr(not(feature = "inproc-av"), allow(unused_variables))] allow_inproc: bool,sequence:Arc<std::sync::atomic::AtomicU64>,
settings: VideoSettings, #[cfg_attr(not(feature = "inproc-av"), allow(unused_variables))] idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
selection: crate::video_select::Selection,
)->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 selected_output=crate::wayland::capture_source(&display,portal.is_some(),settings.source_id);
// Portal frames come from the session's current monitor, whatever the advertised mode says.
let size=portal.as_ref().map(|p|p.size()).or(selected_output.map(|s|(s.width,s.height))).unwrap_or(size);
let kms=display.starts_with("kms:");
let wayland=kms || display.starts_with("wayland:");
// X11 multi-screen: x11grab reads only the selected monitor's region of the root.
let x11_region=selected_output.filter(|_|!wayland);
let (permits_tx,mut permits_rx)=mpsc::channel::<OwnedSemaphorePermit>(4);
let kms_capture=if kms {
let capture=tokio::task::spawn_blocking(crate::kms::Capture::open).await.map_err(|_|"KMS worker failed")??;
@@ -617,7 +829,7 @@ async fn read_encoder_with(
Some(Arc::new(capture))
} else { None };
#[cfg(feature = "inproc-av")]
if allow_inproc && native_inproc(&display, portal.is_some(), encoder) {
if allow_inproc && x11_region.is_none() && native_inproc(&display, portal.is_some(), encoder) {
let max_kbps = settings.max_kbps().unwrap_or(30_000) as i64;
let config = crate::inproc_encoder::Config {
display: display.clone(), input: size, output: settings.output, fps: u32::from(settings.fps),
@@ -626,8 +838,9 @@ async fn read_encoder_with(
max_bps: max_kbps * 1000, buffer_bits: i64::from(buffer_for(&settings, encoder)) * 1000, codec: settings.codec, chroma: settings.chroma,
vaapi: encoder == Encoder::Vaapi,
};
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} pipeline=in-process",
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec));
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} source={} pipeline=in-process",
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec),
crate::video_select::encoder_source_label(selection.encoder_source));
return read_inprocess(config, latest, sequence, idr, budget).await;
}
let source_size = size;
@@ -639,7 +852,7 @@ async fn read_encoder_with(
let cq = settings.cq().to_string();
// x11grab delivers bgr0; the Wayland/portal/KMS pipe is bgra.
let rgb = nvenc_rgb_input(&settings, encoder, if wayland { "bgra" } else { "bgr0" });
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} pix_fmt={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name_for(settings.codec),if encoder == Encoder::Vaapi { "nv12" } else { rgb.unwrap_or(chroma_args(&settings, encoder).1) });
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} source={} pix_fmt={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name_for(settings.codec),crate::video_select::encoder_source_label(selection.encoder_source),if encoder == Encoder::Vaapi { "nv12" } else { rgb.unwrap_or(chroma_args(&settings, encoder).1) });
// A bundled FFmpeg prefix (config ffmpeg_root / UU_FFMPEG_ROOT) or `ffmpeg` on PATH.
let ffmpeg = ffmpeg_spec();
let mut command = ffmpeg.command();
@@ -650,8 +863,9 @@ async fn read_encoder_with(
"-framerate",&fps,"-i","pipe:0","-an"]);
} else {
// The viewer draws its local pointer; do not bake a second into video.
let input=x11_region.map_or_else(||display.clone(),|o|format!("{display}+{},{}",o.x,o.y));
command.args(["-f","x11grab","-draw_mouse","0","-framerate",&fps,
"-video_size",&size,"-i",&display,"-an"]);
"-video_size",&size,"-i",&input,"-an"]);
}
// 其他分辨率: scale the captured desktop (the host display mode is left untouched).
command.args(scale_options(&settings, encoder, Some(source_size)));
@@ -716,7 +930,8 @@ async fn read_encoder_with(
let interval=Duration::from_nanos(1_000_000_000/u64::from(settings.fps));
let mut tick=tokio::time::interval(interval);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut frame=vec![0;(session.width as usize)*(session.height as usize)*4];
let (width,height)=session.size();
let mut frame=vec![0;(width as usize)*(height as usize)*4];
let mut version=None;
loop {
tick.tick().await;
@@ -791,7 +1006,9 @@ pub(crate) fn transport_closed(pc: &RTCPeerConnection) -> bool {
|| pc.sctp().state() == webrtc::sctp_transport::sctp_transport_state::RTCSctpTransportState::Closed
}
fn probe_settings() -> Result<VideoSettings,String> {
/// Encoder and settings for `desktop-video-probe` / `UU_PROBE_INPUT`.
/// `UU_PROBE_CHROMA=444` is the viewer's 真彩 request, applied when the selected encoder can do 4:4:4.
pub(crate) fn probe_plan() -> Result<(crate::video_select::Selection, VideoSettings), String> {
let fps=crate::wayland::capture_fps(std::env::var("UU_PROBE_FPS").ok().as_deref())?;
// UU_PROBE_QUALITY selects a viewer preset (1 fast 1M, 2 general 2M, 3 HD 8M, 4 bluray 20M,
// 5 auto); bitrate presets exercise the capped/ABR encoder path instead of CRF.
@@ -799,19 +1016,15 @@ 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")?,
};
let mut settings=VideoSettings {fps,quality,codec:probe_codec(),..VideoSettings::default()};
// UU_PROBE_CHROMA=444 requests 真彩 like the viewer does (only where full_chroma_available()).
if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") && full_chroma_available() { settings.chroma=crate::capture_setting::CHROMA_444; }
Ok(settings)
}
/// 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,
let mut settings=VideoSettings {fps,quality,..VideoSettings::default()};
let selection = crate::video_select::selection();
let chroma = if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") { crate::capture_setting::CHROMA_444 } else { crate::capture_setting::CHROMA_420 };
settings.codec = match crate::video_select::codec_force(selection.codec_pref) {
Some("h265") => VideoCodec::H265,
_ => VideoCodec::H264,
}
};
if chroma == crate::capture_setting::CHROMA_444 && full_chroma_for(selection.encoder) { settings.chroma = chroma; }
Ok((selection, settings))
}
fn probe_input_command(spec:&FfmpegSpec,input:&std::ffi::OsStr,loop_input:bool,settings:&VideoSettings,
@@ -846,13 +1059,14 @@ async fn probe_input_size(spec:&FfmpegSpec,input:&std::ffi::OsStr)->Result<(u32,
/// Fixed input bypasses desktop initialization and always uses the FFmpeg process encoder.
pub async fn probe_input(input:OsString,path:Option<String>)->Result<(),String> {
ensure_auto_probed().await;
use std::io::Write;
let settings=probe_settings()?;
let (selection, settings)=probe_plan()?;
let wanted:u64=std::env::var("UU_PROBE_FRAMES").ok().and_then(|v|v.parse().ok()).unwrap_or(5);
if wanted==0 { return Err("Fixed-input UU_PROBE_FRAMES must be positive".into()); }
let spec=ffmpeg_spec();
let size=probe_input_size(&spec,&input).await?;
let encoder=Encoder::requested();
let encoder = selection.encoder;
let (maxrate,_)=rate_args(&settings,encoder);
let output=settings.output.unwrap_or(size);
println!("Fixed input probe: source={}x{} output={}x{} fps={} cq={} maxrate={} encoder={}",
@@ -896,6 +1110,7 @@ pub async fn probe_input(input:OsString,path:Option<String>)->Result<(),String>
/// Exercise the real capture/encoder chain without UU auth or a network peer.
pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,path:Option<String>)->Result<(),String> {
ensure_auto_probed().await;
use std::io::Write;
let mut file=match path {
Some(path)=>Some(std::fs::OpenOptions::new().write(true).create_new(true).open(path).map_err(|e|format!("Video probe file: {e}"))?),
@@ -903,8 +1118,8 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
};
let (tx,mut rx)=mpsc::channel(4);
let sequence=Arc::new(std::sync::atomic::AtomicU64::new(0));
let settings=probe_settings()?;
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)),Arc::new(Semaphore::new(4)))));
let (selection, settings)=probe_plan()?;
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)),Arc::new(Semaphore::new(4)),selection)));
let mut count=0;
let mut bytes=0;
// UU_PROBE_FRAMES lengthens the sample for baseline measurements; default is 5 frames.
@@ -922,8 +1137,25 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
Ok(())
}
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, mut size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>) -> Result<(), String> {
fn keep_stream_display_awake() {
#[cfg(test)]
let result = wake_tests::wake().unwrap_or_else(crate::capture::keep_display_awake);
#[cfg(not(test))]
let result = crate::capture::keep_display_awake();
// Waking the output is optional; a transient failure does not mean capture failed.
if result.is_err() { log::warn!("Display wake failed; continuing desktop stream and retrying next interval"); }
}
/// `sync_tx` receives a Message 25 payload when a live encoder switch changes the encoded chroma.
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>,
selection: crate::video_select::Selection, sync_tx: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>) -> Result<(), String> {
stream_desktop_at(pc, track, size, display, portal, settings, applied, idr, selection, sync_tx, crate::video_select::reload_generation_value()).await
}
pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, mut size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>,
selection: crate::video_select::Selection, sync_tx: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>, reload_at_session: u64) -> Result<(), String> {
let _desktop_mode = crate::desktop_mode::StreamGuard::new();
loop {
if transport_closed(&pc) { return Ok(()); }
@@ -933,7 +1165,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
}
// Portal power/idle policy belongs to its CONTROL-scoped supervisor,
// including when video has no frames or the user locks manually.
if portal.is_none() { crate::capture::keep_display_awake()?; }
if portal.is_none() { keep_stream_display_awake(); }
let portal_stream = portal.is_some();
let (latest, mut receiver) = mpsc::channel(4);
let budget=Arc::new(Semaphore::new(4));
@@ -944,7 +1176,26 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
applied.send_replace(current);
settings.borrow_and_update();
}
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone())));
// SIGUSR2 re-reads host_settings and restarts this encoder when the effective encoder changes.
// The negotiated codec stays; a codec-only change is logged and applied on the next connection.
let mut live_selection = selection;
let mut seen_codec_pref = selection.codec_pref;
let mut reload = crate::video_select::subscribe_reload();
// Only a SIGUSR2 since the session snapshot. A probe that finishes during setup is not a reload
// (sessions started before the probe keep the legacy encoder for their lifetime).
let mut reload_pending = crate::video_select::reload_since_session(reload_at_session, *reload.borrow());
let open = {
let display = display.clone();
let portal = portal.clone();
let latest = latest.clone();
let sequence = sequence.clone();
let idr = idr.clone();
let budget = budget.clone();
move |size: (u32, u32), selection: crate::video_select::Selection, settings: VideoSettings| {
read_encoder(size, display.clone(), portal.clone(), latest.clone(), settings, sequence.clone(), idr.clone(), budget.clone(), selection)
}
};
let mut reader = EncoderTask(tokio::spawn(open(size, live_selection, current)));
let mut previous = None;
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
let mut settings_open = true;
@@ -959,6 +1210,43 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
let (mut window_frames, mut window_skipped) = (0u64, 0u64);
let mut send_interrupted=false;
'stream: loop {
if reload.has_changed().unwrap_or(false) || reload_pending {
reload_pending = false;
// Mark the watch seen. An unconsumed has_changed stays true and restarts every frame.
let _ = reload.borrow_and_update();
let fresh = crate::video_select::selection();
let plan = crate::video_select::plan_switch(live_selection.encoder, seen_codec_pref, &fresh, current.chroma);
if let Some(plan) = plan.filter(|plan| plan.encoder.is_some()) {
let encoder = plan.encoder.unwrap();
let chroma = if plan.chroma_downgraded { "420" } else if current.chroma == crate::capture_setting::CHROMA_444 { "444" } else { "420" };
log::info!("Encoder switch: {} -> {} reason={} chroma={chroma}",
format!("{:?}", live_selection.encoder).to_ascii_lowercase(),
format!("{encoder:?}").to_ascii_lowercase(),
crate::video_select::encoder_source_label(fresh.encoder_source));
live_selection.encoder = encoder;
live_selection.encoder_source = fresh.encoder_source;
seen_codec_pref = fresh.codec_pref;
if plan.chroma_downgraded {
applied.send_modify(|value| value.chroma = plan.chroma);
current.chroma = plan.chroma;
settings.borrow_and_update();
if let Some(sync) = sync_tx.as_ref() {
// Wayland: x11_resized is None, and the connection size can be a previous output.
let native = x11_resized(&display, portal_stream, size).unwrap_or_else(|| crate::wayland::sync_native(&display, current.source_id, size));
let payload = crate::capture_setting::sync_payload(&current, native);
let _ = sync.send(payload);
}
}
// In-process engines honor this on the first frame; the process pipeline starts on an IDR.
idr.store(true, std::sync::atomic::Ordering::Relaxed);
reader.restart(open(size, live_selection, current)).await;
} else if plan.is_some() {
log::info!("Codec preference changed; takes effect the next time a desktop connection starts");
seen_codec_pref = fresh.codec_pref;
live_selection.codec_pref = fresh.codec_pref;
live_selection.codec_source = fresh.codec_source;
}
}
let next = *settings.borrow_and_update();
if next != current || send_interrupted {
let discard = next.codec != current.codec || next.source_generation != current.source_generation || next.source_id != current.source_id || send_interrupted;
@@ -970,9 +1258,9 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
reader.0.abort();
let _ = (&mut reader.0).await;
while receiver.try_recv().is_ok() {}
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone()));
reader.0 = tokio::spawn(open(size, live_selection, next));
} else {
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone())).await;
reader.restart(open(size, live_selection, next)).await;
}
send_interrupted=false;
}
@@ -983,7 +1271,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
log::info!("Desktop geometry changed during the stream ({}x{} -> {}x{}); restarting capture", size.0, size.1, resized.0, resized.1);
size = resized;
while receiver.try_recv().is_ok() {}
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone()));
reader.0 = tokio::spawn(open(size, live_selection, current));
continue;
}
if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) {
@@ -991,7 +1279,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
applied.send_modify(|value| value.codec = VideoCodec::H264);
current = *settings.borrow_and_update();
while receiver.try_recv().is_ok() {}
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone()));
reader.0 = tokio::spawn(open(size, live_selection, current));
continue;
}
if result.is_err() && !crate::wayland::outputs().is_empty() && !crate::wayland::input_ready() {
@@ -1046,8 +1334,10 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
previous = Some(frame.sequence);
max_send_ms=max_send_ms.max(send_started.elapsed().as_millis());
frames += 1;
#[cfg(test)]
if wake_tests::active() { stats = Instant::now() - Duration::from_secs(30); }
if stats.elapsed() >= Duration::from_secs(30) {
if !portal_stream { crate::capture::keep_display_awake()?; }
if !portal_stream { keep_stream_display_awake(); }
log::info!("Desktop latest-frame stats: sent={} skipped={} latest_seq={} window_s={} window_sent={} window_skipped={} max_slot_age_ms={} max_send_ms={}",
frames, skipped, frame.sequence, stats.elapsed().as_secs(), frames - window_frames, skipped - window_skipped, max_age_ms, max_send_ms);
(window_frames, window_skipped) = (frames, skipped);
@@ -1062,6 +1352,28 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
#[cfg(test)]
mod tests {
#[test]
fn nvidia_display_is_detected_from_connected_connectors() {
use std::os::unix::fs::symlink;
let root = std::env::temp_dir().join(format!("uu-drm-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
let card = |n: &str, driver: &str, connector: &str, status: &str| {
std::fs::create_dir_all(root.join(format!("drivers/{driver}"))).unwrap();
std::fs::create_dir_all(root.join(format!("drm/{n}/device"))).unwrap();
let _ = symlink(root.join(format!("drivers/{driver}")), root.join(format!("drm/{n}/device/driver")));
std::fs::create_dir_all(root.join(format!("drm/{n}-{connector}"))).unwrap();
std::fs::write(root.join(format!("drm/{n}-{connector}/status")), format!("{status}\n")).unwrap();
};
let drm = root.join("drm");
card("card0", "i915", "HDMI-A-1", "connected");
card("card1", "nvidia", "DP-1", "disconnected");
assert!(!super::nvidia_drives_display(&drm), "iGPU drives the display");
card("card1", "nvidia", "DP-2", "connected");
assert!(super::nvidia_drives_display(&drm), "NVIDIA drives a display");
assert!(!super::nvidia_drives_display(&root.join("missing")));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn native_frame_dimensions_are_padded_to_even() {
// A scaled compositor can report an odd logical desktop (e.g. two stacked 150% monitors →
@@ -1182,6 +1494,26 @@ mod tests {
assert!(!timing_args(FfmpegTimingMode::Modern, 60).contains(&"-r".to_owned()));
}
#[test]
fn native_unprobed_only_when_x11_inproc_is_eligible() {
use crate::video_select::{outcome_for_candidate, ProbeFail, ProbeOutcome};
let exit = ProbeOutcome::Fail(ProbeFail::Exit);
for kind in [NativeDisplayKind::Wayland, NativeDisplayKind::Portal, NativeDisplayKind::Kms, NativeDisplayKind::None] {
assert!(!native_engine_eligible(Encoder::Nvenc, kind), "{kind:?}");
assert_eq!(outcome_for_candidate(exit, native_engine_eligible(Encoder::Nvenc, kind)), exit);
}
assert!(!native_engine_eligible(Encoder::Cpu, NativeDisplayKind::X11));
let x11 = native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11);
let stored = outcome_for_candidate(exit, x11);
if cfg!(feature = "inproc-av") && native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11) {
assert!(x11);
assert_eq!(stored, ProbeOutcome::NativeUnprobed);
} else {
assert!(!x11);
assert_eq!(stored, exit);
}
}
#[test]
fn timing_probe_failure_keeps_modern_args() {
let modern = b" -fps_mode mode\n -enc_time_base ratio\n";
@@ -1241,26 +1573,21 @@ mod tests {
}
#[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));
fn hw_buffer_env_is_opt_in_and_bounded() {
assert_eq!(buffer_ms_kbits(30_000, None), None);
assert_eq!(buffer_ms_kbits(30_000, Some("250")), Some(7500));
assert_eq!(buffer_ms_kbits(30_000, Some(" 10 ")), Some(300));
assert_eq!(buffer_ms_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}");
assert_eq!(buffer_ms_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));
assert_eq!(buffer_ms_kbits(1, Some("10")), Some(1));
}
#[test]
fn vaapi_is_explicit_and_upload_follows_scale() {
assert_eq!(Encoder::from_setting(None, true), Encoder::Nvenc);
assert_eq!(Encoder::from_setting(None, false), Encoder::Cpu);
assert_eq!(Encoder::from_setting(Some("nvenc"), false), Encoder::Nvenc);
assert_eq!(Encoder::from_setting(Some("cpu"), true), Encoder::Cpu);
assert_eq!(Encoder::from_setting(Some("vaapi"), true), Encoder::Vaapi);
assert_eq!(vaapi_filter(None), "format=nv12,hwupload");
assert_eq!(vaapi_filter(Some((1280,720))), "scale=1280:720:flags=bilinear,format=nv12,hwupload");
let options = vaapi_options(&VideoSettings::default(), "30");
@@ -1390,7 +1717,25 @@ mod tests {
#[tokio::test]
#[ignore = "requires installed FFmpeg with a working HEVC encoder"]
async fn hevc_capability_probe_initializes_real_encoder() {
assert!(hevc_available().await);
assert!(hevc_available(crate::video_select::selection().encoder).await);
}
#[tokio::test]
async fn hevc_probe_cache_is_keyed_by_encoder_and_ffmpeg_spec() {
let cache = Mutex::new(HashMap::new());
let spec = FfmpegSpec { program: PathBuf::from("ffmpeg"), ld_library_path: None, path: None };
let other = FfmpegSpec { program: PathBuf::from("/opt/ffmpeg/bin/ffmpeg"), ld_library_path: None, path: None };
let calls = Arc::new(AtomicUsize::new(0));
let lookup = |spec: &FfmpegSpec, encoder: Encoder, result: bool| {
let cell = hevc_cell(&cache, spec, encoder);
let calls = calls.clone();
async move { *cell.get_or_init(|| async move { calls.fetch_add(1, Ordering::SeqCst); result }).await }
};
assert!(lookup(&spec, Encoder::Cpu, true).await);
assert!(lookup(&spec, Encoder::Cpu, false).await);
assert_eq!(calls.load(Ordering::SeqCst), 1);
assert!(!lookup(&spec, Encoder::Nvenc, false).await);
assert!(lookup(&other, Encoder::Cpu, true).await);
assert_eq!(calls.load(Ordering::SeqCst), 3);
}
#[test]
fn hevc_annex_b_boundaries_and_irap_use_two_byte_headers() {
+897
View File
@@ -0,0 +1,897 @@
//! Runtime encoder / codec preference. host_settings.json beats the environment,
//! and "auto" or a missing field falls through. Illegal values are ignored.
//! Auto follows `auto_order` (NVENC then CPU when NVIDIA is present, else CPU).
//! A finished background probe can replace that choice; an unfinished probe keeps
//! the legacy NVIDIA/CPU result so the first connection is not delayed.
use crate::video::Encoder;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Source {
Setting,
Env,
Auto,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CodecPref {
Auto,
H264,
H265,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Selection {
pub encoder: Encoder,
pub encoder_source: Source,
pub codec_pref: CodecPref,
pub codec_source: Source,
}
pub fn parse_encoder(value: Option<&str>) -> Option<Option<Encoder>> {
match value
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|s| s.to_ascii_lowercase())
{
None => Some(None),
Some(v) if v == "auto" => Some(None),
Some(v) if v == "cpu" => Some(Some(Encoder::Cpu)),
Some(v) if v == "vaapi" => Some(Some(Encoder::Vaapi)),
Some(v) if v == "nvenc" => Some(Some(Encoder::Nvenc)),
Some(_) => None,
}
}
pub fn parse_codec(value: Option<&str>) -> Option<Option<CodecPref>> {
match value
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|s| s.to_ascii_lowercase())
{
None => Some(None),
Some(v) if v == "auto" => Some(None),
Some(v) if v == "h264" => Some(Some(CodecPref::H264)),
Some(v) if v == "h265" || v == "hevc" => Some(Some(CodecPref::H265)),
Some(_) => None,
}
}
fn file_fields() -> (Option<String>, Option<String>) {
let path = crate::system_actions::settings_path();
let Ok(bytes) = std::fs::read(path) else { return (None, None) };
let Ok(value) = serde_json::from_slice::<serde_json::Value>(&bytes) else { return (None, None) };
let field = |name: &str| value.get(name).and_then(|v| v.as_str()).map(str::to_owned);
(field("video_encoder"), field("video_codec"))
}
/// Unset/auto tries NVENC only with an NVIDIA driver loaded: `ffmpeg -encoders` lists h264_nvenc
/// on any machine, so without this every stream start first ran a doomed NVENC process (#10).
pub fn legacy_auto(nvidia: bool) -> Encoder {
if nvidia { Encoder::Nvenc } else { Encoder::Cpu }
}
/// Auto candidate order. NVIDIA present: NVENC then CPU. No NVIDIA: CPU only.
/// VAAPI is not an auto candidate until #33 (FFmpeg-process VAAPI ignores maxrate).
/// Explicit vaapi (setting or `UU_VIDEO_ENCODER`) is unchanged.
pub fn auto_order(nvidia: bool) -> Vec<Encoder> {
if nvidia { vec![Encoder::Nvenc, Encoder::Cpu] } else { vec![Encoder::Cpu] }
}
/// Why one candidate's synthetic IDR did not count. Logged as the variant name only.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProbeFail { Timeout, NoIdr, Spawn, Exit }
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProbeOutcome {
Ok,
Fail(ProbeFail),
/// inproc-av only: the FFmpeg process probe failed, but this session would try the native
/// engine first (`read_encoder_with`) on an X11 display (not Wayland, portal, or KMS).
/// Opening that engine needs a display, so the candidate is not failed here; auto falls
/// back to the pre-probe NVIDIA/CPU choice for it.
NativeUnprobed,
/// Single auto candidate (CPU, no NVIDIA): the synthetic IDR is skipped.
NotProbed,
}
impl ProbeOutcome {
/// Counts as a successful probe for `choose_from_probe`.
/// `NativeUnprobed` does not: that candidate was not shown to encode.
pub fn ok(self) -> bool { matches!(self, Self::Ok) }
pub fn label(self) -> &'static str {
match self {
Self::Ok => "ok",
Self::Fail(ProbeFail::Timeout) => "timeout",
Self::Fail(ProbeFail::NoIdr) => "no_idr",
Self::Fail(ProbeFail::Spawn) => "spawn",
Self::Fail(ProbeFail::Exit) => "exit",
Self::NativeUnprobed => "native_unprobed",
Self::NotProbed => "not probed (only candidate)",
}
}
}
/// How a process-probe result becomes the stored outcome.
/// `native_would_run` is true only on inproc-av when `inproc_encoder::selected` is true
/// (hardware, not `UU_VIDEO_PIPELINE=process` / `UU_CAPTURE=grab` / a bundled FFmpeg).
/// A process failure then becomes `NativeUnprobed` instead of disqualifying that candidate.
/// Default builds pass `native_would_run = false`, so the process result is unchanged.
pub fn outcome_for_candidate(process: ProbeOutcome, native_would_run: bool) -> ProbeOutcome {
if process.ok() || !native_would_run { process } else { ProbeOutcome::NativeUnprobed }
}
/// Encoder auto should use when a hardware candidate was left `NativeUnprobed`.
/// That candidate is skipped by `choose_from_probe`; if it was the legacy pick (NVENC when
/// NVIDIA is present), keep the legacy encoder. Otherwise use the probe choice.
pub fn chosen_after_native(nvidia: bool, order: &[Encoder], outcomes: &[ProbeOutcome], probed: Encoder) -> Encoder {
let legacy = legacy_auto(nvidia);
let native_legacy = order.iter().zip(outcomes.iter()).any(|(e, o)| {
*e == legacy && matches!(o, ProbeOutcome::NativeUnprobed)
});
if native_legacy { legacy } else { probed }
}
/// How long a hardware-candidate failure stays cached. A boot-time NVENC miss
/// (module not ready, GPU busy, consumer session limit) must not stick until exit.
pub const PROBE_FAILURE_TTL: std::time::Duration = std::time::Duration::from_secs(600);
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProbeReport {
pub order: Vec<Encoder>,
pub outcomes: Vec<ProbeOutcome>,
pub chosen: Encoder,
/// `None` means the result does not expire (success, or CPU-only `NotProbed`).
pub expires_at: Option<std::time::Instant>,
/// `nvidia_present()` at the time the report was stored. A later desktop
/// connection whose presence differs treats the report as stale.
pub nvidia: bool,
}
impl ProbeReport {
pub fn fresh(order: Vec<Encoder>, outcomes: Vec<ProbeOutcome>, chosen: Encoder, now: std::time::Instant, nvidia: bool) -> Self {
let expires_at = probe_failure_deadline(&order, &outcomes, chosen, now);
Self { order, outcomes, chosen, expires_at, nvidia }
}
}
/// Expiry is only for the hardware candidate that caused the CPU fallback
/// (NVENC `Fail` and `chosen == Cpu`). A `Fail` on CPU while NVENC is `Ok`
/// does not expire, and doctor does not label that report a failure.
/// `NotProbed` and `Ok` do not. `NativeUnprobed` keeps the legacy encoder
/// and is not a failure cache.
pub fn probe_failure_deadline(
order: &[Encoder],
outcomes: &[ProbeOutcome],
chosen: Encoder,
now: std::time::Instant,
) -> Option<std::time::Instant> {
let hardware_failed = order.iter().zip(outcomes).any(|(encoder, outcome)| {
*encoder != Encoder::Cpu && matches!(outcome, ProbeOutcome::Fail(_))
});
(hardware_failed && chosen == Encoder::Cpu).then_some(now + PROBE_FAILURE_TTL)
}
pub fn probe_expired(report: &ProbeReport, now: std::time::Instant) -> bool {
report.expires_at.is_some_and(|at| now >= at)
}
/// Time-to-live elapsed, or NVIDIA presence no longer matches the report.
/// Presence is `nvidia_present()` (proc version or `/dev/nvidia0`).
pub fn probe_stale(report: &ProbeReport, now: std::time::Instant, nvidia: bool) -> bool {
probe_expired(report, now) || report.nvidia != nvidia
}
/// Log suffix for a probe that replaces `previous`. `None` is a first probe.
/// A failure deadline (`expires_at`) is "retry after failure". A presence
/// mismatch without that deadline is "NVIDIA availability changed".
pub fn reprobe_reason(previous: Option<&ProbeReport>, nvidia_now: bool) -> Option<&'static str> {
let previous = previous?;
if previous.expires_at.is_some() {
Some("retry after failure")
} else if previous.nvidia != nvidia_now {
Some("NVIDIA availability changed")
} else {
None
}
}
/// Empty cache, or the cached report is stale for `nvidia` at `now`.
/// Callers still use the cached encoder until the replacement probe is stored.
pub fn probe_needs_run(now: std::time::Instant, nvidia: bool) -> bool {
match cached_probe() {
None => true,
Some(report) => probe_stale(&report, now, nvidia),
}
}
/// Background warm-up (startup and each new desktop connection) runs only for auto.
/// Setting or `UU_VIDEO_ENCODER` (non-auto) matches v0.2.23: no GPU probe.
pub fn should_warm_auto_probe(source: Source) -> bool {
source == Source::Auto
}
/// First candidate that produced an IDR, else CPU.
pub fn choose_from_probe(order: &[Encoder], outcomes: &[ProbeOutcome]) -> Encoder {
order.iter().zip(outcomes.iter()).find_map(|(e, o)| o.ok().then_some(*e)).unwrap_or(Encoder::Cpu)
}
fn cache() -> &'static std::sync::Mutex<Option<ProbeReport>> {
static CACHE: std::sync::OnceLock<std::sync::Mutex<Option<ProbeReport>>> = std::sync::OnceLock::new();
CACHE.get_or_init(|| std::sync::Mutex::new(None))
}
pub fn store_probe(report: ProbeReport) {
if let Ok(mut slot) = cache().lock() { *slot = Some(report); }
}
pub fn cached_probe() -> Option<ProbeReport> {
cache().lock().ok().and_then(|g| g.clone())
}
/// Tests that call `clear_probe` / `store_probe` share this lock. The probe
/// cache is process-global and `cargo test` runs tests in parallel.
#[cfg(test)]
pub(crate) static PROBE_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
/// Tests that read or bump the process-global reload generation share this lock.
#[cfg(test)]
pub(crate) static RELOAD_TEST_LOCK:std::sync::Mutex<()> = std::sync::Mutex::new(());
#[cfg(test)]
pub fn clear_probe() {
if let Ok(mut slot) = cache().lock() { *slot = None; }
}
/// Why a live desktop encoder was asked to change.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SwitchReason {
/// Effective encoder differs. The log line uses `Selection::encoder_source`, not this variant.
Encoder,
/// Codec preference changed. The negotiated codec stays until the next stream.
CodecDeferred,
}
/// What SIGUSR2 should do to one live desktop stream.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SwitchPlan {
/// Restart the encoder. None keeps the running encoder (codec-only or no change).
pub encoder: Option<Encoder>,
pub reason: SwitchReason,
/// Chroma the restarted encoder can actually produce. VAAPI has no 4:4:4.
pub chroma: u64,
/// True when the request was 4:4:4 and the new encoder must report 4:2:0.
pub chroma_downgraded: bool,
}
/// Compare the selection this stream is using with a freshly read one.
/// Codec preference is the stored preference, not the negotiated m-line codec.
pub fn plan_switch(active_encoder: Encoder, previous_codec: CodecPref, next: &Selection, active_chroma: u64) -> Option<SwitchPlan> {
if next.encoder != active_encoder {
let chroma = if active_chroma == crate::capture_setting::CHROMA_444 && !crate::video::full_chroma_for(next.encoder) {
crate::capture_setting::CHROMA_420
} else {
active_chroma
};
return Some(SwitchPlan {
encoder: Some(next.encoder),
reason: SwitchReason::Encoder,
chroma,
chroma_downgraded: chroma != active_chroma,
});
}
if next.codec_pref != previous_codec {
return Some(SwitchPlan {
encoder: None,
reason: SwitchReason::CodecDeferred,
chroma: active_chroma,
chroma_downgraded: false,
});
}
None
}
/// Monotonic generation bumped by SIGUSR2. Streams watch it and re-read `selection()`.
fn reload_generation() -> &'static std::sync::atomic::AtomicU64 {
static GEN: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
&GEN
}
pub fn reload_generation_value() -> u64 {
reload_generation().load(std::sync::atomic::Ordering::Relaxed)
}
/// SIGUSR2: ask live desktop streams to re-read host_settings. Does not clear the probe cache.
pub fn notify_reload() {
reload_generation().fetch_add(1, std::sync::atomic::Ordering::Relaxed);
}
pub fn reload_watch() -> &'static tokio::sync::watch::Sender<u64> {
static WATCH: std::sync::OnceLock<tokio::sync::watch::Sender<u64>> = std::sync::OnceLock::new();
WATCH.get_or_init(|| {
let (tx, _) = tokio::sync::watch::channel(reload_generation_value());
tx
})
}
pub fn subscribe_reload() -> tokio::sync::watch::Receiver<u64> {
reload_watch().subscribe()
}
/// True when SIGUSR2 has bumped the generation since the session snapshot.
/// A background auto probe that finishes during setup does not bump it.
pub fn reload_since_session(at_session: u64, current: u64) -> bool {
current != at_session
}
/// Publish the generation so every subscribed desktop stream wakes.
pub fn publish_reload() {
notify_reload();
// send() drops the value when nobody is subscribed (the gap between desktop connections).
reload_watch().send_replace(reload_generation_value());
}
/// Setting (non-auto) beats the environment, which beats the NVIDIA/CPU default.
pub fn selection() -> Selection {
selection_with(cached_probe().as_ref())
}
/// Same as `selection`, but auto uses `report` when it is already cached.
/// `None` keeps the legacy NVIDIA/CPU result (the probe is still running or has not started).
pub fn selection_with(report: Option<&ProbeReport>) -> Selection {
let (file_enc, file_codec) = file_fields();
let env_enc = std::env::var("UU_VIDEO_ENCODER").ok();
let env_codec = std::env::var("UU_VIDEO_CODEC").ok();
resolve_pair(file_enc.as_deref(), env_enc.as_deref(), file_codec.as_deref(), env_codec.as_deref(), crate::video::nvidia_present(), report)
}
pub fn resolve_pair(
enc_setting: Option<&str>,
enc_env: Option<&str>,
codec_setting: Option<&str>,
codec_env: Option<&str>,
nvidia: bool,
probed: Option<&ProbeReport>,
) -> Selection {
let (encoder, encoder_source) = match parse_encoder(enc_setting) {
Some(Some(e)) => (e, Source::Setting),
None => {
log::warn!("Ignoring video_encoder value (not auto/cpu/vaapi/nvenc)");
pick_encoder(enc_env, nvidia, probed)
}
Some(None) => pick_encoder(enc_env, nvidia, probed),
};
let (codec_pref, codec_source) = match parse_codec(codec_setting) {
Some(Some(p)) => (p, Source::Setting),
None => {
log::warn!("Ignoring video_codec value (not auto/h264/h265)");
pick_codec(codec_env)
}
Some(None) => pick_codec(codec_env),
};
Selection {
encoder,
encoder_source,
codec_pref,
codec_source,
}
}
fn pick_encoder(env: Option<&str>, nvidia: bool, probed: Option<&ProbeReport>) -> (Encoder, Source) {
match parse_encoder(env) {
Some(Some(e)) => (e, Source::Env),
None => {
log::warn!("Ignoring UU_VIDEO_ENCODER value (not auto/cpu/vaapi/nvenc)");
(auto_encoder(nvidia, probed), Source::Auto)
}
Some(None) => (auto_encoder(nvidia, probed), Source::Auto),
}
}
fn auto_encoder(nvidia: bool, probed: Option<&ProbeReport>) -> Encoder {
probed.map(|p| p.chosen).unwrap_or_else(|| legacy_auto(nvidia))
}
fn pick_codec(env: Option<&str>) -> (CodecPref, Source) {
match parse_codec(env) {
Some(Some(p)) => (p, Source::Env),
None => {
log::warn!("Ignoring UU_VIDEO_CODEC value (not auto/h264/h265)");
(CodecPref::Auto, Source::Auto)
}
Some(None) => (CodecPref::Auto, Source::Auto),
}
}
pub fn codec_force(pref: CodecPref) -> Option<&'static str> {
match pref {
CodecPref::H264 => Some("h264"),
CodecPref::H265 => Some("h265"),
CodecPref::Auto => None,
}
}
/// Hardware (VAAPI / NVENC) prefers H.265 unless the preference forces a codec.
pub fn hardware(encoder: Encoder) -> bool {
encoder != Encoder::Cpu
}
pub fn source_label(source: Source) -> &'static str {
match source {
Source::Setting => "setting",
Source::Env => "env",
Source::Auto => "default",
}
}
pub fn encoder_source_label(source: Source) -> &'static str {
match source {
Source::Setting => "setting",
Source::Env => "env",
Source::Auto => "auto",
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sel(
es: Option<&str>,
ee: Option<&str>,
cs: Option<&str>,
ce: Option<&str>,
nvidia: bool,
) -> Selection {
resolve_pair(es, ee, cs, ce, nvidia, None)
}
#[test]
fn priority_matrix_and_illegal_values() {
let encoders = [
None,
Some("auto"),
Some("cpu"),
Some("vaapi"),
Some("nvenc"),
Some("bogus"),
];
let codecs = [None, Some("auto"), Some("h264"), Some("h265"), Some("nope")];
for setting in encoders {
for env in encoders {
let got = sel(setting, env, None, None, true);
let expect_enc = match (parse_encoder(setting), parse_encoder(env)) {
(Some(Some(e)), _) => (e, Source::Setting),
(None, Some(Some(e))) | (Some(None), Some(Some(e))) => (e, Source::Env),
_ => (Encoder::Nvenc, Source::Auto),
};
assert_eq!(
(got.encoder, got.encoder_source),
expect_enc,
"{setting:?} {env:?}"
);
}
}
for setting in codecs {
for env in codecs {
let got = sel(None, None, setting, env, false);
let expect = match (parse_codec(setting), parse_codec(env)) {
(Some(Some(p)), _) => (p, Source::Setting),
(None, Some(Some(p))) | (Some(None), Some(Some(p))) => (p, Source::Env),
_ => (CodecPref::Auto, Source::Auto),
};
assert_eq!(
(got.codec_pref, got.codec_source),
expect,
"{setting:?} {env:?}"
);
}
}
assert_eq!(
sel(Some("auto"), Some("cpu"), Some("auto"), Some("h264"), true).encoder,
Encoder::Cpu
);
assert_eq!(
sel(Some("auto"), None, None, None, false).encoder,
Encoder::Cpu
);
assert_eq!(
sel(None, Some("auto"), None, None, true).encoder,
Encoder::Nvenc
);
assert_eq!(
sel(Some(" NVENC "), None, Some(" HEVC "), None, false).encoder,
Encoder::Nvenc
);
assert_eq!(
sel(None, None, Some(" HEVC "), None, false).codec_pref,
CodecPref::H265
);
}
#[test]
fn process_failure_keeps_native_candidate_unprobed() {
let exit = ProbeOutcome::Fail(ProbeFail::Exit);
assert_eq!(outcome_for_candidate(ProbeOutcome::Ok, true), ProbeOutcome::Ok);
assert_eq!(outcome_for_candidate(exit, false), exit, "default build keeps the process result");
assert_eq!(outcome_for_candidate(exit, true), ProbeOutcome::NativeUnprobed);
assert!(!ProbeOutcome::NativeUnprobed.ok());
assert_eq!(ProbeOutcome::NativeUnprobed.label(), "native_unprobed");
}
#[test]
fn native_unprobed_hardware_uses_legacy_choice() {
let order = auto_order(true);
let outcomes = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok];
let probed = choose_from_probe(&order, &outcomes);
assert_eq!(probed, Encoder::Cpu);
assert_eq!(chosen_after_native(true, &order, &outcomes, probed), Encoder::Nvenc);
let cpu_only = auto_order(false);
assert_eq!(chosen_after_native(false, &cpu_only, &[ProbeOutcome::Ok], Encoder::Cpu), Encoder::Cpu);
let both_ok = [ProbeOutcome::Ok, ProbeOutcome::Ok];
assert_eq!(chosen_after_native(true, &order, &both_ok, Encoder::Nvenc), Encoder::Nvenc);
}
fn probe_report(nvidia: bool, outcomes: &[ProbeOutcome]) -> ProbeReport {
let order = auto_order(nvidia);
let chosen = choose_from_probe(&order, outcomes);
ProbeReport::fresh(order, outcomes.to_vec(), chosen, std::time::Instant::now(), nvidia)
}
#[test]
fn auto_order_keeps_nvenc_when_nvidia_is_present() {
assert_eq!(auto_order(true), vec![Encoder::Nvenc, Encoder::Cpu]);
assert_eq!(auto_order(false), vec![Encoder::Cpu]);
assert_eq!(legacy_auto(true), Encoder::Nvenc);
assert_eq!(legacy_auto(false), Encoder::Cpu);
}
#[test]
fn auto_falls_back_when_the_first_candidate_fails() {
let both = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Fail(ProbeFail::Exit)]);
assert_eq!(both.chosen, Encoder::Cpu);
let nv = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
assert_eq!(nv.chosen, Encoder::Nvenc);
let failed = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok]);
assert_eq!(failed.chosen, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, true, Some(&nv)).encoder, Encoder::Nvenc);
assert_eq!(resolve_pair(None, None, None, None, true, Some(&failed)).encoder, Encoder::Cpu);
let cpu = probe_report(false, &[ProbeOutcome::Ok]);
assert_eq!(cpu.chosen, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, false, Some(&cpu)).encoder, Encoder::Cpu);
let skipped = probe_report(false, &[ProbeOutcome::NotProbed]);
assert_eq!(skipped.chosen, Encoder::Cpu);
assert_eq!(ProbeOutcome::NotProbed.label(), "not probed (only candidate)");
assert!(!ProbeOutcome::NotProbed.ok());
assert_eq!(resolve_pair(None, None, None, None, false, Some(&skipped)).encoder, Encoder::Cpu);
}
#[test]
fn explicit_env_and_setting_ignore_the_probe() {
let va = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, Some(&va)).encoder, Encoder::Nvenc);
assert_eq!(resolve_pair(None, Some("cpu"), None, None, true, Some(&va)).encoder, Encoder::Cpu);
assert_eq!(resolve_pair(Some("vaapi"), Some("nvenc"), None, None, true, Some(&va)).encoder, Encoder::Vaapi);
assert_eq!(resolve_pair(Some("nvenc"), None, None, None, false, Some(&va)).encoder_source, Source::Setting);
assert_eq!(resolve_pair(None, Some("cpu"), None, None, false, Some(&va)).encoder_source, Source::Env);
assert_eq!(resolve_pair(Some("auto"), Some("vaapi"), None, None, false, None).encoder, Encoder::Vaapi);
assert_eq!(resolve_pair(None, None, None, Some("h264"), false, Some(&va)).codec_pref, CodecPref::H264);
}
fn selection_of(encoder: Encoder, codec: CodecPref) -> Selection {
Selection { encoder, encoder_source: Source::Setting, codec_pref: codec, codec_source: Source::Setting }
}
#[test]
fn live_switch_restarts_encoder_and_defers_codec() {
let nv = selection_of(Encoder::Nvenc, CodecPref::Auto);
assert!(plan_switch(Encoder::Nvenc, CodecPref::Auto, &nv, crate::capture_setting::CHROMA_420).is_none());
let to_cpu = plan_switch(Encoder::Nvenc, CodecPref::Auto, &selection_of(Encoder::Cpu, CodecPref::Auto), crate::capture_setting::CHROMA_444).unwrap();
assert_eq!(to_cpu.encoder, Some(Encoder::Cpu));
assert_eq!(to_cpu.reason, SwitchReason::Encoder);
assert!(!to_cpu.chroma_downgraded);
assert_eq!(to_cpu.chroma, crate::capture_setting::CHROMA_444);
let to_vaapi = plan_switch(Encoder::Nvenc, CodecPref::H265, &selection_of(Encoder::Vaapi, CodecPref::H265), crate::capture_setting::CHROMA_444).unwrap();
assert_eq!(to_vaapi.encoder, Some(Encoder::Vaapi));
assert!(to_vaapi.chroma_downgraded);
assert_eq!(to_vaapi.chroma, crate::capture_setting::CHROMA_420);
let codec = plan_switch(Encoder::Nvenc, CodecPref::Auto, &selection_of(Encoder::Nvenc, CodecPref::H264), crate::capture_setting::CHROMA_420).unwrap();
assert_eq!(codec.encoder, None);
assert_eq!(codec.reason, SwitchReason::CodecDeferred);
let both = plan_switch(Encoder::Cpu, CodecPref::Auto, &selection_of(Encoder::Nvenc, CodecPref::H264), crate::capture_setting::CHROMA_420).unwrap();
assert_eq!(both.encoder, Some(Encoder::Nvenc));
assert_eq!(both.reason, SwitchReason::Encoder);
// The log reason is the source of the new selection (setting / env / auto), not a fixed word.
for (source, label) in [(Source::Setting, "setting"), (Source::Env, "env"), (Source::Auto, "auto")] {
let mut next = selection_of(Encoder::Vaapi, CodecPref::Auto);
next.encoder_source = source;
let plan = plan_switch(Encoder::Nvenc, CodecPref::Auto, &next, crate::capture_setting::CHROMA_420).unwrap();
assert!(plan.encoder.is_some());
assert_eq!(encoder_source_label(next.encoder_source), label);
}
}
#[test]
fn reload_does_not_clear_the_probe_cache() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let report = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
store_probe(report.clone());
let before = reload_generation_value();
notify_reload();
assert_eq!(reload_generation_value(), before + 1);
assert_eq!(cached_probe(), Some(report));
assert!(reload_since_session(before, reload_generation_value()));
assert!(!reload_since_session(reload_generation_value(), reload_generation_value()));
clear_probe();
}
#[test]
fn probe_finish_is_not_a_reload_since_the_session_snapshot() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let at_session = reload_generation_value();
// A finished background probe updates the cache only. It does not bump the generation.
assert!(!reload_since_session(at_session, reload_generation_value()));
notify_reload();
assert!(reload_since_session(at_session, reload_generation_value()));
}
#[test]
fn mark_reload_seen_clears_has_changed() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let mut watch = subscribe_reload();
let _ = watch.borrow_and_update();
publish_reload();
assert!(watch.has_changed().unwrap());
let _ = watch.borrow_and_update();
assert!(!watch.has_changed().unwrap());
});
}
/// Codec at CONTROL open is `preferred_codec_for` on the session snapshot.
/// Auto + CPU uses H.264 when both codecs are negotiated; auto + NVENC keeps H.265.
/// Forced codec ignores the encoder. 真彩 does not switch codec (true_color_keeps_codec_and_vaapi_reports_420).
#[test]
fn auto_codec_follows_the_encoder_chosen_at_session_setup() {
use crate::capture_setting::{preferred_codec_for, VideoCodec};
let cpu_fallback = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Ok]);
let session = resolve_pair(None, None, None, None, true, Some(&cpu_fallback));
assert_eq!((session.encoder, session.encoder_source, session.codec_pref), (Encoder::Cpu, Source::Auto, CodecPref::Auto));
assert_eq!(preferred_codec_for(true, true, session), VideoCodec::H264);
// Not the H.265 an unfinished probe would pick for legacy NVENC.
let early_nvenc = resolve_pair(None, None, None, None, true, None);
assert_eq!(early_nvenc.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, early_nvenc), VideoCodec::H265);
let nvenc_ok = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
let nvenc = resolve_pair(None, None, None, None, true, Some(&nvenc_ok));
assert_eq!(nvenc.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, nvenc), VideoCodec::H265);
let order = auto_order(true);
let unprobed = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok];
let chosen = chosen_after_native(true, &order, &unprobed, choose_from_probe(&order, &unprobed));
let report = ProbeReport::fresh(order.clone(), unprobed.to_vec(), chosen, std::time::Instant::now(), true);
let native = resolve_pair(None, None, None, None, true, Some(&report));
assert_eq!(native.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, native), VideoCodec::H265);
let forced_h264 = resolve_pair(None, None, Some("h264"), None, true, Some(&nvenc_ok));
assert_eq!(forced_h264.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, forced_h264), VideoCodec::H264);
let forced_h265 = resolve_pair(None, None, None, Some("h265"), true, Some(&cpu_fallback));
assert_eq!(forced_h265.encoder, Encoder::Cpu);
assert_eq!(preferred_codec_for(true, true, forced_h265), VideoCodec::H265);
}
#[test]
fn session_before_probe_uses_legacy_auto() {
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
clear_probe();
assert!(cached_probe().is_none());
let early = resolve_pair(None, None, None, None, false, None);
assert_eq!((early.encoder, early.encoder_source), (Encoder::Cpu, Source::Auto));
assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc);
store_probe(probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok]));
assert_eq!(cached_probe().unwrap().chosen, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, Encoder::Cpu);
// A snapshot taken before the cache filled stays on the legacy encoder.
assert_eq!(early.encoder, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc);
clear_probe();
}
#[test]
fn success_and_not_probed_do_not_expire() {
let now = std::time::Instant::now();
let later = now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1);
let ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true);
assert!(ok.expires_at.is_none());
assert!(!probe_expired(&ok, later));
let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
assert!(skipped.expires_at.is_none());
assert!(!probe_expired(&skipped, later));
let native = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok],
Encoder::Nvenc,
now,
true,
);
assert!(native.expires_at.is_none(), "native_unprobed is not a recorded process failure");
assert!(!probe_expired(&native, later));
}
#[test]
fn hardware_failure_expires_after_ttl() {
let now = std::time::Instant::now();
let failed = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok],
Encoder::Cpu,
now,
true,
);
assert!(!probe_expired(&failed, now + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1)));
assert!(probe_expired(&failed, now + PROBE_FAILURE_TTL));
assert_eq!(failed.chosen, Encoder::Cpu);
}
/// NVENC produced an IDR and CPU failed: the session uses NVENC, so this is
/// not the hardware-fallback cache. No TTL, and doctor (which keys off
/// `expires_at`) does not append the failure label.
#[test]
fn nvenc_ok_cpu_fail_does_not_expire() {
let now = std::time::Instant::now();
let report = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Ok, ProbeOutcome::Fail(ProbeFail::Exit)],
Encoder::Nvenc,
now,
true,
);
assert_eq!(report.chosen, Encoder::Nvenc);
assert!(report.expires_at.is_none());
assert!(!probe_expired(&report, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1)));
let cpu_only_fail = ProbeReport::fresh(
auto_order(false),
vec![ProbeOutcome::Fail(ProbeFail::Exit)],
Encoder::Cpu,
now,
false,
);
assert!(cpu_only_fail.expires_at.is_none(), "a CPU-only Fail is not a hardware fallback");
}
/// Failed NVENC stays CPU until `PROBE_FAILURE_TTL`. After that a desktop connection
/// asks for one background re-probe (`probe_needs_run`, what `warm_auto_probe` checks)
/// and still selects the cached CPU encoder. A successful re-probe selects NVENC and
/// does not expire. A second failure restarts the TTL.
#[test]
fn failure_then_reprobe_success_selects_nvenc() {
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
clear_probe();
let t0 = std::time::Instant::now();
let failed = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok],
Encoder::Cpu,
t0,
true,
);
store_probe(failed);
let before = t0 + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1);
assert!(!probe_needs_run(before, true), "no re-probe before the failure expires");
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Cpu
);
let after = t0 + PROBE_FAILURE_TTL;
assert!(probe_expired(cached_probe().as_ref().unwrap(), after));
assert!(probe_needs_run(after, true), "desktop connection starts one background re-probe");
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Cpu,
"the connection that notices expiry still uses the cached encoder"
);
let retried = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Ok, ProbeOutcome::Ok],
Encoder::Nvenc,
after,
true,
);
store_probe(retried);
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Nvenc
);
assert!(!probe_needs_run(after + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), true));
let failed_again = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok],
Encoder::Cpu,
after,
true,
);
store_probe(failed_again);
assert!(!probe_needs_run(after + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1), true));
assert!(probe_needs_run(after + PROBE_FAILURE_TTL, true));
clear_probe();
}
/// A CPU-only `NotProbed` report does not expire by time. When NVIDIA appears
/// (module or device after the user service started), the next desktop
/// connection treats it as stale and `probe_needs_run` asks for one background
/// re-probe. The inverse (NVENC success, device gone) is stale the same way.
/// The connection that notices still selects the cached encoder.
#[test]
fn nvidia_presence_change_makes_probe_stale() {
let now = std::time::Instant::now();
let cpu_only = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
assert!(!probe_stale(&cpu_only, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), false));
assert!(probe_stale(&cpu_only, now, true), "NVIDIA appeared after the CPU-only skip");
let nvenc_ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true);
assert!(!probe_stale(&nvenc_ok, now, true));
assert!(probe_stale(&nvenc_ok, now, false), "NVIDIA gone after a successful NVENC probe");
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
clear_probe();
store_probe(cpu_only);
assert!(!probe_needs_run(now, false));
assert!(probe_needs_run(now, true));
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Cpu,
"the connection that notices the presence change still uses the cached encoder"
);
clear_probe();
}
#[test]
fn reprobe_reason_follows_previous_state() {
let now = std::time::Instant::now();
assert_eq!(reprobe_reason(None, false), None);
assert_eq!(reprobe_reason(None, true), None);
let failed = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok],
Encoder::Cpu,
now,
true,
);
assert!(failed.expires_at.is_some());
assert_eq!(reprobe_reason(Some(&failed), true), Some("retry after failure"));
assert_eq!(reprobe_reason(Some(&failed), false), Some("retry after failure"));
let nvenc_ok = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Ok, ProbeOutcome::Ok],
Encoder::Nvenc,
now,
true,
);
assert_eq!(reprobe_reason(Some(&nvenc_ok), true), None);
assert_eq!(reprobe_reason(Some(&nvenc_ok), false), Some("NVIDIA availability changed"));
let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
assert_eq!(reprobe_reason(Some(&skipped), false), None);
assert_eq!(reprobe_reason(Some(&skipped), true), Some("NVIDIA availability changed"));
assert_ne!(reprobe_reason(Some(&nvenc_ok), false), Some("retry after failure"));
assert_ne!(reprobe_reason(Some(&skipped), true), Some("retry after failure"));
}
#[test]
fn warm_probe_only_when_encoder_source_is_auto() {
assert!(should_warm_auto_probe(Source::Auto));
assert!(!should_warm_auto_probe(Source::Setting));
assert!(!should_warm_auto_probe(Source::Env));
assert_eq!(resolve_pair(Some("cpu"), None, None, None, true, None).encoder_source, Source::Setting);
assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, None).encoder_source, Source::Env);
assert_eq!(resolve_pair(None, Some("auto"), None, None, false, None).encoder_source, Source::Auto);
}
}
+123
View File
@@ -0,0 +1,123 @@
//! Exercise the real video loop and RTP transport without cloud or desktop access.
//! Thread-local faults are confined to each test's current-thread Tokio runtime.
use super::*;
use std::cell::RefCell;
use webrtc::{api::{APIBuilder, media_engine::MediaEngine},
peer_connection::configuration::RTCConfiguration,
rtp_transceiver::rtp_codec::RTPCodecType};
pub(super) const DISPLAY: &str = "wayland:test-wake";
struct Faults { wake_calls: AtomicUsize, fail_wake: usize, fail_capture: bool, stop: AtomicBool }
thread_local! { static FAULTS: RefCell<Option<Arc<Faults>>> = const { RefCell::new(None) }; }
struct Reset;
impl Drop for Reset { fn drop(&mut self) { FAULTS.with(|value| *value.borrow_mut() = None); } }
pub(super) fn active() -> bool { FAULTS.with(|value| value.borrow().is_some()) }
pub(super) fn wake() -> Option<Result<(), String>> {
FAULTS.with(|value| value.borrow().as_ref().map(|faults| {
let call = faults.wake_calls.fetch_add(1, Ordering::SeqCst) + 1;
if call == faults.fail_wake { Err("Wayland output power control unavailable".into()) } else { Ok(()) }
}))
}
pub(super) async fn encode(latest: mpsc::Sender<Arc<CompleteFrame>>, settings: VideoSettings,
sequence: Arc<std::sync::atomic::AtomicU64>, budget: Arc<Semaphore>) -> Result<(), String> {
let faults = FAULTS.with(|value| value.borrow().clone()).expect("test faults installed");
loop {
tokio::time::sleep(Duration::from_millis(10)).await;
if faults.stop.load(Ordering::SeqCst) { return Ok(()); }
if faults.fail_capture && sequence.load(Ordering::Relaxed) >= 4 {
return Err("synthetic capture failed".into());
}
let permit = budget.clone().acquire_owned().await.map_err(|_| "test budget closed")?;
let frame = Arc::new(CompleteFrame {
source_generation: settings.source_generation, source_id: settings.source_id,
codec: settings.codec, sequence: sequence.fetch_add(1, Ordering::Relaxed) + 1,
completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2], _permit: Some(permit),
});
if latest.send(frame).await.is_err() { return Ok(()); }
}
}
async fn exercise(fail_wake: usize, fail_capture: bool) {
tokio::time::timeout(Duration::from_secs(15), async {
let faults = Arc::new(Faults { wake_calls: AtomicUsize::new(0), fail_wake, fail_capture, stop: AtomicBool::new(false) });
FAULTS.with(|value| *value.borrow_mut() = Some(faults.clone()));
let _reset = Reset;
let (host_setting, remote_setting, router) = crate::test_network::virtual_network().await;
let mut media = MediaEngine::default();
media.register_default_codecs().unwrap();
let host = Arc::new(APIBuilder::new().with_setting_engine(host_setting).with_media_engine(media)
.build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let mut media = MediaEngine::default();
media.register_default_codecs().unwrap();
let remote = APIBuilder::new().with_setting_engine(remote_setting).with_media_engine(media)
.build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
remote.add_transceiver_from_kind(RTPCodecType::Video, None).await.unwrap();
let _control = remote.create_data_channel("CONTROL_DATA_CHANNEL", None).await.unwrap();
let track = Arc::new(crate::video_track::VideoTrack::new());
host.add_track(track.clone()).await.unwrap();
let (packets, mut received) = mpsc::unbounded_channel();
remote.on_track(Box::new(move |track, _, _| {
let packets = packets.clone();
Box::pin(async move {
tokio::spawn(async move {
while let Ok((packet, _)) = track.read_rtp().await {
if packets.send(packet).is_err() { break; }
}
});
})
}));
let mut gathered = remote.gathering_complete_promise().await;
remote.set_local_description(remote.create_offer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
host.set_remote_description(remote.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.gathering_complete_promise().await;
host.set_local_description(host.create_answer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
remote.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
let settings = VideoSettings { source_id: 0, source_generation: 0, ..Default::default() };
let (settings_tx, settings_rx) = tokio::sync::watch::channel(settings);
let selection = crate::video_select::resolve_pair(Some("cpu"), None, Some("h264"), None, false, None);
let mut task = tokio::spawn(stream_desktop(host.clone(), track.clone(), (640, 480),
DISPLAY.into(), None, settings_rx, Arc::new(settings_tx), Arc::new(AtomicBool::new(false)), selection, None));
let result = if fail_capture {
Some((&mut task).await.unwrap())
} else {
let mut previous: Option<u16> = None;
for _ in 0..6 {
tokio::select! {
result = &mut task => panic!("video stopped after a recoverable wake failure: {result:?}"),
packet = received.recv() => {
let packet = packet.expect("RTP receiver closed");
if let Some(sequence) = previous {
assert_eq!(packet.header.sequence_number, sequence.wrapping_add(1));
}
previous = Some(packet.header.sequence_number);
}
}
}
assert!(faults.wake_calls.load(Ordering::SeqCst) > fail_wake, "wake was not retried");
None
};
assert!(track.revision() >= 4, "video must continue across wake failure");
let result = match result {
Some(result) => result,
None => {
faults.stop.store(true, Ordering::SeqCst);
task.await.unwrap()
},
};
host.close().await.unwrap();
remote.close().await.unwrap();
router.lock().await.stop().await.unwrap();
assert_eq!(result, if fail_capture { Err("synthetic capture failed".into()) } else { Ok(()) });
}).await.expect("video wake regression timed out");
}
#[tokio::test]
async fn startup_wake_failure_does_not_stop_video() { exercise(1, false).await; }
#[tokio::test]
async fn periodic_wake_failure_does_not_stop_video() { exercise(2, false).await; }
#[tokio::test]
async fn capture_failure_still_stops_video_after_wake_failure() { exercise(2, true).await; }
+27 -10
View File
@@ -22,20 +22,35 @@ fn device_platform(data:&Value,device:&str)->Option<i64>{
.find(|d|d.get("device_id").and_then(Value::as_str)==Some(device))
.and_then(|d|d.get("platform")).and_then(Value::as_i64)
}
/// English for server messages observed in assistance and connection replies.
fn english_message(msg: &str) -> Option<&'static str> {
Some(match msg {
"验证码错误" => "Wrong verification code",
"对方未开启协助" => "The partner has not turned on remote assistance",
"无法对同账号的设备发起远程协助" => "Remote assistance between devices of the same account is not possible",
"被控端正在被远控中,无法发起连接" => "This computer is already being controlled from another device",
_ => return None,
})
}
#[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})"),
// Observed 2002: the target already has a controller (another viewer, a phone).
Error::Api(2002, _) => f.write_str(crate::i18n::s("被控端正在被远控中,无法发起连接(错误码 2002)",
"This computer is already being controlled from another device; disconnect there and try again (error 2002)")),
// Server messages are Chinese only: the English UI translates the known ones.
Error::Api(code, msg) if !msg.is_empty() && !crate::i18n::english() => write!(f, "{msg} (code {code})"),
Error::Api(code, msg) if english_message(msg).is_some() => write!(f, "{} (code {code})", english_message(msg).unwrap_or_default()),
Error::AuthenticationExpired => f.write_str(crate::i18n::s("登录已过期,请重新登录","Sign-in expired, please sign in again")),
Error::Transport => f.write_str(crate::i18n::s("网络连接失败","Network connection failed")),
Error::InvalidAssist => f.write_str(crate::i18n::s("请输入对方的设备 ID 和有效验证码","Enter the partner's device ID and a valid code")),
Error::InvalidResponse => f.write_str(crate::i18n::s("服务器响应格式无效","Invalid server response")),
Error::MissingRoom => f.write_str(crate::i18n::s("服务器未返回可用的房间或信令信息","The server returned no usable room or signaling info")),
Error::UnknownKeyboardPlatform => f.write_str(crate::i18n::s("无法确定目标键盘平台,不能启用控制","Unknown remote keyboard platform; control is disabled")),
Error::Api(code, _) => f.write_str(&crate::tr!("连接请求失败(错误码 {code})","Connection request failed (error {code})")),
_ => write!(f, "viewer API: {self:?}"),
}
}
@@ -237,7 +252,8 @@ mod tests {
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)"));
let shown=if crate::i18n::english() {english_message(msg).unwrap()} else {msg};
assert_eq!(parse_share(422,json!({"code":9876,"msg":msg}),&[]).err().unwrap().to_string(),format!("{shown} (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);
@@ -405,7 +421,8 @@ mod http_tests {
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);
let shown=if crate::i18n::english() {english_message(msg).unwrap()} else {msg};
assert_eq!(error.to_string(),format!("{shown} (code 9876)"));assert_eq!(job.await.unwrap().len(),1);
}
for (status,body,expected) in [
(200,json!({"code":405,"msg":"业务拒绝"}),Error::Api(405,"业务拒绝".into())),
+7 -7
View File
@@ -4,10 +4,10 @@ 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())}
input.take(1025).read_line(&mut code).map_err(|_|crate::i18n::s("无法从 stdin 读取验证码","Cannot read the code from stdin"))?;
if code.len()>1024 {return Err(crate::i18n::s("验证码过长","Code is too long").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())}
if code.trim().is_empty() || code.chars().any(char::is_control) {return Err(crate::i18n::s("请输入有效验证码","Enter a valid code").into())}
Ok(code)
}
pub fn command(exe:&Path,id:&str)->Command {
@@ -17,10 +17,10 @@ pub fn command(exe:&Path,id:&str)->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(|_|"无法关闭会话输入管道")
let mut stdin=child.stdin.take().ok_or(crate::i18n::s("无法打开会话输入管道","Cannot open the session input pipe"))?;
stdin.write_all(code.as_bytes()).await.map_err(|_|crate::i18n::s("无法向会话传递验证码","Cannot pass the code to the session"))?;
stdin.write_all(b"\n").await.map_err(|_|crate::i18n::s("无法向会话传递验证码","Cannot pass the code to the session"))?;
stdin.shutdown().await.map_err(|_|crate::i18n::s("无法关闭会话输入管道","Cannot close the session input pipe"))
}.await;
if result.is_err() {let _=child.kill().await;}
result.map_err(str::to_owned)
+4 -3
View File
@@ -93,20 +93,21 @@ mod playback {
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 }
pub struct Playback { queue:sdl2::audio::AudioQueue<i16>, decoder:Decoder, pub volume:u8 }
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})
let decoder=Decoder::new(audio)?;queue.resume();Ok::<_,String>(Self{queue,decoder,volume:100})
})();
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() {
while let Some(mut samples)=self.decoder.pcm.pop() {
if self.volume<100 {let v=i32::from(self.volume);for s in samples.iter_mut(){*s=(i32::from(*s)*v/100) as i16;}}
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(())
+22 -1
View File
@@ -156,6 +156,16 @@ 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>}
#[cfg(feature="viewer-sdl")]
fn sdl_backend(wayland:bool,niri:bool,tx:mpsc::Sender<ClipboardRequest>,find:impl Fn(&str)->Option<PathBuf>)->Option<Backend>{
if wayland && niri {
// SDL3 only retains a Wayland selection offer associated with its seat;
// niri's regular clipboard is not exposed through that seat state.
// Unlike GNOME, niri supports data-control, so polling wl-clipboard
// neither requires a focused toplevel nor creates transient windows.
CommandBackend::select(true,find).map(Backend::Command).or(Some(Backend::Sdl(tx)))
}else{Some(Backend::Sdl(tx))}
}
impl Bridge {
pub fn new(desktop:bool)->Self{
let backend=if desktop{Backend::detect()}else{None};let enabled=backend.is_some();
@@ -163,7 +173,9 @@ impl Bridge {
}
#[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));
let wayland=std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty());
let backend=(std::env::var("UU_VIEWER_CLIPBOARD").as_deref()!=Ok("0"))
.then(||sdl_backend(wayland,std::env::var_os("NIRI_SOCKET").is_some(),tx,executable)).flatten();
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;}
@@ -249,6 +261,15 @@ impl Drop for Bridge{fn drop(&mut self){self.stop();}}
assert!(select(true,&[]).is_none());
}
#[cfg(feature="viewer-sdl")]
#[test] fn niri_command_backend_avoids_sdl_seat_selection(){
let(tx,_rx)=mpsc::channel(1);
let find=|n:&str|n.starts_with("wl-").then(||PathBuf::from(n));
assert!(matches!(sdl_backend(true,true,tx.clone(),find),Some(Backend::Command(_))));
assert!(matches!(sdl_backend(true,true,tx.clone(),|_|None),Some(Backend::Sdl(_))));
assert!(matches!(sdl_backend(true,false,tx.clone(),find),Some(Backend::Sdl(_))));
assert!(matches!(sdl_backend(false,true,tx,find),Some(Backend::Sdl(_))));
}
#[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{
+1 -1
View File
@@ -37,7 +37,7 @@ impl Decoder for Ffmpeg {
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});
frames.push(Frame{width:w,height:h,rgb:data,content:None});
} Ok(frames)
}
}
+114 -23
View File
@@ -1,52 +1,108 @@
//! 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.
//! Frames are decoded at the host's native size (resampling the picture blurs text); ffmpeg's verbose
//! scaler line gives the size before the first frame. `UU_VIEWER_SIZE` keeps the old fixed letterboxed
//! canvas, where the stream line tells the window which sub-rectangle is picture content.
use super::desktop::{Decoder,Frame};
use super::media::Codec;
use std::io::{Read,Write};
use std::io::{BufRead,Read,Write};
use std::process::{Child,ChildStdin,Command,Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool,AtomicU64,Ordering};
use std::sync::mpsc::{Receiver,TryRecvError};
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32 }
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<(u32,u32,Vec<u8>)>, fixed:Option<(u32,u32)>, source:Arc<AtomicU64>, resized:Arc<AtomicBool> }
impl Cli {
/// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary.
/// `UU_VIEWER_SIZE=WxH` scales into a fixed canvas (default: native size); `UU_VIEWER_FFMPEG` the binary.
pub fn new()->Result<Self,String> {
let (width,height)=std::env::var("UU_VIEWER_SIZE").ok()
let fixed=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)
.filter(|&(w,h):&(u32,u32)|(16..=8192).contains(&w)&&(16..=8192).contains(&h)&&w%2==0&&h%2==0);
Self::with_codec(Codec::H264,fixed)
}
fn with_codec(codec:Codec,width:u32,height:u32)->Result<Self,String> {
fn with_codec(codec:Codec,fixed:Option<(u32,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 filter=fixed.map(|(width,height)|format!("scale={width}:{height}:force_original_aspect_ratio=decrease:flags=lanczos,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",
let mut command=Command::new(&ffmpeg);
command.args(["-hide_banner","-loglevel","verbose","-nostats","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an"]);
if let Some(filter)=&filter {command.args(["-vf",filter]);}
let mut child=command.args(["-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())
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped())
.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;
// Source picture size from the one-time stream line; 0 until parsed. Only the numbers are kept.
let source=Arc::new(AtomicU64::new(0));let resized=Arc::new(AtomicBool::new(false));
let (size_tx,size_rx)=std::sync::mpsc::sync_channel::<(u32,u32)>(1);
if let Some((w,h))=fixed {let _=size_tx.send((w,h));}
if let Some(stderr)=child.stderr.take() {
let (source,resized)=(source.clone(),resized.clone());
let _=std::thread::Builder::new().name("uu-viewer-ffmpeg-info".into()).spawn(move||{
let mut native=None;
for line in std::io::BufReader::new(stderr).lines().map_while(Result::ok) {
if fixed.is_some() {
if source.load(Ordering::Relaxed)!=0 {continue}
if let Some((w,h))=parse_video_size(&line) {source.store((u64::from(w)<<32)|u64::from(h),Ordering::Relaxed);}
continue
}
// Native: the first scaler line fixes the output size; ffmpeg auto-scales a later
// resolution change to it, so a different input size means the decoder must restart.
let Some((input,out))=parse_scaler_sizes(&line) else {continue};
match native {
None=>{native=Some(out);let _=size_tx.send(out);},
Some(size) if input!=size=>resized.store(true,Ordering::Release),
Some(_)=>{},
}
}
});
}
// 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||{
let Ok((width,height))=size_rx.recv() else {return};
let size=width as usize*height as usize*3;
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 }
match tx.try_send((width,height,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})
Ok(Self{child,input:Some(input),codec,frames,fixed,source,resized})
}
}
/// Verbose swscale setup line: `[auto_scale_0 @ 0x..] w:3024 h:1964 fmt:yuv420p ... -> w:3024 h:1964 fmt:rgb24 ...`.
fn parse_scaler_sizes(line:&str)->Option<((u32,u32),(u32,u32))> {
let (input,out)=line.split_once(" -> ")?;
if !out.contains(" fmt:") {return None}
fn size(part:&str)->Option<(u32,u32)> {
let mut words=part.split_whitespace();
let w=words.find_map(|t|t.strip_prefix("w:"))?.parse().ok()?;
let h=words.next()?.strip_prefix("h:")?.parse().ok()?;
((16..=16384).contains(&w)&&(16..=16384).contains(&h)).then_some((w,h))
}
Some((size(input.rsplit_once("] ").map_or(input,|(_,rest)|rest))?,size(out)?))
}
/// `30000/1001`-style or display strings are irrelevant here: the first WxH on a `Video:` line is the
/// coded picture size, which is the aspect the scale+pad filter letterboxes into the canvas.
fn parse_video_size(line:&str)->Option<(u32,u32)> {
let rest=line.split_once("Video:")?.1;
rest.split(|c:char|c==','||c==' '||c=='('||c==')'||c=='['||c==']').find_map(|token|{
let token=token.trim_matches(|c:char|!c.is_ascii_digit()&&c!='x');
let (w,h)=token.split_once('x')?;
if w.is_empty()||h.is_empty()||!w.bytes().all(|b|b.is_ascii_digit())||!h.bytes().all(|b|b.is_ascii_digit()) {return None}
let (w,h)=(w.parse::<u32>().ok()?,h.parse::<u32>().ok()?);
((16..=16384).contains(&w)&&(16..=16384).contains(&h)).then_some((w,h))
})
}
/// 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) {
@@ -66,16 +122,34 @@ fn passthrough_args(ffmpeg:&str)->(&'static str,&'static str) {
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(())
if self.codec!=codec {*self=Self::with_codec(codec,self.fixed)?;}Ok(())
}
fn reset(&mut self) {}
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String> {
if self.resized.load(Ordering::Acquire) {
// The caller resets and asks for a key frame; the new process sizes itself from it.
*self=Self::with_codec(self.codec,self.fixed)?;
return Err("remote resolution changed".into());
}
let input=self.input.as_mut().ok_or("ffmpeg input closed")?;
input.write_all(au).and_then(|_|input.flush()).map_err(|_|"ffmpeg decoder exited")?;
// The raw-stream parser ends an access unit only when the next one starts; an access unit
// delimiter right after it releases the picture now instead of one remote frame later.
let delimiter:&[u8]=match self.codec {Codec::H264=>&[0,0,0,1,0x09,0xf0],Codec::H265=>&[0,0,0,1,0x46,0x01,0x50]};
input.write_all(au).and_then(|_|input.write_all(delimiter)).and_then(|_|input.flush()).map_err(|_|"ffmpeg decoder exited")?;
self.take_frames()
}
fn poll(&mut self)->Vec<Frame> {self.take_frames().unwrap_or_default()}
}
impl Cli {
fn take_frames(&mut self)->Result<Vec<Frame>,String> {
let mut out=Vec::new();
loop {
match self.frames.try_recv() {
Ok(rgb)=>out.push(Frame{width:self.width,height:self.height,rgb}),
Ok((width,height,rgb))=>{
let source=self.source.load(Ordering::Relaxed);
let content=(self.fixed.is_some()&&source!=0).then(||((source>>32) as u32,source as u32));
out.push(Frame{width,height,rgb,content})
},
Err(TryRecvError::Empty)=>break,
Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()),
}
@@ -104,7 +178,9 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
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();
// Native size and the fixed UU_VIEWER_SIZE canvas.
for fixed in [None,Some((32,32))] {
let mut cli=Cli::with_codec(Codec::H265,fixed).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")[..]),
@@ -115,7 +191,7 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
// 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}),
Ok((width,height,rgb))=>frames.push(Frame{width,height,rgb,content:None}),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected)=>break,
Err(e)=>panic!("{codec:?} decoder did not finish: {e}"),
}}
@@ -124,8 +200,23 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
assert!(!frames.is_empty(),"{codec:?}: no RGB frames");
for frame in frames {
assert_eq!(frame.rgb.len(),32*32*3);
assert_eq!((frame.width,frame.height),(32,32));
assert!(frame.rgb.chunks_exact(3).all(|p|p[0]>220 && p[1]<30 && p[2]<30),"{codec:?}: RGB conversion");
}
}
}
}
#[test] fn native_size_is_read_from_the_scaler_line(){
assert_eq!(super::parse_scaler_sizes("[auto_scale_0 @ 0x7f55ac005f40] w:3024 h:1964 fmt:yuv420p csp:unknown range:unknown sar:1/1 -> w:3024 h:1964 fmt:rgb24 csp:gbr range:pc sar:1/1 flags:0x00000004"),Some(((3024,1964),(3024,1964))));
assert_eq!(super::parse_scaler_sizes("[auto_scaler_0 @ 0x55d] w:2560 h:1440 fmt:yuv444p sar:1/1 -> w:1920 h:1080 fmt:rgb24 sar:1/1 flags:0x4"),Some(((2560,1440),(1920,1080))));
assert_eq!(super::parse_scaler_sizes("[Parsed_pad_1 @ 0x7f00] w:32 h:32 -> w:64 h:32 x:16 y:0 color:0x000000FF"),None);
assert_eq!(super::parse_scaler_sizes(" Stream #0:0 -> #0:0 (h264 (native) -> rawvideo (native))"),None);
}
#[test] fn source_size_is_read_from_the_ffmpeg_stream_line(){
assert_eq!(super::parse_video_size(" Stream #0:0: Video: h264 (High), yuv420p(progressive), 3024x1964, 25 fps"),Some((3024,1964)));
assert_eq!(super::parse_video_size("Stream #0:0: Video: hevc, yuv420p, 1920x1080 [SAR 1:1 DAR 16:9]"),Some((1920,1080)));
assert_eq!(super::parse_video_size("Stream #0:0: Audio: opus, 48000 Hz, stereo"),None);
assert_eq!(super::parse_video_size("frame= 1 fps=0.0 q=0.0"),None);
assert_eq!(super::parse_video_size("Stream #0:0: Video: h264, 1920xsynth"),None);
}
}
+79 -4
View File
@@ -5,13 +5,64 @@ pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<Ato
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); }
/// `content` is the source picture size inside the (possibly padded) RGB canvas; None = full frame.
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8>, pub content:Option<(u32,u32)> }
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);
/// Frames finished since the last call, without new input; an asynchronous decoder
/// returns a picture here instead of holding it until the next access unit arrives.
fn poll(&mut self)->Vec<Frame> {Vec::new()} }
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)];
fn wants_key_frame(units:u64,presented:u64)->bool {presented==0 && units%30==0}
/// True when an Annex-B access unit carries a picture the decoder can restart from: an IDR/IRAP,
/// an H.264 recovery-point SEI or an H.264 I slice (some hosts answer PLI without an IDR, #136).
pub fn is_key_frame(codec:super::media::Codec,au:&[u8])->bool {
au.windows(4).enumerate().filter(|(_,w)|w[..3]==[0,0,1]).any(|(i,w)|match codec {
super::media::Codec::H264=>match w[3]&0x1f {5=>true,6=>au.get(i+4)==Some(&6),1=>h264_i_slice(&au[i+4..]),_=>false},
super::media::Codec::H265=>(16..=21).contains(&((w[3]>>1)&0x3f)),
})
}
/// Reads first_mb_in_slice and slice_type (both ue(v)) from a slice header; I = 2 or 7.
fn h264_i_slice(rbsp:&[u8])->bool {
let mut bit=0usize;
let mut ue=||->Option<u32>{
let mut zeros=0;
while (rbsp.get(bit/8)?>>(7-bit%8))&1==0 {zeros+=1;bit+=1;if zeros>31 {return None}}
bit+=1;let mut v=0u32;
for _ in 0..zeros {v=(v<<1)|u32::from((rbsp.get(bit/8)?>>(7-bit%8))&1);bit+=1;}
Some((1u32<<zeros)-1+v)
};
ue().is_some() && matches!(ue(),Some(2|7))
}
/// After a local reset, holds back pictures until a restart point arrives, but never longer
/// than `limit`: a host that ignores PLI must not leave the window blank (#136).
pub struct KeyGate { since:Option<std::time::Instant>, limit:std::time::Duration }
impl KeyGate {
pub fn new()->Self {Self{since:None,limit:std::time::Duration::from_millis(1500)}}
pub fn arm(&mut self) {self.since.get_or_insert_with(std::time::Instant::now);}
/// False = drop this unit and keep asking for a key frame.
pub fn admit(&mut self,codec:super::media::Codec,au:&[u8])->bool {
let Some(since)=self.since else {return true};
let timed_out=since.elapsed()>=self.limit;
if timed_out || is_key_frame(codec,au) {
if timed_out {log::debug!("Viewer desktop: no key frame within {:?} after reset; decoding on",self.limit);}
self.since=None;true
} else {false}
}
}
/// Shows the newest frame a decoder finished between access units.
pub fn drain(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink)->Result<(),String> {
if let Some(frame)=decoder.poll().pop() {STATS[1].fetch_add(1,Ordering::Relaxed);sink.present(&frame)?;}
Ok(())
}
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);
let units=STATS[0].fetch_add(1,Ordering::Relaxed)+1;
// A later session can join a clean stream with no IDR in flight (#124): keep asking until a frame shows.
if wants_key_frame(units,STATS[1].load(Ordering::Relaxed)) {
pli.store(true,Ordering::Release);
if units==300 { log::warn!("Viewer desktop: no decodable frame after {units} access units; requesting key frames (another session may hold the host)"); }
}
// 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);}
@@ -28,8 +79,32 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
}
}
#[cfg(test)] mod tests {
#[test] fn key_frames_by_nal_type(){
use crate::viewer::media::Codec;
assert!(super::is_key_frame(Codec::H264,&[0,0,0,1,0x67,1,0,0,0,1,0x68,2,0,0,0,1,0x65,3]));
assert!(!super::is_key_frame(Codec::H264,&[0,0,0,1,0x61,1]));
assert!(super::is_key_frame(Codec::H265,&[0,0,0,1,0x40,1,0,0,1,0x26,1,3]));
assert!(!super::is_key_frame(Codec::H265,&[0,0,0,1,0x02,1]));
// I slice (first_mb=0 '1', slice_type=7 '0001000') and P slice (slice_type=5 '00110').
assert!(super::is_key_frame(Codec::H264,&[0,0,0,1,0x41,0b1000_1000,0]));
assert!(!super::is_key_frame(Codec::H264,&[0,0,0,1,0x41,0b1001_1000]));
// Recovery-point SEI (payload type 6).
assert!(super::is_key_frame(Codec::H264,&[0,0,0,1,0x06,0x06,1,0x80]));
}
#[test] fn key_gate_waits_then_gives_up(){
use crate::viewer::media::Codec;
let mut g=super::KeyGate::new();let p=[0,0,0,1,0x41,0b1001_1000];
assert!(g.admit(Codec::H264,&p));
g.arm();assert!(!g.admit(Codec::H264,&p));
assert!(g.admit(Codec::H264,&[0,0,0,1,0x65,0x88]));assert!(g.admit(Codec::H264,&p));
g.limit=std::time::Duration::ZERO;g.arm();assert!(g.admit(Codec::H264,&p));
}
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 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],content:None}])}} 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 requests_key_frames_until_the_first_frame(){
assert_eq!((1..=90).filter(|&n|wants_key_frame(n,0)).count(),3);
assert!(!(1..=90).any(|n|wants_key_frame(n,1)));
}
#[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);}
}
+55
View File
@@ -0,0 +1,55 @@
//! "Allow the same account to control this device": the Settings switch runs this computer's own
//! host (`uuremote-server`, the sibling binary) as the systemd user service, so the Linux machine
//! shows up in every client of that account. Hosting is opt-in: the viewer never enables the
//! service by itself, and the unit's enabled state is the saved choice. The host reads the shared
//! config.json, so a running host only needs a restart to go online with a new account.
use std::process::{Command, Stdio};
const UNIT: &str = "uuremote-native.service";
/// `UU_VIEWER_HOST=0` leaves the host service alone.
pub fn managed() -> bool { std::env::var("UU_VIEWER_HOST").as_deref() != Ok("0") }
fn systemctl(args: &[&str]) -> bool {
Command::new("systemctl").arg("--user").args(args).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
.status().is_ok_and(|s| s.success())
}
pub fn active() -> bool { systemctl(&["is-active", "--quiet", UNIT]) }
fn installed() -> bool { systemctl(&["cat", UNIT]) }
/// Same unit as packaging/deb and README (graphical-session.target imports DISPLAY / WAYLAND_DISPLAY).
fn unit_text(server: &std::path::Path) -> String {
format!("[Unit]\nDescription=UU Remote Linux host (unofficial)\nAfter=graphical-session.target\nPartOf=graphical-session.target\n\n\
[Service]\nEnvironment=RUST_LOG=info\nExecStart={}\nRestart=always\nRestartSec=5\n\n[Install]\nWantedBy=graphical-session.target\n", server.display())
}
fn install(server: &std::path::Path) -> Result<(), String> {
let base = std::env::var_os("XDG_CONFIG_HOME").map(std::path::PathBuf::from).filter(|p| p.is_absolute())
.or_else(|| std::env::var_os("HOME").map(|h| std::path::PathBuf::from(h).join(".config"))).ok_or("No config directory")?;
let dir = base.join("systemd/user");
std::fs::create_dir_all(&dir).map_err(|_| "Cannot create the systemd user directory")?;
std::fs::write(dir.join(UNIT), unit_text(server)).map_err(|_| "Cannot write the host service")?;
if systemctl(&["daemon-reload"]) { Ok(()) } else { Err("systemctl --user daemon-reload failed".into()) }
}
/// Starts the host and keeps it enabled (installing the user unit next to the viewer's binary if
/// there is none). Only the Settings switch calls this.
pub fn enable(viewer: &std::path::Path) -> Result<(), String> {
if !installed() {
let server = viewer.with_file_name("uuremote-server");
if !server.is_file() { return Err("uuremote-server is not installed next to the viewer".into()) }
install(&server)?;
}
if systemctl(&["enable", "--now", UNIT]) { log::info!("Host service enabled"); Ok(()) } else { Err("Cannot start the host service".into()) }
}
/// The account changed: a running host reloads its credentials. A stopped host stays stopped.
pub fn restart() -> Result<(), String> {
if systemctl(&["try-restart", UNIT]) { log::info!("Host service restarted"); Ok(()) } else { Err("Cannot restart the host service".into()) }
}
pub fn disable() -> Result<(), String> {
if systemctl(&["disable", "--now", UNIT]) { log::info!("Host service disabled"); Ok(()) } else { Err("Cannot stop the host service".into()) }
}
#[cfg(test)] mod tests {
#[test] fn unit_runs_the_given_server(){
let text=super::unit_text(std::path::Path::new("/opt/uu/uuremote-server"));
assert!(text.contains("ExecStart=/opt/uu/uuremote-server\n"));assert!(text.contains("WantedBy=graphical-session.target"));
}
}
+378
View File
@@ -0,0 +1,378 @@
//! In-window viewer chrome drawn over the remote picture, like the official client's: the loading
//! screen, the network-status panel (Ctrl+Alt+G), the control-center tab and its menu (Ctrl+Alt+M).
//! Shapes and text are rasterized on the CPU into small RGBA layers (anti-aliased); text uses a system
//! font found with fc-match (CJK capable). Without a font only shapes are drawn.
use ab_glyph::{Font, FontVec, PxScale, ScaleFont};
use crate::i18n::s;
pub type Rgba = [u8; 4];
const PANEL: Rgba = [32, 34, 40, 255];
const HOVER: Rgba = [255, 255, 255, 16];
const TEXT: Rgba = [240, 242, 245, 255];
const DIM: Rgba = [160, 166, 176, 255];
const ACCENT: Rgba = [59, 130, 246, 255];
const DANGER: Rgba = [248, 113, 113, 255];
/// Straight-alpha RGBA pixels, uploaded as SDL_PIXELFORMAT_RGBA32 with alpha blending.
pub struct Layer { pub w: u32, pub h: u32, pub px: Vec<u8> }
impl Layer {
pub fn new(w: u32, h: u32) -> Self { Self { w: w.max(1), h: h.max(1), px: vec![0; w.max(1) as usize * h.max(1) as usize * 4] } }
fn blend(&mut self, x: i32, y: i32, c: Rgba, coverage: f32) {
if x < 0 || y < 0 || x >= self.w as i32 || y >= self.h as i32 || coverage <= 0. { return }
let i = (y as usize * self.w as usize + x as usize) * 4;
let sa = c[3] as f32 / 255. * coverage.min(1.);
let da = self.px[i + 3] as f32 / 255.;
let oa = sa + da * (1. - sa);
if oa <= 0. { return }
for k in 0..3 { self.px[i + k] = ((c[k] as f32 * sa + self.px[i + k] as f32 * da * (1. - sa)) / oa).round() as u8; }
self.px[i + 3] = (oa * 255.).round() as u8;
}
/// Anti-aliased rounded rectangle; coverage from the signed distance to the rounded edge.
pub fn round_rect(&mut self, x: f32, y: f32, w: f32, h: f32, r: f32, c: Rgba) {
let r = r.min(w / 2.).min(h / 2.);
for py in y.floor() as i32..(y + h).ceil() as i32 { for px in x.floor() as i32..(x + w).ceil() as i32 {
let (fx, fy) = (px as f32 + 0.5, py as f32 + 0.5);
let qx = (fx - (x + w / 2.)).abs() - (w / 2. - r);
let qy = (fy - (y + h / 2.)).abs() - (h / 2. - r);
let d = (qx.max(0.).hypot(qy.max(0.))) + qx.max(qy).min(0.) - r;
self.blend(px, py, c, 0.5 - d);
}}
}
pub fn circle(&mut self, cx: f32, cy: f32, r: f32, c: Rgba) { self.round_rect(cx - r, cy - r, r * 2., r * 2., r, c); }
/// Text with its top-left at (x, y); returns the advance width.
pub fn text(&mut self, font: Option<&FontVec>, x: f32, y: f32, text: &str, size: f32, c: Rgba) -> f32 {
let Some(font) = font else { return 0. };
let scaled = font.as_scaled(PxScale::from(size));
let mut caret = x;
for ch in text.chars() {
let id = scaled.glyph_id(ch);
let glyph = id.with_scale_and_position(PxScale::from(size), ab_glyph::point(caret, y + scaled.ascent()));
caret += scaled.h_advance(id);
if let Some(outline) = font.outline_glyph(glyph) {
let b = outline.px_bounds();
outline.draw(|gx, gy, v| self.blend(b.min.x.floor() as i32 + gx as i32, b.min.y.floor() as i32 + gy as i32, c, v));
}
}
caret - x
}
}
pub fn measure(font: Option<&FontVec>, text: &str, size: f32) -> f32 {
let Some(font) = font else { return text.chars().count() as f32 * size * 0.55 };
let scaled = font.as_scaled(PxScale::from(size));
text.chars().map(|ch| scaled.h_advance(scaled.glyph_id(ch))).sum()
}
/// The UI font: `UU_VIEWER_FONT` (a .ttf/.otf/.ttc path), else fontconfig's CJK-capable sans-serif.
pub fn load_font() -> Option<FontVec> {
let (path, index) = match std::env::var("UU_VIEWER_FONT") {
Ok(p) if !p.is_empty() => (p, 0),
_ => {
let out = std::process::Command::new("fc-match").args(["-f", "%{file}\t%{index}", "sans-serif:lang=zh-cn"]).output().ok()?;
let line = String::from_utf8(out.stdout).ok()?;
let (file, index) = line.split_once('\t').unwrap_or((line.as_str(), "0"));
// fontconfig puts the variable-font named instance in the upper 16 bits; the face is below.
(file.to_owned(), index.trim().parse::<u32>().unwrap_or(0) & 0xffff)
}
};
let data = std::fs::read(&path).ok()?;
let mut font = FontVec::try_from_vec_and_index(data, index).ok()?;
// Variable CJK fonts default to their lightest master; use a regular UI weight.
use ab_glyph::VariableFont;
font.set_variation(b"wght", 450.);
Some(font)
}
// ---------------------------------------------------------------- loading screen
pub fn spinner(t: f32, size: u32) -> Layer {
let mut l = Layer::new(size, size);
let c = size as f32 / 2.;
let head = (t * 1.1).fract() * std::f32::consts::TAU;
for i in 0..12 {
let a = i as f32 / 12. * std::f32::consts::TAU;
// Brightness falls off smoothly behind the rotating head.
let behind = (head - a).rem_euclid(std::f32::consts::TAU) / std::f32::consts::TAU;
let alpha = (255. * (1. - behind).powf(1.6)).max(40.) as u8;
l.circle(c + a.sin() * c * 0.72, c - a.cos() * c * 0.72, size as f32 * 0.07, [255, 255, 255, alpha]);
}
l
}
pub fn label_layer(font: Option<&FontVec>, text: &str, size: f32, c: Rgba) -> Layer {
let mut l = Layer::new(measure(font, text, size).ceil() as u32 + 4, (size * 1.4).ceil() as u32);
l.text(font, 2., 0., text, size, c);
l
}
// ---------------------------------------------------------------- network status
#[derive(Default, Clone, PartialEq)]
pub struct NetStats { pub elapsed: u64, pub route: String, pub fps: u32, pub kbps: f64, pub rtt_ms: Option<u32>, pub loss: f64, pub size: (u32, u32), pub codec: &'static str, pub chroma: u32 }
pub fn stats_lines(n: &NetStats) -> Vec<String> {
let rate = if n.kbps >= 1000. { format!("{:.1} Mbps", n.kbps / 1000.) } else { format!("{:.0} Kbps", n.kbps) };
vec![
format!("{:02}:{:02}:{:02}", n.elapsed / 3600, n.elapsed / 60 % 60, n.elapsed % 60),
if n.route.is_empty() { "--".into() } else { n.route.clone() },
format!("{} fps · {}", n.fps, n.codec),
rate,
n.rtt_ms.map_or_else(|| "RTT --".into(), |r| format!("RTT {r} ms")),
format!("{} {:.1}%", s("丢包", "Loss"), n.loss),
format!("{}×{} · {}", n.size.0, n.size.1, if n.chroma == 3 { "4:4:4" } else { "4:2:0" }),
]
}
pub fn stats_layer(font: Option<&FontVec>, lines: &[String], scale: f32) -> Layer {
let size = 13. * scale;
let w = lines.iter().map(|l| measure(font, l, size)).fold(0., f32::max) + 24. * scale;
let h = lines.len() as f32 * size * 1.45 + 16. * scale;
let mut l = Layer::new(w.ceil() as u32, h.ceil() as u32);
l.round_rect(0., 0., w, h, 8. * scale, [0, 0, 0, 150]);
for (i, line) in lines.iter().enumerate() { l.text(font, 12. * scale, 8. * scale + i as f32 * size * 1.45, line, size, TEXT); }
l
}
// ---------------------------------------------------------------- control center
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Command {
Quality(u64), Fps(u32), Chroma(u32), FollowRemote(bool), OneToOne(bool), Volume(u8),
AutoLock(bool), HostMute(bool), GrabKeys(bool), Files, Watch(bool), Stats(bool), HideTab(bool), Fullscreen, Disconnect,
}
/// What the menu shows as selected. The host does not report remote settings back; quality, frame
/// rate and color are saved and sent again when the next session's CONTROL is ready.
#[derive(Clone, PartialEq)]
pub struct State {
pub quality: u64, pub fps: u32, pub chroma: u32, pub follow_remote: bool, pub one_to_one: bool, pub volume: u8,
pub auto_lock: bool, pub host_mute: bool, pub grab_keys: bool, pub watch: bool, pub stats: bool, pub hide_tab: bool, pub fullscreen: bool,
}
impl Default for State {
fn default() -> Self { Self { quality: 5, fps: 60, chroma: 1, follow_remote: true, one_to_one: false, volume: 100, auto_lock: false,
host_mute: false, grab_keys: false, watch: false, stats: false, hide_tab: false, fullscreen: false } }
}
enum Opt { Header(&'static str), Radio(&'static str, bool, Command), Check(&'static str, bool, Command), Action(&'static str, Command, &'static str), Slider }
fn categories() -> [&'static str; 10] {
[s("显示屏", "Display"), s("画质", "Quality"), s("窗口", "Window"), s("声音", "Sound"), s("安全", "Security"),
s("外设", "Peripherals"), s("工具", "Tools"), s("更多", "More"), s("全屏", "Full screen"), s("退出远控", "Disconnect")]
}
fn options(cat: usize, st: &State) -> Vec<Opt> {
use Opt::*;
match cat {
0 => vec![Header(s("分辨率", "Resolution")), Radio(s("跟随被控端", "Follow the remote"), st.follow_remote, Command::FollowRemote(true)),
Radio(s("跟随当前窗口", "Match this window"), !st.follow_remote, Command::FollowRemote(false))],
1 => vec![Radio(s("自动", "Auto"), st.quality == 5, Command::Quality(5)), Radio(s("原画 20M", "Original 20M"), st.quality == 4, Command::Quality(4)),
Radio(s("超清 8M", "Ultra HD 8M"), st.quality == 3, Command::Quality(3)), Radio(s("高清 2M", "HD 2M"), st.quality == 2, Command::Quality(2)),
Header(s("帧率", "Frame rate")), Radio(s("144 帧", "144 fps"), st.fps == 144, Command::Fps(144)), Radio(s("90 帧", "90 fps"), st.fps == 90, Command::Fps(90)),
Radio(s("60 帧", "60 fps"), st.fps == 60, Command::Fps(60)), Radio(s("30 帧", "30 fps"), st.fps == 30, Command::Fps(30)),
Header(s("色彩", "Color")), Radio(s("真彩 4:4:4", "True color 4:4:4"), st.chroma == 3, Command::Chroma(3)),
Radio(s("常规色彩", "Standard color"), st.chroma != 3, Command::Chroma(1))],
2 => vec![Radio(s("自适应", "Fit to window"), !st.one_to_one, Command::OneToOne(false)), Radio(s("实际大小 1:1", "Actual size 1:1"), st.one_to_one, Command::OneToOne(true))],
3 => vec![Slider],
4 => vec![Check(s("远程结束后,被控端自动锁屏", "Lock the remote when the session ends"), st.auto_lock, Command::AutoLock(!st.auto_lock)),
Check(s("被控端静音运行", "Mute the remote while connected"), st.host_mute, Command::HostMute(!st.host_mute))],
5 => vec![Header(s("键盘", "Keyboard")), Check(s("发送系统快捷键到被控端", "Send system shortcuts (Alt+Tab)"), st.grab_keys, Command::GrabKeys(!st.grab_keys))],
6 => vec![Action(s("文件传输", "File transfer"), Command::Files, "Ctrl+Alt+F"), Check(s("观看模式", "Watch mode"), st.watch, Command::Watch(!st.watch))],
7 => vec![Check(s("显示网络状态", "Show network status"), st.stats, Command::Stats(!st.stats)),
Check(s("全屏状态隐藏控制按钮", "Hide the control tab in full screen"), st.hide_tab, Command::HideTab(!st.hide_tab))],
_ => vec![],
}
}
#[derive(Clone, Copy, PartialEq)]
pub enum Hit { Tab, Category(usize), Option(usize, usize), Slider(f32, f32), Panel }
#[derive(Clone, PartialEq)]
pub struct Menu { pub open: bool, pub category: usize, pub hover: Option<Hit>, pub dragging: bool }
impl Default for Menu { fn default() -> Self { Self { open: false, category: 1, hover: None, dragging: false } } }
pub struct Rect { pub x: f32, pub y: f32, pub w: f32, pub h: f32 }
impl Rect { pub fn contains(&self, x: f32, y: f32) -> bool { x >= self.x && y >= self.y && x < self.x + self.w && y < self.y + self.h } }
pub const TAB_H: f32 = 30.;
pub fn tab_text() -> &'static str { s("控制中心", "Control center") }
/// Width of the drawn menu icon plus its gap; fonts without U+2630 would show a box.
const ICON_W: f32 = 18.;
pub fn tab_rect(font: Option<&FontVec>, window: (u32, u32), scale: f32) -> Rect {
let w = measure(font, tab_text(), 13. * scale) + (28. + ICON_W) * scale;
Rect { x: (window.0 as f32 - w) / 2., y: 0., w, h: TAB_H * scale }
}
pub fn tab_layer(font: Option<&FontVec>, scale: f32, hover: bool) -> Layer {
let r = tab_rect(font, (0, 0), scale);
let mut l = Layer::new(r.w.ceil() as u32, r.h.ceil() as u32);
// Flat top edge: the pill hangs from the window border.
l.round_rect(0., -12. * scale, r.w, r.h + 12. * scale, 12. * scale, if hover { [40, 44, 52, 235] } else { [24, 26, 31, 205] });
for i in 0..3 { l.round_rect(14. * scale, r.h / 2. + (i as f32 * 4. - 5.) * scale, 11. * scale, 1.6 * scale, 0.8 * scale, TEXT); }
l.text(font, (14. + ICON_W) * scale, (r.h - 13. * scale * 1.25) / 2., tab_text(), 13. * scale, TEXT);
l
}
/// Menu geometry relative to its own layer; the same list drives drawing and hit testing.
/// Cascading like the official client: a narrow category list and, beside the hovered row,
/// a card sized to the selected category's options.
pub struct Layout { pub w: f32, pub h: f32, pub items: Vec<(Rect, Hit)>, pub panels: Vec<Rect> }
const ROW: f32 = 30.; const HEADER: f32 = 22.; const SLIDER: f32 = 36.; const PAD: f32 = 6.; const SHADOW: f32 = 14.;
const MAIN_W: f32 = 150.; const GAP: f32 = 6.; const TEXT_SIZE: f32 = 13.;
fn option_height(opt: &Opt) -> f32 { match opt { Opt::Header(_) => HEADER, Opt::Slider => SLIDER, _ => ROW } }
fn option_width(font: Option<&FontVec>, opt: &Opt, scale: f32) -> f32 {
let text = |t: &str, size: f32| measure(font, t, size * scale);
match opt {
Opt::Header(t) => text(t, 11.) + 28. * scale,
Opt::Radio(t, ..) | Opt::Check(t, ..) => text(t, TEXT_SIZE) + 52. * scale,
Opt::Action(t, _, key) => text(t, TEXT_SIZE) + text(key, 11.) + 72. * scale,
Opt::Slider => 210. * scale,
}
}
pub fn layout(font: Option<&FontVec>, st: &State, menu: &Menu, scale: f32) -> Layout {
let k = |v: f32| v * scale;
let cats = categories().len();
let main = Rect { x: k(SHADOW), y: k(SHADOW), w: k(MAIN_W), h: k(PAD * 2. + ROW * cats as f32) };
let mut items: Vec<(Rect, Hit)> = (0..cats).map(|i| (Rect { x: main.x + k(PAD), y: main.y + k(PAD + ROW * i as f32), w: main.w - k(PAD * 2.), h: k(ROW) }, Hit::Category(i))).collect();
let mut panels = vec![Rect { x: main.x, y: main.y, w: main.w, h: main.h }];
let opts = options(menu.category, st);
let (mut w, mut h) = (main.x + main.w + k(SHADOW), main.y + main.h + k(SHADOW));
if !opts.is_empty() {
let sub_w = opts.iter().map(|o| option_width(font, o, scale)).fold(k(180.), f32::max);
let sub_h = k(PAD * 2.) + opts.iter().map(|o| k(option_height(o))).sum::<f32>();
// Aligned with the selected category row, kept inside the main panel's height when possible.
let row_y = main.y + k(PAD + ROW * menu.category as f32) - k(PAD);
let sub = Rect { x: main.x + main.w + k(GAP), y: row_y.min((main.y + main.h - sub_h).max(main.y)), w: sub_w, h: sub_h };
let mut y = sub.y + k(PAD);
for (i, opt) in opts.iter().enumerate() {
let r = Rect { x: sub.x + k(PAD), y, w: sub.w - k(PAD * 2.), h: k(option_height(opt)) };
match opt {
Opt::Header(_) => {}
Opt::Slider => items.push((r, Hit::Slider(sub.x + k(18.), sub.w - k(70.)))),
_ => items.push((r, Hit::Option(menu.category, i))),
}
y += k(option_height(opt));
}
w = sub.x + sub.w + k(SHADOW); h = h.max(sub.y + sub.h + k(SHADOW));
panels.push(sub);
}
Layout { w, h, items, panels }
}
fn card(l: &mut Layer, r: &Rect, scale: f32) {
// Soft drop shadow, then an opaque card with a hairline border.
for i in (1..=6).rev() {
let e = i as f32 * 2. * scale;
l.round_rect(r.x - e / 2., r.y - e / 2. + 3. * scale, r.w + e, r.h + e, 10. * scale + e / 2., [0, 0, 0, 9]);
}
l.round_rect(r.x - 1., r.y - 1., r.w + 2., r.h + 2., 10. * scale + 1., [255, 255, 255, 26]);
l.round_rect(r.x, r.y, r.w, r.h, 10. * scale, PANEL);
}
pub fn menu_layer(font: Option<&FontVec>, st: &State, menu: &Menu, scale: f32) -> (Layer, Layout) {
let lay = layout(font, st, menu, scale);
let k = |v: f32| v * scale;
let mut l = Layer::new(lay.w.ceil() as u32, lay.h.ceil() as u32);
for p in &lay.panels { card(&mut l, p, scale); }
let size = k(TEXT_SIZE);
let mid = |r: &Rect, size: f32| r.y + (r.h - size * 1.25) / 2.;
let opts = options(menu.category, st);
for (i, name) in categories().iter().enumerate() {
let r = &lay.items[i].0;
let selected = menu.category == i && !opts.is_empty();
if selected { l.round_rect(r.x, r.y + 1., r.w, r.h - 2., k(6.), [255, 255, 255, 30]); }
else if menu.hover == Some(Hit::Category(i)) { l.round_rect(r.x, r.y + 1., r.w, r.h - 2., k(6.), HOVER); }
if i == 9 { l.round_rect(r.x + k(4.), r.y - k(1.), r.w - k(8.), 1., 0., [255, 255, 255, 22]); }
l.text(font, r.x + k(10.), mid(r, size), name, size, if i == 9 { DANGER } else { TEXT });
if !options(i, st).is_empty() { l.text(font, r.x + r.w - k(14.), mid(r, size), "›", size, if selected { TEXT } else { DIM }); }
}
if let Some(sub) = lay.panels.get(1) {
let mut y = sub.y + k(PAD);
for (i, opt) in opts.iter().enumerate() {
let r = Rect { x: sub.x + k(PAD), y, w: sub.w - k(PAD * 2.), h: k(option_height(opt)) };
if menu.hover == Some(Hit::Option(menu.category, i)) { l.round_rect(r.x, r.y + 1., r.w, r.h - 2., k(6.), HOVER); }
match opt {
Opt::Header(t) => { l.text(font, r.x + k(10.), r.y + k(6.), t, k(11.), DIM); }
Opt::Radio(t, on, _) => {
if *on { l.circle(r.x + k(16.), r.y + r.h / 2., k(3.), ACCENT); }
l.text(font, r.x + k(30.), mid(&r, size), t, size, if *on { TEXT } else { [214, 218, 224, 255] });
}
Opt::Check(t, on, _) => {
// Drawn check mark: fonts without U+2713 would show a box.
if *on { let (cx, cy) = (r.x + k(16.), r.y + r.h / 2.);
for j in 0..8 { let f = j as f32 / 7.; l.circle(cx - k(4.) + f * k(3.), cy + f * k(3.), k(1.1), ACCENT); l.circle(cx - k(1.) + f * k(6.), cy + k(3.) - f * k(7.), k(1.1), ACCENT); } }
l.text(font, r.x + k(30.), mid(&r, size), t, size, if *on { TEXT } else { [214, 218, 224, 255] });
}
Opt::Action(t, _, key) => {
l.text(font, r.x + k(30.), mid(&r, size), t, size, TEXT);
let kw = measure(font, key, k(11.));
l.text(font, r.x + r.w - kw - k(10.), mid(&r, k(11.)), key, k(11.), DIM);
}
Opt::Slider => {
let (a, len) = (sub.x + k(18.), sub.w - k(70.));
let v = st.volume as f32 / 100.; let cy = r.y + r.h / 2.;
l.round_rect(a, cy - k(2.), len, k(4.), k(2.), [255, 255, 255, 40]);
l.round_rect(a, cy - k(2.), (len * v).max(k(4.)), k(4.), k(2.), ACCENT);
l.circle(a + len * v, cy, k(7.), [0, 0, 0, 60]);
l.circle(a + len * v, cy, k(6.), [255, 255, 255, 255]);
let label = format!("{}%", st.volume);
l.text(font, sub.x + sub.w - k(14.) - measure(font, &label, k(12.)), mid(&r, k(12.)), &label, k(12.), DIM);
}
}
y += r.h;
}
}
(l, lay)
}
/// The command for a click on an option row.
pub fn option_command(st: &State, cat: usize, index: usize) -> Option<Command> {
match options(cat, st).get(index)? { Opt::Radio(_, _, c) | Opt::Check(_, _, c) | Opt::Action(_, c, _) => Some(*c), _ => None }
}
pub fn category_command(cat: usize) -> Option<Command> { match cat { 8 => Some(Command::Fullscreen), 9 => Some(Command::Disconnect), _ => None } }
pub fn slider_value(x: f32, a: f32, len: f32) -> u8 { (((x - a) / len).clamp(0., 1.) * 100.).round() as u8 }
/// Viewer preferences that outlive a session (`viewer.json` next to config.json).
pub fn load_prefs(st: &mut State) {
let Ok(text) = std::fs::read_to_string(prefs_path()) else { return };
let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) else { return };
if let Some(b) = v["stats"].as_bool() { st.stats = b; }
if let Some(b) = v["hide_tab_fullscreen"].as_bool() { st.hide_tab = b; }
if let Some(b) = v["one_to_one"].as_bool() { st.one_to_one = b; }
if let Some(n) = v["volume"].as_u64() { st.volume = n.min(100) as u8; }
if let Some(q) = v["quality"].as_u64().filter(|q| (2..=5).contains(q)) { st.quality = q; }
if let Some(f) = v["fps"].as_u64().filter(|f| [30, 60, 90, 144].contains(f)) { st.fps = f as u32; }
if let Some(c) = v["chroma"].as_u64().filter(|c| [1, 3].contains(c)) { st.chroma = c as u32; }
}
pub fn save_prefs(st: &State) {
let path = prefs_path();
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
let v = serde_json::json!({"stats": st.stats, "hide_tab_fullscreen": st.hide_tab, "one_to_one": st.one_to_one, "volume": st.volume,
"quality": st.quality, "fps": st.fps, "chroma": st.chroma});
let _ = std::fs::write(path, v.to_string());
}
fn prefs_path() -> std::path::PathBuf { crate::config::path().parent().map_or_else(|| "viewer.json".into(), |d| d.join("viewer.json")) }
#[cfg(test)] mod tests {
use super::*;
#[test] fn layers_blend_inside_bounds_only(){
let mut l=Layer::new(8,8);l.round_rect(-4.,-4.,20.,20.,3.,[255,0,0,255]);l.circle(100.,100.,5.,[0,0,0,255]);
assert!(l.px.chunks_exact(4).all(|p|p==[255,0,0,255]));
let mut l=Layer::new(4,4);l.round_rect(0.,0.,4.,4.,0.,[0,0,255,128]);assert_eq!(&l.px[..4],&[0,0,255,128]);
}
#[test] fn every_option_row_has_a_command_and_categories_map_actions(){
let st=State::default();
for cat in 0..10 { let lay=layout(None,&st,&Menu{category:cat,..Default::default()},1.);
for (_,hit) in &lay.items { if let Hit::Option(c,i)=hit { assert!(option_command(&st,*c,*i).is_some()); } } }
assert_eq!(category_command(9),Some(Command::Disconnect));assert_eq!(category_command(1),None);
assert_eq!(slider_value(150.,100.,100.),50);assert_eq!(slider_value(0.,100.,100.),0);
}
/// `UU_HUD_PREVIEW=dir cargo test render_preview -- --ignored` writes the chrome as PNGs (visual check).
#[test] #[ignore] fn render_preview(){
let Some(dir)=std::env::var_os("UU_HUD_PREVIEW") else {return};let dir=std::path::PathBuf::from(dir);
let font=load_font();let font=font.as_ref();
let save=|name:&str,l:&Layer,bg:[u8;3]|{
let rgb:Vec<u8>=l.px.chunks_exact(4).flat_map(|p|{let a=p[3] as u32;(0..3).map(move|k|((p[k] as u32*a+bg[k] as u32*(255-a))/255) as u8)}).collect();
crate::viewer::type_ipc::write_png_rgb(&dir.join(name),l.w,l.h,&rgb,false).unwrap();
};
let st=State{stats:true,..State::default()};
for cat in [1usize,3,4] {let (l,_)=menu_layer(font,&st,&Menu{open:true,category:cat,hover:Some(Hit::Option(cat,1)),dragging:false},1.);save(&format!("menu{cat}.png"),&l,[200,200,210]);}
save("tab.png",&tab_layer(font,1.,false),[230,230,230]);
let n=NetStats{elapsed:57,route:"UDP · relay".into(),fps:60,kbps:8420.,rtt_ms:Some(36),loss:0.,size:(1920,1080),codec:"H.265",chroma:1};
save("stats.png",&stats_layer(font,&stats_lines(&n),1.),[230,230,230]);
save("spinner.png",&spinner(0.3,56),[17,19,24]);
save("title.png",&label_layer(font,"Connecting to PUNOSEVAC",20.,[240,242,245,255]),[17,19,24]);
}
#[test] fn stats_lines_format_numbers(){
let n=NetStats{elapsed:3723,route:"UDP · relay".into(),fps:60,kbps:8420.,rtt_ms:Some(36),loss:0.25,size:(1920,1080),codec:"H.265",chroma:3};
let l=stats_lines(&n);assert_eq!(l[0],"01:02:03");assert_eq!(l[3],"8.4 Mbps");assert_eq!(l[4],"RTT 36 ms");assert!(l[6].ends_with("4:4:4"));
}
}
+44
View File
@@ -35,6 +35,15 @@ pub fn mac_keycode(scan:i32)->Option<i32>{
_=>return None,
})
}
/// The content rectangle inside a decoder canvas padded to a fixed size (ffmpeg's scale+pad).
/// Mirrors `force_original_aspect_ratio=decrease,pad=…:(ow-iw)/2:(oh-ih)/2` so pointer input
/// ignores the padding instead of compressing the valid area.
pub fn content_rect(canvas:(u32,u32),content:(u32,u32))->Option<(f64,f64,f64,f64)> {
if canvas.0==0||canvas.1==0||content.0==0||content.1==0 {return None}
let scale=(canvas.0 as f64/content.0 as f64).min(canvas.1 as f64/content.1 as f64);
let(w,h)=(content.0 as f64*scale,content.1 as f64*scale);
Some(((canvas.0 as f64-w)/2.,(canvas.1 as f64-h)/2.,w,h))
}
#[derive(Clone,Copy,Debug,PartialEq)]
pub struct Viewport { pub x:f64, pub y:f64, pub width:f64, pub height:f64 }
impl Viewport {
@@ -57,6 +66,7 @@ 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 set_view_only(&mut self,view_only:bool){self.view_only=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)}?;
@@ -75,6 +85,14 @@ impl Input {
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}))
}
/// SDL wheel units are notches; the wire uses the Mac convention (one notch = 120).
/// Positive y is wheel-up, matching the host's `mouse_scroll` (button 4).
pub fn scroll(&mut self,x:f64,y:f64)->Option<Value> {
if self.view_only {return None}
let(dx,dy)=((x*120.).round() as i32,(y*120.).round() as i32);
if dx==0&&dy==0 {return None}
Some(json!({"action":"mouse_scroll","delta_x":dx,"delta_y":dy}))
}
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}));}
@@ -117,6 +135,15 @@ impl Input {
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 wheel_notches_use_mac_wire_units(){
let mut i=Input::default();
assert_eq!(i.scroll(0.,1.).unwrap(),json!({"action":"mouse_scroll","delta_x":0,"delta_y":120}));
assert_eq!(i.scroll(0.,-1.).unwrap()["delta_y"],-120);
assert_eq!(i.scroll(1.,-2.).unwrap(),json!({"action":"mouse_scroll","delta_x":120,"delta_y":-240}));
assert_eq!(i.scroll(0.,0.1).unwrap()["delta_y"],12); // precise trackpad deltas
assert!(i.scroll(0.,0.).is_none());
assert!(Input::new(true).scroll(0.,1.).is_none());
}
#[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);
@@ -138,4 +165,21 @@ assert!(i.release_all().is_empty());
assert_eq!(v.motion(1010.,1000.).unwrap()["abs_x"],1.0);
assert!(v.motion(f64::NAN,0.).is_none());
}
#[test] fn padded_canvas_maps_only_its_content_rectangle(){
// 16:10 picture inside the default 16:9 canvas: 1728x1080 centred, 96 px pillarbox each side.
assert_eq!(content_rect((1920,1080),(1280,800)),Some((96.,0.,1728.,1080.)));
assert_eq!(content_rect((1920,1080),(1920,1080)),Some((0.,0.,1920.,1080.)));
// 4:3 picture: 1440x1080 centred, 240 px each side.
assert_eq!(content_rect((1920,1080),(640,480)),Some((240.,0.,1440.,1080.)));
assert_eq!(content_rect((0,1080),(640,480)),None);
// The content rectangle's edges are the screen edges, not the canvas edges.
let (x,y,w,h)=content_rect((1920,1080),(1280,800)).unwrap();
let v=Viewport::fit((1920,1080),(1280,800));
assert_eq!((x,y,w,h),(v.x,v.y,v.width,v.height));
let abs=|px:f64|v.motion(px,540.).unwrap();
assert_eq!(abs(96.)["abs_x"],0.0);
assert_eq!(abs(960.)["abs_x"],0.5);
assert_eq!(abs(1824.)["abs_x"],1.0);
assert_eq!(abs(0.)["abs_x"],0.0); // padding is clamped to the screen edge
}
}
+8 -3
View File
@@ -16,14 +16,19 @@ pub mod desktop;
#[cfg(uu_gtk)] pub mod ui;
#[cfg(uu_gtk)] pub mod tools_ui;
#[cfg(feature="viewer-sdl")] pub mod sdl;
#[cfg(feature="viewer-sdl")] pub mod hud;
pub mod thumbs;
#[cfg(uu_gtk)] pub mod host;
pub mod tools;
pub mod clipboard;
pub mod power;
pub mod secure_input;
pub mod type_ipc;
fn device_label(name:Option<&str>)->&str{
name.filter(|name|!name.is_empty()).unwrap_or("远端设备")
name.filter(|name|!name.is_empty()).unwrap_or_else(||crate::i18n::s("远端设备","Remote device"))
}
#[cfg(test)]
@@ -31,7 +36,7 @@ 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("")),"远端设备");
assert_eq!(super::device_label(None),crate::i18n::s("远端设备","Remote device"));
assert_eq!(super::device_label(Some("")),crate::i18n::s("远端设备","Remote device"));
}
}
+36
View File
@@ -36,6 +36,10 @@ pub struct Observed {
pub media_packets:AtomicU64,
pub encoder_codecs:AtomicU32,
pub chroma:AtomicU32,
/// Received RTP payload bytes and video packets vs. sequence span, for the network-status panel.
pub media_bytes:AtomicU64,
pub video_received:AtomicU64,
pub video_expected:AtomicU64,
}
pub struct Peer {
clipboard:super::clipboard::Bridge,
@@ -115,11 +119,22 @@ impl Peer {
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);
let mut span:Option<(u16,u64)>=None;
loop {
let output=tokio::select! {
packet=track.read_rtp()=>match packet {
Ok((p,_))=>{
counters.media_packets.fetch_add(1,Ordering::Relaxed);
counters.media_bytes.fetch_add(p.payload.len() as u64+12,Ordering::Relaxed);
if video {
// Extended sequence span: forward steps add, reordered/old packets do not.
let seq=p.header.sequence_number;
let (last,expected)=span.unwrap_or((seq.wrapping_sub(1),0));
let step=seq.wrapping_sub(last);
span=Some(if step!=0 && step<32768 {(seq,expected+u64::from(step))} else {(last,expected)});
counters.video_expected.store(span.map_or(0,|s|s.1),Ordering::Relaxed);
counters.video_received.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};
@@ -172,10 +187,12 @@ impl Peer {
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");
let desktop_track=shape.capture_type==1;
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 desktop_track {let _=channel.send(&bytes::Bytes::from(wire::request_video_track())).await;}
if chroma444 {let _=channel.send(&bytes::Bytes::from(wire::request_chroma444())).await;}
}
})));
@@ -293,6 +310,25 @@ impl Peer {
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(())
}
/// Binary CONTROL message (protobuf envelope), e.g. capture settings and SimpleActions.
pub async fn send_control(&self,data:Vec<u8>)->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(data)).await.map_err(|_|"CONTROL send failed")?;Ok(())
}
/// Selected ICE pair: (round-trip ms, "UDP · direct" / "TCP · relay" ...). Addresses are not kept.
pub async fn route(&self)->(Option<u32>,String) {
use webrtc::stats::StatsReportType as T;
let report=self.pc.get_stats().await;
let pair=report.reports.values().filter_map(|r|match r{T::CandidatePair(p) if p.nominated=>Some(p),_=>None}).max_by_key(|p|p.bytes_received);
let Some(pair)=pair else {return (None,String::new())};
let local=report.reports.get(&pair.local_candidate_id).and_then(|r|match r{T::LocalCandidate(c)=>Some(c),_=>None});
let remote=report.reports.get(&pair.remote_candidate_id).and_then(|r|match r{T::RemoteCandidate(c)=>Some(c),_=>None});
let relay=[local,remote].iter().flatten().any(|c|c.candidate_type==webrtc::ice::candidate::CandidateType::Relay);
let tcp=local.is_some_and(|c|c.network_type.to_string().to_ascii_lowercase().contains("tcp") || c.relay_protocol.eq_ignore_ascii_case("tcp"));
let rtt=(pair.current_round_trip_time>0.).then(||(pair.current_round_trip_time*1000.).round() as u32);
(rtt,format!("{} · {}",if tcp{"TCP"}else{"UDP"},if relay{"relay"}else{"direct"}))
}
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> {
+608 -25
View File
@@ -1,19 +1,44 @@
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
#[derive(Debug)] enum Command { Files, Type }
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> }
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>,
pub last_frame:Option<Frame>, chrome:Chrome }
/// In-window chrome state (src/viewer/hud.rs): menu, network panel, loading screen.
struct Chrome { font:Option<ab_glyph::FontVec>, scale:f32, pub state:hud::State, menu:hud::Menu, net:Option<hud::NetStats>, tab_hover:bool, tab_down:bool,
commands:Vec<hud::Command>, started:std::time::Instant, last_loading:std::time::Instant, title:String, stage:String, labels:std::collections::HashMap<(String,u32,u32),hud::Layer>,
menu_cache:Option<(hud::State,hud::Menu,f32,hud::Layer)> }
use super::hud;
impl Window {
pub fn new()->Result<Self,String>{
// SDL's default nearest-neighbour scaling makes remote text uneven whenever the window size
// differs from the stream; filter instead. Set before the renderer/textures exist.
sdl2::hint::set_with_priority("SDL_RENDER_SCALE_QUALITY","linear",&sdl2::hint::Hint::Default);
#[cfg(uu_gtk)] cairo_decorations();
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 name=super::device_label(std::env::var("UU_VIEWER_DEVICE_NAME").ok().as_deref()).to_owned();
let window=video.window(&format!("{name} · {}",crate::i18n::s("UU 远程 Linux 控制端","UU Remote Linux viewer")),1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
let mut canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
// Wayland maps a toplevel only after its first buffer; without this the window stays
// invisible until the first decoded frame, which a stalled stream never delivers.
canvas.set_draw_color(LOADING_BG);canvas.clear();canvas.present();
let scale=std::env::var("UU_VIEWER_UI_SCALE").ok().and_then(|v|v.parse::<f32>().ok()).filter(|v|(0.5..=4.).contains(v)).unwrap_or(1.);
let mut state=hud::State::default();hud::load_prefs(&mut state);
let now=std::time::Instant::now();
let chrome=Chrome{font:hud::load_font(),scale,state,menu:hud::Menu::default(),net:None,tab_hover:false,tab_down:false,commands:Vec::new(),started:now,last_loading:now-std::time::Duration::from_secs(1),
title:crate::tr!("正在连接 {name}","Connecting to {name}"),stage:crate::i18n::s("正在连接远端设备…","Contacting the remote device…").into(),labels:Default::default(),menu_cache:None};
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})
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests,last_frame:None,chrome})
}
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 viewport(&self)->Viewport {
let window=self.canvas.window().size();
if !self.chrome.state.one_to_one {return Viewport::fit(window,self.frame)}
let (w,h)=(self.frame.0 as f64,self.frame.1 as f64);
Viewport{x:((window.0 as f64-w)/2.).round(),y:((window.1 as f64-h)/2.).round(),width:w,height:h}
}
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(){
@@ -36,12 +61,255 @@ impl Window {
}
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)
let mut redraw=false;
let events=poll_events(&mut self.events);
let mut forward=Vec::with_capacity(events.len());
for event in events {
if matches!(event,Event::ClipboardUpdate{..}|Event::Window{win_event:WindowEvent::FocusGained,..}){self.clipboard_dirty=true;}
redraw|=needs_redraw(&event);
let (consumed,changed)=self.chrome_event(&event);redraw|=changed;
if !consumed {forward.push(event);}
}
let result=translate_actions(forward,input,viewport,&mut self.focused,&mut self.files);
// A compositor resize (tiling, maximize) leaves the surface without a buffer of the new size
// until the next frame; a static remote desktop sends none, so repaint the last frame now.
if redraw {if let Some(frame)=self.last_frame.take(){
log::debug!("Viewer window resized: {:?}",self.canvas.window().size());
if let Err(e)=self.draw(&frame){log::warn!("Viewer redraw failed: {e}");}
self.last_frame=Some(frame);
}else{self.loading_frame(true);}}
result
}
/// Menu, hotkeys and the control tab. Returns (consumed, needs redraw).
fn chrome_event(&mut self,event:&Event)->(bool,bool){
use sdl2::keyboard::{Mod,Scancode};
let size=self.canvas.window().size();let scale=self.chrome.scale;
let tab=hud::tab_rect(self.chrome.font.as_ref(),size,scale);
let tab_visible=self.tab_visible();
if let Event::KeyDown{scancode:Some(code),keymod,repeat,..}=event {
let chord=keymod.intersects(Mod::LCTRLMOD|Mod::RCTRLMOD)&&keymod.intersects(Mod::LALTMOD|Mod::RALTMOD);
let command=match code {Scancode::M=>Some(None),Scancode::G=>Some(Some(hud::Command::Stats(!self.chrome.state.stats))),Scancode::Return=>Some(Some(hud::Command::Fullscreen)),_=>None};
if chord { if let Some(command)=command {
if !repeat { match command {None=>self.chrome.menu.open^=true,Some(c)=>self.command(c)} }
return (true,true)
}}
if self.chrome.menu.open { if *code==Scancode::Escape {self.chrome.menu.open=false;} return (true,true) }
}
if !self.chrome.menu.open {
return match *event {
Event::MouseMotion{x,y,..}=>{let h=tab_visible&&tab.contains(x as f32,y as f32);let changed=h!=self.chrome.tab_hover;self.chrome.tab_hover=h;(false,changed)},
Event::MouseButtonDown{x,y,mouse_btn:MouseButton::Left,..} if tab_visible&&tab.contains(x as f32,y as f32)=>{self.chrome.menu.open=true;self.chrome.tab_down=true;(true,true)},
Event::MouseButtonUp{mouse_btn:MouseButton::Left,..} if self.chrome.tab_down=>{self.chrome.tab_down=false;(true,false)},
_=>(false,false),
}
}
let lay=hud::layout(self.chrome.font.as_ref(),&self.chrome.state,&self.chrome.menu,scale);let origin=self.menu_origin(&lay);
let hit=|x:i32,y:i32|->Option<hud::Hit>{
let (lx,ly)=(x as f32-origin.0,y as f32-origin.1);
if tab.contains(x as f32,y as f32) {return Some(hud::Hit::Tab)}
if !lay.panels.iter().any(|p|p.contains(lx,ly)) {return None}
Some(lay.items.iter().find(|(r,_)|r.contains(lx,ly)).map_or(hud::Hit::Panel,|(_,h)|*h))
};
match *event {
Event::MouseMotion{x,y,..}=>{
if self.chrome.menu.dragging { if let Some((a,len))=slider(&lay) {self.command(hud::Command::Volume(hud::slider_value(x as f32-origin.0,a,len)));} return (true,true) }
let h=hit(x,y);
if let Some(hud::Hit::Category(i))=h { if hud::category_command(i).is_none() {self.chrome.menu.category=i;} }
let changed=h!=self.chrome.menu.hover;self.chrome.menu.hover=h;(true,changed)
},
Event::MouseButtonDown{x,y,mouse_btn:MouseButton::Left,..}=>{
match hit(x,y) {
None|Some(hud::Hit::Tab)=>{self.chrome.menu.open=false;self.chrome.tab_down=true},
Some(hud::Hit::Category(i))=>match hud::category_command(i) {Some(c)=>{self.chrome.menu.open=false;self.command(c)},None=>self.chrome.menu.category=i},
Some(hud::Hit::Option(c,i))=>if let Some(command)=hud::option_command(&self.chrome.state,c,i) {
if command==hud::Command::Files {self.chrome.menu.open=false;}
self.command(command);
},
Some(hud::Hit::Slider(a,len))=>{self.chrome.menu.dragging=true;self.command(hud::Command::Volume(hud::slider_value(x as f32-origin.0,a,len)))},
Some(hud::Hit::Panel)=>{},
}
(true,true)
},
Event::MouseButtonUp{..}=>{self.chrome.tab_down=false;if std::mem::take(&mut self.chrome.menu.dragging){hud::save_prefs(&self.chrome.state);}(true,true)},
Event::MouseButtonDown{..}|Event::MouseWheel{..}|Event::KeyUp{..}|Event::TextInput{..}=>(true,false),
_=>(false,false),
}
}
/// Local effects happen here; remote ones are drained by `run` through `take_commands`.
fn command(&mut self,command:hud::Command){
let st=&mut self.chrome.state;
match command {
hud::Command::Quality(q)=>{st.quality=q;hud::save_prefs(st)}, hud::Command::Fps(f)=>{st.fps=f;hud::save_prefs(st)},
hud::Command::Chroma(c)=>{st.chroma=c;hud::save_prefs(st)},
hud::Command::FollowRemote(b)=>st.follow_remote=b, hud::Command::Volume(v)=>st.volume=v,
hud::Command::AutoLock(b)=>st.auto_lock=b, hud::Command::HostMute(b)=>st.host_mute=b, hud::Command::Watch(b)=>st.watch=b,
hud::Command::OneToOne(b)=>{st.one_to_one=b;hud::save_prefs(st)},
hud::Command::Stats(b)=>{st.stats=b;hud::save_prefs(st)},
hud::Command::HideTab(b)=>{st.hide_tab=b;hud::save_prefs(st)},
hud::Command::GrabKeys(b)=>{st.grab_keys=b;self.canvas.window_mut().set_keyboard_grab(b)},
hud::Command::Fullscreen=>{
st.fullscreen^=true;let mode=if st.fullscreen{sdl2::video::FullscreenType::Desktop}else{sdl2::video::FullscreenType::Off};
let _=self.canvas.window_mut().set_fullscreen(mode);
},
hud::Command::Files=>self.files=true,
hud::Command::Disconnect=>{},
}
self.chrome.commands.push(command);
}
pub fn take_commands(&mut self)->Vec<hud::Command>{std::mem::take(&mut self.chrome.commands)}
/// The host starts every session at the official defaults; repeat the saved choices that differ.
pub fn restore_remote_settings(&mut self){
let(st,d)=(&self.chrome.state,hud::State::default());let c=&mut self.chrome.commands;
if st.quality!=d.quality {c.push(hud::Command::Quality(st.quality));}
if st.fps!=d.fps {c.push(hud::Command::Fps(st.fps));}
if st.chroma!=d.chroma {c.push(hud::Command::Chroma(st.chroma));}
}
pub fn state(&self)->&hud::State{&self.chrome.state}
pub fn sync_chroma(&mut self,chroma:u32){if chroma!=0 {self.chrome.state.chroma=chroma;}}
pub fn set_stage(&mut self,stage:&str){self.chrome.stage=stage.into();}
pub fn window_size(&self)->(u32,u32){self.canvas.window().size()}
pub fn has_picture(&self)->bool{self.last_frame.is_some()}
pub fn set_net(&mut self,net:hud::NetStats){
let show=self.chrome.state.stats;let changed=self.chrome.net.as_ref()!=Some(&net);
self.chrome.net=Some(net);
if show && changed {self.redraw();}
}
fn tab_visible(&self)->bool{!(self.chrome.state.fullscreen&&self.chrome.state.hide_tab)||self.chrome.menu.open}
fn menu_layout(&self)->(hud::Layer,hud::Layout){hud::menu_layer(self.chrome.font.as_ref(),&self.chrome.state,&self.chrome.menu,self.chrome.scale)}
fn menu_origin(&self,lay:&hud::Layout)->(f32,f32){
let size=self.canvas.window().size();
// The category list sits centered under the tab; the cascade card grows to its right.
let shadow=14.*self.chrome.scale;let main=lay.panels.first().map_or(lay.w,|p|p.w);
(((size.0 as f32-main)/2.-shadow).max(-shadow).min(size.0 as f32-lay.w+shadow).round(),(hud::TAB_H*self.chrome.scale+4.-shadow).round())
}
pub fn redraw(&mut self){
if let Some(frame)=self.last_frame.take(){if let Err(e)=self.draw(&frame){log::warn!("Viewer redraw failed: {e}");}self.last_frame=Some(frame);}
else {self.loading_frame(true);}
}
fn blit(&mut self,layer:&hud::Layer,x:i32,y:i32)->Result<(),String>{
let creator=self.canvas.texture_creator();
let mut t=creator.create_texture_streaming(PixelFormatEnum::RGBA32,layer.w,layer.h).map_err(|_|"Texture creation failed")?;
t.set_blend_mode(sdl2::render::BlendMode::Blend);
t.update(None,&layer.px,layer.w as usize*4).map_err(|_|"Texture update failed")?;
self.canvas.copy(&t,None,Some(Rect::new(x,y,layer.w,layer.h)))
}
fn label(&mut self,text:&str,size:f32,color:hud::Rgba)->hud::Layer{
let key=(text.to_owned(),size.to_bits(),u32::from_le_bytes(color));
if self.chrome.labels.len()>64 {self.chrome.labels.clear();}
let font=self.chrome.font.as_ref();
let layer=self.chrome.labels.entry(key).or_insert_with(||hud::label_layer(font,text,size,color));
hud::Layer{w:layer.w,h:layer.h,px:layer.px.clone()}
}
/// Network panel, control tab and menu over the picture.
fn draw_chrome(&mut self)->Result<(),String>{
let size=self.canvas.window().size();let scale=self.chrome.scale;
if self.chrome.state.stats { if let Some(net)=self.chrome.net.clone() {
let layer=hud::stats_layer(self.chrome.font.as_ref(),&hud::stats_lines(&net),scale);
self.blit(&layer,size.0 as i32-layer.w as i32-(12.*scale) as i32,size.1 as i32-layer.h as i32-(12.*scale) as i32)?;
}}
if self.tab_visible() {
let r=hud::tab_rect(self.chrome.font.as_ref(),size,scale);
let layer=hud::tab_layer(self.chrome.font.as_ref(),scale,self.chrome.tab_hover||self.chrome.menu.open);
self.blit(&layer,r.x.round() as i32,0)?;
}
if self.chrome.menu.open {
// Rasterizing the menu is costly; reuse it until what it shows changes.
let c=&self.chrome;
let cached=matches!(&c.menu_cache,Some((st,m,sc,_)) if *st==c.state&&*m==c.menu&&*sc==c.scale);
if !cached {let (layer,_)=self.menu_layout();self.chrome.menu_cache=Some((self.chrome.state.clone(),self.chrome.menu.clone(),scale,layer));}
let lay=hud::layout(self.chrome.font.as_ref(),&self.chrome.state,&self.chrome.menu,scale);let o=self.menu_origin(&lay);
let (st,m,sc,layer)=self.chrome.menu_cache.take().expect("menu cached above");
let r=self.blit(&layer,o.0 as i32,o.1 as i32);
self.chrome.menu_cache=Some((st,m,sc,layer));r?;
}
Ok(())
}
/// Animated "connecting" screen until the first remote picture; throttled to ~60 fps.
pub fn loading_frame(&mut self,force:bool){
let now=std::time::Instant::now();
if !force && now.duration_since(self.chrome.last_loading)<std::time::Duration::from_millis(16) {return}
self.chrome.last_loading=now;
let size=self.canvas.window().size();let scale=self.chrome.scale;
self.canvas.set_draw_color(LOADING_BG);self.canvas.clear();
let t=now.duration_since(self.chrome.started).as_secs_f32();
let spin=hud::spinner(t,(56.*scale) as u32);
let cy=size.1 as i32/2-(40.*scale) as i32;
let _=self.blit(&spin,(size.0 as i32-spin.w as i32)/2,cy-spin.h as i32/2);
let (title,stage)=(self.chrome.title.clone(),self.chrome.stage.clone());
let a=self.label(&title,20.*scale,[240,242,245,255]);
let _=self.blit(&a,(size.0 as i32-a.w as i32)/2,cy+(48.*scale) as i32);
// The stage line breathes gently so a long wait still looks alive.
let alpha=(170.+60.*(t*2.2).sin()) as u8;
let b=self.label(&stage,14.*scale,[160,166,176,255]);
let mut b2=b;for p in b2.px.chunks_exact_mut(4){p[3]=(u16::from(p[3])*u16::from(alpha)/255) as u8;}
let _=self.blit(&b2,(size.0 as i32-b2.w as i32)/2,cy+(84.*scale) as i32);
if self.chrome.menu.open||self.tab_visible() {let _=self.draw_chrome();}
self.canvas.present();
}
fn draw(&mut self,frame:&Frame)->Result<(),String>{
// Pad bars belong to the decoded canvas, not the remote picture: viewport and input use the
// content aspect, and only the content sub-rectangle of the texture is drawn.
let content=frame.content.unwrap_or((frame.width,frame.height));
self.frame=content;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();
let src=super::input::content_rect((frame.width,frame.height),content)
.map(|(x,y,w,h)|Rect::new(x.round() as i32,y.round() as i32,w.round().max(1.) as u32,h.round().max(1.) as u32));
self.canvas.copy(&texture,src,Some(Rect::new(v.x.round() as i32,v.y.round() as i32,v.width.round().max(1.) as u32,v.height.round().max(1.) as u32)))?;
drop(texture);self.draw_chrome()?;self.canvas.present();Ok(())
}
}
/// On Wayland SDL draws its title bar through libdecor; the GTK plugin calls GTK3 from SDL's thread
/// while the tool windows run gtk_main on theirs, and the two crash in GTK's style code (SIGSEGV on
/// closing the file window). Offer libdecor only its cairo plugin unless the user chose a directory.
#[cfg(uu_gtk)]
fn cairo_decorations(){
if std::env::var_os("LIBDECOR_PLUGIN_DIR").is_some() {return}
let Some(cairo)=["/usr/lib64/libdecor/plugins-1","/usr/lib/x86_64-linux-gnu/libdecor/plugins-1","/usr/lib/libdecor/plugins-1"]
.iter().map(|d|std::path::Path::new(d).join("libdecor-cairo.so")).find(|p|p.exists()) else {return};
let dir=std::env::var_os("XDG_RUNTIME_DIR").map_or_else(std::env::temp_dir,std::path::PathBuf::from).join("uuremote-libdecor");
let link=dir.join("libdecor-cairo.so");
if std::fs::create_dir_all(&dir).is_ok() && (link.exists() || std::os::unix::fs::symlink(&cairo,&link).is_ok()) {
std::env::set_var("LIBDECOR_PLUGIN_DIR",&dir);
}
}
const LOADING_BG:sdl2::pixels::Color=sdl2::pixels::Color::RGB(17,19,24);
/// sdl2 0.37 transmutes every event type into its `SDL_EventType` enum, which is undefined
/// behaviour for a type SDL 2 does not define (an abort with debug checks). sdl2-compat on SDL3
/// delivers such types (e.g. 0x207), so drop them before the crate converts the event.
fn poll_events(_pump:&mut sdl2::EventPump)->Vec<Event>{
let mut events=Vec::new();
loop{
let mut raw=std::mem::MaybeUninit::<sdl2::sys::SDL_Event>::uninit();
// SAFETY: the pump proves SDL events are initialised on this thread; SDL_PollEvent fills the event when it returns 1.
if unsafe{sdl2::sys::SDL_PollEvent(raw.as_mut_ptr())}!=1 {return events}
let raw=unsafe{raw.assume_init()};
if sdl2_event_type(unsafe{raw.type_}) {events.push(Event::from_ll(raw));}
}
}
/// The values of sdl2-sys 0.37 `SDL_EventType`.
fn sdl2_event_type(t:u32)->bool{
matches!(t,0|0x100..=0x107|0x150|0x200|0x201|0x300..=0x305|0x400..=0x403|0x600..=0x607|0x650..=0x659|0x700..=0x702
|0x800..=0x802|0x900|0x1000..=0x1003|0x1100|0x1101|0x1200|0x2000|0x2001|0x7F00|0x8000|0xFFFF)
}
fn slider(lay:&hud::Layout)->Option<(f32,f32)>{lay.items.iter().find_map(|(_,h)|match h{hud::Hit::Slider(a,len)=>Some((*a,*len)),_=>None})}
/// Runs `fut` while the window shows the loading animation; closing the window cancels it.
pub async fn loading<T>(window:Option<&mut Window>,stage:&str,fut:impl std::future::Future<Output=T>)->Result<T,String>{
let Some(window)=window else {return Ok(fut.await)};
window.set_stage(stage);
tokio::pin!(fut);
let mut tick=tokio::time::interval(std::time::Duration::from_millis(16));
loop {tokio::select!{
value=&mut fut=>return Ok(value),
_=tick.tick()=>{
for event in poll_events(&mut window.events) {
if matches!(event,Event::Quit{..}|Event::Window{win_event:WindowEvent::Close,..}) {return Err("Viewer window closed".into())}
let _=window.chrome_event(&event);
}
window.loading_frame(false);
},
}}
}
fn clipboard_text(bytes:&[u8])->Option<String>{
if bytes.len()>super::clipboard::MAX_TEXT{return None}
@@ -79,44 +347,102 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
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)),
Event::MouseWheel{x,y,precise_x,precise_y,direction,..}=>{
let(dx,dy)=if precise_x!=0.||precise_y!=0.{(f64::from(precise_x),f64::from(precise_y))}else{(f64::from(x),f64::from(y))};
let(dx,dy)=match direction{sdl2::mouse::MouseWheelDirection::Flipped=>(-dx,-dy),_=>(dx,dy)};
input.scroll(dx,dy)
},
_=>None,
};if let Some(m)=message{messages.push(m);}
};if let Some(m)=message{
// Several motions in one poll: only the newest position matters. Sending each one
// queues a drag behind itself on a slow (relayed) path; clicks keep their order.
let motion=|m:&serde_json::Value|m.get("action").and_then(serde_json::Value::as_str)==Some("mouse_move_absolute");
if motion(&m) && messages.last().is_some_and(motion) {messages.pop();}
messages.push(m);
}
} (quit,messages)
}
fn needs_redraw(event:&Event)->bool{
matches!(event,Event::Window{win_event:WindowEvent::SizeChanged(..)|WindowEvent::Resized(..)|WindowEvent::Exposed|WindowEvent::Maximized|WindowEvent::Restored,..})
}
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(())
self.last_frame=Some(Frame{width:frame.width,height:frame.height,rgb:frame.rgb.clone(),content:frame.content});
self.draw(frame)
}
}
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool)->Result<(),String>{
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool,device:&str)->Result<(),String>{
#[cfg(uu_gtk)]
let mut files:Option<tokio::task::JoinHandle<Result<(),String>>>=None;
let(tx,mut commands)=tokio::sync::mpsc::channel(8);
let(tx,mut commands)=tokio::sync::mpsc::channel::<Command>(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();}
if byte[0]==b'\n'{
let cmd=match line.as_slice(){b"files"=>Some(Command::Files),b"type"=>Some(Command::Type),_=>None};
line.clear();
if let Some(cmd)=cmd { if tx.blocking_send(cmd).is_err(){break} }
}
else if line.len()<32{line.push(byte[0]);}else{break}
}
});
}else{drop(tx);}
let mut command_open=true;let mut requested=false;
let(type_tx,mut type_rx)=tokio::sync::mpsc::channel::<super::type_ipc::PendingType>(4);
let type_ipc=match super::type_ipc::Server::bind(device).await {
Ok(server)=>{
log::info!("Type IPC ready for device key {}", &super::type_ipc::device_key(device)[..12]);
Some(tokio::spawn(async move { server.run(type_tx).await; }))
}
Err(e)=>{ log::warn!("Type IPC not started: {e}"); None }
};
let mut command_open=true;let mut requested=false;let mut type_requested=false;let mut restored=false;
let mut type_job:Option<TypeJob>=None;
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);
window.set_stage(crate::i18n::s("正在传输画面…","Waiting for the remote picture…"));
if let Some(playback)=audio.as_mut(){playback.volume=window.state().volume;}
if window.state().grab_keys {window.canvas.window_mut().set_keyboard_grab(true);}
let started=std::time::Instant::now();let mut seq=3_000_000u64;
let mut last=(0u64,0u64,0u64,0u64,std::time::Instant::now());
let mut codec_name="--";
// After a local drop the decoder has no reference picture; P-frames would only smear blocks.
let mut key_gate=super::desktop::KeyGate::new();
let mut next_thumb=std::time::Instant::now()+std::time::Duration::from_secs(5);
let result=async {
loop {tokio::select!{
command=commands.recv(),if command_open=>{if command.is_some(){requested=true}else{command_open=false}},
command=commands.recv(),if command_open=>{
match command {
Some(Command::Files)=>{requested=true},
Some(Command::Type)=>{type_requested=true},
None=>{command_open=false},
}
},
pending=type_rx.recv()=>{
if let Some(mut pending)=pending {
if type_job.is_some() {
let _=pending.reply.send(super::type_ipc::TypeResponse{ok:false,events:0,chars:0,snapshot:None,error:Some("Secure input busy".into())});
} else {
let mut snapshot_create_new=false;
if pending.request.snapshot.as_ref().map_or(true, |s| s.is_empty()) {
if let Ok(path)=super::type_ipc::default_snapshot_path(device) {
pending.request.snapshot=Some(path.display().to_string());
snapshot_create_new=true;
}
}
match start_type_job(pending, window.mac, input.enabled(), snapshot_create_new) {
Ok(job)=>type_job=Some(job),
Err(())=>{},
}
}
}
},
_=terminate.recv()=>return Ok(()),
_=tokio::signal::ctrl_c()=>return Ok(()),
result=session.step()=>result?,
@@ -126,10 +452,48 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
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));
// Network-status panel: per-second deltas of local counters plus the selected ICE pair.
let now=(s[1].load(r),o.media_bytes.load(r),o.video_received.load(r),o.video_expected.load(r),std::time::Instant::now());
let secs=now.4.duration_since(last.4).as_secs_f64().max(0.2);
let expected=now.3.saturating_sub(last.3);let lost=expected.saturating_sub(now.2.saturating_sub(last.2));
let (rtt_ms,route)=session.peer.route().await;
window.sync_chroma(o.chroma.load(r));
let size=window.last_frame.as_ref().map_or((0,0),|f|f.content.unwrap_or((f.width,f.height)));
window.set_net(hud::NetStats{elapsed:started.elapsed().as_secs(),route,fps:((now.0-last.0) as f64/secs).round() as u32,
kbps:(now.1-last.1) as f64*8./1000./secs,rtt_ms,loss:if expected>0 {lost as f64*100./expected as f64} else {0.},size,
codec:codec_name,chroma:window.state().chroma});
last=now;
if std::time::Instant::now()>=next_thumb { if let Some(frame)=window.last_frame.as_ref() {
if let Err(e)=super::thumbs::save(device,frame){log::debug!("Viewer thumbnail not saved: {e}");}
next_thumb=std::time::Instant::now()+std::time::Duration::from_secs(30);
}}
},
_=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);
let (quit,mut messages)=window.poll(&mut input);
if !window.has_picture() {window.loading_frame(false);}
if !restored && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false) {restored=true;window.restore_remote_settings();}
for command in window.take_commands() {
seq+=1;
let control=match command {
hud::Command::Quality(q)=>Some(super::wire::capture_setting(seq,&[(2,q)])),
hud::Command::Fps(f)=>Some(super::wire::capture_setting(seq,&[(1,match f{30=>1,60=>2,90=>3,_=>4}),(18,u64::from(f))])),
hud::Command::Chroma(c)=>Some(super::wire::capture_setting(seq,&[(7,u64::from(c))])),
hud::Command::FollowRemote(true)=>Some(super::wire::capture_setting(seq,&[(10,3)])),
hud::Command::FollowRemote(false)=>{let (w,h)=window.window_size();let (w,h)=(u64::from(w&!1),u64::from(h&!1));
Some(super::wire::capture_setting(seq,&[(5,w),(6,h),(16,w),(17,h)]))},
// 远程结束后自动锁屏: SimpleAction 19, value 2 = on, 1 = off.
hud::Command::AutoLock(on)=>Some(super::wire::simple_action(seq,19,Some(if on {2} else {1}))),
// 静音运行: on = SimpleAction 14 then 18, off = 16 (src/system_actions.rs).
hud::Command::HostMute(true)=>{let _=session.peer.send_control(super::wire::simple_action(seq,14,None)).await;seq+=1;Some(super::wire::simple_action(seq,18,None))},
hud::Command::HostMute(false)=>Some(super::wire::simple_action(seq,16,None)),
hud::Command::Volume(v)=>{if let Some(playback)=audio.as_mut(){playback.volume=v;}None},
hud::Command::Watch(on)=>{messages.extend(input.release_all());input.set_view_only(on||view_only);None},
hud::Command::Disconnect=>return Ok(()),
_=>None,
};
if let Some(data)=control { if let Err(e)=session.peer.send_control(data).await {log::warn!("Viewer control command not sent: {e}");} }
}
window.poll_clipboard();
requested|=std::mem::take(&mut window.files);
#[cfg(uu_gtk)] {
@@ -145,22 +509,198 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
}
}
#[cfg(not(uu_gtk))] {if requested{log::warn!("File window requires GTK3");requested=false;}}
if type_requested {
type_requested=false;
if type_job.is_some() {
log::warn!("Secure type command ignored: busy");
} else if !input.enabled() {
log::warn!("Secure type command ignored: view-only session");
} else if std::env::var_os("UU_INPUT_ENV").is_none() {
log::warn!("Secure type command ignored: set UU_INPUT_ENV (stdin is the command channel)");
} else {
match super::secure_input::load_secret(std::io::Cursor::new([] as [u8;0])) {
Ok(mut secret)=>{
match enqueue_local_type(&mut type_job, &mut secret, window.mac, None, 0, std::time::Duration::ZERO, None) {
Ok(())=>{},
Err(e)=>log::warn!("Secure type failed: {e}"),
}
}
Err(e)=>log::warn!("Secure type load failed: {e}"),
}
}
}
if let Some(job)=type_job.as_mut() {
if let Err(e)=pump_type_job(job, session, window).await {
log::warn!("Secure type job failed: {e}");
type_job=None;
} else if job.done {
type_job=None;
}
}
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)?;}
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();key_gate.arm();}
if !key_gate.admit(au.codec,&au.data) {session.peer.desktop.pli.store(true,std::sync::atomic::Ordering::Release);super::desktop::drain(decoder,window)?;}
else {
decoder.set_codec(au.codec)?;
codec_name=if au.codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;
}}
// A picture can finish after its access unit was written; show it without waiting
// for the next one (a single keystroke may change the remote screen only once).
else {super::desktop::drain(decoder,window)?;}
}
}}
}.await;
if let Some(frame)=window.last_frame.as_ref() {if let Err(e)=super::thumbs::save(device,frame){log::debug!("Viewer thumbnail not saved: {e}");}}
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
if let Some(t)=type_ipc {t.abort();let _=t.await;}
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
result
}
struct TypeJob {
actions: super::secure_input::ActionList,
index: usize,
delay: std::time::Duration,
next_at: tokio::time::Instant,
chars: usize,
snapshot_path: Option<std::path::PathBuf>,
snapshot_create_new: bool,
phase: TypePhase,
reply: Option<tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>>,
done: bool,
}
enum TypePhase { Sending, WaitSnap(tokio::time::Instant) }
fn start_type_job(mut pending: super::type_ipc::PendingType, mac: bool, enabled: bool, snapshot_create_new: bool) -> Result<TypeJob, ()> {
let reply = pending.reply;
let respond_err = |reply: tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>, msg: String| {
let _ = reply.send(super::type_ipc::TypeResponse{ok:false,events:0,chars:0,snapshot:None,error:Some(msg)});
};
if !enabled {
respond_err(reply, "view-only session".into());
return Err(());
}
let mut secret = super::secure_input::Secret::new(std::mem::take(&mut pending.request.secret));
if let Err(e) = secret.omit_last_chars(pending.request.omit_last) {
respond_err(reply, e);
return Err(());
}
let chars = secret.chars_count();
let actions = match super::secure_input::expand(secret.as_str(), mac) {
Ok(a) => a,
Err(e) => { respond_err(reply, e); return Err(()); }
};
drop(secret);
log::info!("Secure input prepared: chars={} events={} delay_ms={}", chars, actions.len(), pending.request.delay_ms);
let snapshot_path = pending.request.snapshot.as_ref().filter(|s| !s.is_empty()).map(std::path::PathBuf::from);
Ok(TypeJob {
actions,
index: 0,
delay: std::time::Duration::from_millis(pending.request.delay_ms.min(5_000)),
next_at: tokio::time::Instant::now(),
chars,
snapshot_path,
snapshot_create_new,
phase: TypePhase::Sending,
reply: Some(reply),
done: false,
})
}
fn enqueue_local_type(
slot: &mut Option<TypeJob>,
secret: &mut super::secure_input::Secret,
mac: bool,
snapshot: Option<std::path::PathBuf>,
omit_last: usize,
delay: std::time::Duration,
reply: Option<tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>>,
) -> Result<(), String> {
secret.omit_last_chars(omit_last)?;
let chars = secret.chars_count();
let actions = super::secure_input::expand(secret.as_str(), mac)?;
drop(std::mem::replace(secret, super::secure_input::Secret::new(String::new())));
log::info!("Secure input prepared: chars={} events={}", chars, actions.len());
*slot = Some(TypeJob {
actions,
index: 0,
delay,
next_at: tokio::time::Instant::now(),
chars,
snapshot_path: snapshot,
snapshot_create_new: false,
phase: TypePhase::Sending,
reply,
done: false,
});
Ok(())
}
async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Window) -> Result<(), String> {
use super::type_ipc::TypeResponse;
match job.phase {
TypePhase::Sending => {
if !session.peer.ready(super::rtc::ReadyPolicy::EchoOnly, false) {
return Ok(());
}
if tokio::time::Instant::now() < job.next_at {
return Ok(());
}
if job.index >= job.actions.len() {
let wait = tokio::time::Instant::now() + std::time::Duration::from_secs(1);
job.phase = TypePhase::WaitSnap(wait);
return Ok(());
}
let action = &job.actions[job.index];
session.peer.send_input(&action.to_json()).await?;
job.index += 1;
if !job.delay.is_zero() {
job.next_at = tokio::time::Instant::now() + job.delay;
}
Ok(())
}
TypePhase::WaitSnap(deadline) => {
if tokio::time::Instant::now() < deadline {
return Ok(());
}
let mut snap = None;
if let Some(path) = job.snapshot_path.clone() {
if let Some(frame) = window.last_frame.as_ref() {
match super::type_ipc::write_png_rgb(&path, frame.width, frame.height, &frame.rgb, job.snapshot_create_new) {
Ok(()) => {
log::info!("Secure input snapshot written: {}", path.display());
snap = Some(path.display().to_string());
}
Err(e) => log::warn!("Secure input snapshot failed: {e}"),
}
} else {
log::warn!("Secure input snapshot skipped: no decoded frame yet");
}
}
let events = job.actions.len();
let chars = job.chars;
if let Some(reply) = job.reply.take() {
let _ = reply.send(TypeResponse {
ok: true,
events,
chars,
snapshot: snap,
error: None,
});
} else {
log::info!("Secure input finished: chars={} events={}", chars, events);
}
job.done = true;
Ok(())
}
}
}
#[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.
@@ -205,6 +745,15 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
assert!(tx.is_closed());drop(bridge);
let window=Window::new().unwrap();assert!(window.clipboard_bridge().enabled);
}
#[test] fn only_event_types_sdl2_defines_reach_the_crate(){
use sdl2::sys::SDL_EventType as T;
for t in [T::SDL_QUIT,T::SDL_LOCALECHANGED,T::SDL_DISPLAYEVENT,T::SDL_WINDOWEVENT,T::SDL_TEXTEDITING_EXT,T::SDL_MOUSEWHEEL,
T::SDL_JOYBATTERYUPDATED,T::SDL_CONTROLLERSENSORUPDATE,T::SDL_FINGERMOTION,T::SDL_MULTIGESTURE,T::SDL_CLIPBOARDUPDATE,
T::SDL_DROPCOMPLETE,T::SDL_AUDIODEVICEREMOVED,T::SDL_SENSORUPDATE,T::SDL_RENDER_DEVICE_RESET,T::SDL_POLLSENTINEL,T::SDL_USEREVENT]{
assert!(sdl2_event_type(t as u32),"{:#x}",t as u32);
}
for t in [0x151,0x202,0x207,0x306,0x404,0x608,0x65A,0x703,0x901,0x1004,0x1102,0x1201,0x2002,0x8001]{assert!(!sdl2_event_type(t),"{t:#x}");}
}
#[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()));
@@ -223,6 +772,29 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
assert!(input.release_all().is_empty());
}
}
#[test] fn compositor_resize_and_expose_repaint_the_last_frame(){
let w=|win_event|Event::Window{timestamp:0,window_id:1,win_event};
for e in [WindowEvent::SizeChanged(1280,800),WindowEvent::Resized(1280,800),WindowEvent::Exposed,WindowEvent::Maximized,WindowEvent::Restored]{assert!(needs_redraw(&w(e)));}
for e in [WindowEvent::FocusGained,WindowEvent::Moved(0,0)]{assert!(!needs_redraw(&w(e)));}
}
#[test] fn wheel_events_become_scroll_messages(){
use sdl2::mouse::MouseWheelDirection;
let mut input=Input::default();let mut focused=true;
let v=Viewport::fit((800,600),(1920,1080));
let wheel=|direction,x,y|Event::MouseWheel{timestamp:0,window_id:1,which:0,mouse_x:0,mouse_y:0,x,y,precise_x:0.,precise_y:0.,direction};
let(_,out)=translate([wheel(MouseWheelDirection::Normal,0,1),wheel(MouseWheelDirection::Flipped,0,1),wheel(MouseWheelDirection::Normal,0,0)],&mut input,v,&mut focused);
assert_eq!(out.len(),2);
assert_eq!(out[0]["action"],"mouse_scroll");
assert_eq!(out[0]["delta_y"],120);
assert_eq!(out[1]["delta_y"],-120);
// Trackpads report fractional precise deltas; a quarter notch is 30 wire units.
let precise=Event::MouseWheel{timestamp:0,window_id:1,which:0,mouse_x:0,mouse_y:0,x:0,y:0,precise_x:0.,precise_y:-0.25,direction:MouseWheelDirection::Normal};
let(_,out)=translate([precise],&mut input,v,&mut focused);
assert_eq!(out[0]["delta_y"],-30);
let mut watch=Input::new(true);let mut watching=true;
let(_,out)=translate([wheel(MouseWheelDirection::Normal,0,1)],&mut watch,v,&mut watching);
assert!(out.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());
@@ -237,6 +809,17 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
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 motions_in_one_poll_send_only_the_newest_and_keep_click_order(){
let mut input=Input::default();let mut focused=true;
let motion=|x,y|Event::MouseMotion{timestamp:0,window_id:1,which:0,mousestate:sdl2::mouse::MouseState::from_sdl_state(0),x,y,xrel:1,yrel:1};
let down=Event::MouseButtonDown{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:0,y:0};
let v=Viewport::fit((800,600),(800,600));
let (_,out)=translate([motion(10,10),motion(20,20),down,motion(30,30),motion(40,40)],&mut input,v,&mut focused);
let actions:Vec<&str>=out.iter().map(|m|m["action"].as_str().unwrap()).collect();
assert_eq!(actions.len(),3,"{out:?}");
assert_eq!(actions[0],"mouse_move_absolute");assert_eq!(actions[2],"mouse_move_absolute");assert_ne!(actions[1],"mouse_move_absolute");
assert!((out[0]["abs_x"].as_f64().unwrap()-20./800.).abs()<0.01 && (out[2]["abs_x"].as_f64().unwrap()-40./800.).abs()<0.01,"{out:?}");
}
#[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};
+731
View File
@@ -0,0 +1,731 @@
//! Compose CONTROL keyboard JSON for scripted typing. Secrets never appear in logs or Debug.
use serde_json::{json, Value};
use std::fmt;
use std::io::{BufRead, Read};
use std::ops::{Deref, DerefMut};
#[cfg(test)]
use std::sync::Mutex;
use std::time::Duration;
/// Serializes tests that mutate process environment.
#[cfg(test)]
pub static ENV_LOCK: Mutex<()> = Mutex::new(());
/// Holds secret text; Debug/Display only show length.
pub struct Secret(String);
impl Secret {
pub fn new(value: String) -> Self {
Self(value)
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn chars_count(&self) -> usize {
self.0.chars().count()
}
/// Drop the last `n` Unicode scalars (fill-without-submit for Windows PIN).
pub fn omit_last_chars(&mut self, n: usize) -> Result<(), String> {
let count = self.0.chars().count();
if n > count {
return Err("omit-last exceeds secret length".into());
}
if n == 0 {
return Ok(());
}
let keep = count - n;
let truncated: String = self.0.chars().take(keep).collect();
zeroize_str(&mut self.0);
self.0 = truncated;
Ok(())
}
}
impl fmt::Debug for Secret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Secret(len={})", self.0.len())
}
}
impl fmt::Display for Secret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "*** ({} bytes)", self.0.len())
}
}
impl Drop for Secret {
fn drop(&mut self) {
zeroize_str(&mut self.0);
}
}
fn zeroize_str(s: &mut String) {
let bytes = unsafe { s.as_bytes_mut() };
for b in bytes.iter_mut() {
*b = 0;
}
s.clear();
}
/// One CONTROL keyboard action (Windows VK or Mac keycode in `key`).
#[derive(Clone, Debug, PartialEq)]
pub enum KeyAction {
Press(i32),
Release(i32),
}
impl KeyAction {
pub fn to_json(&self) -> Value {
match self {
Self::Press(k) => json!({"action":"kbd_press","key":k}),
Self::Release(k) => json!({"action":"kbd_release","key":k}),
}
}
fn zeroize(&mut self) {
match self {
Self::Press(k) | Self::Release(k) => *k = 0,
}
}
}
/// Key event list that wipes key codes on drop.
pub struct ActionList(Vec<KeyAction>);
impl std::fmt::Debug for ActionList {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ActionList(len={})", self.0.len())
}
}
impl ActionList {
pub fn new(actions: Vec<KeyAction>) -> Self {
Self(actions)
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn as_slice(&self) -> &[KeyAction] {
&self.0
}
}
impl Deref for ActionList {
type Target = [KeyAction];
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for ActionList {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl Drop for ActionList {
fn drop(&mut self) {
for a in &mut self.0 {
a.zeroize();
}
self.0.clear();
}
}
pub fn parse_delay_ms(raw: Option<&str>) -> Result<Duration, String> {
let Some(raw) = raw else {
return Ok(Duration::ZERO);
};
let ms: u64 = raw
.parse()
.map_err(|_| String::from("delay must be a non-negative integer (milliseconds)"))?;
if ms > 5_000 {
return Err("delay must be at most 5000 ms".into());
}
Ok(Duration::from_millis(ms))
}
pub fn parse_omit_last(raw: Option<&str>) -> Result<usize, String> {
let Some(raw) = raw else {
return Ok(0);
};
let n: usize = raw
.parse()
.map_err(|_| String::from("omit-last must be a non-negative integer"))?;
if n > 64 {
return Err("omit-last must be at most 64".into());
}
Ok(n)
}
/// `UU_INPUT_ENV` names another variable that holds the secret; otherwise one stdin line.
/// After reading a named secret variable, that variable is removed from the environment.
pub fn load_secret(stdin: impl BufRead) -> Result<Secret, String> {
if let Ok(name) = std::env::var("UU_INPUT_ENV") {
validate_env_name(&name)?;
let value = std::env::var(&name)
.map_err(|_| "Environment variable named by UU_INPUT_ENV is not set".to_string())?;
std::env::remove_var(&name);
if value.is_empty() {
return Err("Secret environment variable is empty".into());
}
if value.len() > 16 * 1024 {
return Err("Secret exceeds 16 KiB".into());
}
return Ok(Secret::new(value));
}
let mut line = String::new();
stdin
.take(16 * 1024 + 1)
.read_to_string(&mut line)
.map_err(|_| "Cannot read secret from stdin")?;
if line.len() > 16 * 1024 {
return Err("Secret exceeds 16 KiB".into());
}
if line.ends_with('\n') {
line.pop();
if line.ends_with('\r') {
line.pop();
}
}
if line.is_empty() {
return Err("Secret stdin is empty (set UU_INPUT_ENV or pipe text)".into());
}
Ok(Secret::new(line))
}
fn validate_env_name(name: &str) -> Result<(), String> {
if name.is_empty() || name.len() > 128 {
return Err("UU_INPUT_ENV must be a non-empty variable name".into());
}
if !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
return Err("UU_INPUT_ENV must be an alphanumeric variable name".into());
}
Ok(())
}
/// Expand template text into key actions. Brace tokens: `{Enter}`, `{Tab}`, `{Esc}`,
/// `{Backspace}`, `{Delete}`, `{Space}`, `{Ctrl+Alt+Del}`, arrows, `{Home}`, `{End}`, `{F1}`…`{F12}`.
/// Plain characters use a US QWERTY VK/Mac mapping (Shift for uppercase/symbols).
/// Errors never include the offending character or token text — only a 0-based char index.
pub fn expand(text: &str, mac: bool) -> Result<ActionList, String> {
let mut out = Vec::new();
let mut chars = text.chars().peekable();
let mut index = 0usize;
while let Some(c) = chars.next() {
if c == '{' {
if chars.peek() == Some(&'{') {
chars.next();
push_char(&mut out, '{', mac, index)?;
index += 1;
continue;
}
let start = index;
let mut name = String::new();
let mut closed = false;
for n in chars.by_ref() {
if n == '}' {
closed = true;
break;
}
if n == '{' || name.len() > 32 {
zeroize_str(&mut name);
return Err(format!("Invalid special-key token at index {start}"));
}
name.push(n);
}
if !closed {
zeroize_str(&mut name);
return Err(format!("Unclosed special-key token at index {start}"));
}
// Advance index past '{' + name + '}'
index += 1 + name.chars().count() + 1;
let result = push_special(&mut out, &name, mac, start);
zeroize_str(&mut name);
result?;
continue;
}
if c.is_control() && c != '\t' && c != '\n' && c != '\r' {
return Err(format!("Control character at index {index}"));
}
match c {
'\n' | '\r' => push_special(&mut out, "Enter", mac, index)?,
'\t' => push_special(&mut out, "Tab", mac, index)?,
_ => push_char(&mut out, c, mac, index)?,
}
index += 1;
}
Ok(ActionList::new(out))
}
fn push_special(
out: &mut Vec<KeyAction>,
name: &str,
mac: bool,
index: usize,
) -> Result<(), String> {
let key = match name {
"Enter" | "Return" => Some(vk_or_mac(0x0d, 36, mac)),
"Tab" => Some(vk_or_mac(0x09, 48, mac)),
"Esc" | "Escape" => Some(vk_or_mac(0x1b, 53, mac)),
"Backspace" => Some(vk_or_mac(0x08, 51, mac)),
"Delete" | "Del" => Some(vk_or_mac(0x2e, 117, mac)),
"Space" => Some(vk_or_mac(0x20, 49, mac)),
"Up" => Some(vk_or_mac(0x26, 126, mac)),
"Down" => Some(vk_or_mac(0x28, 125, mac)),
"Left" => Some(vk_or_mac(0x25, 123, mac)),
"Right" => Some(vk_or_mac(0x27, 124, mac)),
"Home" => Some(vk_or_mac(0x24, 115, mac)),
"End" => Some(vk_or_mac(0x23, 119, mac)),
"Ctrl+Alt+Del" | "CAD" => {
let ctrl = vk_or_mac(0xa2, 59, mac);
let alt = vk_or_mac(0xa4, 58, mac);
let del = vk_or_mac(0x2e, 117, mac);
out.push(KeyAction::Press(ctrl));
out.push(KeyAction::Press(alt));
out.push(KeyAction::Press(del));
out.push(KeyAction::Release(del));
out.push(KeyAction::Release(alt));
out.push(KeyAction::Release(ctrl));
return Ok(());
}
other if other.len() >= 2 && other.as_bytes()[0] == b'F' => {
let n: u32 = other[1..]
.parse()
.map_err(|_| format!("Unknown special key at index {index}"))?;
if !(1..=12).contains(&n) {
return Err(format!("Unknown special key at index {index}"));
}
let vk = 0x70 + (n as i32 - 1);
let mac_code = match n {
1 => 122,
2 => 120,
3 => 99,
4 => 118,
5 => 96,
6 => 97,
7 => 98,
8 => 100,
9 => 101,
10 => 109,
11 => 103,
12 => 111,
_ => unreachable!(),
};
Some(vk_or_mac(vk, mac_code, mac))
}
_ => return Err(format!("Unknown special key at index {index}")),
};
let Some(key) = key else {
return Ok(());
};
out.push(KeyAction::Press(key));
out.push(KeyAction::Release(key));
Ok(())
}
fn vk_or_mac(vk: i32, mac: i32, is_mac: bool) -> i32 {
if is_mac {
mac
} else {
vk
}
}
fn push_char(out: &mut Vec<KeyAction>, c: char, mac: bool, index: usize) -> Result<(), String> {
let (vk, shift) = us_qwerty_vk(c)
.ok_or_else(|| format!("Unsupported character at index {index}"))?;
let key = if mac {
mac_from_vk(vk).ok_or_else(|| format!("Unsupported character at index {index}"))?
} else {
vk
};
let shift_key = vk_or_mac(0xa0, 56, mac);
if shift {
out.push(KeyAction::Press(shift_key));
}
out.push(KeyAction::Press(key));
out.push(KeyAction::Release(key));
if shift {
out.push(KeyAction::Release(shift_key));
}
Ok(())
}
fn us_qwerty_vk(c: char) -> Option<(i32, bool)> {
match c {
'a'..='z' => Some((0x41 + (c as i32 - 'a' as i32), false)),
'A'..='Z' => Some((0x41 + (c as i32 - 'A' as i32), true)),
'0' => Some((0x30, false)),
'1'..='9' => Some((0x30 + (c as i32 - '0' as i32), false)),
' ' => Some((0x20, false)),
'-' => Some((0xbd, false)),
'_' => Some((0xbd, true)),
'=' => Some((0xbb, false)),
'+' => Some((0xbb, true)),
'[' => Some((0xdb, false)),
'{' => Some((0xdb, true)),
']' => Some((0xdd, false)),
'}' => Some((0xdd, true)),
'\\' => Some((0xdc, false)),
'|' => Some((0xdc, true)),
';' => Some((0xba, false)),
':' => Some((0xba, true)),
'\'' => Some((0xde, false)),
'"' => Some((0xde, true)),
'`' => Some((0xc0, false)),
'~' => Some((0xc0, true)),
',' => Some((0xbc, false)),
'<' => Some((0xbc, true)),
'.' => Some((0xbe, false)),
'>' => Some((0xbe, true)),
'/' => Some((0xbf, false)),
'?' => Some((0xbf, true)),
'!' => Some((0x31, true)),
'@' => Some((0x32, true)),
'#' => Some((0x33, true)),
'$' => Some((0x34, true)),
'%' => Some((0x35, true)),
'^' => Some((0x36, true)),
'&' => Some((0x37, true)),
'*' => Some((0x38, true)),
'(' => Some((0x39, true)),
')' => Some((0x30, true)),
_ => None,
}
}
fn mac_from_vk(vk: i32) -> Option<i32> {
let scan = match vk {
0x41..=0x5a => 4 + (vk - 0x41),
0x31..=0x39 => 30 + (vk - 0x31),
0x30 => 39,
0x0d => 40,
0x1b => 41,
0x08 => 42,
0x09 => 43,
0x20 => 44,
0xbd => 45,
0xbb => 46,
0xdb => 47,
0xdd => 48,
0xdc => 49,
0xba => 51,
0xde => 52,
0xc0 => 53,
0xbc => 54,
0xbe => 55,
0xbf => 56,
0xa0 => 225,
_ => return None,
};
super::input::mac_keycode(scan)
}
pub async fn send_actions(
send: impl Fn(Value) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), String>> + Send>>,
actions: &[KeyAction],
delay: Duration,
) -> Result<(), String> {
for (i, action) in actions.iter().enumerate() {
send(action.to_json()).await?;
if !delay.is_zero() && i + 1 != actions.len() {
tokio::time::sleep(delay).await;
}
}
Ok(())
}
/// Wait for CONTROL echo on an open desktop session, then send key actions.
pub async fn run_session(
session: &mut super::session::Session,
actions: &[KeyAction],
delay: Duration,
) -> Result<(), String> {
use std::sync::atomic::Ordering;
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)) => {}
}
}
};
tokio::time::timeout(Duration::from_secs(30), ready)
.await
.map_err(|_| "CONTROL echo timed out")??;
for (i, action) in actions.iter().enumerate() {
session.peer.send_input(&action.to_json()).await?;
if !delay.is_zero() && i + 1 != actions.len() {
tokio::time::sleep(delay).await;
}
}
Ok(())
}
/// Dry-run summary: lengths only, never the secret or key codes.
pub fn dry_run_report(secret: &Secret, omit_last: usize, mac: bool) -> Result<String, String> {
let mut owned = Secret::new(secret.as_str().to_owned());
owned.omit_last_chars(omit_last)?;
let actions = expand(owned.as_str(), mac)?;
Ok(format!(
"dry-run: chars={} omit_last={} events={} mac={}",
owned.chars_count(),
omit_last,
actions.len(),
mac
))
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
#[test]
fn secret_debug_and_display_never_leak() {
let s = Secret::new("hunter2".into());
let d = format!("{s:?}");
let p = format!("{s}");
assert!(d.contains("len=7"));
assert!(!d.contains("hunter"));
assert!(!p.contains("hunter"));
assert!(p.contains("***"));
}
#[test]
fn action_list_debug_shows_len_only() {
let list = ActionList::new(vec![
KeyAction::Press(0x41),
KeyAction::Release(0x41),
KeyAction::Press(0x42),
KeyAction::Release(0x42),
]);
let d = format!("{list:?}");
assert_eq!(d, "ActionList(len=4)");
assert!(!d.contains("0x41"));
assert!(!d.contains("Press"));
assert!(!d.contains("41"));
}
#[test]
fn letters_digits_and_shift_symbols_map_to_windows_vk() {
let actions = expand("Ab1!", false).unwrap();
assert_eq!(
&actions[0..4],
&[
KeyAction::Press(0xa0),
KeyAction::Press(0x41),
KeyAction::Release(0x41),
KeyAction::Release(0xa0),
]
);
assert_eq!(
&actions[4..6],
&[KeyAction::Press(0x42), KeyAction::Release(0x42)]
);
assert_eq!(
&actions[6..8],
&[KeyAction::Press(0x31), KeyAction::Release(0x31)]
);
assert_eq!(
&actions[8..12],
&[
KeyAction::Press(0xa0),
KeyAction::Press(0x31),
KeyAction::Release(0x31),
KeyAction::Release(0xa0),
]
);
}
#[test]
fn special_keys_and_ctrl_alt_del() {
let a = expand("{Enter}{Tab}{Esc}{Backspace}{Ctrl+Alt+Del}", false).unwrap();
assert!(a
.windows(2)
.any(|w| w == [KeyAction::Press(0x0d), KeyAction::Release(0x0d)]));
let cad: Vec<_> = a.iter().rev().take(6).rev().cloned().collect();
assert_eq!(
cad,
vec![
KeyAction::Press(0xa2),
KeyAction::Press(0xa4),
KeyAction::Press(0x2e),
KeyAction::Release(0x2e),
KeyAction::Release(0xa4),
KeyAction::Release(0xa2),
]
);
}
#[test]
fn unknown_special_key_errors_without_echoing_payload() {
let err = expand("{NotAKey}", false).unwrap_err();
assert!(err.contains("Unknown special key at index"));
assert!(!err.contains("NotAKey"));
assert!(!err.contains("password"));
}
#[test]
fn unsupported_char_errors_without_codepoint_or_char() {
let err = expand("a中", false).unwrap_err();
assert!(err.contains("Unsupported character at index 1"));
assert!(!err.contains('中'));
assert!(!err.contains("4E2D"));
assert!(!err.contains("U+"));
}
#[test]
fn unclosed_token_and_control_char_rejected() {
assert!(expand("{Enter", false).is_err());
assert!(expand("a\u{0001}b", false).is_err());
}
#[test]
fn load_from_named_env_and_stdin() {
let _g = ENV_LOCK.lock().unwrap();
std::env::set_var("UU_INPUT_ENV", "UU_SECRET");
std::env::set_var("UU_SECRET", "pin-value");
let s = load_secret(Cursor::new(b"")).unwrap();
assert_eq!(s.as_str(), "pin-value");
assert!(!format!("{s:?}").contains("pin"));
assert!(std::env::var("UU_SECRET").is_err());
std::env::remove_var("UU_INPUT_ENV");
let s = load_secret(Cursor::new(b"from-stdin\n")).unwrap();
assert_eq!(s.as_str(), "from-stdin");
}
#[test]
fn invalid_env_name_and_empty_secret() {
let _g = ENV_LOCK.lock().unwrap();
std::env::set_var("UU_INPUT_ENV", "bad-name!");
assert!(load_secret(Cursor::new(b"")).is_err());
std::env::remove_var("UU_INPUT_ENV");
std::env::set_var("UU_INPUT_ENV", "EMPTY_SECRET_TEST");
std::env::set_var("EMPTY_SECRET_TEST", "");
assert!(load_secret(Cursor::new(b"")).is_err());
std::env::remove_var("UU_INPUT_ENV");
std::env::remove_var("EMPTY_SECRET_TEST");
assert!(load_secret(Cursor::new(b"\n")).is_err());
}
#[test]
fn delay_and_omit_bounds() {
assert_eq!(parse_delay_ms(None).unwrap(), Duration::ZERO);
assert_eq!(
parse_delay_ms(Some("50")).unwrap(),
Duration::from_millis(50)
);
assert!(parse_delay_ms(Some("-1")).is_err());
assert!(parse_delay_ms(Some("5001")).is_err());
assert_eq!(parse_omit_last(None).unwrap(), 0);
assert_eq!(parse_omit_last(Some("2")).unwrap(), 2);
assert!(parse_omit_last(Some("65")).is_err());
}
#[test]
fn omit_last_and_dry_run() {
let mut s = Secret::new("1234567".into());
s.omit_last_chars(1).unwrap();
assert_eq!(s.as_str(), "123456");
let report = dry_run_report(&Secret::new("1234567".into()), 1, false).unwrap();
assert!(report.contains("chars=6"));
assert!(report.contains("omit_last=1"));
assert!(report.contains("events="));
assert!(report.contains("omit_last=1"));
assert!(!report.contains("123456"));
assert!(!report.contains("1234567"));
}
#[test]
fn brace_escape_types_literal_brace() {
let a = expand("{{a", false).unwrap();
assert_eq!(
&a[0..4],
&[
KeyAction::Press(0xa0),
KeyAction::Press(0xdb),
KeyAction::Release(0xdb),
KeyAction::Release(0xa0),
]
);
assert_eq!(
&a[4..6],
&[KeyAction::Press(0x41), KeyAction::Release(0x41)]
);
}
#[test]
fn password_with_enter_suffix() {
let a = expand("secret{Enter}", false).unwrap();
assert_eq!(a.last(), Some(&KeyAction::Release(0x0d)));
assert_eq!(a[a.len() - 2], KeyAction::Press(0x0d));
}
#[test]
fn action_list_zeroizes_on_drop() {
let mut a = KeyAction::Press(0x41);
a.zeroize();
assert_eq!(a, KeyAction::Press(0));
let list = ActionList::new(vec![KeyAction::Press(7), KeyAction::Release(7)]);
assert_eq!(list.len(), 2);
drop(list);
}
#[tokio::test]
async fn send_actions_respects_delay_and_order() {
use std::sync::{Arc, Mutex};
let log = Arc::new(Mutex::new(Vec::new()));
let recorded = log.clone();
let actions = expand("a{Enter}", false).unwrap();
let start = std::time::Instant::now();
send_actions(
|v| {
let recorded = recorded.clone();
Box::pin(async move {
recorded.lock().unwrap().push(v);
Ok(())
})
},
actions.as_slice(),
Duration::from_millis(20),
)
.await
.unwrap();
assert!(start.elapsed() >= Duration::from_millis(50));
let keys: Vec<_> = log
.lock()
.unwrap()
.iter()
.map(|v| {
(
v["action"].as_str().unwrap().to_owned(),
v["key"].as_i64().unwrap(),
)
})
.collect();
assert_eq!(
keys,
vec![
("kbd_press".into(), 0x41),
("kbd_release".into(), 0x41),
("kbd_press".into(), 0x0d),
("kbd_release".into(), 0x0d),
]
);
}
}
+4 -6
View File
@@ -3,13 +3,11 @@
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>>,
ws: crate::ws_transport::Socket,
next_ack:u64,
pending:VecDeque<Value>,
legacy_prefix:bool,
@@ -17,14 +15,14 @@ pub struct Signal {
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)}
if let Ok(Ok(signal))=tokio::time::timeout(timeout,Self::one(url,token,legacy_prefix,timeout)).await {return Ok(signal)}
}
Err("Signaling connection failed (details omitted)".into())
}
async fn one(url:&str,token:&str,legacy_prefix:bool)->Result<Self,String> {
async fn one(url:&str,token:&str,legacy_prefix:bool,timeout:Duration)->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 ws=crate::ws_transport::connect(request,timeout).await?;
let mut s=Self{ws,next_ack:10,pending:VecDeque::new(),legacy_prefix};
let mut opened=false;
loop {
+2
View File
@@ -82,6 +82,8 @@ async fn complete_session_uses_loopback_signaling_and_virtual_rtc_through_echo()
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}
}
// Desktop sessions also request the video track (RPC 15), like the official viewer.
if message.data.as_ref()==wire::request_video_track().as_slice() {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();}
+58
View File
@@ -0,0 +1,58 @@
//! Device preview pictures for the launcher, like the official client's device card: the desktop
//! window saves a small PNG of the last remote picture. Local only (`$XDG_CACHE_HOME/uuremote/thumbs`,
//! 0700 directory, 0600 files); `UU_VIEWER_THUMBNAILS=0` turns it off.
use std::path::PathBuf;
pub fn enabled() -> bool { std::env::var("UU_VIEWER_THUMBNAILS").as_deref() != Ok("0") }
fn dir() -> Option<PathBuf> {
let base = std::env::var_os("XDG_CACHE_HOME").map(PathBuf::from).filter(|p| p.is_absolute())
.or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".cache")))?;
Some(base.join("uuremote").join("thumbs"))
}
pub fn path(device: &str) -> Option<PathBuf> { Some(dir()?.join(format!("{}.png", &super::type_ipc::device_key(device)[..32]))) }
pub fn existing(device: &str) -> Option<PathBuf> { enabled().then(|| path(device)).flatten().filter(|p| p.is_file()) }
/// Box-filtered downscale of the content rectangle to at most `max_w` pixels wide.
pub fn downscale(width: u32, height: u32, rgb: &[u8], content: (u32, u32, u32, u32), max_w: u32) -> (u32, u32, Vec<u8>) {
let (cx, cy, cw, ch) = content;
let ratio = (cw as f64 / max_w as f64).max(1.);
let (w, h) = (((cw as f64 / ratio).round() as u32).max(1), ((ch as f64 / ratio).round() as u32).max(1));
let mut out = Vec::with_capacity(w as usize * h as usize * 3);
for y in 0..h { for x in 0..w {
let (x0, x1) = (cx + (x as f64 * ratio) as u32, (cx + ((x + 1) as f64 * ratio) as u32).max(cx + (x as f64 * ratio) as u32 + 1).min(cx + cw).min(width));
let (y0, y1) = (cy + (y as f64 * ratio) as u32, (cy + ((y + 1) as f64 * ratio) as u32).max(cy + (y as f64 * ratio) as u32 + 1).min(cy + ch).min(height));
let mut sum = [0u64; 3]; let mut n = 0u64;
for sy in y0..y1 { for sx in x0..x1 {
let i = (sy as usize * width as usize + sx as usize) * 3;
for k in 0..3 { sum[k] += u64::from(rgb[i + k]); } n += 1;
}}
for k in 0..3 { out.push((sum[k] / n.max(1)) as u8); }
}}
(w, h, out)
}
pub fn save(device: &str, frame: &super::desktop::Frame) -> Result<(), String> {
if !enabled() { return Ok(()) }
let path = path(device).ok_or("No cache directory")?;
let dir = path.parent().ok_or("No cache directory")?;
use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
std::fs::DirBuilder::new().recursive(true).mode(0o700).create(dir).map_err(|_| "Cannot create the thumbnail directory")?;
let _ = std::fs::set_permissions(dir, std::fs::Permissions::from_mode(0o700));
let content = super::input::content_rect((frame.width, frame.height), frame.content.unwrap_or((frame.width, frame.height)))
.map_or((0, 0, frame.width, frame.height), |(x, y, w, h)| (x as u32, y as u32, w as u32, h as u32));
let (w, h, rgb) = downscale(frame.width, frame.height, &frame.rgb, content, 640);
// Write then rename, so the launcher never reads a half-written file.
let tmp = path.with_extension("tmp");
let _ = std::fs::remove_file(&tmp);
super::type_ipc::write_png_rgb(&tmp, w, h, &rgb, true)?;
std::fs::rename(&tmp, &path).map_err(|_| "Cannot store the thumbnail".into())
}
#[cfg(test)] mod tests {
#[test] fn downscale_averages_and_keeps_aspect(){
let rgb:Vec<u8>=(0..4*2).flat_map(|i|if i%2==0{[0,0,0]}else{[200,100,50]}).collect();
let (w,h,out)=super::downscale(4,2,&rgb,(0,0,4,2),2);
assert_eq!((w,h),(2,1));assert_eq!(&out[..3],&[100,50,25]);
assert_eq!(super::downscale(4,2,&rgb,(0,0,4,2),640).0,4);
}
}
+1 -1
View File
@@ -161,7 +161,7 @@ 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")=>"已分离",_=>"--"};
let state=match s["state"].as_str(){Some("running")=>crate::i18n::s("运行中","Running"),Some("detached")=>crate::i18n::s("已分离","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()
}
+1 -1
View File
@@ -156,7 +156,7 @@ fn terminal_metadata_is_allowlisted_and_sorted(){
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_eq!(rows,format!("2\t/bin/bash\t0\t{}\n9\t/bin/sh X Y \t123\t{}\n",crate::i18n::s("运行中","Running"),crate::i18n::s("已分离","Detached")));
assert!(!rows.contains("PRIVATE"));assert!(terminal::session_rows(&[]).is_empty());
}
#[tokio::test]
+18 -18
View File
@@ -54,7 +54,7 @@ fn task(id:i32,name:&str,status:&str,done:u64,total:u64,from:&str,to:&str,state:
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}")}}
fn reason(error:&str)->String{if error.contains("canceled"){crate::i18n::s("已取消","Canceled").into()}else{crate::tr!("失败:{error}","Failed: {error}")}}
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
start("files",name)?;
@@ -67,7 +67,7 @@ pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),
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);
task(a.id,&a.name,&crate::tr!("传输中 {percent}%","Transferring {percent}%"),p.transferred,p.total,&a.from,&a.to,0);
}
});
let _reporter=super::tools::Cancel(reporter.abort_handle());
@@ -79,24 +79,24 @@ pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),
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}")),
Err(e)=>toast(&crate::tr!("无法读取远端目录:{e}","Cannot read remote folder: {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}")),
Err(e)=>toast(&crate::tr!("无法创建远端文件夹:{e}","Cannot create remote folder: {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}
if generation!=worker_gen.load(Ordering::Acquire){task(id,&name,crate::i18n::s("已取消","Canceled"),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);
task(id,&name,crate::i18n::s("传输中","Transferring"),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);
task(id,&name,crate::i18n::s("已完成","Done"),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()}}
}
@@ -118,7 +118,7 @@ pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),
["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 name=base_name(from);task(id,name,crate::i18n::s("等待中","Waiting"),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();}
@@ -147,12 +147,12 @@ pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(
["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})),
Err(e)=>toast(&crate::tr!("添加失败:{}","Add failed: {}",if e.contains("bind"){crate::i18n::s("本地端口已被占用","Local port is already in use").to_owned()}else{e})),
},
_=>toast("端口无效"),
_=>toast(crate::i18n::s("端口无效","Invalid port")),
},
["remove",id]=>if let Ok(id)=id.parse::<u64>(){
if let Err(e)=p.remove_rule(id).await{toast(&format!("删除失败:{e}"))}targets.remove(&id);
if let Err(e)=p.remove_rule(id).await{toast(&crate::tr!("删除失败:{e}","Remove failed: {e}"))}targets.remove(&id);
},
_=>{}
}
@@ -160,9 +160,9 @@ pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(
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 s.failures>0{crate::tr!("已启用 · {} 个连接 · {} 次失败","On · {} connections · {} failures",s.streams,s.failures)}else{crate::tr!("已启用 · {} 个连接","On · {} connections",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))=>{}}
tokio::select!{_=&mut closed_transport=>{toast(crate::i18n::s("连接已断开","Disconnected"));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
@@ -190,14 +190,14 @@ pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&
unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}
},
id=queue.recv()=>match id{
Some(id)=>{if t.kill(id).await.is_err(){toast("结束会话失败,会话可能已退出")}
Some(id)=>{if t.kill(id).await.is_err(){toast(crate::i18n::s("结束会话失败,会话可能已退出","Could not end the session; it may have exited"))}
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("终端连接已断开,请关闭窗口后重试")}
if operation.is_err(){unsafe{uu_terminal_ui_set(c("").as_ptr(),0)};toast(crate::i18n::s("终端连接已断开,请关闭窗口后重试","Terminal disconnected. Close the window and try again"))}
});
let _worker=super::tools::Cancel(worker.abort_handle());
let mut children:Vec<std::process::Child>=Vec::new();
@@ -205,7 +205,7 @@ pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&
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}
if worker.is_finished(){toast(crate::i18n::s("连接已断开","Disconnected"));continue}
let parts:Vec<_>=cmd.split('\t').collect();
let session=match parts.as_slice(){
["create"]=>None,
@@ -214,8 +214,8 @@ pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&
_=>continue,
};
match local_terminal_command(&exe,&path,session){
Some(mut command)=>match command.spawn(){Ok(child)=>children.push(child),Err(_)=>toast("无法启动本机终端程序")},
None=>toast("没有找到本机终端程序(可设置 TERMINAL 环境变量)"),
Some(mut command)=>match command.spawn(){Ok(child)=>children.push(child),Err(_)=>toast(crate::i18n::s("无法启动本机终端程序","Cannot start a local terminal"))},
None=>toast(crate::i18n::s("没有找到本机终端程序(可设置 TERMINAL 环境变量)","No local terminal found (set the TERMINAL environment variable)")),
}
}
tokio::time::sleep(Duration::from_millis(100)).await;
+634
View File
@@ -0,0 +1,634 @@
//! Local Unix-socket bridge: `uuremote-viewer type` hands secrets to a running desktop session.
//! Frames are length-prefixed JSON; secrets never appear in logs. Peer UID must match.
use serde::{Deserialize, Serialize};
use std::{
os::unix::fs::DirBuilderExt,
path::{Path, PathBuf},
};
use tokio::{
io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
net::{UnixListener, UnixStream},
sync::mpsc,
};
/// Max JSON frame (header + secret). 16 KiB secret + margin.
pub const MAX_FRAME: usize = 20 * 1024;
#[derive(Serialize, Deserialize)]
pub struct TypeRequest {
pub delay_ms: u64,
pub omit_last: usize,
pub snapshot: Option<String>,
/// Secret text; Debug only exposes length.
pub secret: String,
}
impl std::fmt::Debug for TypeRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TypeRequest")
.field("delay_ms", &self.delay_ms)
.field("omit_last", &self.omit_last)
.field(
"snapshot",
&self.snapshot.as_ref().map(|s| format!("len={}", s.len())),
)
.field("secret_len", &self.secret.len())
.finish()
}
}
impl Drop for TypeRequest {
fn drop(&mut self) {
zeroize_string(&mut self.secret);
if let Some(s) = self.snapshot.as_mut() {
zeroize_string(s);
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TypeResponse {
pub ok: bool,
pub events: usize,
pub chars: usize,
pub snapshot: Option<String>,
pub error: Option<String>,
}
fn zeroize_string(s: &mut String) {
// Best-effort wipe before drop.
let bytes = unsafe { s.as_bytes_mut() };
for b in bytes.iter_mut() {
*b = 0;
}
s.clear();
}
/// Ensure `dir` is a real directory owned by us with mode & 0o077 == 0 (no symlink).
pub fn validate_private_dir(dir: &Path) -> Result<(), String> {
use std::os::unix::fs::{MetadataExt, PermissionsExt};
let meta = std::fs::symlink_metadata(dir).map_err(|_| "Cannot inspect type-ipc directory")?;
if meta.file_type().is_symlink() {
return Err("Type-ipc path is a symlink".into());
}
if !meta.file_type().is_dir() {
return Err("Type-ipc path is not a directory".into());
}
let me = unsafe { libc::getuid() };
if meta.uid() != me {
return Err("Type-ipc directory owner mismatch".into());
}
if meta.permissions().mode() & 0o077 != 0 {
return Err("Type-ipc directory permissions too open".into());
}
Ok(())
}
pub fn runtime_dir() -> Result<PathBuf, String> {
let base = std::env::var_os("XDG_RUNTIME_DIR")
.map(PathBuf::from)
.unwrap_or_else(|| {
PathBuf::from(format!(
"{}/uu-viewer-type-{}",
std::env::temp_dir().display(),
unsafe { libc::getuid() }
))
});
let dir = if base.ends_with("uu-viewer-type") || base.file_name().is_some_and(|n| {
n.to_string_lossy().starts_with("uu-viewer-type")
}) {
base
} else {
base.join("uu-viewer-type")
};
// Use symlink_metadata so a pre-planted symlink is not followed before we decide.
match std::fs::symlink_metadata(&dir) {
Ok(_) => {
validate_private_dir(&dir)?;
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
std::fs::DirBuilder::new()
.recursive(true)
.mode(0o700)
.create(&dir)
.map_err(|_| "Cannot create private type-ipc directory")?;
validate_private_dir(&dir)?;
}
Err(_) => return Err("Cannot inspect type-ipc directory".into()),
}
Ok(dir)
}
pub fn device_key(device: &str) -> String {
use sha2::{Digest, Sha256};
hex::encode(Sha256::digest(device.as_bytes()))
}
pub fn socket_path(device: &str) -> Result<PathBuf, String> {
Ok(runtime_dir()?.join(format!("{}.sock", device_key(device))))
}
pub fn default_snapshot_path(device: &str) -> Result<PathBuf, String> {
let ts = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis())
.unwrap_or(0);
Ok(runtime_dir()?.join(format!("snap-{}-{ts}.png", &device_key(device)[..12])))
}
pub async fn read_frame(r: &mut (impl AsyncRead + Unpin)) -> Result<Vec<u8>, String> {
let n = r.read_u32().await.map_err(|_| "Type IPC closed")? as usize;
if n > MAX_FRAME {
return Err("Type IPC frame exceeds size limit".into());
}
let mut b = vec![0; n];
r.read_exact(&mut b)
.await
.map_err(|_| "Type IPC closed")?;
Ok(b)
}
pub async fn write_frame(w: &mut (impl AsyncWrite + Unpin), body: &[u8]) -> Result<(), String> {
if body.len() > MAX_FRAME {
return Err("Type IPC frame exceeds size limit".into());
}
w.write_u32(body.len() as u32)
.await
.map_err(|_| "Type IPC closed")?;
w.write_all(body).await.map_err(|_| "Type IPC closed")?;
Ok(())
}
fn check_peer(stream: &UnixStream) -> Result<(), String> {
let cred = stream
.peer_cred()
.map_err(|_| "Type IPC peer credentials unavailable")?;
let uid = cred.uid();
let me = unsafe { libc::getuid() };
if uid != me {
return Err("Type IPC peer uid mismatch".into());
}
Ok(())
}
pub struct Server {
pub path: PathBuf,
listener: Option<UnixListener>,
}
impl Drop for Server {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
}
}
impl Server {
pub async fn bind(device: &str) -> Result<Self, String> {
let path = socket_path(device)?;
if path.exists() {
match UnixStream::connect(&path).await {
Ok(_) => return Err("A desktop viewer is already listening for this device".into()),
Err(_) => {
let _ = std::fs::remove_file(&path);
}
}
}
let listener = UnixListener::bind(&path).map_err(|_| "Cannot bind type IPC socket")?;
use std::os::unix::fs::PermissionsExt;
let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600));
Ok(Self { path, listener: Some(listener) })
}
/// Accept connections and forward validated TypeRequests to `tx`.
pub async fn run(mut self, tx: mpsc::Sender<PendingType>) {
let path = self.path.clone();
let listener = self.listener.take().expect("type IPC listener");
// Prevent Drop from removing the socket twice while we still hold `path` in a guard.
self.path = PathBuf::new();
struct Guard(PathBuf);
impl Drop for Guard {
fn drop(&mut self) {
if !self.0.as_os_str().is_empty() {
let _ = std::fs::remove_file(&self.0);
}
}
}
let _guard = Guard(path);
loop {
let accepted = listener.accept().await;
let Ok((stream, _)) = accepted else { break };
if check_peer(&stream).is_err() {
continue;
}
let tx = tx.clone();
tokio::spawn(async move {
let _ = serve_client(stream, tx).await;
});
}
}
}
pub struct PendingType {
pub request: TypeRequest,
pub reply: tokio::sync::oneshot::Sender<TypeResponse>,
}
async fn serve_client(mut stream: UnixStream, tx: mpsc::Sender<PendingType>) -> Result<(), String> {
let body = read_frame(&mut stream).await?;
let request: TypeRequest =
serde_json::from_slice(&body).map_err(|_| "Invalid type IPC request")?;
let mut body = body;
for b in &mut body {
*b = 0;
}
let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
// Move request into PendingType; zeroize on drop if send fails.
if tx
.send(PendingType {
request,
reply: reply_tx,
})
.await
.is_err()
{
return Err("Desktop session is gone".into());
}
let response = reply_rx.await.map_err(|_| "Desktop session is gone")?;
let out = serde_json::to_vec(&response).map_err(|_| "Type IPC encode failed")?;
write_frame(&mut stream, &out).await
}
/// Client: deliver a type request to a running viewer. Returns response or connection error.
pub async fn send_to_viewer(device: &str, mut request: TypeRequest) -> Result<TypeResponse, String> {
let path = socket_path(device)?;
let mut stream = UnixStream::connect(&path)
.await
.map_err(|_| "No running desktop viewer for this device")?;
check_peer(&stream)?;
let body = serde_json::to_vec(&request).map_err(|_| "Type IPC encode failed")?;
// Clear serde copy in request early — response path still needs omit metadata only.
zeroize_string(&mut request.secret);
write_frame(&mut stream, &body).await?;
// Wipe encoded body
let mut body = body;
for b in &mut body {
*b = 0;
}
let resp_body = read_frame(&mut stream).await?;
let response: TypeResponse =
serde_json::from_slice(&resp_body).map_err(|_| "Invalid type IPC response")?;
Ok(response)
}
/// Encode an RGB24 frame as a minimal PNG (8-bit RGB, no filtering beyond None).
/// Write RGB24 as PNG. Always uses O_NOFOLLOW + mode 0600.
/// `create_new`: true for default runtime paths (refuse overwrite); false for user `--snapshot`.
pub fn write_png_rgb(
path: &Path,
width: u32,
height: u32,
rgb: &[u8],
create_new: bool,
) -> Result<(), String> {
let expected = width as usize * height as usize * 3;
if rgb.len() != expected || width == 0 || height == 0 {
return Err("Snapshot frame size mismatch".into());
}
use flate2::{write::ZlibEncoder, Compression};
use std::io::Write;
let mut raw = Vec::with_capacity((width as usize * 3 + 1) * height as usize);
for row in 0..height as usize {
raw.push(0); // filter None
let start = row * width as usize * 3;
raw.extend_from_slice(&rgb[start..start + width as usize * 3]);
}
let mut enc = ZlibEncoder::new(Vec::new(), Compression::fast());
enc.write_all(&raw).map_err(|_| "Snapshot zlib failed")?;
for b in &mut raw {
*b = 0;
}
let compressed = enc.finish().map_err(|_| "Snapshot zlib failed")?;
fn chunk(tag: &[u8; 4], data: &[u8], out: &mut Vec<u8>) {
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
out.extend_from_slice(tag);
out.extend_from_slice(data);
let mut crc = crc32_ieee_update(0xffff_ffff, tag);
crc = crc32_ieee_update(crc, data);
out.extend_from_slice(&(crc ^ 0xffff_ffff).to_be_bytes());
}
let mut png = Vec::with_capacity(compressed.len() + 128);
png.extend_from_slice(&[137, 80, 78, 71, 13, 10, 26, 10]);
let mut ihdr = Vec::with_capacity(13);
ihdr.extend_from_slice(&width.to_be_bytes());
ihdr.extend_from_slice(&height.to_be_bytes());
ihdr.extend_from_slice(&[8, 2, 0, 0, 0]); // 8-bit RGB
chunk(b"IHDR", &ihdr, &mut png);
chunk(b"IDAT", &compressed, &mut png);
chunk(b"IEND", &[], &mut png);
use std::os::unix::fs::OpenOptionsExt;
let mut opts = std::fs::OpenOptions::new();
opts.write(true).mode(0o600).custom_flags(libc::O_NOFOLLOW);
if create_new {
opts.create_new(true);
} else {
opts.create(true).truncate(true);
}
let mut file = opts
.open(path)
.map_err(|_| "Cannot write snapshot file")?;
file.write_all(&png).map_err(|_| "Cannot write snapshot file")?;
Ok(())
}
fn crc32_ieee(data: &[u8]) -> u32 {
crc32_ieee_update(0xffff_ffff, data) ^ 0xffff_ffff
}
fn crc32_ieee_update(mut crc: u32, data: &[u8]) -> u32 {
for &b in data {
crc ^= u32::from(b);
for _ in 0..8 {
let mask = (!(crc & 1)).wrapping_add(1); // 0 or 0xFFFFFFFF
crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
}
}
crc
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn frame_limit_rejects_oversized_length() {
// Unit-level: MAX_FRAME constant is the contract used by read_frame.
assert!(MAX_FRAME >= 16 * 1024);
assert!(MAX_FRAME < 1024 * 1024);
}
#[test]
fn device_key_is_stable_hex() {
let a = device_key("device-1");
let b = device_key("device-1");
assert_eq!(a, b);
assert_eq!(a.len(), 64);
assert!(a.chars().all(|c| c.is_ascii_hexdigit()));
assert_ne!(device_key("device-1"), device_key("device-2"));
}
#[test]
fn png_roundtrip_header_and_mode() {
let dir = tempfile_dir();
let path = dir.join("t.png");
write_png_rgb(&path, 2, 2, &[255, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 255], true).unwrap();
let meta = std::fs::metadata(&path).unwrap();
use std::os::unix::fs::PermissionsExt;
assert_eq!(meta.permissions().mode() & 0o777, 0o600);
let bytes = std::fs::read(&path).unwrap();
assert_eq!(&bytes[..8], &[137, 80, 78, 71, 13, 10, 26, 10]);
let _ = std::fs::remove_dir_all(dir);
}
fn tempfile_dir() -> PathBuf {
use std::os::unix::fs::DirBuilderExt;
// One directory per call: tests run in parallel and must not remove each other's files.
static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
let dir = std::env::temp_dir().join(format!("uu-type-ipc-test-{}-{}", std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)));
let _ = std::fs::remove_dir_all(&dir);
std::fs::DirBuilder::new()
.mode(0o700)
.create(&dir)
.unwrap();
dir
}
#[tokio::test]
async fn server_client_roundtrip_and_uid_gate() {
let device = format!("ipc-test-{}", uuidish());
// XDG_RUNTIME_DIR is process-wide; another test points it at a planted directory.
let _env = crate::viewer::secure_input::ENV_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let server = Server::bind(&device).await.unwrap();
let path = server.path.clone();
let (tx, mut rx) = mpsc::channel::<PendingType>(4);
let run = tokio::spawn(async move { server.run(tx).await });
// Handle one request in background
let worker = tokio::spawn(async move {
if let Some(pending) = rx.recv().await {
assert_eq!(pending.request.secret, "sentinel-SECRET-9f3a");
assert_eq!(pending.request.delay_ms, 10);
assert_eq!(pending.request.omit_last, 1);
let _ = pending.reply.send(TypeResponse {
ok: true,
events: 12,
chars: 6,
snapshot: Some("/tmp/fake.png".into()),
error: None,
});
}
});
let response = send_to_viewer(
&device,
TypeRequest {
delay_ms: 10,
omit_last: 1,
snapshot: None,
secret: "sentinel-SECRET-9f3a".into(),
},
)
.await
.unwrap();
assert!(response.ok);
assert_eq!(response.events, 12);
assert_eq!(response.snapshot.as_deref(), Some("/tmp/fake.png"));
worker.abort();
run.abort();
let _ = std::fs::remove_file(path);
}
#[tokio::test]
async fn connect_without_server_errors_without_secret() {
let device = format!("missing-{}", uuidish());
let err = send_to_viewer(
&device,
TypeRequest {
delay_ms: 0,
omit_last: 0,
snapshot: None,
secret: "sentinel-SECRET-9f3a".into(),
},
)
.await
.unwrap_err();
assert!(err.contains("No running desktop viewer"));
assert!(!err.contains("sentinel"));
}
#[tokio::test]
async fn oversized_frame_rejected() {
let device = format!("oversize-{}", uuidish());
// XDG_RUNTIME_DIR is process-wide; another test points it at a planted directory.
let _env = crate::viewer::secure_input::ENV_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let server = Server::bind(&device).await.unwrap();
let path = server.path.clone();
let (tx, mut rx) = mpsc::channel::<PendingType>(1);
let run = tokio::spawn(async move { server.run(tx).await });
// Drain so accept happens
let _drain = tokio::spawn(async move { while rx.recv().await.is_some() {} });
let mut stream = UnixStream::connect(&path).await.unwrap();
let huge = vec![0u8; MAX_FRAME + 1];
let result = write_frame(&mut stream, &huge).await;
// Client-side write_frame rejects before send
assert!(result.is_err());
assert!(!format!("{result:?}").contains("sentinel"));
run.abort();
let _ = std::fs::remove_file(path);
}
#[test]
fn validate_private_dir_rejects_symlink_and_open_mode() {
use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
let base = std::env::temp_dir().join(format!(
"uu-type-ipc-val-{}-{}",
std::process::id(),
uuidish()
));
let _ = std::fs::remove_dir_all(&base);
std::fs::DirBuilder::new().mode(0o700).create(&base).unwrap();
let open = base.join("open");
std::fs::DirBuilder::new().mode(0o755).create(&open).unwrap();
let err = validate_private_dir(&open).unwrap_err();
assert!(err.contains("permissions"), "{err}");
assert!(!err.contains("sentinel"));
let good = base.join("good");
std::fs::DirBuilder::new().mode(0o700).create(&good).unwrap();
validate_private_dir(&good).unwrap();
let link = base.join("link");
std::os::unix::fs::symlink(&good, &link).unwrap();
let err = validate_private_dir(&link).unwrap_err();
assert!(err.contains("symlink"), "{err}");
let file = base.join("file");
std::fs::write(&file, b"x").unwrap();
let err = validate_private_dir(&file).unwrap_err();
assert!(err.contains("not a directory"), "{err}");
let _ = std::fs::remove_dir_all(&base);
}
#[test]
fn runtime_dir_rejects_preexisting_open_or_symlink() {
use std::os::unix::fs::DirBuilderExt;
// Serialize against other tests that read/write process environment.
let _env = crate::viewer::secure_input::ENV_LOCK.lock().unwrap();
let base = std::env::temp_dir().join(format!(
"uu-type-ipc-rt-{}-{}",
std::process::id(),
uuidish()
));
let _ = std::fs::remove_dir_all(&base);
std::fs::DirBuilder::new().mode(0o700).create(&base).unwrap();
// Point XDG_RUNTIME_DIR at a private base; plant a bad uu-viewer-type child.
let child = base.join("uu-viewer-type");
std::fs::DirBuilder::new().mode(0o755).create(&child).unwrap();
let _guard = EnvGuard::set("XDG_RUNTIME_DIR", base.to_str().unwrap());
let err = runtime_dir().unwrap_err();
assert!(err.contains("permissions"), "{err}");
let _ = std::fs::remove_dir_all(&child);
let target = base.join("target");
std::fs::DirBuilder::new().mode(0o700).create(&target).unwrap();
std::os::unix::fs::symlink(&target, &child).unwrap();
let err = runtime_dir().unwrap_err();
assert!(err.contains("symlink"), "{err}");
let _ = std::fs::remove_file(&child);
// Fresh create succeeds and validates.
let dir = runtime_dir().unwrap();
assert!(dir.ends_with("uu-viewer-type"));
validate_private_dir(&dir).unwrap();
let _ = std::fs::remove_dir_all(&base);
}
#[test]
fn write_png_refuses_symlink_target() {
let dir = tempfile_dir();
let real = dir.join("real.png");
let link = dir.join("link.png");
std::fs::write(&real, b"old").unwrap();
std::os::unix::fs::symlink(&real, &link).unwrap();
let err = write_png_rgb(
&link,
1,
1,
&[1, 2, 3],
false,
)
.unwrap_err();
assert!(err.contains("Cannot write snapshot"), "{err}");
// Original untouched
assert_eq!(std::fs::read(&real).unwrap(), b"old");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn write_png_create_new_refuses_existing() {
let dir = tempfile_dir();
let path = dir.join("exists.png");
std::fs::write(&path, b"old").unwrap();
let err = write_png_rgb(&path, 1, 1, &[1, 2, 3], true).unwrap_err();
assert!(err.contains("Cannot write snapshot"), "{err}");
assert_eq!(std::fs::read(&path).unwrap(), b"old");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn type_request_debug_shows_secret_len_only() {
let req = TypeRequest {
delay_ms: 40,
omit_last: 1,
snapshot: Some("/tmp/out.png".into()),
secret: "sentinel-SECRET-9f3a".into(),
};
let d = format!("{req:?}");
assert!(d.contains("secret_len: 20") || d.contains("secret_len: 20,"), "{d}");
assert!(!d.contains("sentinel"));
assert!(!d.contains("SECRET"));
assert!(!d.contains("9f3a"));
}
struct EnvGuard {
key: &'static str,
prev: Option<std::ffi::OsString>,
}
impl EnvGuard {
fn set(key: &'static str, val: &str) -> Self {
let prev = std::env::var_os(key);
std::env::set_var(key, val);
Self { key, prev }
}
}
impl Drop for EnvGuard {
fn drop(&mut self) {
match &self.prev {
Some(v) => std::env::set_var(self.key, v),
None => std::env::remove_var(self.key),
}
}
}
fn uuidish() -> String {
format!(
"{:x}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
)
}
}
+54 -23
View File
@@ -13,6 +13,7 @@ extern "C" {
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 uu_viewer_ui_set_host(active: c_int);
}
fn toast(text: &str) { let t = c(text); unsafe { uu_viewer_ui_toast(t.as_ptr()) } }
@@ -46,12 +47,12 @@ fn watch_session(mut child: tokio::process::Child, mut cancel: tokio::sync::ones
}).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(),
"" => crate::i18n::s("连接已断开","Disconnected").to_owned(),
"CONTROL echo timed out" => crate::i18n::s("连接超时:被控端没有响应(官方主机互通尚未完成)","Timed out: the remote device did not answer (official host interop is not finished)").to_owned(),
"Remote session released" => crate::i18n::s("被控端结束了本次连接","The remote device ended the connection").to_owned(),
other => other.to_owned(),
};
toast(&format!("连接失败:{reason}"));
toast(&crate::tr!("连接失败:{reason}","Connection failed: {reason}"));
} else if let Some(message) = success { toast(message); }
})
}
@@ -81,7 +82,8 @@ pub fn device_rows(devices: &[Value], current: Option<&str>) -> String {
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))
let thumb = super::thumbs::existing(id).map(|p| clean(&p.to_string_lossy())).unwrap_or_default();
Some(format!("{}\t{}\t{}\t{}\t{}\t{}\n", clean(id), clean(name), platform, online as u8, (current == Some(id)) as u8, thumb))
}).collect()
}
@@ -94,6 +96,10 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
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();
// Account token seen last; a new sign-in restarts a host the user turned on.
let mut host_token: Option<String> = None;
let mut just_logged_in = false;
unsafe { uu_viewer_ui_set_host(super::host::active().into()) }
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 }
@@ -103,27 +109,40 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
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 meta.modified().ok() != qr_seen { qr_seen = meta.modified().ok(); set_login(false, &qr.to_string_lossy(), crate::i18n::s("请用手机扫码并确认","Scan with your phone and confirm"), ""); }
}
if let Ok(Some(_)) = child.try_wait() { login = None; let _ = std::fs::remove_file(&qr); next_refresh = Instant::now(); }
if let Ok(Some(_)) = child.try_wait() { login = None; let _ = std::fs::remove_file(&qr); next_refresh = Instant::now(); just_logged_in = true; }
} else if Instant::now() >= next_refresh {
next_refresh = Instant::now() + Duration::from_secs(30);
match credentials() {
Ok(creds) => {
set_login(true, "", "", "已登录");
set_login(true, "", "", crate::i18n::s("已登录","Signed in"));
// Hosting is opt-in (Settings switch): signing in never starts the host, but a
// host the user turned on goes online with the new account.
if host_token.as_deref() != Some(creds.token.as_str()) {
let changed = host_token.is_some() || std::mem::take(&mut just_logged_in);
if changed && super::host::managed() && super::host::active() {
match super::host::restart() {
Ok(()) => toast(crate::i18n::s("本机已上线,可在你的其他设备上远程控制","This computer is online; control it from your other devices")),
Err(e) => log::warn!("Host service not restarted: {e}"),
}
unsafe { uu_viewer_ui_set_host(super::host::active().into()) }
}
host_token = Some(creds.token.clone());
}
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();
d.get("alias").and_then(Value::as_str).unwrap_or_else(|| crate::i18n::s("远端设备","Remote device")).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(super::api::Error::AuthenticationExpired) => set_login(false, "", crate::i18n::s("登录已过期,请重新登录","Sign-in expired, please sign in again"), ""),
Err(_) => {}
}
}
Err(_) => set_login(false, "", "尚未登录", ""),
Err(_) => set_login(false, "", crate::i18n::s("尚未登录","Not signed in"), ""),
}
}
while let Some(cmd) = take() {
@@ -131,6 +150,18 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
match parts.as_slice() {
["quit"] => break,
["refresh"] => next_refresh = Instant::now(),
["relaunch"] => {
// Language is read once at start: restart the launcher in place. Open
// sessions are separate processes and keep running.
use std::os::unix::process::CommandExt;
let _ = std::process::Command::new(&exe).args(std::env::args_os().skip(1)).exec();
toast(crate::i18n::s("请重新启动控制端以切换语言","Restart the viewer to switch the language"));
}
["host", state] => {
let result = if *state == "on" { super::host::enable(&exe) } else { super::host::disable() };
if let Err(e) = result { toast(&crate::tr!("本机被控设置失败:{e}","Could not change hosting: {e}")); }
unsafe { uu_viewer_ui_set_host(super::host::active().into()) }
}
["logout"] => {
// Sign out locally: drop the account token, keep the device identity.
let path = crate::config::path();
@@ -140,7 +171,7 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
}
for (_,s) in sessions.drain() { s.stop().await; }
unsafe { uu_viewer_ui_set_devices(c("").as_ptr()) }
set_login(false, "", "已退出登录", "");
set_login(false, "", crate::i18n::s("已退出登录","Signed out"), "");
next_refresh = Instant::now() + Duration::from_secs(3600);
}
["login"] if login.is_none() => {
@@ -149,7 +180,7 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
.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", ""); }
if login.is_none() { set_login(false, "", crate::i18n::s("找不到配套的 uuremote-server","The matching uuremote-server was not found"), ""); }
}
["connect", id, kind] if matches!(*kind, "desktop" | "watch") => {
if !replace(&mut sessions,id).await{continue}
@@ -161,38 +192,38 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
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("连接失败:无法启动会话进程"),
Err(_) => toast(crate::i18n::s("连接失败:无法启动会话进程","Connection failed: cannot start the session process")),
}
}
["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(reason) => toast(&crate::tr!("连接失败:{reason}","Connection failed: {reason}")),
},
Err(_) => toast("连接失败:无法启动协助会话进程"),
Err(_) => toast(crate::i18n::s("连接失败:无法启动协助会话进程","Connection failed: cannot start the assistance session")),
}
}
["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 input.write_all(b"files\n").await.is_err(){toast(crate::i18n::s("桌面会话命令发送失败,请重试","Could not send the command to the desktop session, try again"))}continue
}}}
if !replace(&mut sessions,id).await{continue}
let name = names.get(*id).cloned().unwrap_or_else(|| "远端设备".into());
let name = names.get(*id).cloned().unwrap_or_else(|| crate::i18n::s("远端设备","Remote device").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("连接失败:无法启动工具进程"),
Err(_) => toast(crate::i18n::s("连接失败:无法启动工具进程","Connection failed: cannot start the tool process")),
}
}
["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("电源指令失败:无法启动会话进程"),
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,Some(crate::i18n::s("电源指令已发送,未确认远端执行结果","Power command sent; the result on the remote device is not confirmed")));sessions.insert((*id).into(),Running{cancel,task,input:None}); }
Err(_) => toast(crate::i18n::s("电源指令失败:无法启动会话进程","Power command failed: cannot start the session process")),
}
}
["connect", id, "unbind"] => {
@@ -201,7 +232,7 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
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}"))}
match result {Ok(())=>toast(crate::i18n::s("设备已从账号删除","Device removed from the account")),Err(e)=>toast(&crate::tr!("删除设备失败:{e}","Removing the device failed: {e}"))}
next_refresh=Instant::now();
}
["connect", _, kind] => log::info!("Viewer UI: {kind} is not supported yet"),
@@ -221,6 +252,6 @@ pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, Stri
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");
assert_eq!(rows, "d1\ta b\t4\t1\t0\t\nd2\td2\t1\t0\t1\t\n");
}
}
+30
View File
@@ -198,6 +198,14 @@ mod tests {
}
}
/// RpcRequest case 15 SendVideoTrackReq with no fields (track 0), sent by the official iPhone
/// viewer right after CONTROL opens (host logs: response_field=11 value=None). Without it a
/// second session only joins the stream already encoded for another viewer: no SPS/PPS/IDR (#124).
pub fn request_video_track()->Vec<u8>{
let mut header=Vec::new();int(1,2_000_001,&mut header);
let mut rpc=Vec::new();bytes(1,&header,&mut rpc);bytes(15,&[],&mut rpc);
envelope(2_000_001,21,&rpc)
}
/// 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);
@@ -205,6 +213,19 @@ pub fn request_chroma444()->Vec<u8>{
let mut rpc=Vec::new();bytes(1,&header,&mut rpc);bytes(2,&setting,&mut rpc);
envelope(2_000_000,21,&rpc)
}
/// RpcRequest case 2 CaptureSettingRequest with the given (field, value) pairs: 1 fps option
/// index, 18 fpsCount, 2 quality, 7 chroma, 10 resolution_type, 16/17 pixel size (src/capture_setting.rs).
pub fn capture_setting(seq:u64,fields:&[(u32,u64)])->Vec<u8>{
let mut header=Vec::new();int(1,seq,&mut header);
let mut setting=Vec::new();for &(f,v) in fields {int(f,v,&mut setting);}
let mut rpc=Vec::new();bytes(1,&header,&mut rpc);bytes(2,&setting,&mut rpc);
envelope(seq,21,&rpc)
}
/// Message 3 SimpleAction {1 action, 5 value} as the official 安全 menu sends it.
pub fn simple_action(seq:u64,action:u64,value:Option<u64>)->Vec<u8>{
let mut body=Vec::new();int(1,action,&mut body);if let Some(v)=value {int(5,v,&mut body);}
envelope(seq,3,&body)
}
/// 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>){
@@ -237,6 +258,15 @@ pub fn media_control(data:&[u8])->(Option<u32>,Option<u32>){
assert!(s.video_preferences(force).connect_options("synthetic-device",false).unwrap()==options);
}
}
#[test] fn video_track_request_is_an_empty_rpc_15(){
let message=request_video_track();
let fields=decode_wire(&message).unwrap();
assert!(fields.iter().any(|f|f.number==1));
let rpc=fields.iter().find_map(|f|match (f.number,&f.value){(21,WireValue::Bytes(b))=>Some(*b),_=>None}).unwrap();
let rpc=decode_wire(rpc).unwrap();
assert!(rpc.iter().any(|f|f.number==1));
assert!(rpc.iter().any(|f|matches!((f.number,&f.value),(15,WireValue::Bytes(b)) if b.is_empty())));
}
#[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);
+124 -11
View File
@@ -2,7 +2,9 @@
#![allow(dead_code)]
#[path = "auth.rs"] mod auth;
#[path = "config.rs"] mod config;
#[path = "i18n.rs"] mod i18n;
#[path = "protocol.rs"] mod protocol;
mod ws_transport;
mod viewer;
#[cfg(test)] #[path="hevc.rs"] mod hevc;
use viewer::clipboard;
@@ -13,7 +15,7 @@ use viewer::clipboard;
#[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 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 type DEVICE [options] (secret from UU_INPUT_ENV or stdin; reuses running viewer)\n options: --delay-ms MS --omit-last N --snapshot PATH --dry-run --new-session\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; desktop sessions send one sendVideoTrack RPC (like the official iPhone viewer).";
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}],
@@ -56,10 +58,11 @@ async fn run(args:&[String])->Result<(),String> {
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(())
api()?.unbind(&args[1],args.len()==3).await.map_err(|e|crate::tr!("删除设备失败:{e}","Removing the device failed: {e}"))?;
println!("{}",crate::i18n::s("已从账号删除设备","Device removed from the account"));Ok(())
}
Some("power")=>power_command(args).await,
Some("type")=>type_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
@@ -67,7 +70,7 @@ async fn run(args:&[String])->Result<(),String> {
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}"))
desktop_command(&["connect".into(),args[1].clone(),"false".into(),"-".into(),"echo".into(),"legacy".into()],Some(code)).await.map_err(|e|crate::tr!("协助连接失败:{e}","Assistance connection failed: {e}"))
}
Some("connect") if args.len()==6 || args.len()==7=> desktop_command(args,None).await,
_=>Err(HELP.into()),
@@ -94,11 +97,16 @@ async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String>
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 {
#[cfg(feature="viewer-sdl")]
macro_rules! wait {($stage:expr,$fut:expr)=>{viewer::sdl::loading(desktop.as_mut().map(|d|&mut d.0),$stage,$fut).await?}}
#[cfg(not(feature="viewer-sdl"))]
macro_rules! wait {($stage:expr,$fut:expr)=>{{let _=$stage;$fut.await}}}
let contacting=i18n::s("正在连接远端设备…","Contacting the remote device…");
let room=wait!(contacting,async{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)};
}}).map_err(|e|e.to_string())?;
let target_mac=if shape.capture_type==1 {wait!(contacting,api.target_is_mac(&room,account_connection.then_some(args[1].as_str())))} 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())?);
@@ -109,13 +117,95 @@ async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String>
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?;
let mut session=wait!(i18n::s("正在建立安全连接…","Establishing a secure connection…"),Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()))?;
#[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};
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only,&args[1]).await}else{session.run().await};
#[cfg(not(feature="viewer-sdl"))]
let result=session.run().await;
session.close().await;result
}
async fn type_command(args:&[String])->Result<(),String>{
// type DEVICE [--delay-ms MS] [--omit-last N] [--snapshot PATH] [--dry-run] [--new-session]
if args.len()<2 || args[1].trim().is_empty() { return Err(HELP.into()) }
let device=&args[1];
let mut delay_ms:Option<&str>=None;
let mut omit_last:Option<&str>=None;
let mut snapshot:Option<String>=None;
let mut dry_run=false;
let mut new_session=false;
let mut i=2;
while i<args.len() {
match args[i].as_str() {
"--delay-ms" => {
i+=1; delay_ms=Some(args.get(i).map(String::as_str).ok_or_else(||HELP.to_string())?);
}
"--omit-last" => {
i+=1; omit_last=Some(args.get(i).map(String::as_str).ok_or_else(||HELP.to_string())?);
}
"--snapshot" => {
i+=1; snapshot=Some(args.get(i).cloned().ok_or_else(||HELP.to_string())?);
}
"--dry-run" => { dry_run=true; }
"--new-session" => { new_session=true; }
_ => return Err(HELP.into()),
}
i+=1;
}
let delay=viewer::secure_input::parse_delay_ms(delay_ms)?;
let omit=viewer::secure_input::parse_omit_last(omit_last)?;
let mut secret=viewer::secure_input::load_secret(std::io::stdin().lock())?;
if dry_run {
let report=viewer::secure_input::dry_run_report(&secret, omit, false)?;
drop(secret);
println!("{report}");
return Ok(());
}
secret.omit_last_chars(omit)?;
// Prefer a running desktop viewer (avoids force-replacing the live session, upstream #30).
match viewer::type_ipc::socket_path(device) {
Ok(path) if path.exists() && !new_session => {
let req=viewer::type_ipc::TypeRequest{
delay_ms: delay.as_millis() as u64,
omit_last: 0, // already applied locally
snapshot,
secret: secret.as_str().to_owned(),
};
drop(secret);
let response=viewer::type_ipc::send_to_viewer(device, req).await?;
if !response.ok {
return Err(response.error.unwrap_or_else(||"Secure input failed on running viewer".into()));
}
println!("{}",crate::tr!("安全输入已发送({} 个按键事件,{} 字符)。","Secure input sent ({} key events, {} characters).", response.events, response.chars));
if let Some(path)=response.snapshot {
println!("snapshot={path}");
log::info!("Secure input snapshot: {path}");
}
return Ok(());
}
_ => {}
}
if !new_session {
drop(secret);
return Err("No running desktop viewer for this device; open a connect/ui session first, or pass --new-session".into());
}
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in type shape")?;
shape.capture_type=1;
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let room=api.join(device,false,true).await.map_err(|e|e.to_string())?;
let mac=api.target_is_mac(&room,Some(device)).await.map_err(|e|e.to_string())?;
let actions=viewer::secure_input::expand(secret.as_str(),mac)?;
let event_count=actions.len();
let char_count=secret.chars_count();
drop(secret);
log::info!("Secure input prepared (new session): chars={} events={} delay_ms={} mac={}", char_count, event_count, delay.as_millis(), mac);
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::secure_input::run_session(&mut session,actions.as_slice(),delay).await;
session.close().await;
if result.is_ok(){println!("{}",crate::tr!("安全输入已发送({event_count} 个按键事件);新会话路径无截图。","Secure input sent ({event_count} key events); no snapshot on the new-session path."));}
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))}
@@ -128,11 +218,34 @@ 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"]] {
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["type"],vec!["type","device","--delay-ms"],vec!["type","device","--delay-ms","x"],vec!["type","device","extra"],vec!["type","device","--omit-last"],vec!["type","device","--snapshot"],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 type_dry_run_and_no_viewer_paths_are_redacted() {
let _g = viewer::secure_input::ENV_LOCK.lock().unwrap();
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
let out = {
// dry-run
let args: Vec<String> = ["type","missing-device-id","--dry-run"].into_iter().map(str::to_owned).collect();
// reload env for dry-run — previous load_secret removed the var
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
run(&args).await
};
assert!(out.is_ok(), "{out:?}");
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
let err = run(&["type".into(),"missing-device-id".into()]).await.unwrap_err();
assert!(err.contains("No running desktop viewer") || err.contains("--new-session"), "{err}");
assert!(!err.contains("sentinel"));
assert!(!err.contains("SECRET"));
std::env::remove_var("UU_INPUT_ENV");
std::env::remove_var("UU_TYPE_SENTINEL_ENV");
}
#[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()));
@@ -188,6 +301,6 @@ async fn power_command(args:&[String])->Result<(),String>{
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!("电源指令已发送;未确认远端执行结果。");}
if result.is_ok(){println!("{}",crate::i18n::s("电源指令已发送;未确认远端执行结果。","Power command sent; the result on the remote device is not confirmed."));}
result
}
+217 -13
View File
@@ -199,16 +199,19 @@ pub fn text_probe()->Result<(),String> {
typed+=one;
}
if typed<0 { return Err(format!("Wayland text typing failed ({typed})")); }
std::thread::sleep(std::time::Duration::from_millis(100));
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.
// Opt-in single-track monitor switching: Hyprland outputs (UU_WAYLAND_MULTISCREEN) or X11 RandR
// monitors (UU_X11_MULTISCREEN). The existing engines own capture/pointer binding; X11 crops the
// root to the selected monitor. 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();
pub struct Output { pub name:String, pub width:u32, pub height:u32, pub fps:i32, pub x:i32, pub y:i32 }
struct Inventory { outputs:Vec<Output>, x11:bool, portal:bool }
static OUTPUTS: std::sync::OnceLock<Inventory> = std::sync::OnceLock::new();
#[derive(Default)]
struct Selection { id:usize, generation:u64, presented:Option<u64>, failed:bool }
impl Selection {
@@ -221,19 +224,124 @@ impl Selection {
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] {
fn inventory() -> &'static Inventory {
OUTPUTS.get_or_init(|| {
let backend=crate::desktop_backend::detect().ok();
if backend==Some(crate::desktop_backend::DesktopBackend::X11) && !crate::desktop_backend::headless()
&& std::env::var("UU_X11_MULTISCREEN").ok().as_deref()==Some("1") {
let outputs=x11_outputs();
return Inventory {x11:!outputs.is_empty(),outputs,portal:false};
}
if backend==Some(crate::desktop_backend::DesktopBackend::Portal) && !crate::desktop_backend::headless() {
let outputs=portal_outputs();
return Inventory {portal:!outputs.is_empty(),outputs,x11:false};
}
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())
|| backend!=Some(crate::desktop_backend::DesktopBackend::Wayland) {return Inventory {outputs:Vec::new(),x11:false,portal:false};}
let niri=std::env::var_os("NIRI_SOCKET").is_some();
let output=if niri {std::process::Command::new("niri").args(["msg","--json","outputs"]).output()}
else {std::process::Command::new("hyprctl").args(["monitors","-j"]).output()};
let result=output.map_err(|_|"monitor command unavailable").and_then(|output| {
if !output.status.success() {return Err("monitor command failed");}
let preferred=std::env::var("UU_WAYLAND_OUTPUT").unwrap_or_default();
if niri {parse_niri_outputs(&output.stdout,&preferred)} else {parse_outputs(&output.stdout,&preferred)}
});
match result {Ok(outputs)=>outputs,Err(reason)=>{log::warn!("Wayland multi-screen disabled: {}",reason);Vec::new()}}
let outputs=match result {Ok(outputs)=>outputs,Err(reason)=>{log::warn!("Wayland multi-screen disabled: {}",reason);Vec::new()}};
Inventory {outputs,x11:false,portal:false}
})
}
pub fn outputs() -> &'static [Output] {&inventory().outputs}
/// GNOME portal grants one monitor per consent (multi-select is refused), so each monitor
/// gets its own saved consent and a switch opens that monitor's session. Read once.
fn portal_outputs()->Vec<Output> {
let monitors=crate::portal::monitors();
if monitors.len()<2 {return Vec::new();}
let fps=crate::video::display_fps() as i32;
let mut outputs:Vec<Output>=monitors.iter().map(|m|Output {name:m.connector.clone(),width:m.width,height:m.height,fps,x:m.x,y:m.y}).collect();
// Screen 0 is the one opened first: the monitor whose consent is already saved, else the primary.
let dir=crate::portal::permissions_directory();
let granted=|name:&str|dir.as_deref().is_some_and(|d|d.join(crate::portal::monitor_key(name)).exists());
let primary=monitors.iter().find(|m|m.primary).map(|m|m.connector.clone()).unwrap_or_default();
outputs.sort_by_key(|o|(!granted(&o.name),o.name!=primary,o.x,o.y));
outputs.truncate(16);
log::info!("Portal multi-screen: {} monitors",outputs.len());
outputs
}
/// Connector of the selected screen when the portal advertises several monitors.
pub fn portal_monitor()->Option<String> {
if !inventory().portal {return None;}
source(selected()).map(|o|o.name.clone())
}
/// Monitor at a portal stream's logical position (Mutter logical layout).
pub fn portal_monitor_at(x:i32,y:i32)->Option<String> {
if !inventory().portal {return None;}
outputs().iter().find(|o|(o.x,o.y)==(x,y)).map(|o|o.name.clone())
}
/// X11 monitors are advertised: the stream captures the selected monitor's region of the root.
pub fn x11_multiscreen()->bool {inventory().x11}
/// Read once, like the Hyprland inventory: a changed monitor layout needs a host restart.
fn x11_outputs()->Vec<Output> {
let mut command=std::process::Command::new("xrandr");
if let Some(display)=crate::capture::x11_display().or_else(||std::env::var("DISPLAY").ok()).filter(|d|!d.is_empty()) {
command.arg("--display").arg(display);
}
let result=command.arg("--listmonitors").output().map_err(|_|"xrandr unavailable").and_then(|output| {
if !output.status.success() {return Err("xrandr failed");}
parse_x11_monitors(&String::from_utf8_lossy(&output.stdout),&std::env::var("UU_X11_OUTPUT").unwrap_or_default(),crate::video::display_fps() as i32)
});
match result {
Ok(outputs) if outputs.len()>=2=>{log::info!("X11 multi-screen: {} monitors",outputs.len());outputs},
Ok(_)=>{log::warn!("X11 multi-screen disabled: fewer than two monitors");Vec::new()},
Err(reason)=>{log::warn!("X11 multi-screen disabled: {}",reason);Vec::new()},
}
}
/// `xrandr --listmonitors`: ` 0: +*HDMI-0 1920/527x1080/296+1920+0 HDMI-0` (`*` = primary).
/// The preferred monitor (UU_X11_OUTPUT, else the primary) is id 0; the rest go left to right.
fn parse_x11_monitors(text:&str,preferred:&str,fps:i32)->Result<Vec<Output>,&'static str> {
fn geometry(text:&str)->Option<(u32,u32,i32,i32)> {
let (width,rest)=text.split_once('x')?;
let split=rest.find('+')?;
let (height,offsets)=rest.split_at(split);
let mut offsets=offsets[1..].split('+');
let size=|v:&str|v.split('/').next()?.parse::<u32>().ok();
let (x,y)=(offsets.next()?.parse::<i32>().ok()?,offsets.next()?.parse::<i32>().ok()?);
if offsets.next().is_some() || x<0 || y<0 {return None;}
Some((size(width)?,size(height)?,x,y))
}
let mut seen=std::collections::HashSet::new();
let mut primary=String::new();
let mut outputs=Vec::new();
for line in text.lines().skip(1) {
let mut fields=line.split_whitespace();
let (Some(_),Some(tag),Some(rect))=(fields.next(),fields.next(),fields.next()) else {continue};
let name=tag.trim_start_matches(['+','*']);
let Some((width,height,x,y))=geometry(rect) else {continue};
if name.is_empty() || name.len()>127 || !seen.insert(name.to_owned())
|| width<2 || height<2 || width>16384 || height>16384 || u64::from(width)*u64::from(height)*4>256*1024*1024 {continue;}
if tag.contains('*') {primary=name.to_owned();}
outputs.push(Output {name:name.into(),width,height,fps,x,y});
}
let first=if preferred.is_empty() {primary} else {preferred.to_owned()};
outputs.sort_by_key(|m| (m.name!=first,m.x,m.y));
outputs.truncate(16);
if outputs.is_empty() || (!preferred.is_empty() && outputs[0].name!=preferred) {return Err("No capturable preferred output");}
Ok(outputs)
}
fn parse_niri_outputs(json:&[u8],preferred:&str)->Result<Vec<Output>,&'static str> {
let inventory=serde_json::from_slice::<serde_json::Map<String,serde_json::Value>>(json).map_err(|_|"Invalid niri inventory")?;
let monitors:Vec<_>=inventory.values().filter_map(|m| {
let logical=m["logical"].as_object()?;
let mode=m["modes"].as_array()?.get(usize::try_from(m["current_mode"].as_u64()?).ok()?)?;
let transform=logical.get("transform")?.as_str()?;
if !matches!(transform,"Normal"|"90"|"180"|"270") {return None;}
let (w,h)=(mode["width"].as_u64()?,mode["height"].as_u64()?);
let (w,h)=if matches!(transform,"90"|"270") {(h,w)} else {(w,h)};
Some(serde_json::json!({"name":m["name"],"width":w,"height":h,"transform":0,
"refreshRate":mode["refresh_rate"].as_f64()?/1000.0}))
}).collect();
parse_outputs(&serde_json::to_vec(&monitors).map_err(|_|"Invalid niri inventory")?,preferred)
}
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();
@@ -244,7 +352,7 @@ fn parse_outputs(json:&[u8],preferred:&str)->Result<Vec<Output>,&'static str> {
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})
Some(Output {name:name.into(),width,height,fps:m["refreshRate"].as_f64()?.round().clamp(1.0,240.0) as i32,x:0,y:0})
}).collect();
outputs.sort_by_key(|m| (m.name!=preferred,m.name.clone()));
outputs.truncate(16);
@@ -255,6 +363,35 @@ pub fn selection()->(usize,u64) {let s=SELECTION.lock().unwrap();(s.id,s.generat
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))}
/// Region the encoder captures for this display: the Wayland output, or the selected X11 monitor.
pub fn capture_source(display:&str,portal:bool,id:usize)->Option<&'static Output> {
if display.starts_with("wayland:") || (!portal && !display.starts_with("kms:") && x11_multiscreen()) {source(id)} else {None}
}
/// Offset of the selected X11 monitor in the root: absolute input is relative to that monitor.
pub fn x11_placement()->Option<(i32,i32)> {
if !x11_multiscreen() {return None;}
source(selected()).map(|s|(s.x,s.y))
}
/// Pixel size of one advertised output. Unknown ids keep `fallback` (connection size).
pub fn source_size(id:usize,fallback:(u32,u32))->(u32,u32) {
#[cfg(test)]
if let Some(outputs)=*test_outputs().lock().unwrap_or_else(|e|e.into_inner()) {
return outputs.get(id).map_or(fallback,|s|(s.width,s.height));
}
source(id).map_or(fallback,|s|(s.width,s.height))
}
#[cfg(test)]
fn test_outputs()->&'static std::sync::Mutex<Option<&'static [Output]>> {
static SLOT:std::sync::OnceLock<std::sync::Mutex<Option<&'static [Output]>>>=std::sync::OnceLock::new();
SLOT.get_or_init(||std::sync::Mutex::new(None))
}
/// Native size written into CaptureSettingSync. Wayland uses the output the encoder is reading
/// (`source_id`), which can differ from the size captured when the connection opened; so does an
/// X11 monitor with UU_X11_MULTISCREEN. Otherwise X11, portal and KMS keep the connection size
/// (X11 mode changes go through `x11_resized`).
pub fn sync_native(display:&str,source_id:usize,connection:(u32,u32))->(u32,u32) {
if display.starts_with("wayland:") || (!display.starts_with("kms:") && x11_multiscreen()) {source_size(source_id,connection)} else {connection}
}
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);}
@@ -263,7 +400,19 @@ pub fn failed(id:usize,generation:u64) {
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")?;
let output=source(id).ok_or("Unknown screen")?;
if inventory().portal {
let mut state=SELECTION.lock().unwrap();
crate::portal::switch_active(&output.name)?;
state.begin(id);
log::info!("Portal screen selected: id={} source={}x{}",id,output.width,output.height);
return Ok(());
}
if x11_multiscreen() {
SELECTION.lock().unwrap().begin(id);
log::info!("X11 screen selected: id={} source={}x{}+{}+{}",id,output.width,output.height,output.x,output.y);
return Ok(());
}
#[cfg(all(target_os="linux",feature="wayland"))]
{
let name=std::ffi::CString::new(output.name.as_str()).map_err(|_|"Invalid output name")?;
@@ -335,6 +484,28 @@ mod selection_regressions {
s.sent(0,current);assert!(s.ready());
}
#[test]
#[ignore = "requires an unlocked Wayland session and UU_WAYLAND_MULTISCREEN=1"]
fn live_monitor_switch_captures_each_output() {
assert!(outputs().len()>1);
init().unwrap();
for (id,output) in outputs().iter().enumerate() {
select(id).unwrap();
let mut frame=vec![0;(output.width as usize)*(output.height as usize)*4];
capture(&mut frame).unwrap();
assert_eq!(selected(),id);
}
select(0).unwrap();
}
#[test]
fn niri_inventory_uses_active_mode_and_rotated_pixel_size() {
let json=br#"{"one":{"name":"DP-1","modes":[{"width":2240,"height":1400,"refresh_rate":60000}],"current_mode":0,"logical":{"transform":"90"}},
"off":{"name":"off","modes":[],"current_mode":null,"logical":null}}"#;
let outputs=parse_niri_outputs(json,"").unwrap();
assert_eq!((outputs.len(),outputs[0].width,outputs[0].height,outputs[0].fps),(1,1400,2240,60));
assert!(parse_niri_outputs(json,"off").is_err());
assert!(parse_niri_outputs(b"[]","").is_err());
}
#[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}]"#;
@@ -353,4 +524,37 @@ mod selection_regressions {
assert_eq!(outputs.len(),1);assert_eq!(outputs[0].name,"normal");
assert!(parse_outputs(b"not JSON","").is_err());
}
#[test]
fn x11_monitors_keep_their_root_offsets() {
// #98: GNOME/X11, two 1920x1080 monitors side by side, primary on the right.
let text="Monitors: 2\n 0: +*HDMI-0 1920/527x1080/296+1920+0 HDMI-0\n 1: +HDMI-1 1920/521x1080/293+0+0 HDMI-1\n";
let outputs=parse_x11_monitors(text,"",60).unwrap();
assert_eq!(outputs.iter().map(|m|(m.name.as_str(),m.width,m.height,m.x,m.y)).collect::<Vec<_>>(),
vec![("HDMI-0",1920,1080,1920,0),("HDMI-1",1920,1080,0,0)]);
let outputs=parse_x11_monitors(text,"HDMI-1",60).unwrap();
assert_eq!((outputs[0].name.as_str(),outputs[1].name.as_str()),("HDMI-1","HDMI-0"));
assert!(parse_x11_monitors(text,"DP-9",60).is_err());
// xrandr --setmonitor virtual monitors (output "none"); no primary: left to right.
let virtual_monitors="Monitors: 3\n 0: +A 1280/338x1024/270+1280+0 none\n 1: +B 1280/338x1024/270+0+0 none\n 2: C 0/0x0/0+0+0 none\n";
let outputs=parse_x11_monitors(virtual_monitors,"",30).unwrap();
assert_eq!(outputs.iter().map(|m|(m.name.as_str(),m.x)).collect::<Vec<_>>(),vec![("B",0),("A",1280)]);
assert!(parse_x11_monitors("Monitors: 1\n 0: +*X 1920/1x1080/1-10+0 X\n","",60).is_err());
assert!(parse_x11_monitors("garbage","",60).is_err());
}
#[test]
fn sync_native_follows_the_wayland_source_id() {
assert_eq!(sync_native(":0",1,(1920,1080)),(1920,1080));
assert_eq!(sync_native("kms:/dev/dri/card0",1,(1920,1080)),(1920,1080));
let inventory:&'static [Output]=Box::leak(vec![
Output {name:"eDP-1".into(),width:1920,height:1080,fps:60,x:0,y:0},
Output {name:"HDMI-A-1".into(),width:2560,height:1440,fps:75,x:0,y:0},
].into_boxed_slice());
*test_outputs().lock().unwrap()=Some(inventory);
// Connection opened on the first output; the encoder is reading the second.
assert_eq!(sync_native("wayland:wayland-0",1,(1920,1080)),(2560,1440));
assert_eq!(source_size(0,(800,600)),(1920,1080));
assert_eq!(sync_native("wayland:wayland-0",9,(800,600)),(800,600));
assert_eq!(sync_native(":0",1,(1920,1080)),(1920,1080));
*test_outputs().lock().unwrap()=None;
}
}
+480 -194
View File
@@ -42,12 +42,173 @@ pub struct SessionContext {
pub bundle_media: Option<(String, u16)>,
}
/// Desktop role of one peer. A tool peer (file transfer, terminal, port mapping) gains it
/// when the viewer opens the desktop on that same connection with SimpleAction 4
/// capture_desktop instead of a new desktop offer (#99).
pub struct DesktopRole {
active: tokio::sync::watch::Sender<bool>,
input: std::sync::Mutex<Option<Arc<crate::input::DesktopInputSession>>>,
stream: std::sync::Mutex<Option<DesktopStream>>,
/// The running stream of a promoted peer; aborted on demotion so a quick re-promotion
/// never leaves two encoders on one track.
stream_task: std::sync::Mutex<Option<tokio::task::AbortHandle>>,
/// Capture reinitialized at promotion; the peer's own capture was unavailable when offered.
screen: std::sync::Mutex<Option<Arc<ScreenCapture>>>,
/// One session tracker per peer follows every promotion and demotion.
tracking: std::sync::atomic::AtomicBool,
request: std::sync::OnceLock<Box<dyn Fn() + Send + Sync>>,
}
impl DesktopRole {
fn new(desktop: bool) -> Self {
Self { active: tokio::sync::watch::channel(desktop).0, input: Default::default(),
stream: Default::default(), stream_task: Default::default(), screen: Default::default(), tracking: Default::default(), request: Default::default() }
}
pub fn is_desktop(&self) -> bool { *self.active.borrow() }
/// A promoted peer whose video ended on its own (capture failed while locked or off, #114);
/// capture_desktop on it starts the video again.
fn stream_ended(&self) -> bool { self.stream_task.lock().unwrap().as_ref().is_some_and(|task| task.is_finished()) }
fn input(&self) -> Option<Arc<crate::input::DesktopInputSession>> { self.input.lock().unwrap().clone() }
fn screen_or(&self, screen: &Arc<ScreenCapture>) -> Arc<ScreenCapture> {
self.screen.lock().unwrap().clone().unwrap_or_else(|| screen.clone())
}
/// Waits until this peer is a desktop; false once the channel closes first.
async fn wait_desktop(&self, channel: &RTCDataChannel) -> bool {
let mut active = self.active.subscribe();
loop {
if *active.borrow_and_update() { return true; }
tokio::select! {
changed = active.changed() => if changed.is_err() { return false; },
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return false; }
}
}
}
}
}
/// Live desktop video for one peer; a tool peer keeps it unstarted until it becomes a desktop.
#[derive(Clone)]
struct DesktopStream {
pc: std::sync::Weak<RTCPeerConnection>,
track: Arc<crate::video_track::VideoTrack>,
portal_desktop: Option<Arc<crate::desktop_session::PortalDesktop>>,
capture_size: (u32, u32),
capture_display: String,
portal: Option<Arc<crate::portal::PortalSession>>,
settings_rx: tokio::sync::watch::Receiver<crate::capture_setting::VideoSettings>,
settings: Arc<tokio::sync::watch::Sender<crate::capture_setting::VideoSettings>>,
idr_request: Arc<std::sync::atomic::AtomicBool>,
selection: crate::video_select::Selection,
chroma_sync: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>,
reload_at_session: u64,
}
pub struct WebRtcSession {
pub pc: Arc<RTCPeerConnection>,
pub capture: Arc<ScreenCapture>,
pub input: Arc<InputInjector>,
/// The role this peer was offered with; `role` also covers a later capture_desktop.
pub desktop: bool,
pub role: Arc<DesktopRole>,
pub controller: crate::input::Controller,
pub context: Arc<Mutex<SessionContext>>,
actions: Arc<crate::system_actions::PeerActions>,
}
/// Counts a desktop session once it is connected (a failed offer is not a session), while the
/// peer is the desktop. Started once per peer, so a quick demote and re-promote cannot end the
/// count of a session that is still streaming.
fn track_session(end_pc: Arc<RTCPeerConnection>, actions: Arc<crate::system_actions::PeerActions>, role: &DesktopRole) {
if role.tracking.swap(true, std::sync::atomic::Ordering::AcqRel) { return; }
let active = role.active.subscribe();
tokio::spawn(async move {
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
loop {
while end_pc.connection_state() != State::Connected || !*active.borrow() {
if matches!(end_pc.connection_state(), State::Closed | State::Failed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
let starting = actions.clone();
let _ = tokio::task::spawn_blocking(move || starting.session_started()).await;
while !matches!(end_pc.connection_state(), State::Closed | State::Failed) && *active.borrow() {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
let closed = matches!(end_pc.connection_state(), State::Closed | State::Failed);
let ending = actions.clone();
let _ = tokio::task::spawn_blocking(move || ending.session_ended()).await;
if closed { return; }
}
});
}
type EchoReplay = (Arc<std::sync::atomic::AtomicU64>, Arc<std::sync::atomic::AtomicBool>, Arc<std::sync::atomic::AtomicBool>);
/// A promoted tool peer starts its TEXT clipboard after the viewer's echo was answered without
/// ff_clipboard; declare it again on CONTROL once the bridge is ready, as the Portal path does.
fn replay_clipboard_echo(channel: Arc<RTCDataChannel>, sequence: Arc<std::sync::atomic::AtomicU64>,
(echo_request, echo_seen, clipboard_ready): EchoReplay, role: Arc<DesktopRole>) {
tokio::spawn(async move {
for _ in 0..100 {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
if !role.is_desktop() || channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
if !clipboard_ready.load(std::sync::atomic::Ordering::Acquire) { continue; }
// echo_seen is published after the request seq, so reading it first gives a current seq.
if echo_seen.load(std::sync::atomic::Ordering::Acquire) {
let request_seq = echo_request.load(std::sync::atomic::Ordering::Acquire);
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let response = crate::control_protocol::encode_echo_response_with_clipboard(
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), timestamp, request_seq, true);
let _ = channel.send(&bytes::Bytes::from(response)).await;
log::info!("CONTROL clipboard capability declared after capture_desktop");
}
return;
}
});
}
impl DesktopStream {
/// Encode current frames only while the peer is connected and still the desktop.
fn spawn(self, screen: Option<Arc<ScreenCapture>>, mut active: tokio::sync::watch::Receiver<bool>) -> Option<tokio::task::AbortHandle> {
let streaming_pc = self.pc.upgrade()?;
let DesktopStream { track: video_track, portal_desktop, capture_size, capture_display, portal,
settings_rx, settings, idr_request, selection, chroma_sync, reload_at_session, .. } = self;
let (capture_size, capture_display, portal) = screen.map_or((capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
Some(tokio::spawn(async move { tokio::select! {
_ = active.wait_for(|active| !*active) => log::info!("Live desktop stream stopped: a newer desktop took over"),
_ = async move {
let screen = if let Some(desktop) = portal_desktop {
if let Err(error) = crate::locked_video::run(&streaming_pc, &video_track, &desktop, selection).await {
log::warn!("Locked desktop video unavailable: {error}");
}
let mut updates = desktop.subscribe();
loop {
let state = updates.borrow_and_update().clone();
if state.ready() { break Some(state.screen); }
if !state.waiting { return; }
if crate::video::transport_closed(&streaming_pc) { return; }
tokio::select! {
changed = updates.changed() => if changed.is_err() { return; },
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
}
}
} else { None };
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
(capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
let state_pc = streaming_pc.clone();
if let Err(e) = crate::video::stream_desktop_at(streaming_pc, video_track, capture_size, capture_display, portal, settings_rx, settings, idr_request, selection, chroma_sync, reload_at_session).await {
// A send racing the viewer's close fails with a misleading track error.
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
log::info!("Live desktop stream ended: peer connection closed ({})", e);
} else {
log::error!("Live desktop stream stopped: {}", e);
}
}
} => {},
} }).abort_handle())
}
}
impl WebRtcSession {
@@ -63,7 +224,12 @@ impl WebRtcSession {
m.register_default_codecs()
.map_err(|e| format!("Register standard codecs failed: {}", e))?;
let hevc = desktop && crate::video::hevc_available().await;
// Encoder, codec preference and 4:4:4 stay fixed for this peer (codec is negotiated at CONTROL open).
// Read once before the HEVC probe so a concurrent set-encoder/set-codec cannot split capability from CONTROL.
// reload_at_session is the generation at that snapshot. A probe that finishes later is not a reload.
let reload_at_session = crate::video_select::reload_generation_value();
let video_selection = crate::video_select::selection();
let hevc = desktop && crate::video::hevc_available(video_selection.encoder).await;
if hevc { crate::video_track::register_hevc(&mut m).map_err(|e| format!("Register HEVC failed: {e}"))?; }
m.register_header_extension(
@@ -101,7 +267,8 @@ impl WebRtcSession {
.map_err(|e| format!("Create PeerConnection failed: {}", e))?,
);
let input_session=desktop.then(||input.desktop_session());
let role = Arc::new(DesktopRole::new(desktop));
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); }
let context = Arc::new(Mutex::new(SessionContext::default()));
crate::network_diagnostics::start(Arc::downgrade(&pc));
@@ -159,14 +326,16 @@ impl WebRtcSession {
}));
let connected_context = context.clone();
let connection_input=input_session.clone();
let connection_role=role.clone();
let connected_signal = signaling_client.clone();
let notified = Arc::new(std::sync::atomic::AtomicBool::new(false));
let connected_selection = video_selection;
pc.on_peer_connection_state_change(Box::new(move |state| {
let ctx = connected_context.clone();
let input=connection_input.clone();
let input=connection_role.input();
let sig = connected_signal.clone();
let notified = notified.clone();
let video_selection = connected_selection;
Box::pin(async move {
log::info!("PeerConnection State changed: {:?}", state);
if let Some(session)=input.as_ref() {
@@ -177,10 +346,10 @@ 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 encoder = crate::video::Encoder::requested();
let encoder = video_selection.encoder;
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());
hevc, crate::video::full_chroma_for(encoder));
if let Err(e) = sig.emit_event(crate::capability::FORWARD_SETTING_EVENT, payload).await {
log::error!("Device capability notification failed: {}", e);
}
@@ -275,67 +444,24 @@ impl WebRtcSession {
let video_settings = Arc::new(video_settings);
// Per-connection mute / lock-after-session settings (安全 menu).
let peer_actions = Arc::new(crate::system_actions::PeerActions::default());
let session_actions = peer_actions.clone();
let desktop_sound = desktop && crate::audio::enabled();
if desktop && !cfg!(test) {
let (end_pc, actions) = (pc.clone(), peer_actions.clone());
tokio::spawn(async move {
{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
// Count the session once it is actually connected (a failed offer is not a session).
while end_pc.connection_state() != State::Connected {
if matches!(end_pc.connection_state(), State::Closed | State::Failed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
let starting = actions.clone();
let _ = tokio::task::spawn_blocking(move || starting.session_started()).await;
}
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
while !matches!(end_pc.connection_state(), State::Closed | State::Failed) {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
drop(end_pc);
let _ = tokio::task::spawn_blocking(move || actions.session_ended()).await;
});
}
let portal=capture.portal.clone();
let stream_desktop = portal_desktop.clone();
// File/terminal/port-mapping connections carry no desktop video.
if desktop && !cfg!(test) { track_session(pc.clone(), peer_actions.clone(), &role); }
// Live encoder switch (SIGUSR2) sends CaptureSettingSync when chroma is downgraded.
let (chroma_sync_tx, chroma_sync_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let chroma_sync_rx = Arc::new(std::sync::Mutex::new((!cfg!(test)).then_some(chroma_sync_rx)));
// File/terminal/port-mapping connections carry no desktop video until capture_desktop.
let control_video_track = video_track.clone();
let stream_settings = video_settings.clone();
if desktop && !cfg!(test) {
let state_pc = streaming_pc.clone();
tokio::spawn(async move {
let screen = if let Some(desktop) = stream_desktop {
if let Err(error) = crate::locked_video::run(&streaming_pc, &video_track, &desktop).await {
log::warn!("Locked desktop video unavailable: {error}");
}
let mut updates = desktop.subscribe();
loop {
let state = updates.borrow_and_update().clone();
if state.ready() { break Some(state.screen); }
if !state.waiting { return; }
if crate::video::transport_closed(&streaming_pc) { return; }
tokio::select! {
changed = updates.changed() => if changed.is_err() { return; },
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
}
}
} else { None };
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
(capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request).await {
// A send racing the viewer's close fails with a misleading track error.
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
log::info!("Live desktop stream ended: peer connection closed ({})", e);
} else {
log::error!("Live desktop stream stopped: {}", e);
}
}
});
} else {
drop((streaming_pc, video_track, capture_size, capture_display, video_settings_rx));
}
let stream = DesktopStream {
pc: Arc::downgrade(&streaming_pc), track: video_track, portal_desktop: portal_desktop.clone(),
capture_size, capture_display, portal: capture.portal.clone(), settings_rx: video_settings_rx,
settings: video_settings.clone(), idr_request, selection: video_selection,
chroma_sync: (!cfg!(test)).then_some(chroma_sync_tx), reload_at_session,
};
drop(streaming_pc);
if cfg!(test) { drop(stream); }
else if desktop { let _ = stream.spawn(None, role.active.subscribe()); }
else { *role.stream.lock().unwrap() = Some(stream); }
let input_clone = input.clone();
let control_capture = capture.clone();
let desktop_pc = Arc::downgrade(&pc);
@@ -393,6 +519,7 @@ impl WebRtcSession {
// Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
let settings_serial=Arc::new(Mutex::new(()));
let data_role = role.clone();
// 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string();
@@ -400,7 +527,7 @@ impl WebRtcSession {
let peer_settings_serial=settings_serial.clone();
let input_inst = input_clone.clone();
let channel_input_session=input_session.clone();
let channel_role=data_role.clone();
let screen = control_capture.clone();
let portal_desktop = portal_desktop.clone();
let desktop_pc = desktop_pc.clone();
@@ -414,6 +541,8 @@ impl WebRtcSession {
let peer_video_settings = video_settings.clone();
let peer_video_track = control_video_track.clone();
let peer_actions = peer_actions.clone();
let peer_selection = video_selection;
let chroma_sync_rx = chroma_sync_rx.clone();
if label == "FILE_DATA_CHANNEL" { *file_channel.lock().unwrap() = Some(d.clone()); }
Box::pin(async move {
@@ -428,24 +557,54 @@ impl WebRtcSession {
let rich_state=Arc::new(std::sync::Mutex::new(crate::clipboard_rich::State::default()));
let clipboard_enabled = shared_clipboard_ready.clone();
if label=="CONTROL_DATA_CHANNEL" {
let closing=channel_input_session.clone();
let closing=channel_role.clone();
d.on_close(Box::new(move || {
let closing=closing.clone();
let closing=closing.input();
Box::pin(async move {if let Some(session)=closing {session.disconnected();}})
}));
}
// Ordered outbound queue for protocol replies produced outside this callback.
let (outbound, mut outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
// webrtc-rs announces the channel before handle_open (ready_state Connecting);
// send() returns ErrClosedPipe until Open. Draining CONTROL here would drop
// Message 25 and every later reply. Start CONTROL from the on_open below
// (one handler; a second on_open replaces it). Receiver taken once.
let mut control_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx)));
if label == "CONTROL_DATA_CHANNEL" {
if let Some(mut chroma_sync_rx) = chroma_sync_rx.lock().unwrap().take() {
let sync_out = outbound.clone();
let sync_seq = reply_sequence.clone();
tokio::spawn(async move {
while let Some(payload) = chroma_sync_rx.recv().await {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let seq = sync_seq.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let _ = sync_out.send(crate::initialization::envelope(seq, timestamp, 25, &payload));
}
});
}
}
{
let out_channel = d.clone();
let out_label = label.clone();
tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await {
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break;
}
}
});
let outbound_rx = outbound_rx.clone();
let start_drain = move || {
let out_channel = out_channel.clone();
let out_label = out_label.clone();
let outbound_rx = outbound_rx.clone();
Box::pin(async move {
let Some(mut outbound_rx) = take_outbound_once(&outbound_rx).await else { return; };
tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await {
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break;
}
}
});
}) as std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>
};
if label != "CONTROL_DATA_CHANNEL" { tokio::spawn(start_drain()); }
else { control_drain = Some(Box::new(start_drain)); }
}
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") {
@@ -456,8 +615,9 @@ 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 capture_role=channel_role.clone();
let settings_serial=peer_settings_serial.clone();
let capture_selection = peer_selection;
tokio::spawn(async move {
let mut health = tokio::time::interval(std::time::Duration::from_millis(100));
loop {
@@ -473,6 +633,7 @@ impl WebRtcSession {
}
};
let _serial=settings_serial.lock().await;
let (desktop,switch_owner)=(capture_role.is_desktop(),capture_role.input());
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) {
@@ -518,10 +679,10 @@ impl WebRtcSession {
if channel.upgrade().is_none_or(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) { return; }
}
} else {
Some(initial_screen.clone())
Some(capture_role.screen_or(&initial_screen))
}
} else {
Some(initial_screen.clone())
Some(capture_role.screen_or(&initial_screen))
};
let Some(active_screen) = active_screen else { continue; };
let input_size = if active_screen.init_error.is_none() {
@@ -561,9 +722,11 @@ impl WebRtcSession {
}) else { continue; };
let Ok(rpc_fields) = crate::protocol::decode_wire(rpc) else { continue; };
// X11: 分辨率 changes the display mode itself, like the official Windows host; the stream
// then carries the new native size instead of a scaled one (desktop_mode).
// then carries the new native size instead of a scaled one (desktop_mode). With
// UU_X11_MULTISCREEN the monitor layout stays as it is and the stream is scaled.
let resized = if desktop && active_screen.init_error.is_none() && active_screen.portal.is_none()
&& active_screen.backend == crate::desktop_backend::DesktopBackend::X11 && crate::desktop_mode::enabled() {
&& active_screen.backend == crate::desktop_backend::DesktopBackend::X11 && crate::desktop_mode::enabled()
&& !crate::wayland::x11_multiscreen() {
match crate::capture_setting::requested_resolution(&rpc_fields) {
Some(request) => {
let display = active_screen.display.clone();
@@ -577,10 +740,10 @@ impl WebRtcSession {
let before = *settings.borrow();
let output_before = before.output;
let revision = track.revision();
let apply=|| crate::capture_setting::handle_rpc_with_codecs(
let apply=|| crate::capture_setting::handle_rpc_for(
&rpc_fields, &settings, input_size,
track.supports(crate::capture_setting::VideoCodec::H264),
track.supports(crate::capture_setting::VideoCodec::H265));
track.supports(crate::capture_setting::VideoCodec::H265), capture_selection);
let response=if let Some(owner)=&switch_owner {
let mut response=None;owner.with_current(||response=apply());response
} else {apply()};
@@ -628,9 +791,12 @@ impl WebRtcSession {
let open_video = channel_video_settings.clone();
let open_track = peer_video_track.clone();
let open_desktop = portal_desktop.clone();
let open_owner = channel_input_session.clone();
let open_owner = channel_role.input();
let open_role = channel_role.clone();
let open_screen = screen.clone();
let open_selection = peer_selection;
d.on_open(Box::new(move || {
if let Some(start_drain) = control_drain { tokio::spawn(start_drain()); }
let init_actions = open_actions.clone();
let init_video = open_video.clone();
let init_track = open_track.clone();
@@ -642,82 +808,91 @@ impl WebRtcSession {
let rich_outgoing=rich_outgoing.clone();
let portal_desktop = open_desktop.clone();
let owner = open_owner.clone();
let role = open_role.clone();
let pc = desktop_pc.upgrade();
Box::pin(async move {
// Permission dialogs and first-frame waits must not occupy the
// channel-open callback or delay CONTROL message dispatch.
tokio::spawn(async move {
if channel.label() == "TEXT_DATA_CHANNEL" {
if !desktop { return; }
let screen = if let Some(desktop) = &portal_desktop {
let mut updates = desktop.subscribe();
let Some(_) = crate::desktop_session::wait_ready(&mut updates, &channel).await else { return; };
let mut locked = desktop.lock_state();
loop {
let state = desktop.snapshot();
if !state.waiting && state.screen.init_error.is_some() { return; }
if let Some(session) = state.screen.portal.as_ref() {
if session.is_alive() && *locked.borrow() == Some(false) {
break state.screen;
}
}
tokio::select! {
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
changed = locked.changed() => if changed.is_err() { return; },
_ = async {
loop {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
} => return,
}
}
} else { screen };
let bridge = if let Some(session)=screen.portal.clone() { crate::clipboard::start_portal(session) } else { crate::clipboard::start(screen.display.clone()) };
*clipboard_sink.lock().unwrap() = Some(bridge.incoming);
let clipboard_channel = channel.clone();
let clipboard_sequence = sequence.clone();
let clipboard_cleanup = clipboard_sink.clone();
let ready = bridge.ready.await.unwrap_or(false);
clipboard_ready.store(ready,std::sync::atomic::Ordering::Relaxed);
tokio::spawn(async move {
if !ready {
*clipboard_cleanup.lock().unwrap() = None;
log::warn!("Native text clipboard unavailable"); return;
}
log::info!("Native text clipboard bridge ready");
let mut updates = bridge.outgoing;
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
loop {
tokio::select! {
_ = health.tick() => {
if clipboard_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; }
},
changed = updates.changed() => {
if changed.is_err() { break; }
let text = updates.borrow_and_update().clone();
let Some(text) = text else { continue; };
{
let request_id=clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed);
let payload = match rich_outgoing.lock().unwrap().offer(request_id,text.clone()) {
Ok(payload)=>payload,Err(reason)=>{log::warn!("Clipboard offer rejected: {}",reason);continue;}
};
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::initialization::envelope(clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,21,&payload);
if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),clipboard_channel.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))) {
log::warn!("Native clipboard RPC send failed"); break;
}
}
log::info!("Native clipboard text format offered: bytes={}",text.len());
}
}
}
*clipboard_cleanup.lock().unwrap() = None;
clipboard_ready.store(false,std::sync::atomic::Ordering::Relaxed);
});
return;
loop {
if !role.is_desktop() && !role.wait_desktop(&channel).await { return; }
let screen = if let Some(desktop) = &portal_desktop {
let mut updates = desktop.subscribe();
let Some(_) = crate::desktop_session::wait_ready(&mut updates, &channel).await else { return; };
let mut locked = desktop.lock_state();
loop {
let state = desktop.snapshot();
if !state.waiting && state.screen.init_error.is_some() { return; }
if let Some(session) = state.screen.portal.as_ref() {
if session.is_alive() && *locked.borrow() == Some(false) {
break state.screen;
}
}
tokio::select! {
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
changed = locked.changed() => if changed.is_err() { return; },
_ = async {
loop {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
} => return,
}
}
} else { role.screen_or(&screen) };
let bridge = if let Some(session)=screen.portal.clone() { crate::clipboard::start_portal(session) } else { crate::clipboard::start(screen.display.clone()) };
*clipboard_sink.lock().unwrap() = Some(bridge.incoming);
let clipboard_channel = channel.clone();
let clipboard_sequence = sequence.clone();
let clipboard_cleanup = clipboard_sink.clone();
let rich_outgoing = rich_outgoing.clone();
let ready = bridge.ready.await.unwrap_or(false);
clipboard_ready.store(ready,std::sync::atomic::Ordering::Relaxed);
{
if !ready {
*clipboard_cleanup.lock().unwrap() = None;
log::warn!("Native text clipboard unavailable"); return;
}
log::info!("Native text clipboard bridge ready");
let mut updates = bridge.outgoing;
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
let mut active = role.active.subscribe();
loop {
tokio::select! {
_ = health.tick() => {
if clipboard_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; }
},
_ = async { let _ = active.wait_for(|active| !*active).await; } => break,
changed = updates.changed() => {
if changed.is_err() { break; }
let text = updates.borrow_and_update().clone();
let Some(text) = text else { continue; };
{
let request_id=clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed);
let payload = match rich_outgoing.lock().unwrap().offer(request_id,text.clone()) {
Ok(payload)=>payload,Err(reason)=>{log::warn!("Clipboard offer rejected: {}",reason);continue;}
};
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::initialization::envelope(clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,21,&payload);
if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),clipboard_channel.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))) {
log::warn!("Native clipboard RPC send failed"); break;
}
}
log::info!("Native clipboard text format offered: bytes={}",text.len());
}
}
}
*clipboard_cleanup.lock().unwrap() = None;
clipboard_ready.store(false,std::sync::atomic::Ordering::Relaxed);
}
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
// A newer desktop took over this promoted tool peer; capture_desktop restarts the clipboard.
log::info!("Native text clipboard stopped: a newer desktop took over");
}
}
let replay = (last_echo_request.clone(), echo_seen.clone(), clipboard_ready.clone());
let early_desktop_selection = desktop && portal_desktop.is_some();
if early_desktop_selection {
// Android 4.43.0's unlock presenter requires CaptureChange
@@ -804,58 +979,75 @@ impl WebRtcSession {
}
} else { snapshot.screen }
} else { screen };
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let next_seq = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
// Default file-transfer folder: the desktop user's home directory.
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
// Tool peers are permitted without a desktop; the port-mapping viewer aborts on Reject.
let desktop_permission=if screen.init_error.is_none() || !desktop {
crate::system_metrics::Permission::Allow
} 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=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, 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)))),
(18, Ok(crate::initialization::envelope(next_seq(), timestamp, 18,
&crate::capture_setting::codec_negotiation(screen_size, crate::video::display_fps(), init_track.supports(crate::capture_setting::VideoCodec::H265))))),
(7, crate::capture_setting::screen_sources(next_seq(), timestamp, screen_size, init_video.borrow().output, "Linux desktop")),
];
if desktop && screen.init_error.is_none() {
let codec = crate::capture_setting::preferred_codec(init_track.supports(crate::capture_setting::VideoCodec::H264),
init_track.supports(crate::capture_setting::VideoCodec::H265));
init_video.send_if_modified(|current| if current.codec != codec {
log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false });
}
for (field, message) in messages {
if early_desktop_selection && field == 8 { continue; }
if (!desktop || screen.init_error.is_some()) && field == 18 { continue; }
if desktop && screen.init_error.is_some() && matches!(field,7|8) { continue; }
let message = match message {
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
let (mut desktop, mut promoted, mut lock_reported) = (desktop, false, desktop);
let mut screen = screen;
loop {
loop {
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
// Tool peers are permitted without a desktop; the port-mapping viewer aborts on Reject.
let desktop_permission=if screen.init_error.is_none() || !desktop {
crate::system_metrics::Permission::Allow
} 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=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, 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)))),
(18, Ok(crate::initialization::envelope(next_seq(), timestamp, 18,
&crate::capture_setting::codec_negotiation(screen_size, crate::video::display_fps(), init_track.supports(crate::capture_setting::VideoCodec::H265))))),
(7, crate::capture_setting::screen_sources(next_seq(), timestamp, screen_size, init_video.borrow().output, "Linux desktop")),
];
if desktop && screen.init_error.is_none() {
let codec = crate::capture_setting::preferred_codec_for(init_track.supports(crate::capture_setting::VideoCodec::H264),
init_track.supports(crate::capture_setting::VideoCodec::H265), open_selection);
init_video.send_if_modified(|current| if current.codec != codec {
log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false });
}
log::info!("CONTROL initialization field {} sent", field);
for (field, message) in messages {
if early_desktop_selection && field == 8 { continue; }
if promoted && field == 26 { continue; }
if (!desktop || screen.init_error.is_some()) && field == 18 { continue; }
if desktop && screen.init_error.is_some() && matches!(field,7|8) { continue; }
let message = match message {
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
}
log::info!("CONTROL initialization field {} sent", field);
}
if desktop { break; }
// The viewer opened the desktop on this tool connection (#99): repeat the
// desktop initialization once the host has started its video and input.
if !role.wait_desktop(&channel).await { return; }
(desktop, promoted) = (true, true);
screen = role.screen_or(&screen);
replay_clipboard_echo(channel.clone(), sequence.clone(), replay.clone(), role.clone());
}
if !lock_reported {
lock_reported = true;
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked()));
}
// Mirror the Linux pointer shape; the video itself carries no pointer.
if !desktop { return; }
let mut shapes = crate::cursor::monitor(&screen.display);
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
let mut sent = 0usize;
loop {
let mut active = role.active.subscribe();
'cursor: loop {
let current = shapes.borrow_and_update().clone();
if let Some(cursor) = current {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::cursor::encode_cursor_shape(next_seq(), timestamp, &cursor);
if channel.send(&bytes::Bytes::from(message)).await.is_err() { break; }
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
sent += 1;
if sent <= 3 || sent % 100 == 0 {
log::info!("Cursor shape sent: count={} size={}x{} hotspot={},{} png_bytes={}", sent, cursor.width, cursor.height, cursor.hot_x, cursor.hot_y, cursor.png.len());
@@ -864,12 +1056,18 @@ impl WebRtcSession {
loop {
tokio::select! {
changed = shapes.changed() => { if changed.is_err() { return; } break; },
_ = active.wait_for(|active| !*active) => break 'cursor,
_ = health.tick() => {
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
},
}
}
}
// A newer desktop took over this promoted tool peer; wait for capture_desktop again.
if !role.wait_desktop(&channel).await { return; }
screen = role.screen_or(&screen);
replay_clipboard_echo(channel.clone(), sequence.clone(), replay.clone(), role.clone());
}
});
})
}));
@@ -878,14 +1076,15 @@ impl WebRtcSession {
d.on_message(Box::new(move |msg: DataChannelMessage| {
// Keep the whole state: a cached screen waiting for a closed Portal is not ready for input.
let (screen, desktop_ready) = portal_desktop.as_ref().map_or_else(|| (screen.clone(), true), |desktop| {
let (screen, desktop_ready) = portal_desktop.as_ref().map_or_else(|| (channel_role.screen_or(&screen), true), |desktop| {
let state = desktop.snapshot();
let ready = state.ready();
(state.screen, ready)
});
let channel_name = lbl.clone();
let input_worker = inp.clone();
let message_input_session=channel_input_session.clone();
let message_input_session=channel_role.input();
let message_role=channel_role.clone();
let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone();
let reply_chan = d_reply.clone();
@@ -922,6 +1121,22 @@ impl WebRtcSession {
use crate::protocol::WireValue;
let rpc = fields.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None });
let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok());
if let Some(request) = rpc.filter(|_| rpc_fields.as_deref().is_some_and(crate::privacy_screen::is_request)) {
let (request, actions, chan, seq_out, rpc_out) = (request.to_vec(), actions.clone(), reply_chan.clone(), out_sequence.clone(), rpc_out.clone());
let settings_portal = portal_for_message.clone();
tokio::spawn(async move {
let response = tokio::task::spawn_blocking(move || crate::protocol::decode_wire(&request).ok()
.and_then(|r| crate::privacy_screen::rpc_response(&r))).await.ok().flatten();
let Some(response) = response else { return };
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = rpc_out.send(crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
// The 防窥 switch shows SettingMetric 4 like the other 安全 settings.
let permission = settings_portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |manager| manager.snapshot().permission(desktop));
let message = crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &actions.metrics_payload(desktop_sound, permission));
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
});
return;
}
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) {
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
@@ -1119,6 +1334,19 @@ impl WebRtcSession {
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
}
});
} else if action == sa::CAPTURE_DESKTOP && channel_name == "CONTROL_DATA_CHANNEL" {
if message_role.is_desktop() && !message_role.stream_ended() {
log::info!("SimpleAction 4 (capture_desktop) received on a desktop connection");
} else if let Some(request) = message_role.request.get() {
if message_role.is_desktop() {
log::info!("SimpleAction 4 (capture_desktop) received on a tool connection whose desktop video ended; restarting it");
} else {
log::info!("SimpleAction 4 (capture_desktop) received on a tool connection; starting the desktop");
}
request();
} else {
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route");
}
} else if action > 1 && action != 15 {
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(*v), _ => None }).unwrap_or(&[]);
log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));
@@ -1241,10 +1469,53 @@ impl WebRtcSession {
capture,
input,
desktop,
role,
controller: crate::input::Controller::Other,
context,
actions: session_actions,
})
}
/// Route for capture_desktop on this tool peer; the caller decides whether it may become the desktop.
pub fn on_desktop_request(&self, request: impl Fn() + Send + Sync + 'static) {
let _ = self.role.request.set(Box::new(request));
}
/// Makes this tool peer the desktop: it takes the input lease, starts the video it negotiated
/// (H.264; audio was never negotiated) and repeats the desktop CONTROL initialization.
/// `screen` replaces a capture that was unavailable when the peer was offered.
/// A promoted peer whose video ended keeps its input lease and only restarts the video.
pub fn promote(&self, screen: Option<Arc<ScreenCapture>>) {
let restart = self.role.is_desktop();
if restart && !self.role.stream_ended() { return; }
if let Some(screen) = screen { *self.role.screen.lock().unwrap() = Some(screen); }
if !restart {
let session = self.input.desktop_session();
if self.pc.connection_state() == RTCPeerConnectionState::Connected { session.connected(); }
*self.role.input.lock().unwrap() = Some(session);
self.role.active.send_replace(true);
}
let stream = self.role.stream.lock().unwrap().clone();
let task = stream.and_then(|stream| stream.spawn(self.role.screen.lock().unwrap().clone(), self.role.active.subscribe()));
if let Some(old) = std::mem::replace(&mut *self.role.stream_task.lock().unwrap(), task) { old.abort(); }
if restart { log::info!("Desktop video restarted on a tool connection after its stream ended"); return; }
if !cfg!(test) { track_session(self.pc.clone(), self.actions.clone(), &self.role); }
log::info!("Desktop started on an existing tool connection");
}
/// The capture this peer's desktop uses: its own, or the one reinitialized at promotion.
pub fn desktop_capture(&self) -> Arc<ScreenCapture> { self.role.screen_or(&self.capture) }
/// A newer desktop took over a promoted tool peer: stop its video, input and session count,
/// keep the connection's tools. capture_desktop on it promotes it again.
pub fn demote(&self) {
if self.desktop || !self.role.is_desktop() { return; }
self.role.active.send_replace(false);
if let Some(task) = self.role.stream_task.lock().unwrap().take() { task.abort(); }
if let Some(session) = self.role.input.lock().unwrap().take() { session.disconnected(); }
log::info!("Desktop on a tool connection stopped: a newer desktop took over");
}
/// 应用远端 Offer,生成并返回 Answer
pub async fn handle_offer(&self, soac: &SoacMessage) -> Result<String, String> {
// 同步当前的客户端与房间会话上下文
@@ -1413,6 +1684,11 @@ fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> {
None
}
/// First drain owns the outbound receiver; a later open must not start another.
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<T>>>) -> Option<tokio::sync::mpsc::UnboundedReceiver<T>> {
slot.lock().await.take()
}
#[cfg(test)]
mod tests {
use super::negotiated_bundle_media;
@@ -1435,6 +1711,16 @@ mod tests {
let sdp = "a=group:BUNDLE data video\nm=video 9 RTP 98\na=mid:video\nm=application 9 SCTP 0\na=mid:data\n";
assert_eq!(negotiated_bundle_media(sdp), Some(("data".into(), 1)));
}
#[tokio::test]
async fn outbound_receiver_is_taken_once() {
let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let slot = std::sync::Arc::new(tokio::sync::Mutex::new(Some(rx)));
let first = super::take_outbound_once(&slot).await;
let second = super::take_outbound_once(&slot).await;
assert!(first.is_some());
assert!(second.is_none());
drop(tx);
}
}
#[cfg(test)]
+105
View File
@@ -0,0 +1,105 @@
//! Socket.IO's WebSocket transport uses the same opt-in proxy policy as the REST client.
//! No proxy addresses, room headers, response text or underlying errors are displayed.
use std::time::Duration;
use reqwest::header::{HeaderMap, CONNECTION, UPGRADE, SEC_WEBSOCKET_ACCEPT, SEC_WEBSOCKET_KEY,
SEC_WEBSOCKET_EXTENSIONS, SEC_WEBSOCKET_PROTOCOL};
use tokio_tungstenite::{WebSocketStream, tungstenite::{handshake::{client::Request, derive_accept_key}, protocol::Role}};
pub type Socket = WebSocketStream<reqwest::Upgraded>;
/// Validate configuration rather than let reqwest silently ignore an unsupported proxy URL.
/// Selection/NO_PROXY matching still belongs to reqwest, not a second proxy implementation.
fn validate_proxy_url(value: &str) -> Result<(), &'static str> {
if value.is_empty() { return Ok(()); }
// Match reqwest's system-proxy parser before URL normalization (which would accept
// whitespace/Unicode that http::Uri rejects and the connector would silently ignore).
let uri: tokio_tungstenite::tungstenite::http::Uri = value.parse().map_err(|_| "Invalid signaling proxy configuration")?;
if uri.authority().is_none() { return Err("Invalid signaling proxy configuration"); }
let url = if value.contains("://") { reqwest::Url::parse(value) }
else { reqwest::Url::parse(&format!("http://{value}")) }
.map_err(|_| "Invalid signaling proxy configuration")?;
if !matches!(url.scheme(), "http" | "https") || url.host_str().is_none()
|| url.port_or_known_default().is_none() || url.path() != "/" || url.query().is_some() || url.fragment().is_some() {
return Err("Unsupported signaling proxy configuration (HTTP/HTTPS only)");
}
Ok(())
}
fn client() -> Result<reqwest::Client, String> {
if crate::auth::proxy_enabled() {
let mut configured = false;
for names in [["HTTP_PROXY", "http_proxy"], ["HTTPS_PROXY", "https_proxy"], ["ALL_PROXY", "all_proxy"]] {
if let Some(value) = names.iter().find_map(std::env::var_os) {
let value = value.to_str().ok_or("Invalid signaling proxy configuration")?;
validate_proxy_url(value)?;
configured |= !value.is_empty();
}
}
// reqwest disables environment proxies in CGI contexts; don't silently ignore an opt-in.
if configured && std::env::var_os("REQUEST_METHOD").is_some() {
return Err("Signaling environment proxies are disabled in CGI contexts".into());
}
}
crate::auth::http_client_builder().http1_only().redirect(reqwest::redirect::Policy::none())
.retry(reqwest::retry::never()).build().map_err(|_| "Signaling HTTP client setup failed".into())
}
pub async fn connect(request: Request, timeout: Duration) -> Result<Socket, String> {
let client = client()?;
match tokio::time::timeout(timeout, connect_with_client(&client, request)).await {
Ok(result) => result,
Err(_) => Err("WS connect failed: timeout".into()),
}
}
async fn connect_with_client(client: &reqwest::Client, request: Request) -> Result<Socket, String> {
let (mut parts, _) = request.into_parts();
if parts.method != reqwest::Method::GET || parts.headers.contains_key(SEC_WEBSOCKET_EXTENSIONS)
|| parts.headers.contains_key(SEC_WEBSOCKET_PROTOCOL) || parts.headers.contains_key("proxy-authorization") {
return Err("Unsupported signaling WebSocket request".into());
}
let mut url = reqwest::Url::parse(&parts.uri.to_string()).map_err(|_| "Invalid signaling endpoint")?;
if !url.username().is_empty() || url.password().is_some() || url.fragment().is_some() {
return Err("Invalid signaling endpoint".into());
}
let scheme = match url.scheme() { "ws" => "http", "wss" => "https", _ => return Err("Unsupported signaling endpoint scheme".into()) };
url.set_scheme(scheme).map_err(|_| "Invalid signaling endpoint")?;
let key = parts.headers.get(SEC_WEBSOCKET_KEY).ok_or("Missing WebSocket handshake key")?;
let accept = derive_accept_key(key.as_bytes());
for name in ["x-nrd-auth", "authorization", "cookie"] {
if let Some(value) = parts.headers.get_mut(name) { value.set_sensitive(true); }
}
// reqwest owns DNS/TCP/proxy CONNECT/TLS. No custom relay, direct fallback or redirect.
let response = client.get(url).version(reqwest::Version::HTTP_11).headers(parts.headers).send().await
.map_err(|e| if e.is_timeout() { "WS connect failed: timeout" } else if e.is_connect() { "WS connect failed: connection" } else { "WS connect failed: request" })?;
if response.status() != reqwest::StatusCode::SWITCHING_PROTOCOLS {
return Err(format!("WS upgrade refused: http_status={}", response.status().as_u16()));
}
verify_upgrade(response.version(), response.headers(), &accept)?;
let stream = response.upgrade().await.map_err(|_| "WS upgrade failed")?;
Ok(WebSocketStream::from_raw_socket(stream, Role::Client, None).await)
}
/// RFC 6455 §4.1: validate before handing upgraded bytes to the frame codec. Socket.IO
/// requests no extensions/subprotocols. Unlike a generic HTTP client we never follow redirects.
fn verify_upgrade(version: reqwest::Version, headers: &HeaderMap, accept: &str) -> Result<(), &'static str> {
let single = |name: reqwest::header::HeaderName| {
let mut values = headers.get_all(name).iter();
let value = values.next()?.to_str().ok()?;
values.next().is_none().then_some(value)
};
let connection_upgrade = headers.get_all(CONNECTION).iter().all(|value| value.to_str().is_ok())
&& headers.get_all(CONNECTION).iter().any(|value|
value.to_str().is_ok_and(|value| value.split(',').any(|token| token.trim().eq_ignore_ascii_case("upgrade"))));
if version != reqwest::Version::HTTP_11 || !connection_upgrade
|| !single(UPGRADE).is_some_and(|v| v.eq_ignore_ascii_case("websocket"))
|| single(SEC_WEBSOCKET_ACCEPT) != Some(accept)
|| headers.contains_key(SEC_WEBSOCKET_EXTENSIONS) || headers.contains_key(SEC_WEBSOCKET_PROTOCOL) {
return Err("Invalid signaling WebSocket upgrade response");
}
Ok(())
}
#[cfg(test)]
#[path = "ws_transport_tests.rs"]
mod tests;
+245
View File
@@ -0,0 +1,245 @@
use super::*;
use futures_util::{SinkExt, StreamExt};
use tokio::{io::{AsyncRead, AsyncReadExt, AsyncWriteExt}, net::{TcpListener, TcpStream}};
use tokio_tungstenite::tungstenite::{client::IntoClientRequest, Message};
fn request(url: &str) -> Request {
let mut request = url.into_client_request().unwrap();
request.headers_mut().insert("x-nrd-auth", "fixture-room-secret".parse().unwrap());
request
}
fn test_client() -> reqwest::ClientBuilder {
reqwest::Client::builder().no_proxy().http1_only()
.redirect(reqwest::redirect::Policy::none()).retry(reqwest::retry::never())
}
async fn read_headers<S: AsyncRead + Unpin>(socket: &mut S) -> String {
let mut bytes = Vec::new();
while !bytes.ends_with(b"\r\n\r\n") {
let mut byte = [0];
socket.read_exact(&mut byte).await.unwrap();
bytes.push(byte[0]);
assert!(bytes.len() < 16384);
}
String::from_utf8(bytes).unwrap()
}
fn header<'a>(request: &'a str, name: &str) -> Option<&'a str> {
request.lines().filter_map(|line| line.split_once(':'))
.find(|(key, _)| key.eq_ignore_ascii_case(name)).map(|(_, value)| value.trim())
}
async fn accept_upgrade(listener: TcpListener, proxy: bool) -> TcpStream {
let (mut socket, _) = listener.accept().await.unwrap();
let received = read_headers(&mut socket).await;
assert!(received.starts_with(if proxy { "GET http://" } else { "GET /" }));
assert!(header(&received, "x-nrd-auth") == Some("fixture-room-secret"));
if !proxy { assert!(header(&received, "proxy-authorization").is_none()); }
let accept = derive_accept_key(header(&received, "sec-websocket-key").unwrap().as_bytes());
let mut response = format!("HTTP/1.1 101 Switching Protocols\r\nConnection: keep-alive, Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Accept: {accept}\r\n\r\n").into_bytes();
// The first Engine.IO frame shares a single write with the HTTP response.
response.extend_from_slice(&[0x81, 3, b'0', b'{', b'}']);
socket.write_all(&response).await.unwrap();
socket
}
async fn no_connection(listener: &TcpListener) {
assert!(tokio::time::timeout(Duration::from_millis(150), listener.accept()).await.is_err());
}
#[test]
fn strict_upgrade_validation_accepts_tokens_and_rejects_unsolicited_or_ambiguous_headers() {
let mut headers = HeaderMap::new();
headers.insert(CONNECTION, "keep-alive, Upgrade".parse().unwrap());
headers.insert(UPGRADE, "WebSocket".parse().unwrap());
headers.insert(SEC_WEBSOCKET_ACCEPT, "fixture-accept".parse().unwrap());
assert!(verify_upgrade(reqwest::Version::HTTP_11, &headers, "fixture-accept").is_ok());
headers.append(CONNECTION, "keep-alive".parse().unwrap());
assert!(verify_upgrade(reqwest::Version::HTTP_11, &headers, "fixture-accept").is_ok());
assert!(verify_upgrade(reqwest::Version::HTTP_2, &headers, "fixture-accept").is_err());
assert!(verify_upgrade(reqwest::Version::HTTP_11, &headers, "wrong").is_err());
for name in [CONNECTION, UPGRADE, SEC_WEBSOCKET_ACCEPT] {
let mut missing = headers.clone(); missing.remove(name);
assert!(verify_upgrade(reqwest::Version::HTTP_11, &missing, "fixture-accept").is_err());
}
for name in [UPGRADE, SEC_WEBSOCKET_ACCEPT, SEC_WEBSOCKET_EXTENSIONS, SEC_WEBSOCKET_PROTOCOL] {
let mut invalid = headers.clone(); invalid.append(name, "fixture-server-secret".parse().unwrap());
let error = verify_upgrade(reqwest::Version::HTTP_11, &invalid, "fixture-accept").unwrap_err();
assert!(!error.contains("fixture"));
}
}
#[test]
fn proxy_configuration_errors_never_echo_proxy_values() {
for proxy in ["", "127.0.0.1:3128", "http://127.0.0.1:3128", "https://fixture-user:[email protected]:3128"] {
assert!(validate_proxy_url(proxy).is_ok());
}
for proxy in ["socks5://fixture-user:[email protected]:3128", "http://127.0.0.1:3128/?fixture-token", "http://127.0.0.1:3128/#fixture-token", "http://127.0.0.1:3128/fixture-secret", "http://[fixture-invalid", " http://127.0.0.1:3128", "http://127.0.0.1:3128 ", "http://例子.invalid:3128"] {
let error = validate_proxy_url(proxy).unwrap_err();
assert!(!error.contains("fixture"));
assert!(!error.contains("127.0.0.1"));
}
}
#[tokio::test]
async fn upgrade_keeps_prefetched_frame_and_does_not_limit_socket_lifetime() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!("ws://{}/socket.io/?fixture-query-secret", listener.local_addr().unwrap());
let server = tokio::spawn(async move {
let socket = accept_upgrade(listener, false).await;
let mut socket = WebSocketStream::from_raw_socket(socket, Role::Server, None).await;
tokio::time::sleep(Duration::from_millis(1200)).await;
assert!(matches!(socket.next().await, Some(Ok(Message::Text(value))) if value == "fixture-client-frame"));
socket.send(Message::Text("fixture-late-frame".into())).await.unwrap();
});
let http = test_client().build().unwrap();
let mut socket = tokio::time::timeout(Duration::from_secs(1), connect_with_client(&http, request(&url))).await.unwrap().unwrap();
assert!(matches!(socket.next().await, Some(Ok(Message::Text(value))) if value == "0{}"));
// A one-second establishment deadline must not remain attached to the upgraded stream.
tokio::time::sleep(Duration::from_millis(1300)).await;
socket.send(Message::Text("fixture-client-frame".into())).await.unwrap();
let message = tokio::time::timeout(Duration::from_secs(3), socket.next()).await.unwrap();
assert!(matches!(message, Some(Ok(Message::Text(value))) if value == "fixture-late-frame"));
server.await.unwrap();
}
#[tokio::test]
async fn proxy_refusal_never_falls_back_to_origin_or_echoes_server_content() {
let origin = TcpListener::bind("127.0.0.1:0").await.unwrap();
let proxy = TcpListener::bind("127.0.0.1:0").await.unwrap();
let proxy_url = format!("http://{}", proxy.local_addr().unwrap());
let server = tokio::spawn(async move {
let (mut socket, _) = proxy.accept().await.unwrap();
let received = read_headers(&mut socket).await;
assert!(received.starts_with("GET http://"));
assert!(header(&received, "proxy-authorization").is_some());
socket.write_all(b"HTTP/1.1 407 Proxy Authentication Required\r\nContent-Length: 19\r\n\r\nfixture-body-secret").await.unwrap();
});
let proxy = reqwest::Proxy::all(proxy_url).unwrap().basic_auth("fixture-user", "fixture-proxy-secret");
let http = test_client().proxy(proxy).build().unwrap();
let result = tokio::time::timeout(Duration::from_secs(5),
connect_with_client(&http, request(&format!("ws://{}/fixture-path-secret", origin.local_addr().unwrap()))))
.await.expect("proxy refusal must not wait on a fallback origin");
let error = result.err().expect("proxy refusal must fail");
assert!(error.contains("407")); assert!(!error.contains("fixture"));
no_connection(&origin).await;
server.await.unwrap();
}
#[tokio::test]
async fn redirects_are_not_followed_with_room_credentials() {
let origin = TcpListener::bind("127.0.0.1:0").await.unwrap();
let destination = TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!("ws://{}/socket.io/", origin.local_addr().unwrap());
let location = format!("http://{}/fixture-redirect-secret", destination.local_addr().unwrap());
let server = tokio::spawn(async move {
let (mut socket, _) = origin.accept().await.unwrap();
let _ = read_headers(&mut socket).await;
socket.write_all(format!("HTTP/1.1 302 Found\r\nLocation: {location}\r\nContent-Length: 0\r\n\r\n").as_bytes()).await.unwrap();
});
let result = tokio::time::timeout(Duration::from_secs(5),
connect_with_client(&test_client().build().unwrap(), request(&url)))
.await.expect("redirect must not wait on its destination");
let error = result.err().expect("redirect must fail");
assert!(error.contains("302")); assert!(!error.contains("fixture"));
no_connection(&destination).await;
server.await.unwrap();
}
// No global environment mutation: the subprocess has only synthetic loopback configuration.
#[test]
fn environment_policy_probe() {
let Ok(url) = std::env::var("UU_WS_TEST_ENDPOINT") else { return; };
assert!(url.starts_with("ws://127.0.0.1:"));
let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
runtime.block_on(async {
let mut socket = connect(request(&url), Duration::from_secs(5)).await.expect("fixture connection failed");
let message = tokio::time::timeout(Duration::from_secs(3), socket.next()).await.unwrap();
assert!(matches!(message, Some(Ok(Message::Text(value))) if value == "0{}"));
});
}
#[tokio::test]
async fn environment_proxy_opt_in_and_no_proxy_match_rest_policy() {
for (opt_in, bypass, via_proxy) in [(false, false, false), (true, false, true), (true, true, false)] {
let origin = TcpListener::bind("127.0.0.1:0").await.unwrap();
let proxy = TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!("ws://{}/socket.io/", origin.local_addr().unwrap());
let proxy_url = format!("http://fixture-user:fixture-proxy-secret@{}", proxy.local_addr().unwrap());
let (selected, unused) = if via_proxy { (proxy, origin) } else { (origin, proxy) };
let server = tokio::spawn(async move { let _socket = accept_upgrade(selected, via_proxy).await; });
let mut child = tokio::process::Command::new(std::env::current_exe().unwrap());
child.args(["--exact", "ws_transport::tests::environment_policy_probe", "--nocapture"])
.env_clear().env("UU_WS_TEST_ENDPOINT", url).env("HTTP_PROXY", proxy_url);
if opt_in { child.env("UU_USE_PROXY", "1"); }
if bypass { child.env("NO_PROXY", "127.0.0.1"); }
let output = tokio::time::timeout(Duration::from_secs(10), child.output()).await.unwrap().unwrap();
assert!(output.status.success(), "isolated proxy-policy subprocess failed");
assert!(!output.stdout.windows(b"fixture-room-secret".len()).any(|s| s == b"fixture-room-secret"));
assert!(!output.stderr.windows(b"fixture-proxy-secret".len()).any(|s| s == b"fixture-proxy-secret"));
no_connection(&unused).await;
server.await.unwrap();
}
}
#[tokio::test]
async fn wss_connect_keeps_origin_auth_inside_tls_and_requires_trusted_certificate() {
use std::sync::Arc;
use tokio_rustls::{rustls, TlsAcceptor};
use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer};
// A fresh test certificate/key, kept only in memory. The mock does not relay anywhere:
// it accepts CONNECT and then speaks TLS + WebSocket on that same loopback socket.
let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
let cert_der = cert.serialize_der().unwrap();
let root = reqwest::Certificate::from_der(&cert_der).unwrap();
let config = rustls::ServerConfig::builder_with_provider(Arc::new(rustls::crypto::ring::default_provider()))
.with_safe_default_protocol_versions().unwrap().with_no_client_auth()
.with_single_cert(vec![CertificateDer::from(cert_der)],
PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(cert.serialize_private_key_der()))).unwrap();
let acceptor = TlsAcceptor::from(Arc::new(config));
for trusted in [false, true] {
let origin = TcpListener::bind("127.0.0.1:0").await.unwrap();
let proxy = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = origin.local_addr().unwrap().port();
let proxy_url = format!("http://{}", proxy.local_addr().unwrap());
let acceptor = acceptor.clone();
let server = tokio::spawn(async move {
let (mut socket, _) = proxy.accept().await.unwrap();
let received = read_headers(&mut socket).await;
assert!(received.starts_with(&format!("CONNECT localhost:{port} HTTP/1.1\r\n")));
assert!(header(&received, "x-nrd-auth").is_none());
assert!(header(&received, "proxy-authorization").is_some());
assert!(!received.contains("fixture-room-secret"));
socket.write_all(b"HTTP/1.1 200 Connection Established\r\n\r\n").await.unwrap();
let tls = acceptor.accept(socket).await;
if !trusted { assert!(tls.is_err()); return; }
let mut tls = tls.expect("fixture TLS handshake failed");
let received = read_headers(&mut tls).await;
assert!(received.starts_with("GET /socket.io/"));
assert!(header(&received, "x-nrd-auth") == Some("fixture-room-secret"));
assert!(header(&received, "proxy-authorization").is_none());
assert!(!received.contains("fixture-proxy-secret"));
let accept = derive_accept_key(header(&received, "sec-websocket-key").unwrap().as_bytes());
let mut response = format!("HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Accept: {accept}\r\n\r\n").into_bytes();
response.extend_from_slice(&[0x81, 3, b'0', b'{', b'}']);
tls.write_all(&response).await.unwrap();
});
let proxy = reqwest::Proxy::all(proxy_url).unwrap().basic_auth("fixture-user", "fixture-proxy-secret");
let mut builder = test_client().proxy(proxy);
if trusted { builder = builder.add_root_certificate(root.clone()); }
let client = builder.build().unwrap();
let result = tokio::time::timeout(Duration::from_secs(5),
connect_with_client(&client, request(&format!("wss://localhost:{port}/socket.io/?fixture-query-secret")))).await.unwrap();
if trusted {
let mut socket = result.expect("trusted fixture WebSocket failed");
let message = tokio::time::timeout(Duration::from_secs(3), socket.next()).await.unwrap();
assert!(matches!(message, Some(Ok(Message::Text(value))) if value == "0{}"));
} else {
let error = result.err().expect("untrusted fixture certificate must fail");
assert!(!error.contains("fixture")); assert!(!error.contains("localhost"));
}
no_connection(&origin).await;
tokio::time::timeout(Duration::from_secs(5), server).await.unwrap().unwrap();
}
}
+34
View File
@@ -0,0 +1,34 @@
# Requires an unlocked niri session; opens a fullscreen test window and moves the pointer.
# UU_TEST_OUTPUT selects the output. UU_TEST_ENGINE is the built libuu-wayland.so.
import os,json,subprocess,ctypes,gi
os.environ['UU_WAYLAND_OUTPUT']=os.environ['UU_TEST_OUTPUT']
gi.require_version('Gtk','3.0');from gi.repository import Gtk,Gdk,GLib
inv=json.loads(subprocess.check_output(['niri','msg','-j','outputs']))
out=next(o for o in inv.values() if o['name']==os.environ['UU_TEST_OUTPUT']);geo=out['logical'];d=Gdk.Display.get_default()
monitor=next(i for i in range(d.get_n_monitors()) if (d.get_monitor(i).get_geometry().x,d.get_monitor(i).get_geometry().y)==(geo['x'],geo['y']))
w=Gtk.Window(title='UU pointer acceptance');box=Gtk.EventBox();box.set_above_child(True);grid=Gtk.Grid();grid.set_row_homogeneous(True);grid.set_column_homogeneous(True)
for i,color in enumerate(['red','lime','blue','yellow']):
cell=Gtk.EventBox();rgba=Gdk.RGBA();rgba.parse(color);cell.override_background_color(Gtk.StateFlags.NORMAL,rgba);grid.attach(cell,i%2,i//2,1,1)
box.add(grid);w.add(box);box.add_events(Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.ENTER_NOTIFY_MASK)
positions=[];box.connect('motion-notify-event',lambda widget,e:positions.append((e.x,e.y)) or False)
box.connect('enter-notify-event',lambda widget,e:positions.append((e.x,e.y)) or False)
w.fullscreen_on_monitor(w.get_screen(),monitor);w.show_all()
lib=ctypes.CDLL(os.environ['UU_TEST_ENGINE']);width=ctypes.c_int();height=ctypes.c_int();points=iter([(0.2,0.2),(0.8,0.2),(0.8,0.8),(0.2,0.8),(0.5,0.5)]);passed=[];image_matches=0
def step():
try:x,y=next(points)
except StopIteration:print('pointer_points_passed=',sum(passed),'total=',len(passed),'points=',passed,flush=True);Gtk.main_quit();return False
positions.clear();assert lib.uu_wl_move(int(x*width.value),int(y*height.value),0)==0
def check():
size=box.get_allocation();matched=any(abs(px-x*size.width)<4 and abs(py-y*size.height)<4 for px,py in positions);passed.append(matched);GLib.timeout_add(100,step);return False
GLib.timeout_add(150,check);return False
def start():
global image_matches
assert lib.uu_wl_init(ctypes.byref(width),ctypes.byref(height))==0
frame=(ctypes.c_ubyte*(width.value*height.value*4))();assert lib.uu_wl_capture(frame,len(frame))==0
for (x,y),(r,g,b) in zip([(0.25,0.25),(0.75,0.25),(0.25,0.75),(0.75,0.75)],[(255,0,0),(0,255,0),(0,0,255),(255,255,0)]):
at=(int(y*height.value)*width.value+int(x*width.value))*4
image_matches+=abs(frame[at]-b)<10 and abs(frame[at+1]-g)<10 and abs(frame[at+2]-r)<10
print('rotation_color_checks=',image_matches,'of=4',flush=True)
step();return False
GLib.timeout_add(1500,start);GLib.timeout_add(10000,lambda:(Gtk.main_quit(),False)[1]);Gtk.main()
raise SystemExit(0 if len(passed)==5 and all(passed) and image_matches==4 else 1)
+25
View File
@@ -0,0 +1,25 @@
# Run with /usr/bin/python, UU_TEST_BIN set to the test binary, and GDK_BACKEND=x11 or wayland.
# Opens and focuses a dedicated entry; only the built-in sample is injected.
import os
os.environ["GTK_IM_MODULE"]="gtk-im-context-simple"
import gi,subprocess,threading
gi.require_version('Gtk','3.0')
from gi.repository import Gtk,GLib
events=[]
passed=False
expected=os.environ.get("UU_PROBE_SEQUENCE","abc你好XYZ").replace("|","")
w=Gtk.Window(title='UU input acceptance'); e=Gtk.Entry();w.add(e);w.show_all();e.grab_focus();w.present();e.connect("key-press-event",lambda widget,event:events.append(event.keyval) and False)
def start():
if "UU input acceptance" not in subprocess.check_output(["niri","msg","-j","focused-window"],text=True):
Gtk.main_quit();return False
def run():
r=subprocess.run([os.environ.get('UU_TEST_BIN',os.path.expanduser('~/.local/bin/uuremote-server')),'wayland-text-probe'],env={**os.environ,'UU_PROBE_TEXT':'abc你好XYZ'},stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
GLib.timeout_add(1000,finish,r.returncode)
threading.Thread(target=run).start();return False
def finish(code):
global passed
passed=code==0 and e.get_text()==expected
print('probe_exit=',code,'matches=',e.get_text()==expected,'received_chars=',len(e.get_text()),'key_events=',len(events),flush=True);Gtk.main_quit();return False
GLib.timeout_add(1500,start);GLib.timeout_add(15000,lambda:(Gtk.main_quit(),False)[1]);Gtk.main()
raise SystemExit(0 if passed else 1)
+63 -2
View File
@@ -23,7 +23,7 @@ static GVariant *test_call_with_unix_fd_list_sync(GDBusConnection *connection,
#define CAP_MASK (EI_DEVICE_CAP_POINTER | EI_DEVICE_CAP_POINTER_ABSOLUTE | \
EI_DEVICE_CAP_BUTTON | EI_DEVICE_CAP_SCROLL | EI_DEVICE_CAP_KEYBOARD)
#define EVENT_CAP_MASK (EIS_DEVICE_CAP_POINTER | EIS_DEVICE_CAP_POINTER_ABSOLUTE | \
EIS_DEVICE_CAP_BUTTON | EIS_DEVICE_CAP_SCROLL | EIS_DEVICE_CAP_KEYBOARD)
EIS_DEVICE_CAP_BUTTON | EIS_DEVICE_CAP_SCROLL | EIS_DEVICE_CAP_KEYBOARD | EIS_DEVICE_CAP_TOUCH)
static const unsigned capabilities[] = {
EIS_DEVICE_CAP_POINTER,
@@ -31,6 +31,7 @@ static const unsigned capabilities[] = {
EIS_DEVICE_CAP_BUTTON,
EIS_DEVICE_CAP_SCROLL,
EIS_DEVICE_CAP_KEYBOARD,
EIS_DEVICE_CAP_TOUCH,
};
struct received {
@@ -166,7 +167,9 @@ static void handle_server_events(struct harness *h) {
h->stops++;
} else if (type == EIS_EVENT_POINTER_MOTION || type == EIS_EVENT_POINTER_MOTION_ABSOLUTE ||
type == EIS_EVENT_BUTTON_BUTTON || type == EIS_EVENT_SCROLL_DISCRETE ||
type == EIS_EVENT_KEYBOARD_KEY) {
type == EIS_EVENT_KEYBOARD_KEY || type == EIS_EVENT_TOUCH_DOWN ||
type == EIS_EVENT_TOUCH_MOTION || type == EIS_EVENT_TOUCH_UP ||
type == EIS_EVENT_SCROLL_DELTA || type == EIS_EVENT_SCROLL_STOP) {
assert(h->n_events < sizeof(h->events) / sizeof(h->events[0]));
struct received *got = &h->events[h->n_events++];
got->type = type;
@@ -187,6 +190,15 @@ static void handle_server_events(struct harness *h) {
got->dx = eis_event_scroll_get_discrete_dx(event);
got->dy = eis_event_scroll_get_discrete_dy(event);
break;
case EIS_EVENT_SCROLL_DELTA:
got->x = eis_event_scroll_get_dx(event);
got->y = eis_event_scroll_get_dy(event);
break;
case EIS_EVENT_TOUCH_DOWN:
case EIS_EVENT_TOUCH_MOTION:
got->x = eis_event_touch_get_x(event);
got->y = eis_event_touch_get_y(event);
break;
case EIS_EVENT_KEYBOARD_KEY:
got->code = eis_event_keyboard_get_key(event);
got->pressed = eis_event_keyboard_get_key_is_press(event);
@@ -255,6 +267,15 @@ static void wait_for_input(struct harness *h) {
assert(h->frames > 0);
}
static int input_within(struct harness *h, gint64 microseconds) {
gint64 deadline = g_get_monotonic_time() + microseconds;
while (!h->n_events && g_get_monotonic_time() < deadline) {
pump(h);
g_usleep(1000);
}
return h->n_events > 0;
}
static void pause_resume(struct harness *h) {
/* libeis 1.5 pauses only a resumed device; pause while emulating is a
* no-op. End the client transaction before exercising pause/resume. */
@@ -295,6 +316,7 @@ static void run_geometry(const struct geometry *geometry) {
h.portal->mapping_id = g_strdup("synthetic-screen");
h.portal->session = strdup("/synthetic/session");
h.portal->absolute_stream_pixels = 1;
h.portal->devices = 7;
h.server = eis_new(NULL);
assert(h.server && eis_setup_backend_fd(h.server) == 0);
@@ -380,6 +402,45 @@ static void run_geometry(const struct geometry *geometry) {
assert(h.events[0].type == EIS_EVENT_SCROLL_DISCRETE);
assert(h.events[0].dx == 0 && h.events[0].dy == -120);
/* Smooth scroll maps like relative motion; finish ends the gesture with a scroll stop. */
clear_events(&h);
assert(uu_portal_scroll(h.portal, geometry->width / 8.0, -(double)geometry->height / 8.0, 1) == 0);
wait_for_input(&h);
assert(h.events[0].type == EIS_EVENT_SCROLL_DELTA);
assert(fabs(h.events[0].x - geometry->logical_width / 8.0) < 0.001 && fabs(h.events[0].y + geometry->logical_height / 8.0) < 0.001);
for (gint64 until = g_get_monotonic_time() + 300000; h.n_events < 2 && g_get_monotonic_time() < until; g_usleep(1000)) pump(&h);
assert(h.n_events == 2 && h.events[1].type == EIS_EVENT_SCROLL_STOP);
/* A touch drag lands in the stream's region; motion without a finger down is refused. */
assert(uu_portal_touch(h.portal, 1, 1, 1) == 11);
clear_events(&h);
unsigned diagnostics = h.diagnostics;
assert(uu_portal_touch(h.portal, 0, geometry->width / 2.0, geometry->height / 2.0) == 0);
if (!input_within(&h, 300000)) {
/* libei before 1.3.0 accepts a touch only inside every region of the device (later:
* any region). This device also has a region for another screen, so an older library
* rejects the point with a client-bug diagnostic; a real one-stream session has one region. */
assert(h.diagnostics > diagnostics);
assert(uu_portal_touch(h.portal, 2, 0, 0) == 0 && !h.portal->ei_touch);
h.diagnostics = diagnostics; /* expected: the rejected touch and its release */
goto touched;
}
assert(h.events[0].type == EIS_EVENT_TOUCH_DOWN);
assert(h.events[0].x == geometry->x + geometry->logical_width / 2.0);
assert(h.events[0].y == geometry->y + geometry->logical_height / 2.0);
clear_events(&h);
assert(uu_portal_touch(h.portal, 1, 0, 0) == 0);
wait_for_input(&h);
assert(h.events[0].type == EIS_EVENT_TOUCH_MOTION);
assert(h.events[0].x == geometry->x && h.events[0].y == geometry->y);
assert(uu_portal_touch(h.portal, 1, geometry->width, 0) == 11);
clear_events(&h);
assert(uu_portal_touch(h.portal, 2, 0, 0) == 0);
wait_for_input(&h);
assert(h.events[0].type == EIS_EVENT_TOUCH_UP && !h.portal->ei_touch);
assert(uu_portal_touch(h.portal, 2, 0, 0) == 0);
touched:;
uint8_t storage[256];
struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *format = spa_format_video_raw_build(&builder, SPA_PARAM_Format,
+45 -1
View File
@@ -18,6 +18,7 @@ enum response_mode { UNKNOWN_METHOD, NOT_SUPPORTED, TEMPORARY_FAILURE, NO_FDS, B
static enum response_mode mode;
static unsigned connects, legacy_calls;
static double last_x, last_y;
static int last_finish;
static GVariant *test_call(GDBusConnection *bus, const gchar *dest, const gchar *path,
const gchar *interface, const gchar *method, GVariant *parameters,
@@ -26,7 +27,24 @@ static GVariant *test_call(GDBusConnection *bus, const gchar *dest, const gchar
assert(!strcmp(interface, REMOTE));
assert(!strcmp(method, "NotifyKeyboardKeysym") || !strcmp(method, "NotifyPointerButton") ||
!strcmp(method, "NotifyPointerAxisDiscrete") || !strcmp(method, "NotifyPointerMotion") ||
!strcmp(method, "NotifyPointerMotionAbsolute"));
!strcmp(method, "NotifyPointerMotionAbsolute") || !strcmp(method, "NotifyTouchDown") ||
!strcmp(method, "NotifyTouchMotion") || !strcmp(method, "NotifyTouchUp") || !strcmp(method, "NotifyPointerAxis"));
if (!strcmp(method, "NotifyPointerAxis")) {
assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}dd)")));
GVariant *options = g_variant_get_child_value(parameters, 1);
GVariant *x = g_variant_get_child_value(parameters, 2), *y = g_variant_get_child_value(parameters, 3);
last_x = g_variant_get_double(x); last_y = g_variant_get_double(y);
gboolean finish = FALSE; last_finish = g_variant_lookup(options, "finish", "b", &finish) && finish;
g_variant_unref(options); g_variant_unref(x); g_variant_unref(y);
}
if (!strcmp(method, "NotifyTouchDown") || !strcmp(method, "NotifyTouchMotion")) {
assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}uudd)")));
GVariant *x = g_variant_get_child_value(parameters, 4);
GVariant *y = g_variant_get_child_value(parameters, 5);
last_x = g_variant_get_double(x); last_y = g_variant_get_double(y);
g_variant_unref(x); g_variant_unref(y);
}
if (!strcmp(method, "NotifyTouchUp")) assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}u)")));
if (!strcmp(method, "NotifyPointerMotion") || !strcmp(method, "NotifyPointerMotionAbsolute")) {
unsigned offset = !strcmp(method, "NotifyPointerMotion") ? 2 : 3;
GVariant *x = g_variant_get_child_value(parameters, offset);
@@ -93,6 +111,28 @@ static void legacy_input(struct uu_portal *p) {
assert(legacy_calls == 7 && uu_portal_alive(p) && !p->ei);
}
/* Smooth scroll maps like relative motion; only the last event of a gesture carries "finish". */
static void legacy_scroll(struct uu_portal *p) {
unsigned before = legacy_calls;
assert(uu_portal_scroll(p, 20, -40, 0) == 0);
assert(last_x == 20. * p->logical_width / p->width && last_y == -40. * p->logical_height / p->height && !last_finish);
assert(uu_portal_scroll(p, 0, 0, 1) == 0 && last_finish && last_x == 0 && last_y == 0);
assert(uu_portal_scroll(p, NAN, 0, 0) == 11 && legacy_calls == before + 2);
}
/* Touch needs the granted touchscreen type and uses the same stream mapping as absolute motion. */
static void legacy_touch(struct uu_portal *p) {
p->devices = 3;
assert(uu_portal_touch(p, 0, 10, 10) == 11 && legacy_calls == 7);
p->devices = 7;
assert(uu_portal_touch(p, 0, 1920, 1080) == 0);
assert(last_x == (p->absolute_stream_pixels ? 1920 : 960));
assert(last_y == (p->absolute_stream_pixels ? 1080 : 540));
assert(uu_portal_touch(p, 1, 3840, 0) == 11);
assert(uu_portal_touch(p, 1, 0, 0) == 0 && last_x == 0 && last_y == 0);
assert(uu_portal_touch(p, 2, 0, 0) == 0);
assert(legacy_calls == 10 && !p->ei);
}
int main(void) {
struct uu_portal *p = session(1, 1, 0);
legacy_input(p);
@@ -107,10 +147,14 @@ int main(void) {
}
p = session(0, 1, 1); /* Unscaled GNOME keeps Notify*. */
legacy_input(p);
legacy_touch(p);
legacy_scroll(p);
assert(!connects);
uu_portal_close(p);
p = session(1, 0, 1); /* KDE keeps its compositor-logical mapping. */
legacy_input(p);
legacy_touch(p);
legacy_scroll(p);
assert(!connects);
uu_portal_close(p);
+19
View File
@@ -0,0 +1,19 @@
#include <assert.h>
#include "../c_engine/wayland_transform.h"
int main(void) {
assert(uu_output_transform_supported(0,0));
for(int t=1;t<=3;t++) {
assert(!uu_output_transform_supported(t,0));
assert(uu_output_transform_supported(t,1));
}
assert(!uu_output_transform_supported(4,1));
assert(!uu_output_transform_supported(-1,1));
const unsigned expected[4][6]={{0,1,2,3,4,5},{3,0,4,1,5,2},{5,4,3,2,1,0},{2,5,1,4,0,3}};
for(int t=0;t<4;t++) {
unsigned dw=t&1?2:3,dh=t&1?3:2;
for(unsigned y=0;y<dh;y++) for(unsigned x=0;x<dw;x++) {
uint32_t sx,sy;uu_source_pixel(t,3,2,x,y,&sx,&sy);
assert(sx<3 && sy<2 && sy*3+sx==expected[t][y*dw+x]);
}
}
}
+11
View File
@@ -0,0 +1,11 @@
# Generated by Cargo
# will have compiled files and executables
/target/
/.idea/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
Cargo.lock
# These are backup files generated by rustfmt
**/*.rs.bk
+49
View File
@@ -0,0 +1,49 @@
# webrtc-ice changelog
## Unreleased
### Breaking changes
* remove non used `MulticastDnsMode::Unspecified` variant [#404](https://github.com/webrtc-rs/webrtc/pull/404):
## v0.9.0
* Increased minimum support rust version to `1.60.0`.
### Breaking changes
* Make functions non-async [#338](https://github.com/webrtc-rs/webrtc/pull/338):
- `Agent`:
- `get_bytes_received`;
- `get_bytes_sent`;
- `on_connection_state_change`;
- `on_selected_candidate_pair_change`;
- `on_candidate`;
- `add_remote_candidate`;
- `gather_candidates`.
- `unmarshal_candidate`;
- `CandidateHostConfig::new_candidate_host`;
- `CandidatePeerReflexiveConfig::new_candidate_peer_reflexive`;
- `CandidateRelayConfig::new_candidate_relay`;
- `CandidateServerReflexiveConfig::new_candidate_server_reflexive`;
- `Candidate`:
- `addr`;
- `set_ip`.
## v0.8.2
* Add IP filter to ICE `AgentConfig` [#306](https://github.com/webrtc-rs/webrtc/pull/306) and [#318](https://github.com/webrtc-rs/webrtc/pull/318).
* Add `rust-version` at 1.57.0 to `Cargo.toml`. This was already the minimum version so does not constitute a change.
## v0.8.1
This release was released in error and contains no changes from 0.8.0.
## v0.8.0
* Increased min version of `log` dependency to `0.4.16`. [#250 Fix log at ^0.4.16 to make tests compile](https://github.com/webrtc-rs/webrtc/pull/250) by [@k0nserv](https://github.com/k0nserv).
* Increased serde's minimum version to 1.0.102 [#243 Fixes for cargo minimal-versions](https://github.com/webrtc-rs/webrtc/pull/243) contributed by [algesten](https://github.com/algesten)
## Prior to 0.8.0
Before 0.8.0 there was no changelog, previous changes are sometimes, but not always, available in the [GitHub Releases](https://github.com/webrtc-rs/ice/releases).
+125
View File
@@ -0,0 +1,125 @@
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g., crates.io) dependencies.
#
# If you are reading this file be aware that the original Cargo.toml
# will likely look very different (and much more reasonable).
# See Cargo.toml.orig for the original contents.
[package]
edition = "2021"
name = "webrtc-ice"
version = "0.10.1"
authors = ["Rain Liu <[email protected]>"]
description = "A pure Rust implementation of ICE"
homepage = "https://webrtc.rs"
documentation = "https://docs.rs/webrtc-ice"
readme = "README.md"
license = "MIT OR Apache-2.0"
repository = "https://github.com/webrtc-rs/ice"
[[example]]
name = "ping_pong"
path = "examples/ping_pong.rs"
bench = false
[dependencies.arc-swap]
version = "1"
[dependencies.async-trait]
version = "0.1"
[dependencies.crc]
version = "3"
[dependencies.log]
version = "0.4"
[dependencies.mdns]
version = "0.6.1"
package = "webrtc-mdns"
[dependencies.rand]
version = "0.8"
[dependencies.rustls-native-certs]
version = "0.8"
[dependencies.serde]
version = "1"
features = ["derive"]
[dependencies.serde_json]
version = "1"
[dependencies.stun]
version = "0.5.1"
[dependencies.thiserror]
version = "1"
[dependencies.tokio]
version = "1.32.0"
features = ["full"]
[dependencies.tokio-rustls]
version = "0.26.6"
default-features = false
features = ["ring", "tls12"]
[dependencies.turn]
version = "0.7.1"
[dependencies.url]
version = "2"
[dependencies.util]
version = "0.8.1"
features = [
"conn",
"vnet",
"sync",
]
default-features = false
package = "webrtc-util"
[dependencies.uuid]
version = "1"
features = ["v4"]
[dependencies.waitgroup]
version = "0.1"
[dependencies.webpki-roots]
version = "1"
[dev-dependencies.chrono]
version = "0.4.28"
[dev-dependencies.clap]
version = "3"
[dev-dependencies.env_logger]
version = "0.10"
[dev-dependencies.hyper]
version = "0.14.27"
features = ["full"]
[dev-dependencies.ipnet]
version = "2"
[dev-dependencies.lazy_static]
version = "1"
[dev-dependencies.regex]
version = "1.9.5"
[dev-dependencies.sha1]
version = "0.10"
[dev-dependencies.tokio-test]
version = "0.4"
Loaded 100 of 161 files, more files were not shown because too many files have changed in this diff. Show more