Compare commits

...
45 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 0e1e935fb4 release: v0.2.58
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-12 19:20:09 +08:00
Onekkiandzhuwangqi 4649149ff5 viewer: pick a CJK-capable font for the HUD (#219)
The HUD rasterizes text with a single font and has no per-character
fallback. On systems where fontconfig strongly prefers a Latin-only
sans-serif (e.g. Liberation Sans on Omarchy), 'sans-serif:lang=zh-cn'
resolves to a face without Han glyphs and the Chinese labels render as
empty boxes.

Require U+63A7 (控, from 控制中心) in the fc-match pattern so coverage
influences selection while still respecting the system's font families.

Co-authored-by: zhuwangqi <[email protected]>
2026-11-12 18:17:13 +08:00
阿夜 50a7447b7b 使用 logind D-Bus 监听锁屏变化,减少进程轮询和审计噪声 (#218)
* fix: monitor logind lock state over D-Bus instead of spawning loginctl

* docs: add redacted lock-monitor audit evidence and validation

* fix: retain logind subscription without a graphical session
2026-11-12 17:14:51 +08:00
Kitlee0252 890c46e280 test: keep waiting for the listed session's LIST_RESP on the binary channel (#216)
locked_control_unlock_requests_and_tools_work_without_a_video_frame broke
out of its wait loop on the first BINARY_DATA_CHANNEL message and unwrapped
terminal::decode on it. The process-global terminal change watch also sends
the field-28 list-invalidated notification on that channel
(terminal::changed_message, an initialization::envelope with an empty field
28), which is not a TERM frame, so decode returns None. Any concurrently
running test that opens, kills or reconciles a terminal session can
broadcast it inside this test's wait window, and the suite panics at
desktop_control_tests.rs:302.

Skip messages that do not decode and keep waiting until the LIST_RESP of the
session being listed (71, then 72) arrives, following the sibling terminal
test in webrtc_lifecycle_tests.rs. Test-only change.
2026-11-12 13:08:51 +08:00
Xianjie ZhanandClaude Sonnet 5.5 fe052cdca7 wol: send inner_ip when registering as wake helper (#209)
The helper registration (POST /api/v1/device/wake_on_lan/info) was rejected
with HTTP 422 / code 1001, so the cloud reported 'no helper online' and never
forwarded wake_on_lan pushes. The official macOS client sends inner_ip, ip,
mac and subnet_mask; adding inner_ip makes the server accept the helper.

Verified end to end: headless Linux host in Docker on a NAS, UU_WOL_HELPER=1,
official iOS controller. Registration returns 200 / code 0, the cloud pushes
wake_on_lan, the host sends the magic packet and the Windows PC boots.

Co-authored-by: Claude Sonnet 5.5 <[email protected]>
2026-11-09 22:10:47 +08:00
VallierDevandClaude Opus 5.5 b84e6e4543 release: v0.2.57
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 18:48:41 +08:00
Juck Zhang bfbbe2f677 feat: add opt-in controller microphone input (#207)
* feat: add opt-in controller microphone input

* fix: address microphone CI and review feedback
2026-11-09 17:47:07 +08:00
VallierDevandClaude Opus 5.5 f437328ad1 file_trans: reject send_request without a path instead of walking /
Refs #208

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 14:45:18 +08:00
VallierDevandClaude Opus 5.5 0308498097 release: v0.2.56
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 09:42:48 +08:00
Cr d8e3025fb3 video: size the NVENC VBV buffer like libx264 so keyframes stop blurring (#103) (#205)
The 100-500 kbit NVENC default squeezes every IDR of a high-resolution desktop
into a blur that sharpens over the GOP: at 3840x2160 hevc_nvenc CQ18 / 30M the
IDR frame lost 29-31 dB Y-PSNR against the frame before it, and the following
P-frames spent 15-18 Mbit/s re-sharpening a static desktop.

NVENC now takes one second of the bitrate cap within 500-8000 kbit, the rule
libx264 already uses (#8). UU_NVENC_BUFFER_MS still overrides it, so a small
value brings back the low-latency buffer. VAAPI is unchanged.
2026-11-09 08:37:00 +08:00
Mr. Error 21e9e690ae feat(portal): follow the viewer's mouse mode with the embedded cursor (#203)
* feat(portal): follow the viewer's mouse mode with the embedded cursor

The portal stream hides the compositor cursor. A viewer that drives the pointer
with relative motion (UU's controlled-end mouse, also the Mac trackpad mode)
has no absolute position to draw its own pointer at, and the game's cursor
never reaches the picture, so the mouse can be moved and clicked but not seen.

Request cursor_mode=embedded while relative motion arrives, and keep it hidden
while absolute motion arrives: there the viewer draws its own pointer and an
embedded copy would trail it. The portal reads cursor_mode only when the
session is created, so switch by rebuilding the session with the saved consent,
the same path the privacy screen uses. A run has to last five events and 200 ms
before it counts, so a burst at connect or an alternating controller does not
rebuild; a failed rebuild backs off for five seconds.

The rebuilt session is checked against the monitor the previous one captured,
so a restored consent cannot silently move the share. The engine keeps the mode
for later opens (recovery, privacy, monitor switches) and skips the switch when
an older libuu-portal.so lacks uu_portal_set_cursor_mode.

UU_PORTAL_CURSOR_MODE=embedded sets the startup default.

* fix(portal): keep the cursor rebuild off locks and held input

Do not rebuild while the desktop is locked, and cancel an open that is already
waiting when it locks: GNOME closes the portal session on lock, so the request
would wait for consent that cannot be answered while holding `recovery`
against the post-unlock recovery.

Keys and buttons held through the portal input path are dropped when the
session is replaced, so wait for their release. Monitor selection takes the
same `recovery` lock, so it cannot install a stale source over the cursor
rebuild or the other way round, and the rebuilt session is revalidated against
the source it started from.

* fix(portal): carry the clipboard across cursor rebuilds

The engine keeps the viewer's text only in the session that provided it, and
the host re-sends it only for a new viewer update. A replacement session
therefore had no clipboard ownership, so changing the mouse mode made
previously synchronized text unpasteable until the viewer sent it again.

Offer the text to the replacement before the old session closes, but only
while that session still owns the selection: a local copy that has taken the
clipboard since is left alone. Touch consent upgrades replace the handle too,
so they take the same `recovery` lock as recovery, monitor selection and the
cursor rebuild and cannot install a handle opened under an older cursor mode.

* fix(portal): serialize clipboard writes with the cursor swap

The clipboard bridge calls clipboard_set from its own thread. Installing the
replacement handle and then carrying the old text over left a window where an
update could land on the new session and be overwritten by the older text,
with no pending update left to restore it.

Take a clipboard write lock before the handle is installed and hold it until
the carry-over finishes; clipboard_set takes the same lock. A write that
starts before the swap is included in the text carried over, a write that
starts after waits and wins.

* fix(portal): cancel a waiting rebuild when the desktop ends

The desktop ends its share when the last controller leaves (end_idle), but an
open that is still waiting for consent is not the installed handle, so it
survived that shutdown and installed a live share afterwards.

Bump an end generation in Session::end(), snapshot it before the open, and
cancel the request when it moves. The generation is checked again under the
handle lock before installing, so an end that races the swap either aborts
the rebuild or ends the handle it just installed.

* fix(portal): keep session swaps consistent with the viewer's state

Addresses the ownership race reported on the previous commit and the paths
that share its failure mode.

uu_portal_clipboard_set publishes the new text before SetSelection so a
transfer during the call serves it, restores the old text when the call fails,
and ignores a stale revision so a newer owner wins. The engine reports the
cursor mode it actually requested and the modes the backend advertised; the
host follows that instead of assuming the request was applied and stops
retrying where an embedded cursor is unavailable. The end generation is
sampled before the rebuild queues for `recovery`, a rebuild refuses to start
while the session is no longer alive, and cancellation now covers virtual
output opens.

Portal-bound keys and buttons are tracked separately, so an input held through
the portal defers the swap on every routing path, and the check is repeated
after the open. Every handle replacement (privacy screen, monitor switch,
touch consent, recovery after lock or stream loss) carries the viewer's
clipboard under the clipboard write lock, and the rebuilt session is checked
against the captured geometry.

* fix(portal): stop the swap bookkeeping from outliving a deferred rebuild

open_inner publishes the replacement's cursor mode before the swap. When held
input defers the rebuild, that session is never installed, so the host belief
described the discarded handle and later motion looked like it already matched.
Restore the belief from the installed session on every abort path.

The extra portal releases in release_held now stop at the first failure like
the sweep above; with a dead portal bus each remaining input waited out the
three-second timeout while the input and desktop-owner locks were held.

* fix(portal): invalidate clipboard ownership when a session ends

A closed session stops receiving owner changes, so a cached clipboard_owns
survived into the recovery paths and could republish old viewer text over a
newer local copy. Clear the claim in uu_portal_end and the Closed handler, and
let uu_portal_clipboard_copy refuse a source that is no longer alive.

Mark the embedded cursor unavailable when the engine did not apply it: with
AvailableCursorModes unreadable the session opens hidden, and retrying on every
motion run rebuilt it every 200 ms without changing the mode.

* fix(portal): retire held portal input when the devices are replaced

A key or button held through the native portal path is recorded when its
injection succeeds. If the session dies first, the key-up fails and the record
survives; recovery then installs new devices while the tracker still says an
input is held, so pointer-mode detection keeps deferring.

Keep the tracker in module state and clear it whenever the portal replaces or
ends its devices: the rebuild, both recovery paths and Session::end.

* fix(portal): scope held-input retirement to the retired handle

A press delivered to the replacement after the swap could be recorded while
the old handle was still being retired, and the unconditional reset then
deleted it. Hold the recording lock from before the swap until the reset
finishes, so only inputs sent to the retired devices are dropped.

A portal touchscreen contact was not tracked at all: the swap retired the
active contact while TouchDrag stayed down, so the following move reached a
session that never saw the press. Track contact down/up and include it in the
deferral state.

* fix(portal): serialize touch injection with handle replacement

inject_touch wrote the contact state outside the recording lock the handle
swap holds, so a contact delivered to the replacement between the swap and the
reset could be cleared, and the following phase-1 would fail on new devices
that never saw the press. Take the same lock across the injection and the
state update.

* fix(portal): decide the swap under the held-input lock

The final held-input check ran before install_replacement() took the serial
lock, so an input could be injected and recorded against the old handle while
the install waited for the clipboard lock. The install then retired the
records and swapped, destroying a contact the new devices never saw. Repeat
the check under the serial lock that recording uses, and defer the rebuild
when it hits.

* fix(portal): hold the input lock across native injection, refresh privacy geometry

inject_button and inject_key injected through the portal and only took the
recording lock afterwards, so a swap could take the lock, see no held input
and replace the devices that had just received the press. Take the serial lock
across the injection and its record, as the touch path does; the record
helpers no longer take it themselves.

A cursor rebuild that replaces the privacy virtual output invalidates the
cached pointer region: recompute it from the settled layout so absolute input
keeps landing inside the captured share.
2026-11-09 08:36:37 +08:00
Mr. Error c489f3056f fix(privacy): keep new windows and desktop pets on the virtual output (#201) 2026-11-08 20:16:35 +08:00
Mr. Error 101123797a fix(privacy): accept the Windows viewer's enable=0 encoding (#202) 2026-11-08 20:15:37 +08:00
VallierDevandClaude Opus 5.5 ac9606b872 release: v0.2.55
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-08 00:50:08 +08:00
max2787andmax2787 4e91126561 fix(clipboard): omit format name for predefined Windows Unicode text (#200)
Co-authored-by: max2787 <[email protected]>
2026-11-08 00:48:59 +08:00
VallierDevandClaude Opus 5.5 10825c1fe0 release: v0.2.54
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-07 19:43:17 +08:00
cnetstandCodex 36fd51a9d6 Fix terminal session termination, ownership and list updates (#197)
Co-authored-by: Codex <codex@localhost>
2026-11-07 19:42:15 +08:00
Mr. Error 9271904be6 fix(privacy): accept the iOS screen-off encoding (#199)
The iOS viewer sends PrivateScreenSettingRequest{enable=0, privacy_type=3}
when the user turns the display off: its enable bit is the picture-mode
switch and the explicit type carries the intent. The host treated enable=0
as off, so the screen was restored instead of turned off.

Normalize that combination for iOS controllers only. Android 4.43.0 was
verified with the field-1 semantics, so keep Android and desktop viewers
unchanged. Record the platform after a desktop session is created, update
it on capture_desktop promotion, and cancel a pending UU_PRIVACY_AUTO even
when the switch is refused.
2026-11-07 18:40:49 +08:00
cnetstandCodex 1004806035 Resolve the iOS default upload directory alias (#198)
Co-authored-by: Codex <codex@localhost>
2026-11-07 11:21:56 +08:00
VallierDevandClaude Opus 5.5 af74af0f83 release: v0.2.53
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-06 11:42:15 +08:00
Jeff Zhang 2dd3280b7e perf(inproc): replace portal pseudo-polling with event-driven frame wait (#193)
* perf(portal): wait for frames without polling

* fix(portal): use monotonic clock for condition variable wait deadline

* fix(portal): compute wait_for_first_frame deadline with monotonic clock
2026-11-06 10:41:21 +08:00
VallierDevandClaude Opus 5.5 13c92d8f68 release: v0.2.52
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-06 07:39:51 +08:00
Jeff Zhang b0015a6c48 perf(input): offload text_input to spawn_blocking preserving order and rebase on main (#189) 2026-11-06 05:39:20 +08:00
Jeff Zhang c60d9f1bfa perf: HEVC RTP 分包零拷贝子切片与 X11 终端检测 100ms 缓存 (#182)
* perf: HEVC RTP 分包零拷贝子切片与 X11 终端检测 100ms 缓存

* fix(x11): 绑定焦点窗口缓存并支持焦点切换即时失效
2026-11-06 04:38:00 +08:00
Jeff Zhang 6032129228 perf: 优化 H.265 IRAP 单趟流式扫描与 CONTROL 通道 JSON 单次解析 (#180) 2026-11-06 03:38:47 +08:00
Jeff Zhang 7ba71a5540 webrtc: single-pass decode_wire for data channel packets and merge loop passes (#191) 2026-11-06 03:38:37 +08:00
Jeff Zhang b774bf6b16 perf: CompleteFrame 使用 bytes::Bytes 消除每帧码流克隆深拷贝 (#184) 2026-11-06 03:38:26 +08:00
VallierDevandClaude Opus 5.5 a22f576005 release: v0.2.51
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-05 20:32:15 +08:00
Onekki 212e4943f9 Hyprland 手机输入法文字:统一走独立文字键盘并每批重新 attach (#176)
所有 wlroots 合成器使用独立文字键盘、每批重新 attach 下发 keymap;ASCII 也以 Unicode keysym 发送,Wayland 下 text_input 先走 keysym;切换前同步原设备修饰键。
2026-11-05 19:30:25 +08:00
VallierDevandClaude Opus 5.5 0b3ac4c78e release: v0.2.50
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-05 06:24:03 +08:00
jinpeng2700-techandjinpeng2700-tech 8b6de40605 portal: persist rotated consent before video starts (#175)
Co-authored-by: jinpeng2700-tech <[email protected]>
2026-11-05 05:22:22 +08:00
CrandClaude Opus 5.5 7a0c40af73 annotation: answer viewer draw RPCs and draw strokes on an X11 overlay (#174)
* annotation: answer viewer draw RPCs and draw strokes on an X11 overlay

The official viewer's watch-mode annotation (批注) sends RpcRequest 27
draw_req, which this host never answered, so the viewer reported
批注开启失败 (9998). The schema is taken from the Mac 4.42.0
UURemoteService SwiftProtobuf metadata. Replies go on TEXT because a
reply on CONTROL times out.

Strokes are drawn on a click-through override-redirect ARGB window,
which needs a compositing manager. The window exists only while
annotation is on and is removed when the desktop session ends.

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

* annotation: follow root resizes and scope resets to the owning peer

Addresses the Codex review on #174.

- A RandR resize (on X11 the viewer's resolution choice does this) left
  the overlay at its old size. The overlay now watches root
  ConfigureNotify and is rebuilt at the new geometry. Strokes keep the
  viewer's points and are laid out again.
- A delayed reset from a replaced desktop peer could remove the
  annotation of the viewer that took over. Requests and resets now carry
  the peer (its PeerActions address), and only the owner's reset,
  toggle-off or clear applies.

The ignored overlay smoke test covers both cases. It always checks the
owner takeover, and checks the resize when UU_ANNOTATION_SMOKE_RESIZE is
set on a disposable display.

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

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-11-05 05:22:14 +08:00
Mr. Error f67de7cc7d Privacy: recover the input devices after a reboot renumbers them (#173)
* fix(privacy): match recorded input devices after a reboot

The recovery record stores KWin's `eventN` sysNames, but udev renumbers
them between boots. A record replayed after a reboot (privacy was on at
shutdown) then set `enabled` on a device path that no longer exists; the
restore failed, kept the record, and every later switch failed at the
same step. The device that had been blocked could also stay disabled.

Records now keep name/product/vendor next to the sysName, and a restore
matches the current device by that identity, falling back to the exact
sysName for older string-only records. A device that no longer exists is
skipped with a log line instead of failing the restore, so the record,
the guard and the outputs are cleaned up; a device that exists but cannot
be enabled still fails and keeps the record for the next attempt.

Verified by replaying records with the release build on KDE Plasma 6.8: a
stale `event14` for a mouse now on `event12` is re-enabled and the record
removed; a record for a missing device logs the skip and restores
normally. `cargo test --features wayland,portal`: 330 passed, 10 ignored.

* fix(privacy): restore every device sharing an identity

- enable every current device whose identity matches a record entry,
  deduplicated by sysName: two record entries can describe one device, and
  one identity can cover several (identical keyboards, or a receiver
  exposing several event nodes under the same name)
- a failed property read during restore is an error instead of a missing
  device, so the record and the guard stay for the next attempt; blocking
  keeps the lenient read
- the gone-device warning logs a count only, matching the log-privacy rule

* fix(privacy): re-enable readable devices before reporting incomplete enumeration

A failed property read during restore no longer aborts enumeration before
set_sys runs: the readable matching devices are re-enabled first, then the
incomplete read is returned as an error so the record and the guard stay
for another attempt. Blocking still skips unreadable devices.
2026-11-05 03:22:02 +08:00
Jeff Zhangandferstar b9586f226d input: park the pointer worker until pointer or gesture work exists (#172)
* input: park the pointer worker until pointer or gesture work exists

A fixed 4 ms tick kept ~250 wakeups/s (clock_gettime storms, worker
steal spins, pow-heavy flush math) burning ~3% CPU on an idle host with
no viewer connected. The worker now parks on a Notify permit until a
pointer/scroll/button event or a live touch gesture needs the 4 ms
cadence; notify_one permit semantics make the park check race-free.
Sub-notch scroll residue cannot inject alone, so it parks too.

* fix(input): preserve pointer wake ordering and motion cadence

Hold the serial lock before notifying button transitions so a parked worker cannot miss a newly pending gesture. Keep the 4 ms coalescing cadence until an empty tick and reset the interval after each parked phase.

Add regression coverage for button wake ordering, 1 ms motion streams, and idle cadence reset using Tokio test-only clock control.

---------

Co-authored-by: ferstar <[email protected]>
2026-11-04 23:18:19 +08:00
VallierDevandClaude Opus 5.5 7b8980771d release: v0.2.49
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 23:40:44 +08:00
Mr. Error 50ff42e8d7 Privacy: keep the cover window out of the task manager (#169)
* fix(privacy): keep the cover window out of the task manager

The cover is a plain Wayland toplevel and GTK's skip-taskbar hint is X11
only, so KWin listed it: the task manager showed an unidentified window
(class uuremote-server, caption "uu-remote-linux privacy") with the icon
theme's generic "wayland" icon, a yellow W in Papirus.

Mark the window through KWin scripting after the cover reports ready. The
same one-shot script mechanism already moves windows to the virtual output.
Failure only logs; the cover itself is unaffected.

Verified on KDE Plasma 6.8 Wayland: setting skipTaskbar on the running
cover removes the task manager entry immediately, and the entry returns
when a new cover window is created without the fix. `cargo test --features
wayland,portal`: 320 passed, 10 ignored.

* fix(privacy): match every cover window, not just the first caption

Picture mode creates one cover per physical monitor with the same title,
and KWin appends " <2>" and similar suffixes to duplicate captions, so the
exact match skipped every cover after the first on a multi-monitor host.
Match the title as a prefix instead.

* fix(privacy): report the cover ready only after its windows are mapped

The child wrote "ready" before gtk_main(), so the host marked skip-taskbar
while KWin may not have listed the cover yet; a cover that mapped later
kept the task manager entry. Pump the pending GTK events to map the windows
before the handshake, and run the mark script a second time to catch a
compositor-side delay.
2026-11-03 22:39:08 +08:00
Zhenqiang Weng ba8f8ada20 viewer: mirror remote cursor shapes and hotspots in SDL (#168) 2026-11-03 19:35:53 +08:00
VallierDevandClaude Opus 5.5 c461db10a4 release: v0.2.48
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 16:34:29 +08:00
Mr. Error 4c86c7f782 Privacy: auto-enable on desktop connect (UU_PRIVACY_AUTO) (#161)
* feat(privacy): auto-enable the privacy screen on desktop connect

`UU_PRIVACY_AUTO=picture` / `screen-off` (or 2 / 3) enables the privacy
screen when the first desktop controller connects. Off by default. The
switch waits for the portal capture session and retries while it is
missing; the viewer's own RPC 7 cancels a pending auto-enable for that
session.

The privacy state poller that pushes SystemMetrics and SystemStateChange
now starts for desktop peers too (it only ran for a tool peer promoted to
desktop), and it pushes once on its first tick. A mode the viewer did not
request, such as an auto-enable, therefore reaches its menu, and the
state message also goes to TEXT, which viewers read for privacy replies.

Verified on KDE Plasma Wayland with an iOS viewer: auto picture and auto
screen-off both engage, the menu reflects the mode after the push, and a
disconnect restores the physical outputs. `cargo test --features
wayland,portal`: 320 passed, 10 ignored.

* fix(privacy): let a viewer request win against auto-enable races

Two paths could still override an explicit choice:

- the override was checked before acquiring STATE, so an RPC 7 applied in
  that window could disable privacy and the auto thread could turn it back
  on; the check now happens inside the same lock that enters the mode
- `session_started` captured the override counter as its baseline, so a
  request that arrived after CONTROL opened but before the session counter
  started was treated as unrelated and auto-enable ran anyway; the counter
  is now a flag set by any RPC 7 and cleared only when the last desktop
  session ends

docs/privacy-screen.md now says remote-assistance (guest) sessions are
covered too, and that supported hosts push the current privacy state once
on every desktop connect.
2026-11-03 16:33:41 +08:00
VallierDevandClaude Opus 5.5 81e9ccfa05 fix(signaling): log the sanitized reason when signaling fails to connect
The WebSocket transport already reduces errors to a category or HTTP status
without the token or endpoint, so log it instead of 'details omitted' to tell
a refused upgrade from a network failure (#166).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 15:34:34 +08:00
Zhenqiang Weng c0abdeae72 fix(viewer): restore held modifier combinations after focus changes (#165) 2026-11-03 15:33:13 +08:00
Zhenqiang Weng 1dad755823 fix(viewer): use theme icons in the launcher (#158) 2026-11-03 14:01:02 +08:00
Jeff Zhang fcfd2b6717 feat(wallpaper): discover Omarchy backgrounds automatically (#157)
Read Omarchy's current/background link (XDG_STATE_HOME, falling back to XDG_CONFIG_HOME) on Hyprland; explicit UU_WALLPAPER keeps precedence.
2026-11-03 12:31:33 +08:00
VallierDevandClaude Opus 5.5 73c503a244 release: v0.2.47
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 01:26:54 +08:00
Jeff ZhangandJeff Zhang 3bce605eaa feat(host): 上报系统壁纸,补齐设备卡片缩略图 (#153)
* feat(host): report system wallpaper for device cards

* fix(host): handle quoted wallpaper paths and KDE defaults

* docs: align wallpaper guidance and disclose default uploads

* fix(host): validate active KDE plugin for stored wallpapers

* fix(host): support Plasma 5 wallpaper config queries

* fix(host): exclude Plasma panels from wallpaper reporting

* fix(host): follow image symlinks in KDE wallpaper packages

---------

Co-authored-by: Jeff Zhang <[email protected]>
2026-11-03 01:25:57 +08:00
70 changed files with 6133 additions and 395 deletions

No files matched your search

+3 -1
View File
@@ -127,6 +127,7 @@ viewer does not reconnect them automatically.
| `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_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_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) | | `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) |
| `UU_PORTAL_CURSOR_MODE` | portal capture startup cursor mode: `embedded` draws the compositor pointer into the stream, default hidden. `input::inject_move` reports relative/absolute motion; `portal::note_pointer_motion` flips the mode after a 200 ms run of one kind and rebuilds the session via `Session::set_cursor_embedded`, because the portal only reads `cursor_mode` in `SelectSources`. Relative motion gives the viewer no position to draw its own pointer at, so the stream must carry one; absolute motion means the viewer draws its own and an embedded copy would trail it |
| 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 | | 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) | | `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` | | `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` |
@@ -163,6 +164,7 @@ for a new QR login.
| `src/privacy_screen/`, `c_engine/privacy_wallpaper.c` | host privacy screen (RPC 7): desktop-independent controller, recovery record, guard and cover processes; `Backend` per desktop (`kde/`: KWin virtual output, kscreen-doctor, KWin input devices). See docs/privacy-screen.md | | `src/privacy_screen/`, `c_engine/privacy_wallpaper.c` | host privacy screen (RPC 7): desktop-independent controller, recovery record, guard and cover processes; `Backend` per desktop (`kde/`: KWin virtual output, kscreen-doctor, KWin input devices). See docs/privacy-screen.md |
| `src/session_lock.rs`, `c_engine/pam_check.c` | lock state reporting, auto unlock via PAM + logind | | `src/session_lock.rs`, `c_engine/pam_check.c` | lock state reporting, auto unlock via PAM + logind |
| `src/system_actions.rs`, `src/system_metrics.rs` | SimpleAction system commands, mute, auto-lock, SystemMetrics | | `src/system_actions.rs`, `src/system_metrics.rs` | SimpleAction system commands, mute, auto-lock, SystemMetrics |
| `src/annotation.rs`, `c_engine/annotation_overlay.c` | viewer annotation (RPC 27 `draw_req` → RpcResponse 23): click-through X11 ARGB overlay, needs a compositing manager |
| `src/initialization.rs`, `src/control_protocol.rs`, `src/protocol.rs` | protobuf encoders/decoders for CONTROL | | `src/initialization.rs`, `src/control_protocol.rs`, `src/protocol.rs` | protobuf encoders/decoders for CONTROL |
| `src/session_ice.rs`, `src/network_diagnostics.rs` | cloud ICE servers, address-free path diagnostics | | `src/session_ice.rs`, `src/network_diagnostics.rs` | cloud ICE servers, address-free path diagnostics |
| `src/desktop_backend.rs`, `src/wayland.rs`, `src/portal*.rs` | backend selection, Hyprland, GNOME/KDE portal | | `src/desktop_backend.rs`, `src/wayland.rs`, `src/portal*.rs` | backend selection, Hyprland, GNOME/KDE portal |
@@ -194,7 +196,7 @@ started a second full host server instead, so check that a subcommand exists in
- RPC = Message 21 `RpcRequest {1 header{1 request_id}, <case>}`, answered with Message 22 - RPC = Message 21 `RpcRequest {1 header{1 request_id}, <case>}`, answered with Message 22
`RpcResponse {1 header (same id), <case>}`. Cases used: 2 capture_setting, 3 fps, 4 video_quality, `RpcResponse {1 header (same id), <case>}`. Cases used: 2 capture_setting, 3 fps, 4 video_quality,
6 resolution, 8 file transfer, 9 clipboard, 15 send_video_track, 16–20 plugins, 21 virtual audio policy, 6 resolution, 8 file transfer, 9 clipboard, 15 send_video_track, 16–20 plugins, 21 virtual audio policy,
28/29 terminal. 27 draw (annotation; answered on TEXT, a CONTROL reply times out with 9998), 28/29 terminal.
- CaptureSettingRequest: field 1 is an **fps option index** (1=30, 2=60, 3=90); the real frame rate is - CaptureSettingRequest: field 1 is an **fps option index** (1=30, 2=60, 3=90); the real frame rate is
field 18 `fpsCount`. Field 2 quality: 1 Fast, 2 General (高清 2M), 3 HD (超清 8M), 4 Bluray (原画 20M), field 18 `fpsCount`. Field 2 quality: 1 Fast, 2 General (高清 2M), 3 HD (超清 8M), 4 Bluray (原画 20M),
5 Auto, 6 Custom. Resolution: 16/17 pixel size or 5/6, 10 resolution_type (3 = follow remote). 5 Auto, 6 Custom. Resolution: 16/17 pixel size or 5/6, 10 resolution_type (3 = follow remote).
Generated
+376 -3
View File
@@ -172,6 +172,29 @@ dependencies = [
"syn 1.0.109", "syn 1.0.109",
] ]
[[package]]
name = "async-broadcast"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
dependencies = [
"event-listener",
"event-listener-strategy",
"futures-core",
"pin-project-lite",
]
[[package]]
name = "async-recursion"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f8abc12baad266b1c8cec146854c195b5864b4221d4b2ca7296a7ae82d9e451"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]] [[package]]
name = "async-trait" name = "async-trait"
version = "0.1.92" version = "0.1.92"
@@ -640,6 +663,33 @@ dependencies = [
"zeroize", "zeroize",
] ]
[[package]]
name = "endi"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
[[package]]
name = "enumflags2"
version = "0.7.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
dependencies = [
"enumflags2_derive",
"serde",
]
[[package]]
name = "enumflags2_derive"
version = "0.7.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]] [[package]]
name = "env_filter" name = "env_filter"
version = "2.0.0" version = "2.0.0"
@@ -663,6 +713,12 @@ dependencies = [
"log", "log",
] ]
[[package]]
name = "equivalent"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]] [[package]]
name = "errno" name = "errno"
version = "0.3.14" version = "0.3.14"
@@ -673,6 +729,41 @@ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
[[package]]
name = "event-listener"
version = "5.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"
dependencies = [
"parking",
"pin-project-lite",
]
[[package]]
name = "event-listener-strategy"
version = "0.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
dependencies = [
"event-listener",
"pin-project-lite",
]
[[package]]
name = "fastrand"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
[[package]]
name = "fdeflate"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
dependencies = [
"simd-adler32",
]
[[package]] [[package]]
name = "ff" name = "ff"
version = "0.13.1" version = "0.13.1"
@@ -727,7 +818,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
dependencies = [ dependencies = [
"crc32fast", "crc32fast",
"miniz_oxide", "miniz_oxide 0.9.1",
"zlib-rs", "zlib-rs",
] ]
@@ -788,6 +879,19 @@ version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed" checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
[[package]]
name = "futures-lite"
version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
dependencies = [
"fastrand",
"futures-core",
"futures-io",
"parking",
"pin-project-lite",
]
[[package]] [[package]]
name = "futures-macro" name = "futures-macro"
version = "0.3.34" version = "0.3.34"
@@ -903,6 +1007,12 @@ dependencies = [
"subtle", "subtle",
] ]
[[package]]
name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
[[package]] [[package]]
name = "hermit-abi" name = "hermit-abi"
version = "0.5.3" version = "0.5.3"
@@ -1136,6 +1246,16 @@ dependencies = [
"icu_properties", "icu_properties",
] ]
[[package]]
name = "indexmap"
version = "2.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
dependencies = [
"equivalent",
"hashbrown",
]
[[package]] [[package]]
name = "inout" name = "inout"
version = "0.1.4" version = "0.1.4"
@@ -1317,12 +1437,31 @@ dependencies = [
"autocfg", "autocfg",
] ]
[[package]]
name = "memoffset"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
dependencies = [
"autocfg",
]
[[package]] [[package]]
name = "minimal-lexical" name = "minimal-lexical"
version = "0.2.1" version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]
name = "miniz_oxide"
version = "0.8.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
dependencies = [
"adler2",
"simd-adler32",
]
[[package]] [[package]]
name = "miniz_oxide" name = "miniz_oxide"
version = "0.9.1" version = "0.9.1"
@@ -1353,7 +1492,7 @@ dependencies = [
"bitflags 1.3.2", "bitflags 1.3.2",
"cfg-if", "cfg-if",
"libc", "libc",
"memoffset", "memoffset 0.7.1",
"pin-utils", "pin-utils",
] ]
@@ -1456,6 +1595,16 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
[[package]]
name = "ordered-stream"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
dependencies = [
"futures-core",
"pin-project-lite",
]
[[package]] [[package]]
name = "owned_ttf_parser" name = "owned_ttf_parser"
version = "0.25.1" version = "0.25.1"
@@ -1489,6 +1638,12 @@ dependencies = [
"sha2", "sha2",
] ]
[[package]]
name = "parking"
version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
[[package]] [[package]]
name = "parking_lot" name = "parking_lot"
version = "0.12.5" version = "0.12.5"
@@ -1571,6 +1726,19 @@ version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
[[package]]
name = "png"
version = "0.18.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
dependencies = [
"bitflags 2.13.2",
"crc32fast",
"fdeflate",
"flate2",
"miniz_oxide 0.8.9",
]
[[package]] [[package]]
name = "polyval" name = "polyval"
version = "0.6.2" version = "0.6.2"
@@ -1631,6 +1799,15 @@ dependencies = [
"elliptic-curve", "elliptic-curve",
] ]
[[package]]
name = "proc-macro-crate"
version = "3.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
dependencies = [
"toml_edit",
]
[[package]] [[package]]
name = "proc-macro2" name = "proc-macro2"
version = "1.0.107" version = "1.0.107"
@@ -2197,6 +2374,17 @@ dependencies = [
"zmij", "zmij",
] ]
[[package]]
name = "serde_repr"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]] [[package]]
name = "serde_urlencoded" name = "serde_urlencoded"
version = "0.7.1" version = "0.7.1"
@@ -2431,6 +2619,19 @@ dependencies = [
"syn 3.0.9", "syn 3.0.9",
] ]
[[package]]
name = "tempfile"
version = "3.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"once_cell",
"rustix",
"windows-sys 0.61.2",
]
[[package]] [[package]]
name = "thiserror" name = "thiserror"
version = "1.0.69" version = "1.0.69"
@@ -2531,6 +2732,7 @@ dependencies = [
"signal-hook-registry", "signal-hook-registry",
"socket2 0.6.5", "socket2 0.6.5",
"tokio-macros", "tokio-macros",
"tracing",
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
@@ -2584,6 +2786,36 @@ dependencies = [
"tokio", "tokio",
] ]
[[package]]
name = "toml_datetime"
version = "1.1.3+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "173f25c883cd2176a2d8212155638c0a60d484a9d84546d270866f40f56b6e49"
dependencies = [
"serde_core",
]
[[package]]
name = "toml_edit"
version = "0.25.19+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd43688c4858d7264ae1cf9a9f874a67c3feb74a883b1cd7bebd6a4ea8307218"
dependencies = [
"indexmap",
"toml_datetime",
"toml_parser",
"winnow",
]
[[package]]
name = "toml_parser"
version = "1.1.5+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c"
dependencies = [
"winnow",
]
[[package]] [[package]]
name = "tower" name = "tower"
version = "0.5.3" version = "0.5.3"
@@ -2636,9 +2868,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
dependencies = [ dependencies = [
"pin-project-lite", "pin-project-lite",
"tracing-attributes",
"tracing-core", "tracing-core",
] ]
[[package]]
name = "tracing-attributes"
version = "0.1.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]] [[package]]
name = "tracing-core" name = "tracing-core"
version = "0.1.36" version = "0.1.36"
@@ -2706,6 +2950,17 @@ version = "1.20.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
[[package]]
name = "uds_windows"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
dependencies = [
"memoffset 0.9.1",
"tempfile",
"windows-sys 0.61.2",
]
[[package]] [[package]]
name = "unicode-ident" name = "unicode-ident"
version = "1.0.27" version = "1.0.27"
@@ -2772,7 +3027,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]] [[package]]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.46" version = "0.2.58"
dependencies = [ dependencies = [
"ab_glyph", "ab_glyph",
"async-trait", "async-trait",
@@ -2788,6 +3043,7 @@ dependencies = [
"libc", "libc",
"log", "log",
"nix 0.29.0", "nix 0.29.0",
"png",
"qrcode", "qrcode",
"rand 0.8.8", "rand 0.8.8",
"rcgen", "rcgen",
@@ -2801,6 +3057,7 @@ dependencies = [
"tokio-tungstenite", "tokio-tungstenite",
"webrtc", "webrtc",
"x11rb", "x11rb",
"zbus",
] ]
[[package]] [[package]]
@@ -2811,6 +3068,7 @@ checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606"
dependencies = [ dependencies = [
"getrandom 0.4.3", "getrandom 0.4.3",
"js-sys", "js-sys",
"serde_core",
"wasm-bindgen", "wasm-bindgen",
] ]
@@ -3258,6 +3516,15 @@ version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
name = "winnow"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c3b93199df0ab874cdf0c6a94f0a0dc3423fe41f1cafb62b8bd7b1deb277aef"
dependencies = [
"memchr",
]
[[package]] [[package]]
name = "writeable" name = "writeable"
version = "0.6.4" version = "0.6.4"
@@ -3345,6 +3612,71 @@ dependencies = [
"synstructure 0.14.0", "synstructure 0.14.0",
] ]
[[package]]
name = "zbus"
version = "5.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907"
dependencies = [
"async-broadcast",
"async-recursion",
"async-trait",
"enumflags2",
"event-listener",
"futures-core",
"futures-lite",
"hex",
"libc",
"ordered-stream",
"rustix",
"serde",
"serde_repr",
"tokio",
"tracing",
"uds_windows",
"uuid",
"windows-sys 0.61.2",
"winnow",
"zbus_macros",
"zbus_names",
"zvariant",
]
[[package]]
name = "zbus_macros"
version = "5.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 3.0.9",
"zbus_names",
"zvariant",
"zvariant_utils",
]
[[package]]
name = "zbus_names"
version = "4.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "812a12be4ead7a59e18ea8f047d08add0066b73bc62fc1467066a2472ae088dd"
dependencies = [
"serde",
"winnow",
"zvariant",
]
[[package]]
name = "zcheapstr"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "939f186d9ecebe044315a5cb6d6f78568bbc21152adc954d5a0c2f58bdbc9920"
dependencies = [
"serde",
]
[[package]] [[package]]
name = "zerocopy" name = "zerocopy"
version = "0.8.62" version = "0.8.62"
@@ -3450,3 +3782,44 @@ name = "zmij"
version = "1.0.23" version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
[[package]]
name = "zvariant"
version = "5.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "80bf6d6cd6a4b601acb64cfb8284cdc643fcfa75ef26ae3c46ec8aa4e8a1fbb7"
dependencies = [
"endi",
"enumflags2",
"serde",
"winnow",
"zcheapstr",
"zvariant_derive",
"zvariant_utils",
]
[[package]]
name = "zvariant_derive"
version = "5.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef2672456ba1cb54b5eaec136e63135b3c7495fb938e53b28a62e633496d486d"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 3.0.9",
"zvariant_utils",
]
[[package]]
name = "zvariant_utils"
version = "4.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3"
dependencies = [
"proc-macro2",
"quote",
"serde",
"syn 3.0.9",
"winnow",
]
+5 -2
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.46" version = "0.2.58"
edition = "2021" edition = "2021"
default-run = "uuremote-server" default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"] authors = ["uu-remote-linux contributors"]
@@ -23,7 +23,7 @@ required-features = ["native-viewer"]
default = [] default = []
native-viewer = [] native-viewer = []
viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"] viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"]
viewer-sdl = ["native-viewer", "dep:sdl2", "dep:ab_glyph"] viewer-sdl = ["native-viewer", "dep:sdl2", "dep:ab_glyph", "dep:png"]
wayland = [] wayland = []
# Experimental direct linear framebuffer capture; never enabled in release builds. # Experimental direct linear framebuffer capture; never enabled in release builds.
kms = [] kms = []
@@ -38,6 +38,7 @@ inproc-av = ["dep:x11rb"]
tokio = { version = "1", features = ["full"] } tokio = { version = "1", features = ["full"] }
tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] } tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] }
futures-util = "0.3" futures-util = "0.3"
zbus = { version = "5", default-features = false, features = ["tokio"] }
serde = { version = "1.0", features = ["derive"] } serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0" serde_json = "1.0"
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "rustls-tls-native-roots"] } reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "rustls-tls-native-roots"] }
@@ -60,8 +61,10 @@ x11rb = { version = "0.13", features = ["damage", "shm", "allow-unsafe-code"], o
sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] } sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] }
ab_glyph = { version = "0.2", optional = true } ab_glyph = { version = "0.2", optional = true }
png = { version = "0.18", optional = true }
[dev-dependencies] [dev-dependencies]
tokio = { version = "1", features = ["test-util"] }
# Synthetic loopback WSS certificates only; both crates already occur in Cargo.lock. # Synthetic loopback WSS certificates only; both crates already occur in Cargo.lock.
rcgen = "0.11.3" rcgen = "0.11.3"
tokio-rustls = { version = "0.26.6", default-features = false, features = ["ring", "tls12"] } tokio-rustls = { version = "0.26.6", default-features = false, features = ["ring", "tls12"] }
+23 -6
View File
@@ -25,6 +25,14 @@
## Appearance / 外观 ## Appearance / 外观
Launcher icons use the system icon theme instead of emoji glyphs, so they do not depend on emoji font coverage.
Signed-in graphical hosts report the system wallpaper for disconnected device cards in official clients
(no desktop-window screenshot). GNOME/Cinnamon, KDE, Xfce and Omarchy on Hyprland are supported (following the current wallpaper); checks run every 60 seconds
and unchanged content is not uploaded again. Other desktops can set `UU_WALLPAPER=/absolute/path/image.png`
(PNG/JPEG/WebP). Set `UU_WALLPAPER_UPLOAD=0` to disable; guest and headless hosts skip reporting.
See [protocol evidence and limitations](docs/wallpaper-protocol.md).
Choose **System / Light / Dark** (default: System) in the viewer's **Settings → General → Appearance**, or via the gear settings button in host / tool windows. Choose **System / Light / Dark** (default: System) in the viewer's **Settings → General → Appearance**, or via the gear settings button in host / tool windows.
The choice is saved to `$XDG_CONFIG_HOME/uuremote/theme` (default `~/.config/uuremote/theme`). The choice is saved to `$XDG_CONFIG_HOME/uuremote/theme` (default `~/.config/uuremote/theme`).
@@ -69,10 +77,11 @@ Protocol strings and messages that come from the UU servers are shown as the ser
| 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) | | 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) | | Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
| Clipboard | Two-way text sync; Wayland mobile IME text inputs use clipboard paste fallback (see below) | | Clipboard | Two-way text sync; Wayland mobile IME text inputs use clipboard paste fallback (see below) |
| Viewer annotation | Strokes drawn with 「批注」 (annotate) in the viewer's watch mode appear on the Linux screen and stream back to the viewer (X11, needs a compositing manager; the overlay lets clicks through); cleared when annotation is turned off or the viewer disconnects. Verified with the Mac viewer 4.42.0; mobile viewers untested |
| 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 | | 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 | | Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
| File transfer | Upload, download (including folders), create folder, rename, delete | | File transfer | Upload, download (including folders), create folder, rename, delete; iOS quick uploads use the default receive directory (the current user’s home) |
| Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename | | Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename, termination and automatic list refresh; input and detach messages from an old connection cannot affect a reattached session |
| Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked | | Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked |
| Lock after remote session | Stored on the host, so it still applies after reconnecting | | Lock after remote session | Stored on the host, so it still applies after reconnecting |
| Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards | | Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards |
@@ -119,6 +128,8 @@ The host also accepts a desktop connection while GNOME is locked with no Portal
Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Desktop input is blocked and real video is hidden while locked or when lock state is unknown. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path. Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Desktop input is blocked and real video is hidden while locked or when lock state is unknown. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path.
Lock monitoring reads logind `LockedHint` over the system D-Bus and subscribes to changes instead of spawning `loginctl` every second. Without a graphical session it stays subscribed with unknown state, so login signals trigger a fresh read. It reconciles the session over D-Bus every 30 seconds; if D-Bus fails, it retries with a bounded `loginctl` fallback every 30 seconds, resolving the executable path once. Notifications may be delayed during fallback; unreadable state remains unknown. The locker must still report its state to logind. Suspend, locking and remote connection policies are unchanged.
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. 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. 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. 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.
@@ -151,8 +162,8 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18
| 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 | | 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 | | HDR | Not implemented |
| Super screen / virtual display | Not implemented | | Super screen / virtual display | Not implemented |
| Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; see [docs/privacy-screen.md](docs/privacy-screen.md) | | Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; `UU_PRIVACY_AUTO=picture` / `screen-off` enables it automatically on desktop connect; see [docs/privacy-screen.md](docs/privacy-screen.md) |
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) | | Microphone (viewer audio played on the host) | Experimental: Opus to a virtual input with `UU_MICROPHONE=1`; supports PulseAudio / PipeWire-pulse, see [notes](docs/remote-microphone.md) |
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist | | 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 | | Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested | | Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
@@ -385,17 +396,18 @@ Common environment variables:
| `UU_X11_OUTPUT` | Initial X11 monitor name (`xrandr --listmonitors`); default: the primary | | `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_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_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` |
| `UU_PORTAL_CURSOR_MODE` | Startup cursor mode: `embedded` draws the compositor pointer into the stream; hidden by default. The host switches at runtime as the viewer sends relative or absolute motion. A switch rebuilds the portal session and interrupts picture and input for a moment |
| `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows | | `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 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_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_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_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default matches libx264, one second of the bitrate cap within 500-8000 kbit, so high-resolution keyframes no longer blur and flicker once per GOP (#103). Set a small value (e.g. `50`) for a smaller low-latency buffer on a weak link |
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix | | `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source | | `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) | | `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
| `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) | | `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) |
| `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing | | `UU_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_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_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 (verified end to end with a headless Linux host on a NAS and the official iOS controller) |
| `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` | Share environment HTTP/HTTPS proxy policy between REST and host/viewer WebSocket signaling; proxies are ignored by default |
@@ -458,6 +470,7 @@ flowchart LR
## Security and privacy ## Security and privacy
- By default, signed-in graphical hosts upload the current wallpaper image to UU's file service for device-card backgrounds. Set `UU_WALLPAPER_UPLOAD=0` to disable this upload.
- Logs never contain keystrokes, terminal text, clipboard contents, file contents, passwords or tokens. - Logs never contain keystrokes, terminal text, clipboard contents, file contents, passwords or tokens.
- For auto unlock the password is stored in the **viewer** (the official client). The host only checks it - For auto unlock the password is stored in the **viewer** (the official client). The host only checks it
once with PAM; it is never written to disk or logs. once with PAM; it is never written to disk or logs.
@@ -604,6 +617,10 @@ separate from the host `uuremote-server`; the default host build and behaviour a
terminal emulator (`TERMINAL` selects one). From source: `sudo apt install libsdl2-dev`, then terminal emulator (`TERMINAL` selects one). From source: `sudo apt install libsdl2-dev`, then
`cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`. `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`.
Key combinations use the left/right modifier state attached to each SDL key event. Focus loss releases remote keys; after focus returns, the next non-modifier key restores any still-held Shift/Ctrl/Alt/Win (Command on Mac). This is built in, with no adapter or setting required.
The viewer mirrors remote PNG pointer shapes (including text and window-resize cursors) with their hotspots. Leaving the remote picture or opening local controls restores the local arrow.
SDL clipboard access reuses the desktop window to avoid temporary-window Dock churn on GNOME Wayland (#37). SDL clipboard access reuses the desktop window to avoid temporary-window Dock churn on GNOME Wayland (#37).
On niri, data-control-capable `wl-clipboard` is used instead, so synchronization does not require window focus. 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 Other SDL backends synchronize only while that window is focused. The 30 KiB text limit applies. Selections without a supported
+19 -6
View File
@@ -21,6 +21,10 @@
## 外观 / Appearance ## 外观 / Appearance
启动器图标使用系统主题的符号图标,避免缺少 emoji 字体时显示方框。
已登录的图形主机会上报系统壁纸,供官方客户端的设备卡片在未连接时显示背景图(不是桌面窗口截图)。支持 GNOME/Cinnamon、KDE、Xfce 和 Hyprland 下的 Omarchy(自动跟随当前壁纸);每 60 秒检查一次,内容不变则不重复上传。其他桌面可用 `UU_WALLPAPER=/绝对路径/图片.png` 指定 PNG/JPEG/WebP;`UU_WALLPAPER_UPLOAD=0` 关闭。访客和无桌面模式跳过上报。协议依据与限制见 [设备壁纸上报](docs/wallpaper-protocol.md)。
在控制端的 **设置 → 常规 → 外观**,或主机 / 工具窗口的齿轮设置按钮中选择 **跟随系统 / 浅色 / 深色**(默认跟随系统)。 在控制端的 **设置 → 常规 → 外观**,或主机 / 工具窗口的齿轮设置按钮中选择 **跟随系统 / 浅色 / 深色**(默认跟随系统)。
选择保存在 `$XDG_CONFIG_HOME/uuremote/theme`(默认 `~/.config/uuremote/theme`)。 选择保存在 `$XDG_CONFIG_HOME/uuremote/theme`(默认 `~/.config/uuremote/theme`)。
@@ -62,10 +66,11 @@ UU_LANG=en uuremote-server
| 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) | | 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) | | 鼠标指针样式 | 远端指针形状实时同步(X11) |
| 剪贴板 | 双向文本同步;Wayland 手机输入法输入通过剪贴板兜底粘贴,见下文 | | 剪贴板 | 双向文本同步;Wayland 手机输入法输入通过剪贴板兜底粘贴,见下文 |
| 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 Linux 屏幕上,并随画面传回控制端(X11,需要合成器;覆盖层不拦截鼠标);关闭批注或断开连接时清除。已用 Mac 控制端 4.42.0 实测,手机控制端未测 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 | | 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 | | 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 | | 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除;iOS 直接上传使用默认接收目录(当前用户的主目录) |
| 终端 | 官方「终端」工具,PTY 会话,支持多会话和重命名 | | 终端 | 官方「终端」工具,PTY 会话,支持多会话、重命名、结束会话和列表自动刷新;重连后旧连接的输入和断开消息不会影响当前会话 |
| 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 | | 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 |
| 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 | | 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 |
| 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 | | 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 |
@@ -109,6 +114,8 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏及锁状态未知时停止桌面输入并隐藏真实画面;独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。 无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏及锁状态未知时停止桌面输入并隐藏真实画面;独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。
锁屏状态优先通过系统 D-Bus 读取 logind 的 `LockedHint` 并监听变化,正常监测不按秒启动 `loginctl`。尚无图形会话时保持未知并继续监听,登录后由信号触发重新读取。每 30 秒通过 D-Bus 校验会话;D-Bus 异常时每 30 秒重试并使用带超时的 `loginctl` 回退查询,命令路径只解析一次。回退期间状态通知可能延迟;无法读取时保持未知。锁屏程序仍需正确上报 logind 状态,这不改变睡眠、锁屏或远程连接策略。
锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。 锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。
原生 Wayland 后端需要合成器提供 `wlr-output-power-management` 才能唤醒已关闭的屏幕;缺少该协议不影响采集和编码。视频启动及运行期间,屏幕保活失败仅记录警告并在下轮重试,不终止视频;实际采集、编码或发送错误仍按原逻辑处理。 原生 Wayland 后端需要合成器提供 `wlr-output-power-management` 才能唤醒已关闭的屏幕;缺少该协议不影响采集和编码。视频启动及运行期间,屏幕保活失败仅记录警告并在下轮重试,不终止视频;实际采集、编码或发送错误仍按原逻辑处理。
@@ -136,8 +143,8 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通
| 真彩(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,并如实回报给客户端 | | 真彩(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 | 未实现 | | HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 | | 超级屏 / 虚拟显示器 | 未实现 |
| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显,见 [docs/privacy-screen.md](docs/privacy-screen.md) | | 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) | | 麦克风(控制端声音传到被控端) | 实验性:Opus → 虚拟麦克风,需 `UU_MICROPHONE=1`;支持 PulseAudio / PipeWire-pulse,见 [说明](docs/remote-microphone.md) |
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 | | 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 | | Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 | | 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
@@ -352,17 +359,18 @@ systemctl --user restart uuremote-native.service
| `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 | | `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) | | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) |
| `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` | | `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` |
| `UU_PORTAL_CURSOR_MODE` | 启动时的光标模式:`embedded` 让合成器把指针画进抓屏流,默认隐藏。运行中按客户端发来的相对/绝对位移自动切换;每次切换重建一次 portal 会话,画面和输入短暂中断 |
| `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 | | `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 |
| `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_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_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_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认与 libx264 相同,取 1 秒码率上限并限制在 500–8000 kbit,高分辨率关键帧不再被压糊、按 GOP 周期闪烁(#103)。弱网下想要更小的低延迟缓冲可设小值(如 `50`) |
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg | | `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 | | `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 | | `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
| `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) | | `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) |
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) | | `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) | | `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) | | `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(已在 NAS 上的无头 Linux 主机配合官方 iOS 控制端实测可远程开机) |
| `UU_USE_PROXY=1` | REST API 与 host/viewer WebSocket 信令共用环境 HTTP/HTTPS 代理策略;默认忽略代理、直连 | | `UU_USE_PROXY=1` | REST API 与 host/viewer WebSocket 信令共用环境 HTTP/HTTPS 代理策略;默认忽略代理、直连 |
@@ -402,6 +410,7 @@ flowchart LR
## 安全与隐私 ## 安全与隐私
- 已登录的图形主机默认会将当前壁纸图片上传到 UU 的文件服务,供设备卡片显示背景;可用 `UU_WALLPAPER_UPLOAD=0` 关闭上传。
- 日志不记录键盘输入、终端内容、剪贴板内容、文件内容、密码和令牌。 - 日志不记录键盘输入、终端内容、剪贴板内容、文件内容、密码和令牌。
- 自动解锁的密码保存在**控制端**(官方客户端)里,被控端只拿来做一次 PAM 校验,不落盘、不写日志。 - 自动解锁的密码保存在**控制端**(官方客户端)里,被控端只拿来做一次 PAM 校验,不落盘、不写日志。
- 能连上这台机器的,只有登录了同一个 UU 账号的设备。请保管好你的 UU 账号。 - 能连上这台机器的,只有登录了同一个 UU 账号的设备。请保管好你的 UU 账号。
@@ -530,6 +539,10 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
`ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。 `ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。
从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。 从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。
组合键使用 SDL 按键事件携带的左右修饰键状态;窗口失焦时释放远端按键,重新聚焦后的下一次普通按键会恢复仍按住的 Shift/Ctrl/Alt/Win(Mac 为 Command)。此行为内置,无需适配库或开关。
控制端会同步远端以 PNG 发送的指针形状(如文本光标和窗口缩放箭头),并保留正确热点。离开远控画面或打开本地菜单时恢复本机箭头。
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。niri 改用支持 data-control 的 SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。niri 改用支持 data-control 的
`wl-clipboard`,不需要桌面窗口保持焦点;其他 SDL 后端仅在桌面窗口获得焦点时同步。 `wl-clipboard`,不需要桌面窗口保持焦点;其他 SDL 后端仅在桌面窗口获得焦点时同步。
保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。 保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。
+2
View File
@@ -3,6 +3,7 @@ fn main() {
println!("cargo:rerun-if-changed=c_engine/wayland_transform.h"); 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/portal_clipboard.inc");
println!("cargo:rerun-if-changed=c_engine/x11_engine.c"); println!("cargo:rerun-if-changed=c_engine/x11_engine.c");
println!("cargo:rerun-if-changed=c_engine/annotation_overlay.c");
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.c"); println!("cargo:rerun-if-changed=c_engine/uinput_keymap.c");
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.h"); println!("cargo:rerun-if-changed=c_engine/uinput_keymap.h");
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.c"); println!("cargo:rerun-if-changed=c_engine/nvenc_engine.c");
@@ -34,6 +35,7 @@ fn main() {
} }
let mut x11_build = cc::Build::new(); let mut x11_build = cc::Build::new();
x11_build.file("c_engine/x11_engine.c") x11_build.file("c_engine/x11_engine.c")
.file("c_engine/annotation_overlay.c")
.file("c_engine/uinput_keymap.c") .file("c_engine/uinput_keymap.c")
.file("c_engine/clipboard.c") .file("c_engine/clipboard.c")
.file("c_engine/pam_check.c"); .file("c_engine/pam_check.c");
+137
View File
@@ -0,0 +1,137 @@
// Viewer annotation (观看模式「批注」) overlay for X11 desktops.
//
// A full-screen, override-redirect ARGB window with an empty input shape: strokes from the
// viewer are drawn on it, the compositor blends it over the desktop (so the capture shows the
// strokes), and every pointer event passes through to the windows below. The window only
// exists while the viewer keeps annotation enabled. One thread owns each handle (Xlib is not
// initialized for threads here).
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/extensions/shape.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
Display *dpy;
Window win, root;
Colormap cmap;
GC gc;
int x, y, width, height;
int root_width, root_height;
} uu_annotation;
static int has_compositor(Display *dpy, int screen) {
char name[32];
snprintf(name, sizeof name, "_NET_WM_CM_S%d", screen);
Atom selection = XInternAtom(dpy, name, False);
return XGetSelectionOwner(dpy, selection) != None;
}
// Opens the overlay over the root region (x, y, width, height); width/height <= 0 = whole root.
// error: 1 display, 2 no compositing manager (an ARGB window would be opaque), 3 no 32-bit visual.
void *uu_annotation_open(const char *display, int x, int y, int width, int height, int *error) {
*error = 0;
Display *dpy = XOpenDisplay(display && *display ? display : NULL);
if (!dpy) { *error = 1; return NULL; }
int screen = DefaultScreen(dpy);
Window root = RootWindow(dpy, screen);
if (!has_compositor(dpy, screen)) { XCloseDisplay(dpy); *error = 2; return NULL; }
XVisualInfo info;
if (!XMatchVisualInfo(dpy, screen, 32, TrueColor, &info)) { XCloseDisplay(dpy); *error = 3; return NULL; }
if (width <= 0 || height <= 0) {
x = 0; y = 0;
width = DisplayWidth(dpy, screen);
height = DisplayHeight(dpy, screen);
}
Colormap cmap = XCreateColormap(dpy, root, info.visual, AllocNone);
XSetWindowAttributes attrs;
memset(&attrs, 0, sizeof attrs);
attrs.override_redirect = True;
attrs.background_pixel = 0;
attrs.border_pixel = 0;
attrs.colormap = cmap;
attrs.event_mask = ExposureMask | StructureNotifyMask;
Window win = XCreateWindow(dpy, root, x, y, (unsigned)width, (unsigned)height, 0, 32, InputOutput, info.visual,
CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWColormap | CWEventMask, &attrs);
// Empty input region: clicks, scrolls and hovers reach the windows below.
XShapeCombineRectangles(dpy, win, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted);
XStoreName(dpy, win, "uu-remote-linux annotation");
XClassHint hint = { "uu-remote-annotation", "uu-remote-linux" };
XSetClassHint(dpy, win, &hint);
// Keep the overlay composited (2 = never unredirect).
long bypass = 2;
XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_BYPASS_COMPOSITOR", False), XA_CARDINAL, 32,
PropModeReplace, (unsigned char *)&bypass, 1);
XMapRaised(dpy, win);
// Root ConfigureNotify reports RandR resizes, so the caller can rebuild at the new geometry.
XSelectInput(dpy, root, StructureNotifyMask);
GC gc = XCreateGC(dpy, win, 0, NULL);
XFlush(dpy);
uu_annotation *a = calloc(1, sizeof *a);
if (!a) { XFreeGC(dpy, gc); XDestroyWindow(dpy, win); XFreeColormap(dpy, cmap); XCloseDisplay(dpy); *error = 1; return NULL; }
a->dpy = dpy; a->win = win; a->root = root; a->cmap = cmap; a->gc = gc;
a->x = x; a->y = y; a->width = width; a->height = height;
a->root_width = DisplayWidth(dpy, screen); a->root_height = DisplayHeight(dpy, screen);
return a;
}
void uu_annotation_size(void *handle, int *width, int *height) {
uu_annotation *a = handle;
*width = a->width; *height = a->height;
}
// argb: premultiplied 0xAARRGGBB for the 32-bit visual. points: x0,y0,x1,y1,... in window pixels.
void uu_annotation_polyline(void *handle, const short *points, int count, unsigned int argb, int line_width) {
uu_annotation *a = handle;
if (count <= 0) return;
XSetForeground(a->dpy, a->gc, argb);
XSetLineAttributes(a->dpy, a->gc, line_width < 1 ? 1 : (unsigned)line_width, LineSolid, CapRound, JoinRound);
if (count == 1) {
int r = line_width / 2;
XFillArc(a->dpy, a->win, a->gc, points[0] - r, points[1] - r, (unsigned)line_width, (unsigned)line_width, 0, 360 * 64);
} else {
XDrawLines(a->dpy, a->win, a->gc, (XPoint *)points, count, CoordModeOrigin);
}
}
void uu_annotation_clear(void *handle) {
uu_annotation *a = handle;
XClearWindow(a->dpy, a->win);
}
void uu_annotation_flush(void *handle) {
uu_annotation *a = handle;
XRaiseWindow(a->dpy, a->win);
XFlush(a->dpy);
}
// Drains pending events: 2 when the root was resized (reopen the overlay), 1 when the window needs
// a full repaint (exposed or remapped), else 0.
int uu_annotation_poll(void *handle) {
uu_annotation *a = handle;
int result = 0;
while (XPending(a->dpy)) {
XEvent event;
XNextEvent(a->dpy, &event);
if (event.type == ConfigureNotify && event.xconfigure.window == a->root
&& (event.xconfigure.width != a->root_width || event.xconfigure.height != a->root_height)) {
a->root_width = event.xconfigure.width; a->root_height = event.xconfigure.height;
result = 2;
} else if (result == 0 && ((event.type == Expose && event.xexpose.count == 0) || event.type == MapNotify)) {
result = 1;
}
}
return result;
}
void uu_annotation_close(void *handle) {
uu_annotation *a = handle;
if (!a) return;
XFreeGC(a->dpy, a->gc);
XDestroyWindow(a->dpy, a->win);
XFreeColormap(a->dpy, a->cmap);
XCloseDisplay(a->dpy);
free(a);
}
+35 -4
View File
@@ -67,6 +67,7 @@ static void selection_owner(GDBusConnection *bus,const gchar *sender,const gchar
pthread_mutex_lock(&p->lock); pthread_mutex_lock(&p->lock);
g_free(p->clipboard_mime); p->clipboard_mime=selected; g_free(p->clipboard_mime); p->clipboard_mime=selected;
p->clipboard_changed=!owner && selected!=NULL; p->clipboard_revision++; p->clipboard_changed=!owner && selected!=NULL; p->clipboard_revision++;
p->clipboard_owns=owner?1:0;
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
if (types) g_variant_unref(types); if (types) g_variant_unref(types);
} }
@@ -100,16 +101,46 @@ int uu_portal_clipboard_set(struct uu_portal *p,const uint8_t *text,size_t lengt
if (!uu_portal_clipboard_ready(p) || length>CLIP_LIMIT || !g_utf8_validate((const char *)text,(gssize)length,NULL)) return -1; if (!uu_portal_clipboard_ready(p) || length>CLIP_LIMIT || !g_utf8_validate((const char *)text,(gssize)length,NULL)) return -1;
char *copy=g_malloc(length+1); memcpy(copy,text,length); copy[length]=0; char *copy=g_malloc(length+1); memcpy(copy,text,length); copy[length]=0;
pthread_mutex_lock(&p->lock); pthread_mutex_lock(&p->lock);
g_free(p->clipboard_text); p->clipboard_text=copy; p->clipboard_length=length; /* Serve the new text while the portal announces it, and restore the old one on failure. */
p->clipboard_changed=0; char *old_text=p->clipboard_text; size_t old_length=p->clipboard_length;
uint64_t revision=p->clipboard_revision;
p->clipboard_text=copy; p->clipboard_length=length; p->clipboard_changed=0;
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
const char *types[]={"text/plain;charset=utf-8","text/plain",NULL}; const char *types[]={"text/plain;charset=utf-8","text/plain",NULL};
GVariantBuilder options; g_variant_builder_init(&options,G_VARIANT_TYPE_VARDICT); GVariantBuilder options; g_variant_builder_init(&options,G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&options,"{sv}","mime_types",g_variant_new_strv(types,-1)); g_variant_builder_add(&options,"{sv}","mime_types",g_variant_new_strv(types,-1));
GVariant *reply=g_dbus_connection_call_sync(p->bus,DEST,PATH,CLIPBOARD,"SetSelection", GVariant *reply=g_dbus_connection_call_sync(p->bus,DEST,PATH,CLIPBOARD,"SetSelection",
g_variant_new("(o@a{sv})",p->session,g_variant_builder_end(&options)),NULL,G_DBUS_CALL_FLAGS_NONE,2000,NULL,NULL); g_variant_new("(o@a{sv})",p->session,g_variant_builder_end(&options)),NULL,G_DBUS_CALL_FLAGS_NONE,2000,NULL,NULL);
if (!reply) return -1; if (!reply) {
g_variant_unref(reply); return 0; pthread_mutex_lock(&p->lock);
g_free(p->clipboard_text);
p->clipboard_text=old_text; p->clipboard_length=old_length;
pthread_mutex_unlock(&p->lock);
return -1;
}
g_variant_unref(reply);
g_free(old_text);
pthread_mutex_lock(&p->lock);
/* Another owner may have been reported meanwhile; its newer state must win. */
if (p->clipboard_revision==revision) p->clipboard_owns=1;
pthread_mutex_unlock(&p->lock);
return 0;
}
/* Hand the text this session is providing to a replacement session, so a session swap (cursor
* mode, privacy screen, monitor switch) does not drop the viewer's clipboard. Transfers only
* while this session still owns the selection. Returns 0 transferred, 1 nothing to transfer. */
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to) {
if (!from || !to) return -1;
/* A session that ended cannot know whether a newer owner took the selection since. */
if (!uu_portal_alive(from)) return 1;
pthread_mutex_lock(&from->lock);
char *copy=(from->clipboard_owns && from->clipboard_text)?g_memdup2(from->clipboard_text,from->clipboard_length+1):NULL;
size_t length=from->clipboard_length;
pthread_mutex_unlock(&from->lock);
if (!copy) return 1;
int result=uu_portal_clipboard_set(to,(const uint8_t *)copy,length);
g_free(copy);
return result==0?0:-1;
} }
int uu_portal_clipboard_poll(struct uu_portal *p,uint8_t *out,size_t capacity) { int uu_portal_clipboard_poll(struct uu_portal *p,uint8_t *out,size_t capacity) {
if (!out || !uu_portal_clipboard_ready(p) || capacity<CLIP_LIMIT) return -1; if (!out || !uu_portal_clipboard_ready(p) || capacity<CLIP_LIMIT) return -1;
+92 -13
View File
@@ -38,7 +38,8 @@ struct uu_portal {
char *session; char *session;
char *restore_token; char *restore_token;
guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription, display_subscription; guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription, display_subscription;
int clipboard_enabled, clipboard_changed; int clipboard_enabled, clipboard_changed, clipboard_owns;
int cursor_available, cursor_applied;
char *clipboard_text, *clipboard_mime; char *clipboard_text, *clipboard_mime;
size_t clipboard_length; size_t clipboard_length;
uint64_t clipboard_revision; uint64_t clipboard_revision;
@@ -82,6 +83,13 @@ struct uu_portal {
static pthread_once_t pw_once = PTHREAD_ONCE_INIT; static pthread_once_t pw_once = PTHREAD_ONCE_INIT;
static atomic_uint token_sequence = 1; static atomic_uint token_sequence = 1;
/* Cursor preference for sessions opened from now on; -1 defers to UU_PORTAL_CURSOR_MODE. */
static atomic_int cursor_mode_override = -1;
void uu_portal_set_cursor_mode(int mode) { atomic_store(&cursor_mode_override, mode); }
/* Cursor mode the last session actually requested: 1 hidden, 2 embedded, 0 when unavailable. */
int uu_portal_cursor_mode(struct uu_portal *p) { return p ? p->cursor_applied : 0; }
/* Cursor modes the backend advertised for the last session; 0 when the property was unreadable. */
int uu_portal_cursor_modes(struct uu_portal *p) { return p ? p->cursor_available : 0; }
static void initialize_pipewire(void) { pw_init(NULL, NULL); } static void initialize_pipewire(void) { pw_init(NULL, NULL); }
static GVariant *empty_options(void) { return g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0); } static GVariant *empty_options(void) { return g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0); }
static int open_cancelled(struct uu_portal *p) { static int open_cancelled(struct uu_portal *p) {
@@ -89,10 +97,10 @@ static int open_cancelled(struct uu_portal *p) {
} }
static int wait_for_first_frame(struct uu_portal *p); static int wait_for_first_frame(struct uu_portal *p);
#include "portal_eis.inc" #include "portal_eis.inc"
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes); 0 when unreadable. */ /* A uint32 portal property; 0 when unreadable. */
static guint remote_property(struct uu_portal *p, const char *name) { static guint interface_property(struct uu_portal *p, const char *interface, const char *name) {
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH, GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, name), "org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", interface, name),
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL); G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
guint result = 0; guint result = 0;
if (reply) { if (reply) {
@@ -102,6 +110,10 @@ static guint remote_property(struct uu_portal *p, const char *name) {
} }
return result; return result;
} }
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes). */
static guint remote_property(struct uu_portal *p, const char *name) {
return interface_property(p, REMOTE, name);
}
static void fail(struct uu_portal *p, int error) { static void fail(struct uu_portal *p, int error) {
pthread_mutex_lock(&p->lock); pthread_mutex_lock(&p->lock);
if (!p->error) p->error = error; if (!p->error) p->error = error;
@@ -179,6 +191,8 @@ static void session_closed(GDBusConnection *bus, const gchar *sender, const gcha
const gchar *interface, const gchar *signal, GVariant *parameters, gpointer data) { const gchar *interface, const gchar *signal, GVariant *parameters, gpointer data) {
(void)bus; (void)sender; (void)path; (void)interface; (void)signal; (void)parameters; (void)bus; (void)sender; (void)path; (void)interface; (void)signal; (void)parameters;
struct uu_portal *p = data; struct uu_portal *p = data;
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
atomic_store(&p->closed, 1); fail(p, 9); atomic_store(&p->closed, 1); fail(p, 9);
} }
static void *run_dbus(void *data) { static void *run_dbus(void *data) {
@@ -558,7 +572,7 @@ static int wait_for_first_frame(struct uu_portal *p) {
while (!p->sequence && !p->error && !open_cancelled(p) && !(p->dma_requested && p->dma_bad)) { while (!p->sequence && !p->error && !open_cancelled(p) && !(p->dma_requested && p->dma_bad)) {
gint64 remaining = deadline - g_get_monotonic_time(); gint64 remaining = deadline - g_get_monotonic_time();
if (remaining <= 0) break; if (remaining <= 0) break;
clock_gettime(CLOCK_REALTIME, &until); clock_gettime(CLOCK_MONOTONIC, &until);
gint64 wait_us = MIN(100000, remaining); gint64 wait_us = MIN(100000, remaining);
until.tv_nsec += wait_us * 1000; until.tv_nsec += wait_us * 1000;
if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; } if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; }
@@ -594,8 +608,14 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
if (streams) g_variant_unref(streams); if (streams) g_variant_unref(streams);
return error; return error;
} }
static void save_restore_token(struct uu_portal *p, void (*save_token)(const char *, void *),
uu_portal_save_detailed_fn save_detailed, void *save_data) {
if (!p->restore_token) return;
if (save_token) save_token(p->restore_token, save_data);
if (save_detailed) save_detailed(p->restore_token, save_data, p->has_position, p->position_x, p->position_y);
}
static struct uu_portal *open_persist(const char *restore, void (*save_token)(const char *, void *), static struct uu_portal *open_persist(const char *restore, void (*save_token)(const char *, void *),
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, uu_portal_save_detailed_fn save_detailed, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height, uint32_t source_types) { int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height, uint32_t source_types) {
*error = 0; *width = *height = 0; *error = 0; *width = *height = 0;
struct uu_portal *p = calloc(1, sizeof(*p)); struct uu_portal *p = calloc(1, sizeof(*p));
@@ -610,7 +630,12 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
for (gchar **desktop = desktops; *desktop; desktop++) for (gchar **desktop = desktops; *desktop; desktop++)
if (!g_ascii_strcasecmp(*desktop, "GNOME")) p->absolute_stream_pixels = 1; if (!g_ascii_strcasecmp(*desktop, "GNOME")) p->absolute_stream_pixels = 1;
g_strfreev(desktops); g_strfreev(desktops);
pthread_mutex_init(&p->lock, NULL); pthread_cond_init(&p->changed, NULL); pthread_mutex_init(&p->lock, NULL);
pthread_condattr_t cond_attr;
pthread_condattr_init(&cond_attr);
pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC);
pthread_cond_init(&p->changed, &cond_attr);
pthread_condattr_destroy(&cond_attr);
p->context = g_main_context_new(); g_main_context_push_thread_default(p->context); p->context = g_main_context_new(); g_main_context_push_thread_default(p->context);
p->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL); p->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!p->bus) { *error = 1; goto done; } if (!p->bus) { *error = 1; goto done; }
@@ -647,7 +672,23 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
/* 1 monitor; 4 virtual (KDE creates a KWin virtual output for the stream). */ /* 1 monitor; 4 virtual (KDE creates a KWin virtual output for the stream). */
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(source_types)); g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(source_types));
g_variant_builder_add(&options, "{sv}", "multiple", g_variant_new_boolean(FALSE)); g_variant_builder_add(&options, "{sv}", "multiple", g_variant_new_boolean(FALSE));
/* Hidden cursor avoids duplicate pointer; supported since ScreenCast v1. */ /* Hidden cursor avoids a duplicate pointer in absolute mode: the viewer draws its own where
* it last sent motion. Relative mode has no such position, so the game's cursor has to come
* from the compositor. The host flips this at runtime through uu_portal_set_cursor_mode();
* UU_PORTAL_CURSOR_MODE=embedded is the startup default. Only sent when the backend
* advertises embedded, since an unsupported value closes the session. */
int cursor_mode = atomic_load(&cursor_mode_override);
if (cursor_mode < 0) {
const char *wanted = g_getenv("UU_PORTAL_CURSOR_MODE");
cursor_mode = (wanted && !g_ascii_strcasecmp(wanted, "embedded")) ? 2 : 1;
}
/* The host reads these back so its belief matches what the session actually requested. */
p->cursor_available = (int)interface_property(p, SCREEN, "AvailableCursorModes");
p->cursor_applied = 1;
if (cursor_mode == 2 && (p->cursor_available & 2)) {
g_variant_builder_add(&options, "{sv}", "cursor_mode", g_variant_new_uint32(2));
p->cursor_applied = 2;
}
results = request(p, SCREEN, "SelectSources", &options, 1, error); results = request(p, SCREEN, "SelectSources", &options, 1, error);
if (!results) goto done; if (!results) goto done;
g_variant_unref(results); g_variant_unref(results);
@@ -675,7 +716,7 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
fprintf(stderr, "Portal persistence: requested=%d restore_attempted=%d token_returned=%d\n", fprintf(stderr, "Portal persistence: requested=%d restore_attempted=%d token_returned=%d\n",
version >= 2, restore && *restore, p->restore_token && *p->restore_token); version >= 2, restore && *restore, p->restore_token && *p->restore_token);
} }
if (!*error && p->restore_token && save_token) save_token(p->restore_token, save_data); if (!*error) save_restore_token(p, save_token, save_detailed, save_data);
g_variant_unref(results); g_variant_unref(results);
if (*error) goto done; if (*error) goto done;
p->main_loop = g_main_loop_new(p->context, FALSE); p->main_loop = g_main_loop_new(p->context, FALSE);
@@ -708,21 +749,27 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore,
void (*save_token)(const char *, void *), void *save_data, void (*save_token)(const char *, void *), void *save_data,
uu_portal_cancelled_fn cancelled, void *cancel_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
int *error, uint32_t *width, uint32_t *height) { int *error, uint32_t *width, uint32_t *height) {
return open_persist(restore, save_token, save_data, cancelled, cancel_data, 0, error, width, height, 1); return open_persist(restore, save_token, NULL, save_data, cancelled, cancel_data, 0, error, width, height, 1);
} }
struct uu_portal *uu_portal_open_persist_capture(const char *restore, struct uu_portal *uu_portal_open_persist_capture(const char *restore,
void (*save_token)(const char *, void *), void *save_data, void (*save_token)(const char *, void *), void *save_data,
uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf,
int *error, uint32_t *width, uint32_t *height) { int *error, uint32_t *width, uint32_t *height) {
return open_persist(restore, save_token, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, 1); return open_persist(restore, save_token, NULL, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, 1);
} }
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *), struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *),
void *data, int *error, uint32_t *width, uint32_t *height) { void *data, int *error, uint32_t *width, uint32_t *height) {
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height, 1); return open_persist(restore, save_token, NULL, data, NULL, NULL, 0, error, width, height, 1);
} }
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *), struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *),
void *data, int *error, uint32_t *width, uint32_t *height) { void *data, int *error, uint32_t *width, uint32_t *height) {
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height, 4); return open_persist(restore, save_token, NULL, data, NULL, NULL, 0, error, width, height, 4);
}
struct uu_portal *uu_portal_open_detailed(const char *restore, uu_portal_save_detailed_fn save_token,
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf,
uint32_t source_types, int *error, uint32_t *width, uint32_t *height) {
if (source_types != 1 && source_types != 4) { *error = 3; *width = *height = 0; return NULL; }
return open_persist(restore, NULL, save_token, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, source_types);
} }
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height) { struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height) {
return uu_portal_open_persist(restore, NULL, NULL, error, width, height); return uu_portal_open_persist(restore, NULL, NULL, error, width, height);
@@ -820,6 +867,36 @@ int uu_portal_capture_alive(struct uu_portal *p) {
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
return alive; return alive;
} }
int uu_portal_wait_frame(struct uu_portal *p, int64_t timeout_us) {
if (!p || atomic_load(&p->closed)) return -1;
pthread_mutex_lock(&p->lock);
if (p->error || atomic_load(&p->closed) || stream_stalled(p)) {
pthread_mutex_unlock(&p->lock);
return -1;
}
uint64_t prev_seq = p->sequence;
if (timeout_us <= 0) {
int ready = (p->sequence != prev_seq);
pthread_mutex_unlock(&p->lock);
return ready;
}
struct timespec until;
clock_gettime(CLOCK_MONOTONIC, &until);
until.tv_sec += timeout_us / 1000000LL;
until.tv_nsec += (long)(timeout_us % 1000000LL) * 1000L;
if (until.tv_nsec >= 1000000000L) {
until.tv_sec += 1;
until.tv_nsec -= 1000000000L;
}
while (p->sequence == prev_seq && !p->error && !atomic_load(&p->closed) && !stream_stalled(p)) {
int rc = pthread_cond_timedwait(&p->changed, &p->lock, &until);
if (rc != 0) break; // timeout or error
}
int res = (p->error || atomic_load(&p->closed) || stream_stalled(p)) ? -1 :
(p->sequence != prev_seq) ? 1 : 0;
pthread_mutex_unlock(&p->lock);
return res;
}
void uu_portal_input_dispatch(struct uu_portal *p) { void uu_portal_input_dispatch(struct uu_portal *p) {
if (p->ei) portal_eis_dispatch(p); if (p->ei) portal_eis_dispatch(p);
} }
@@ -985,6 +1062,8 @@ int uu_portal_monitors(char *out, size_t length) {
* captures then report a closed stream until the handle is replaced. */ * captures then report a closed stream until the handle is replaced. */
void uu_portal_end(struct uu_portal *p) { void uu_portal_end(struct uu_portal *p) {
if (!p || atomic_exchange(&p->closed, 1)) return; if (!p || atomic_exchange(&p->closed, 1)) return;
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
if (p->bus && p->session) { if (p->bus && p->session) {
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, p->session, SESSION, "Close", GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, p->session, SESSION, "Close",
NULL, NULL, G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL); NULL, NULL, G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
+15
View File
@@ -5,6 +5,9 @@
#include "dmabuf_frame.h" #include "dmabuf_frame.h"
struct uu_portal; struct uu_portal;
typedef int (*uu_portal_cancelled_fn)(void *data); typedef int (*uu_portal_cancelled_fn)(void *data);
typedef void (*uu_portal_save_detailed_fn)(const char *token, void *data, int has_position, int32_t x, int32_t y);
/* Reports the granted position alongside the rotated token before video initialization. */
struct uu_portal *uu_portal_open_detailed(const char *restore, uu_portal_save_detailed_fn save_token, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, uint32_t source_types, int *error, uint32_t *width, uint32_t *height);
/* One object owns one consent/session and one PipeWire stream. */ /* One object owns one consent/session and one PipeWire stream. */
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height); struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
/* Saves the rotated token immediately after Start, before video initialization. */ /* Saves the rotated token immediately after Start, before video initialization. */
@@ -15,13 +18,25 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (
/* Select the capture transport before connecting, including on same-process recovery. */ /* Select the capture transport before connecting, including on same-process recovery. */
struct uu_portal *uu_portal_open_persist_capture(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height); struct uu_portal *uu_portal_open_persist_capture(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height);
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height); struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height);
/* Cursor mode for subsequent sessions: 1 hidden, 2 embedded (the compositor draws the pointer
* into the stream). -1 restores the UU_PORTAL_CURSOR_MODE default. The host switches this at
* runtime because the viewer cannot draw a pointer of its own during relative motion. */
void uu_portal_set_cursor_mode(int mode);
/* What the last session requested and what the backend offered, for host bookkeeping. */
int uu_portal_cursor_mode(struct uu_portal *portal);
int uu_portal_cursor_modes(struct uu_portal *portal);
const char *uu_portal_restore_token(struct uu_portal *portal); const char *uu_portal_restore_token(struct uu_portal *portal);
void uu_portal_close(struct uu_portal *portal); void uu_portal_close(struct uu_portal *portal);
int uu_portal_clipboard_ready(struct uu_portal *portal); int uu_portal_clipboard_ready(struct uu_portal *portal);
int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length); int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length);
/* Offers the text `from` still owns to `to`; 0 transferred, 1 nothing to transfer. */
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to);
int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity); int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
int uu_portal_alive(struct uu_portal *portal); int uu_portal_alive(struct uu_portal *portal);
int uu_portal_capture_alive(struct uu_portal *portal); int uu_portal_capture_alive(struct uu_portal *portal);
/* Wait for a new frame or status change with a timeout in microseconds.
* Returns 1 if a new frame or status change occurred, 0 on timeout, <0 on closed/error. */
int uu_portal_wait_frame(struct uu_portal *portal, int64_t timeout_us);
void uu_portal_input_dispatch(struct uu_portal *portal); void uu_portal_input_dispatch(struct uu_portal *portal);
void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height); void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height);
void uu_portal_reset_frame(struct uu_portal *portal); void uu_portal_reset_frame(struct uu_portal *portal);
+3
View File
@@ -73,6 +73,9 @@ int uu_privacy_wallpaper_run(const char *image, const int *rects, int count) {
shown++; shown++;
} }
if (!shown) return 2; if (!shown) return 2;
/* Map the covers before reporting ready: the host marks them skip-taskbar through KWin right
after this line, and KWin can only list windows whose surfaces already exist. */
while (gtk_events_pending()) gtk_main_iteration_do(FALSE);
/* EOF follows the host process, including crashes, rather than its spawning worker thread. */ /* EOF follows the host process, including crashes, rather than its spawning worker thread. */
GIOChannel *host = g_io_channel_unix_new(0); GIOChannel *host = g_io_channel_unix_new(0);
guint watch = g_io_add_watch(host, G_IO_HUP | G_IO_ERR | G_IO_NVAL, host_closed, NULL); guint watch = g_io_add_watch(host, G_IO_HUP | G_IO_ERR | G_IO_NVAL, host_closed, NULL);
+32 -16
View File
@@ -73,6 +73,14 @@ static GtkWidget *label(const char *text, const char *cls) {
return l; return l;
} }
static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; } static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; }
static GtkWidget *icon(const char *name, int size) {
GtkWidget *image = gtk_image_new_from_icon_name(name, GTK_ICON_SIZE_BUTTON);
gtk_image_set_pixel_size(GTK_IMAGE(image), size); return image;
}
static GtkWidget *icon_button(const char *text, const char *name, const char *cls) {
GtkWidget *b = button(text, cls); gtk_button_set_image(GTK_BUTTON(b), icon(name, 17));
gtk_button_set_always_show_image(GTK_BUTTON(b), TRUE); return b;
}
static GtkWidget *hbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, spacing); } static GtkWidget *hbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, spacing); }
static GtkWidget *vbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, spacing); } static GtkWidget *vbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, spacing); }
static GtkWidget *platform_icon(int platform, int online) { static GtkWidget *platform_icon(int platform, int online) {
@@ -124,10 +132,12 @@ static void open_more(void) {
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(10); GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(10);
gtk_container_set_border_width(GTK_CONTAINER(box), 22); gtk_container_set_border_width(GTK_CONTAINER(box), 22);
gtk_box_pack_start(GTK_BOX(box), label(L("更多工具", "More tools"), "h2"), FALSE, FALSE, 6); 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 *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 *icons[] = {"folder-symbolic", "media-playback-start-symbolic", "utilities-terminal-symbolic", "network-wired-symbolic", "computer-symbolic", "view-refresh-symbolic", "system-shutdown-symbolic", "user-trash-symbolic"};
const char *kinds[] = {"file", "watch", "terminal", "portmap", "wol", "reboot", "shutdown", "unbind"}; const char *kinds[] = {"file", "watch", "terminal", "portmap", "wol", "reboot", "shutdown", "unbind"};
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
GtkWidget *b = gtk_button_new(), *line = hbox(10); add_class(b, "cardbtn"); GtkWidget *b = gtk_button_new(), *line = hbox(10); add_class(b, "cardbtn");
gtk_box_pack_start(GTK_BOX(line), icon(icons[i], 20), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(line), label("›", "hint"), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(line), label("›", "hint"), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(b), line); gtk_container_add(GTK_CONTAINER(b), line);
@@ -224,7 +234,8 @@ static void on_card(GtkButton *b, gpointer index) { (void)b; show_device(GPOINTE
static GtkWidget *nav_row(const char *icon, const char *text, const char *kind) { static GtkWidget *nav_row(const char *icon, const char *text, const char *kind) {
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(10); GtkWidget *row = gtk_list_box_row_new(), *line = hbox(10);
gtk_box_pack_start(GTK_BOX(line), label(icon, "devname"), FALSE, FALSE, 0); GtkWidget *image = gtk_image_new_from_icon_name(icon, GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(line), image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(line), label(text, "devname"), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(line), label(text, "devname"), TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(row), line); gtk_container_add(GTK_CONTAINER(row), line);
g_object_set_data_full(G_OBJECT(row), "kind", g_strdup(kind), g_free); g_object_set_data_full(G_OBJECT(row), "kind", g_strdup(kind), g_free);
@@ -298,7 +309,7 @@ static gboolean apply_devices(gpointer d) {
gtk_box_pack_start(GTK_BOX(all_box), card, FALSE, FALSE, 4); gtk_box_pack_start(GTK_BOX(all_box), card, FALSE, FALSE, 4);
} }
pthread_mutex_unlock(&d_lock); pthread_mutex_unlock(&d_lock);
gtk_list_box_insert(GTK_LIST_BOX(device_list), nav_row("◼", L("全部设备", "All devices"), "all"), -1); gtk_list_box_insert(GTK_LIST_BOX(device_list), nav_row("view-grid-symbolic", L("全部设备", "All devices"), "all"), -1);
gtk_widget_show_all(device_list); gtk_widget_show_all(all_box); gtk_widget_show_all(device_list); gtk_widget_show_all(all_box);
return G_SOURCE_REMOVE; return G_SOURCE_REMOVE;
} }
@@ -367,9 +378,10 @@ static GtkWidget *build_device(void) {
gtk_overlay_add_overlay(GTK_OVERLAY(preview), enter); gtk_overlay_add_overlay(GTK_OVERLAY(preview), enter);
gtk_box_pack_start(GTK_BOX(page), preview, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), preview, FALSE, FALSE, 0);
GtkWidget *tools = hbox(0); add_class(tools, "toolbar"); GtkWidget *tools = hbox(0); add_class(tools, "toolbar");
const char *names[] = {L("🗂 文件传输", "🗂 File transfer"), L("▶ 观看模式", "▶ Watch mode"), L("⌨ 终端", "⌨ Terminal"), L("⇄ 端口映射", "⇄ Port mapping"), "▦"}, *kinds[] = {"file", "watch", "terminal", "portmap", "more"}; const char *names[] = {L("文件传输", "File transfer"), L("观看模式", "Watch mode"), L("终端", "Terminal"), L("端口映射", "Port mapping"), L("更多", "More")}, *kinds[] = {"file", "watch", "terminal", "portmap", "more"};
const char *tool_icons[] = {"folder-symbolic", "media-playback-start-symbolic", "utilities-terminal-symbolic", "network-wired-symbolic", "view-more-symbolic"};
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
GtkWidget *b = button(names[i], "tool"); GtkWidget *b = icon_button(names[i], tool_icons[i], "tool");
g_signal_connect(b, "clicked", G_CALLBACK(on_tool), (gpointer)kinds[i]); g_signal_connect(b, "clicked", G_CALLBACK(on_tool), (gpointer)kinds[i]);
gtk_box_pack_start(GTK_BOX(tools), b, i < 4, TRUE, 0); gtk_box_pack_start(GTK_BOX(tools), b, i < 4, TRUE, 0);
if (i < 4) gtk_box_pack_start(GTK_BOX(tools), gtk_separator_new(GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0); if (i < 4) gtk_box_pack_start(GTK_BOX(tools), gtk_separator_new(GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
@@ -581,7 +593,7 @@ static void open_settings(void) {
GtkWidget *gscroll = gtk_scrolled_window_new(NULL, NULL); GtkWidget *gscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gscroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gscroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(gscroll), general); gtk_container_add(GTK_CONTAINER(gscroll), general);
gtk_stack_add_titled(GTK_STACK(tabs), gscroll, "general", L("⚙ 常规", "⚙ General")); gtk_stack_add_titled(GTK_STACK(tabs), gscroll, "general", L("常规", "General"));
// 安全 // 安全
GtkWidget *security = settings_page(); GtkWidget *security = settings_page();
const char *verify[] = {L("仅使用临时验证码", "Temporary code only"), L("仅使用自定义验证码", "Custom code only"), L("临时与自定义验证码", "Temporary and custom codes")}; const char *verify[] = {L("仅使用临时验证码", "Temporary code only"), L("仅使用自定义验证码", "Custom code only"), L("临时与自定义验证码", "Temporary and custom codes")};
@@ -593,7 +605,7 @@ static void open_settings(void) {
gtk_box_pack_start(GTK_BOX(security), settings_card(s1, 2), FALSE, FALSE, 0); 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(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), settings_card(s3, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), security, "security", L("🔒 安全", "🔒 Security")); gtk_stack_add_titled(GTK_STACK(tabs), security, "security", L("安全", "Security"));
// 键盘 // 键盘
GtkWidget *keys = settings_page(); GtkWidget *keys = settings_page();
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("仅控制端响应的快捷键", "Viewer-only shortcuts"), "h2"), FALSE, FALSE, 0);
@@ -608,13 +620,13 @@ static void open_settings(void) {
for (int i = 0; i < 8; i++) k2[i] = setting_row(fns[i], NULL, edit_button(fns[i])); 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); 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); GtkWidget *kscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(kscroll), keys);
gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", L("⌨ 键盘", "⌨ Keyboard")); gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", L("键盘", "Keyboard"));
// 网络 // 网络
GtkWidget *network = settings_page(); GtkWidget *network = settings_page();
const char *proxy[] = {L("使用系统环境代理", "Use system proxy"), L("不使用代理", "No proxy")}; const char *proxy[] = {L("使用系统环境代理", "Use system proxy"), L("不使用代理", "No proxy")};
GtkWidget *n1[] = { setting_row(L("代理设置", "Proxy"), NULL, combo(proxy, 2)) }; 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_box_pack_start(GTK_BOX(network), settings_card(n1, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), network, "network", L("🌐 网络", "🌐 Network")); gtk_stack_add_titled(GTK_STACK(tabs), network, "network", L("网络", "Network"));
gtk_box_pack_start(GTK_BOX(root), tabs, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(root), tabs, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(settings_window), root); gtk_container_add(GTK_CONTAINER(settings_window), root);
gtk_widget_show_all(settings_window); gtk_widget_show_all(settings_window);
@@ -669,18 +681,21 @@ static void *run(void *arg) {
GtkWidget *side = vbox(0); add_class(side, "sidebar"); gtk_widget_set_size_request(side, 270, -1); GtkWidget *side = vbox(0); add_class(side, "sidebar"); gtk_widget_set_size_request(side, 270, -1);
my_section = vbox(0); 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); 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(L("⧉ 我的设备", "⧉ My devices"), "section"), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(mh), icon("computer-symbolic", 17), FALSE, FALSE, 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); 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); 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); 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 *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 *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 *welcome_nav = gtk_list_box_new(); g_signal_connect(welcome_nav, "row-activated", G_CALLBACK(on_row), NULL);
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); GtkWidget *ah = hbox(8); 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(ah), icon("network-workgroup-symbolic", 17), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ah), label(L("远程协助", "Remote assistance"), "section"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(side_inner), ah, FALSE, FALSE, 0); 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); 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("◧", L("开始协助", "Start assistance"), "assist"), -1); gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("network-workgroup-symbolic", L("开始协助", "Start assistance"), "assist"), -1);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("★", L("收藏设备", "Favorites"), "favorite"), -1); gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("starred-symbolic", L("收藏设备", "Favorites"), "favorite"), -1);
gtk_box_pack_start(GTK_BOX(side_inner), assist, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(side_inner), assist, FALSE, FALSE, 0);
gtk_list_box_unselect_all(GTK_LIST_BOX(assist)); gtk_list_box_unselect_all(GTK_LIST_BOX(assist));
(void)welcome_nav; (void)welcome_nav;
@@ -691,12 +706,13 @@ static void *run(void *arg) {
GtkWidget *main = vbox(0), *header = hbox(10); add_class(header, "header"); GtkWidget *main = vbox(0), *header = hbox(10); add_class(header, "header");
badge = gtk_label_new(""); add_class(badge, "badge"); badge = gtk_label_new(""); add_class(badge, "badge");
title_label = label(L("全部设备", "All devices"), "title"); title_label = label(L("全部设备", "All devices"), "title");
more_button = button("⋮", "hbtn"); g_signal_connect(more_button, "clicked", G_CALLBACK(on_more), NULL); more_button = icon_button("", "view-more-symbolic", "hbtn"); gtk_widget_set_tooltip_text(more_button, L("设备信息", "Device information")); 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), badge, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), title_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(header), title_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), more_button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(header), more_button, FALSE, FALSE, 0);
const char *icons[] = {"☰", "◉", "🔔"}, *kinds[] = {"menu", "account", "notice"}; const char *icons[] = {"open-menu-symbolic", "avatar-default-symbolic", "preferences-system-notifications-symbolic"}, *kinds[] = {"menu", "account", "notice"};
for (int i = 0; i < 3; i++) { GtkWidget *b = button(icons[i], "hbtn"); g_signal_connect(b, "clicked", G_CALLBACK(popup), (gpointer)kinds[i]); gtk_box_pack_end(GTK_BOX(header), b, FALSE, FALSE, 0); } const char *tips[] = {L("菜单", "Menu"), L("账号", "Account"), L("通知", "Notifications")};
for (int i = 0; i < 3; i++) { GtkWidget *b = icon_button("", icons[i], "hbtn"); gtk_widget_set_tooltip_text(b, tips[i]); g_signal_connect(b, "clicked", G_CALLBACK(popup), (gpointer)kinds[i]); gtk_box_pack_end(GTK_BOX(header), b, FALSE, FALSE, 0); }
gtk_box_pack_start(GTK_BOX(main), header, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(main), header, FALSE, FALSE, 0);
GtkWidget *overlay = gtk_overlay_new(); GtkWidget *overlay = gtk_overlay_new();
stack = gtk_stack_new(); stack = gtk_stack_new();
+34 -60
View File
@@ -159,37 +159,10 @@ static size_t symbols_close(const char *text) {
} }
return 0; return 0;
} }
/* Named keycodes the keymap gives no symbol to. Reading the compositor's own list is the only /* Reusable codes for the separate text-only keyboard. Remapping real printable keys on that device
portable way: pressing an unmapped keycode types nothing, and uu_wl_key never matches one keeps the physical-key map untouched and is the form Chromium accepts; the evdev "reserved" codes
because it searches by keysym. Highest first, since uu_wl_key takes the lowest match. */ that have no symbol are discarded by some clients. */
static unsigned find_spare_codes(xkb_keycode_t *out,unsigned limit) { static unsigned find_spare_codes(xkb_keycode_t *out,unsigned limit) {
unsigned count=0;
xkb_keycode_t min=xkb_keymap_min_keycode(keymap);
for(xkb_keycode_t code=xkb_keymap_max_keycode(keymap);code>min && count<limit;code--) {
if(code<8 || code>=sizeof(held_keys) || !xkb_keymap_key_get_name(keymap,code)) continue;
int mapped=0;
for(xkb_level_index_t level=0;level<xkb_keymap_num_levels_for_key(keymap,code,0) && !mapped;level++) {
const xkb_keysym_t *syms;
if(xkb_keymap_key_get_syms_by_level(keymap,code,0,level,&syms)>0) mapped=1;
}
if(!mapped) out[count++]=code;
}
return count;
}
/* A keycode the session keymap already produces this symbol with, unshifted. Typing through it
needs no upload, so no client can mistranslate it - and it is how plain latin text and spaces
arrive without touching the keymap at all. Spares never match: the pristine keymap leaves them
unmapped. */
static xkb_keycode_t existing_keycode(xkb_keysym_t symbol) {
for(xkb_keycode_t code=xkb_keymap_min_keycode(keymap);code<=xkb_keymap_max_keycode(keymap);code++) {
if(code<8 || code>=sizeof(held_keys)) continue;
const xkb_keysym_t *syms;
if(xkb_keymap_key_get_syms_by_level(keymap,code,0,0,&syms)==1 && syms[0]==symbol) return code;
}
return 0;
}
static 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}; 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; unsigned count=0;
for(unsigned i=0;i<sizeof(text_codes)/sizeof(text_codes[0]) && count<limit;i++) for(unsigned i=0;i<sizeof(text_codes)/sizeof(text_codes[0]) && count<limit;i++)
@@ -216,8 +189,12 @@ static void release_held_keys_locked(void) {
key_state and held_keys: pressed and released here. */ 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) { 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(); release_held_keys_locked();
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);} if(sync_display()!=0) return -1;
else if(rekey_keyboard()!=0) return -1; usleep(8000);
/* A keymap re-sent on a keyboard the client already knows is not handed to it again, so the
next batch would still decode with the previous one and repeat it. Re-attaching the text
keyboard is what makes the compositor deliver the new keymap. */
if(rekey_keyboard()!=0) return -1;
size_t at=keymap_insert; size_t at=keymap_insert;
memcpy(buffer,keymap_text,at); memcpy(buffer,keymap_text,at);
for(unsigned i=0;i<count;i++) { for(unsigned i=0;i<count;i++) {
@@ -227,16 +204,16 @@ 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); 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(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); zwp_virtual_keyboard_v1_modifiers(keyboard,0,0,0,0);
if(sync_display()!=0) return -1; if(sync_display()!=0) return -1;
if(getenv("NIRI_SOCKET")) usleep(8000); usleep(8000);
for(unsigned i=0;i<count;i++) { press_keycode(codes[i]); (*typed)++; } for(unsigned i=0;i<count;i++) { press_keycode(codes[i]); (*typed)++; }
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);} if(sync_display()!=0) return -1;
return 0; return 0;
} }
/* Type UTF-8 like xdotool type does on X11, but on Wayland: characters the session keymap already /* Type UTF-8 like xdotool type does on X11: each character is a Unicode keysym carried by the
has go out as ordinary keycodes, the rest share the spares of one keymap upload (~70 KB, so one text-only keyboard's printable codes, one keymap upload (~70 KB, so one batch per upload) in text
batch per upload), in text order. Never logs the text. */ order. Never logs the text. */
static int type_utf8_locked(const char *text) { static int type_utf8_locked(const char *text) {
size_t capacity=keymap_text_len+(size_t)UU_TEXT_SPARE*96+64; size_t capacity=keymap_text_len+(size_t)UU_TEXT_SPARE*96+64;
char *buffer=malloc(capacity); char *buffer=malloc(capacity);
@@ -258,16 +235,11 @@ static int type_utf8_locked(const char *text) {
if(cp=='\n') sym=0xff0d; /* Return */ if(cp=='\n') sym=0xff0d; /* Return */
else if(cp=='\t') sym=0xff09; /* Tab */ else if(cp=='\t') sym=0xff09; /* Tab */
else if(cp<0x20 || cp==0x7f || (cp>=0x80 && cp<0xa0)) continue; /* controls carry no text */ else if(cp<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 */ /* Every character goes out as a Unicode keysym, including ASCII: a plain Latin-1 keysym
else sym=(xkb_keysym_t)(0x1000000|cp); /* Unicode keysym */ is what a running input method composes as pinyin, so "abc" would turn into candidates
xkb_keycode_t existing=getenv("NIRI_SOCKET")?0:existing_keycode(sym); instead of reaching the field. */
if(existing) { else sym=(xkb_keysym_t)(0x1000000|cp);
if(count && flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; } if(count==spare_count) {
count=0;
press_keycode(existing); typed++;
continue;
}
if(count==(getenv("NIRI_SOCKET")?spare_count:UU_TEXT_SPARE)) {
if(flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; } if(flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; }
count=0; count=0;
} }
@@ -278,23 +250,25 @@ static int type_utf8_locked(const char *text) {
} }
if(!failed && count) failed=flush_batch(buffer,capacity,names,codes,count,&typed)!=0; if(!failed && count) failed=flush_batch(buffer,capacity,names,codes,count,&typed)!=0;
free(buffer); free(buffer);
/* Restore the pristine keymap whatever happened above, so uu_wl_key keeps its own symbol map. */
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; return failed && !typed?-1:typed;
} }
int uu_wl_type_utf8(const char *text) { int uu_wl_type_utf8(const char *text) {
pthread_mutex_lock(&lock); pthread_mutex_lock(&lock);
int typed=-1; int typed=-1;
if(initialized && text && keymap_text && keymap_insert && spare_count) { if(initialized && text && keymap_text && keymap_insert && spare_count) {
if(getenv("NIRI_SOCKET")) { if(!keyboard_manager) { pthread_mutex_unlock(&lock); return -1; }
/* Only niri uses printable codes on a separate text device; preserve the Hyprland path. */ /* Text has its own device: remapping printable codes must not change physical-key input. */
release_held_keys_locked(); release_held_keys_locked();
struct zwp_virtual_keyboard_v1 *saved=keyboard; /* The original device stays alive, so key-up alone must not leave its modifiers held. */
keyboard=zwp_virtual_keyboard_manager_v1_create_virtual_keyboard(keyboard_manager,seat); zwp_virtual_keyboard_v1_modifiers(keyboard,
if(keyboard) {typed=type_utf8_locked(text);sync_display();usleep(8000);if(keyboard) zwp_virtual_keyboard_v1_destroy(keyboard);} xkb_state_serialize_mods(key_state,XKB_STATE_MODS_DEPRESSED),
keyboard=saved; xkb_state_serialize_mods(key_state,XKB_STATE_MODS_LATCHED),
} else typed=type_utf8_locked(text); xkb_state_serialize_mods(key_state,XKB_STATE_MODS_LOCKED),
xkb_state_serialize_layout(key_state,XKB_STATE_LAYOUT_EFFECTIVE));
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;
} }
if(typed>=0 && wl_display_flush(display)<0) typed=-1; if(typed>=0 && wl_display_flush(display)<0) typed=-1;
pthread_mutex_unlock(&lock); return typed; pthread_mutex_unlock(&lock); return typed;
@@ -597,7 +571,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 /* 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. */ only costs that path - uu_wl_type_utf8 refuses and the caller keeps its own fallback. */
keymap_insert=symbols_close(keymap_text); keymap_insert=symbols_close(keymap_text);
spare_count=getenv("NIRI_SOCKET")?find_niri_text_codes(spare_codes,UU_TEXT_SPARE):find_spare_codes(spare_codes,UU_TEXT_SPARE); spare_count=find_spare_codes(spare_codes,UU_TEXT_SPARE);
} }
initialized=1; *w=width; *h=height; result=0; initialized=1; *w=width; *h=height; result=0;
end: end:
+36 -4
View File
@@ -331,12 +331,30 @@ static int class_is_terminal(const char *value) {
return 0; return 0;
} }
/* Returns 1 when the focused window belongs to a terminal emulator, else 0. */ /* Returns 1 when the focused window belongs to a terminal emulator, else 0.
Cached by focused Window with a 1000ms TTL, so key bursts on the same window
avoid redundant 12-level XQueryTree walks, while focus changes invalidate immediately. */
int x11_terminal_shortcut_state(void) { int x11_terminal_shortcut_state(void) {
static Window cached_window = 0;
static int cached_terminal = 0;
static struct timespec last_query = {0, 0};
if (!g_probe && !(g_probe = XOpenDisplay(NULL))) return 0; if (!g_probe && !(g_probe = XOpenDisplay(NULL))) return 0;
Window focus = 0; int revert = 0; Window focus = 0; int revert = 0;
XGetInputFocus(g_probe, &focus, &revert); XGetInputFocus(g_probe, &focus, &revert);
if (focus == None || focus == PointerRoot) return 0; if (focus == None || focus == PointerRoot) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
long diff_ms = (now.tv_sec - last_query.tv_sec) * 1000 + (now.tv_nsec - last_query.tv_nsec) / 1000000;
if (focus == cached_window && last_query.tv_sec != 0 && diff_ms >= 0 && diff_ms < 1000) {
return cached_terminal;
}
Window cur = focus; Window cur = focus;
for (int depth = 0; depth < 12 && cur; depth++) { for (int depth = 0; depth < 12 && cur; depth++) {
XClassHint hint = {0}; XClassHint hint = {0};
@@ -344,14 +362,28 @@ int x11_terminal_shortcut_state(void) {
int terminal = class_is_terminal(hint.res_name) || class_is_terminal(hint.res_class); int terminal = class_is_terminal(hint.res_name) || class_is_terminal(hint.res_class);
if (hint.res_name) XFree(hint.res_name); if (hint.res_name) XFree(hint.res_name);
if (hint.res_class) XFree(hint.res_class); if (hint.res_class) XFree(hint.res_class);
cached_window = focus;
cached_terminal = terminal;
last_query = now;
return terminal; return terminal;
} }
Window root, parent, *children = NULL; unsigned int n = 0; Window root, parent, *children = NULL; unsigned int n = 0;
if (!XQueryTree(g_probe, cur, &root, &parent, &children, &n)) return 0; if (!XQueryTree(g_probe, cur, &root, &parent, &children, &n)) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
if (children) XFree(children); if (children) XFree(children);
if (parent == root) return 0; if (parent == root) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
cur = parent; cur = parent;
} }
cached_window = focus;
cached_terminal = 0;
last_query = now;
return 0; return 0;
} }
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env python3
"""Run the opt-in microphone sink-loss regression on a private PulseAudio daemon.
No hardware modules or default configuration are loaded. The Rust test generates
audio in memory and observes only its own null sinks. Requires pactl and parec.
在独立 PulseAudio 服务中运行麦克风回归;仅使用空设备及内存生成音,需要 pactl、parec。
"""
import argparse
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import time
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--daemon", default=shutil.which("pulseaudio"), help="PulseAudio 可执行文件 / PulseAudio executable")
parser.add_argument("--module-dir", help="解压包的模块目录 / module directory for an unpacked package")
parser.add_argument("--test-binary", help="已有 Cargo 测试程序;默认构建 / existing Cargo test executable; otherwise build")
parser.add_argument("--smoke", action="store_true", help="验证生成音传输 / check generated audio delivery instead of target loss")
args = parser.parse_args()
if not args.daemon:
parser.error("请用 --daemon 指定 PulseAudio,无需系统服务 / provide --daemon; no system service is needed")
repo = Path(__file__).resolve().parent.parent
with tempfile.TemporaryDirectory(prefix="uu-microphone-test-") as temp:
private = Path(temp)
for name in ["runtime", "state", "config", "cache"]:
(private / name).mkdir(mode=0o700)
cookie = private / "cookie"
cookie.write_bytes(os.urandom(256))
socket = private / "runtime/native"
env = os.environ.copy()
env.update(
XDG_RUNTIME_DIR=str(private / "runtime"), XDG_CONFIG_HOME=str(private / "config"),
XDG_STATE_HOME=str(private / "state"), XDG_CACHE_HOME=str(private / "cache"),
PULSE_RUNTIME_PATH=str(private / "runtime"), PULSE_STATE_PATH=str(private / "state"),
PULSE_COOKIE=str(cookie), PULSE_SERVER="unix:" + str(socket), UU_MICROPHONE_ISOLATED_TEST="1",
UU_MICROPHONE="1",
)
command = [args.daemon, "-n", "--daemonize=no", "--use-pid-file=no", "--exit-idle-time=-1",
"--disable-shm=yes", "--realtime=no", "--high-priority=no",
"--load=module-native-protocol-unix socket=" + str(socket)
+ " auth-anonymous=1 auth-cookie=" + str(cookie)]
if args.module_dir:
command.append("--dl-search-path=" + args.module_dir)
with (private / "daemon.log").open("w") as log:
daemon = subprocess.Popen(command, env=env, stdout=log, stderr=log)
try:
for _ in range(100):
if daemon.poll() is not None:
raise RuntimeError("独立服务启动失败 / isolated server failed:\n" + (private / "daemon.log").read_text()[-2000:])
if socket.exists() and subprocess.run(
["pactl", "--server=" + env["PULSE_SERVER"], "info"], env=env,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
).returncode == 0:
break
time.sleep(0.03)
else:
raise RuntimeError("独立 PulseAudio 未就绪 / isolated PulseAudio did not become ready")
test = "microphone::tests::pulse_target_loss_never_routes_to_default_output"
if args.smoke:
test = "microphone::tests::pipewire_virtual_microphone_receives_generated_tone"
if args.test_binary:
command = [str(Path(args.test_binary).resolve()), test, "--ignored", "--exact"]
else:
command = ["cargo", "test", "--locked", "--bin", "uuremote-server", test,
"--", "--ignored", "--exact"]
listing = subprocess.run(command + ["--list", "--color=never"], cwd=repo, env=env,
capture_output=True, text=True)
if listing.returncode:
print(listing.stderr, file=sys.stderr)
return listing.returncode
if f"{test}: test" not in listing.stdout.splitlines():
parser.error("目标测试不存在,拒绝零项成功 / requested test is absent; refusing a zero-test success")
return subprocess.run(command, cwd=repo, env=env).returncode
finally:
if daemon.poll() is None:
daemon.terminate()
try:
daemon.wait(timeout=3)
except subprocess.TimeoutExpired:
daemon.kill()
daemon.wait()
if __name__ == "__main__":
raise SystemExit(main())
+25
View File
@@ -30,6 +30,13 @@ is aimed at the virtual output's region. Needs GTK3.
`portal-permissions/kde-virtual`)。窗口会被 KWin 移到虚拟屏,恢复后位置可能变化。 `portal-permissions/kde-virtual`)。窗口会被 KWin 移到虚拟屏,恢复后位置可能变化。
The virtual size is KDE's (1920x1080 by default; the first share may ask on the host, later ones The virtual size is KDE's (1920x1080 by default; the first share may ask on the host, later ones
reuse `portal-permissions/kde-virtual`). KWin moves windows to it; positions may change on restore. reuse `portal-permissions/kde-virtual`). KWin moves windows to it; positions may change on restore.
- 壁纸模式下新出现的窗口也会被送到虚拟输出:KWin 按它认为"当前活动"的屏幕放置新窗口,而那块
屏幕可能是遮罩下的物理屏,远端就看不到。主机在防窥期间保持加载一个 KWin 脚本,新窗口和换了
屏幕的窗口都会被送回虚拟输出,恢复时卸载。
In wallpaper mode, windows that appear later are also sent to the virtual output: KWin places a
new window on the screen it considers active, which may be one under the cover, where the viewer
cannot see it. The host keeps a KWin script loaded for the privacy session that sends new windows
and windows that changed screen back to the virtual output, and unloads it on restore.
- KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput` - KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput`
权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。 权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。
KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the
@@ -44,6 +51,20 @@ is aimed at the virtual output's region. Needs GTK3.
`UU_PRIVACY_BLOCK_INPUT=0` to keep local input. KWin saves the device flag, so a `privacy-guard` `UU_PRIVACY_BLOCK_INPUT=0` to keep local input. KWin saves the device flag, so a `privacy-guard`
child restores devices and outputs from the record whenever the host ends, including SIGKILL; the child restores devices and outputs from the record whenever the host ends, including SIGKILL; the
next start retries too. Devices plugged in during privacy are not blocked. next start retries too. Devices plugged in during privacy are not blocked.
- 自动开启:`UU_PRIVACY_AUTO=picture`(或 `2`)在第一个桌面控制端连上后自动启用隐私屏保,
`UU_PRIVACY_AUTO=screen-off`(或 `3`)自动关屏;默认关闭。远程协助(访客)的桌面会话同样适用。
控制端自己的请求优先:一次会话里只要客户端发过隐私请求(包括连接刚建立、会话计数还没开始的
那一刻),待执行的自动开启就不再触发;断开后照常恢复。主机不支持或依赖缺失时只记日志,不影响连接。
自动开启后主机会向控制端推送一次 SystemMetrics 和 SystemStateChange,控制端菜单随之更新。支持的主机上,
每次桌面连接也会先推送一次当前状态(关闭时为关闭),这是新增的主动上报。
Auto: `UU_PRIVACY_AUTO=picture` (or `2`) enables picture mode when the first desktop controller
connects; `screen-off` (or `3`) turns the physical screens off. Off by default. Remote-assistance
(guest) desktop sessions are covered too. The viewer's own request wins for that session, including
one that arrives right after the connection opens and before the session counter starts: a pending
auto-enable then does not run, and a disconnect restores as usual. Unsupported hosts or missing
tools only log; the connection is unaffected. After an auto-enable the host pushes SystemMetrics
and SystemStateChange once, so the viewer's menu follows; on supported hosts every desktop
connection also pushes the current state first (off when it is off), which is new outbound traffic.
- 这是尽力而为的遮挡,不是保密边界。/ This is best-effort obscuring, not a confidentiality boundary. - 这是尽力而为的遮挡,不是保密边界。/ This is best-effort obscuring, not a confidentiality boundary.
- 恢复记录保存在配置文件旁的 `privacy-power.json`(0600);崩溃后下次启动重新启用记录的物理屏。 - 恢复记录保存在配置文件旁的 `privacy-power.json`(0600);崩溃后下次启动重新启用记录的物理屏。
若主机无法启动,可在本机终端执行 `kscreen-doctor output.<name>.enable`。 若主机无法启动,可在本机终端执行 `kscreen-doctor output.<name>.enable`。
@@ -65,6 +86,10 @@ is aimed at the virtual output's region. Needs GTK3.
The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7. The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7.
成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。 成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。
Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success. Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success.
- iOS 控制端选“关闭显示器”发 `enable=0, privacy_type=3`:iOS 的 `enable` 是图片模式开关,关屏意图由 `type=3` 表达;iOS“不启用”发 `enable=0, privacy_type=1`。主机只对 iOS 控制端把 `0/3` 归一化为开屏保关屏(日志 `iOS screen-off encoding normalized`),其他控制端(包括已验收的 Android 4.43.0)保持字段 1 的语义。
The iOS viewer sends `enable=0, privacy_type=3` for "turn off the display": its `enable` is the picture-mode switch and `type=3` carries the intent; iOS "off" is `enable=0, privacy_type=1`. The host normalizes `0/3` to screen-off for iOS controllers only (log: `iOS screen-off encoding normalized`); other controllers, including the verified Android 4.43.0, keep the field-1 semantics.
- Windows 控制端每个 RPC 7 都带 `enable=0`,意图全在 `type`:`0/0` 关闭、`0/2` 屏保、`0/3` 关屏。其中 `0/0` 和 `0/2` 已在 Windows 客户端上实测;主机只对 `controller_platform=1` 做这层归一化(日志 `Windows encoding normalized`),Android 和 macOS 保持字段 1 的语义。
The Windows viewer sends every RPC 7 with `enable=0` and carries the intent in `type`: `0/0` off, `0/2` picture, `0/3` screen off. `0/0` and `0/2` were verified live on the Windows client. The host normalizes this for `controller_platform=1` only (log: `Windows encoding normalized`); Android and macOS keep the field-1 semantics.
- RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。 - RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。
Sent before picture mode; answered empty (success), the host keeps its own wallpaper. Sent before picture mode; answered empty (success), the host keeps its own wallpaper.
- FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type` - FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type`
+17
View File
@@ -0,0 +1,17 @@
官方客户端的设备卡片在未连接时也能显示 Linux 主机的壁纸。/ Device cards in official clients now show the Linux host's wallpaper while disconnected.
### 新增 / Added
- **上报系统壁纸(#152/#153,感谢 @ferstar)**:已登录的图形主机按官方 Windows 被控端的流程获取文件令牌、上传当前壁纸并回报地址,每 60 秒检查一次,内容不变不重复上传。支持 GNOME/Cinnamon、KDE(Plasma 5/6,含壁纸包和主题默认壁纸)、Xfce;其他桌面可用 `UU_WALLPAPER=/绝对路径/图片` 指定(PNG/JPEG/WebP)。访客与无桌面模式不上报。
Signed-in graphical hosts fetch a file token, upload the current wallpaper and report its URL, following the official Windows host. Checks run every 60 seconds; unchanged content is not re-uploaded. Supports GNOME/Cinnamon, KDE (Plasma 5/6, including wallpaper packages and theme defaults) and Xfce; other desktops can set `UU_WALLPAPER=/absolute/path/image`. Guest and headless hosts skip it.
### 隐私 / Privacy
默认会把当前壁纸图片上传到 UU 的文件服务;设置 `UU_WALLPAPER_UPLOAD=0` 可关闭。日志只记录结果和失败阶段。
By default the current wallpaper image is uploaded to UU's file service; set `UU_WALLPAPER_UPLOAD=0` to disable. Logs record only the outcome and failing stage.
### 验证范围 / Validation
单元测试与 CI;贡献者在 KDE 上实机确认官方客户端显示壁纸。GNOME/Cinnamon、Xfce 尚无实机验收;多屏、动态/XML 壁纸不在本次范围。
### 下载 / Download
`uu-remote-linux_0.2.47_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.47-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.47`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
防窥模式可在连接时自动开启,查看端组合键和启动器图标修复,信令失败日志更易诊断。/ Optional auto-enabled privacy screen, viewer modifier and launcher icon fixes, and clearer signaling failure logs.
### 新增 / Added
- **连接时自动开启防窥(#161,感谢 @RiverOnVenus)**:设置 `UU_PRIVACY_AUTO=picture`(隐私屏保)或 `screen-off`(关闭显示屏),第一个桌面控制端连上后自动开启;默认关闭。控制端自己的防窥请求优先,不覆盖已保存的偏好;远程协助会话同样适用。仅 KDE Plasma Wayland(portal)。
Set `UU_PRIVACY_AUTO=picture` or `screen-off` to enable the privacy screen when the first desktop controller connects (off by default). The viewer's own request wins and the saved preference is not overwritten; remote-assistance sessions are covered too. KDE Plasma Wayland (portal) only.
- **Omarchy 壁纸自动发现(#157,感谢 @ferstar)**:Hyprland 下的 Omarchy 自动跟随当前壁纸上报。/ Omarchy on Hyprland reports its current background automatically.
### 修复 / Fixed
- **查看端组合键(#163/#165,感谢 @Zhenqiang-Weng)**:窗口失焦再聚焦后,仍按住的 Shift/Ctrl/Alt/Win(Mac 为 Command)在下一次按键前恢复,不再丢失修饰键。/ The native viewer restores still-held modifiers after a focus change.
- **启动器图标(#158,感谢 @Zhenqiang-Weng)**:改用系统主题符号图标,缺少 emoji 字体时不再显示方框。/ Launcher icons use the system icon theme instead of emoji glyphs.
- **信令连接失败日志(#166)**:记录脱敏后的失败原因(类别或 HTTP 状态码,不含 token 和地址),区分服务端拒绝与网络问题。/ Signaling connection failures now log a sanitized reason (category or HTTP status).
### 验证范围 / Validation
单元测试与 CI;防窥自动开启由贡献者在 KDE Plasma 6 Wayland + iOS 客户端实机验证。查看端修复为合成事件测试,未做 Mac 主机实机验收。
### 下载 / Download
`uu-remote-linux_0.2.48_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.48-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.48`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
查看端显示远端光标形状,KDE 防窥遮罩不再出现在任务栏。/ The native viewer mirrors remote cursor shapes, and the KDE privacy cover no longer appears in the task manager.
### 新增 / Added
- **查看端远端光标形状(#168,感谢 @Zhenqiang-Weng)**:SDL 查看端使用主机经现有 CONTROL 消息发来的光标图片和热点(文本、调整大小等),指针离开画面、悬停本地控件或失焦时恢复本地箭头。光标 PNG 有大小和尺寸上限,日志只记录数量和尺寸。
The SDL viewer applies the host's cursor image and hotspot from the existing CONTROL message, restoring the local arrow outside the picture, over local controls and on focus loss. Cursor PNGs are size-bounded; logs record only counts and dimensions.
### 修复 / Fixed
- **KDE 防窥遮罩不进任务栏(#169,感谢 @RiverOnVenus)**:隐私屏保模式下,遮罩窗口通过 KWin 脚本设为不显示在任务管理器中(含多显示器的每个遮罩)。/ In picture mode, the cover windows (one per monitor) are hidden from the task manager through KWin scripting.
### 验证范围 / Validation
单元测试与 CI;KDE 遮罩修复由贡献者在 Plasma 6.8 Wayland 单屏实机验证,多屏未实测。光标形状未做官方主机实机验收。
### 下载 / Download
`uu-remote-linux_0.2.49_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.49-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.49`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
观看模式「批注」可用(X11),空闲主机 CPU 占用下降,防窥重启后可恢复输入设备,Portal 授权不再因中途失败丢失。/ Watch-mode annotation works on X11, idle hosts use less CPU, privacy restore survives a reboot, and rotated Portal consent is no longer lost.
### 新增 / Added
- **观看模式批注(#174,感谢 @Chr0mium24)**:主机应答官方查看端的批注 RPC(draw_req),笔迹画在可穿透点击的 X11 覆盖窗口上(需要合成器),分辨率变化时覆盖层随之重建。此前查看端报「批注开启失败(9998)」。仅 X11;Wayland、移动端查看端和多显示器未实测。
The host answers the official viewer's annotation RPC (draw_req) and draws strokes on a click-through X11 overlay (needs a compositor), rebuilt when the resolution changes. X11 only; Wayland, mobile viewers and multiple monitors untested.
### 修复 / Fixed
- **空闲主机 CPU(#172,感谢 @ferstar)**:指针工作线程在没有指针/滚轮/按键/触控手势时挂起,不再以 4 ms 周期空转(无查看端时约 3% CPU)。/ The pointer worker parks while no pointer, scroll, button or gesture work is pending, instead of ticking every 4 ms (~3% CPU idle).
- **防窥重启后恢复输入设备(#173,感谢 @RiverOnVenus)**:KDE 防窥记录按设备名称/产品/厂商匹配,重启后 eventN 编号变化也能重新启用被禁用的设备;已不存在的设备跳过,不再让后续防窥切换一直失败。/ KDE privacy records match devices by name/product/vendor, so a renumbered device is re-enabled after a reboot; missing devices are skipped.
- **Portal 授权先持久化(#175,感谢 @jinpeng2700-tech)**:Portal 返回轮换后的一次性 restore token 时立即保存,不再等首帧;采集失败或取消时不会丢失授权、下次重新弹窗。/ Rotated single-use Portal restore tokens are saved as soon as Portal returns them, so a failed or cancelled capture no longer forces a new consent prompt.
### 验证范围 / Validation
单元测试与 CI。批注由贡献者用 Mac 查看端 4.42.0 在 Ubuntu 22.04 GNOME X11 实机验证;#172 在报告者的 KDE Wayland 主机验证原始版本;#173 由贡献者在 KDE Plasma 6.8 用 release 构建回放记录验证;#175 为单元/合成测试。
### 下载 / Download
`uu-remote-linux_0.2.50_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.50-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.50`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+12
View File
@@ -0,0 +1,12 @@
Hyprland 等 wlroots 合成器上,手机查看端输入法打出的中文/符号文字可正常上屏。/ Phone IME text (Chinese and symbols) from mobile viewers now types correctly on Hyprland and other wlroots compositors.
### 修复 / Fixed
- **wlroots 手机输入法文字(#176,感谢 @Onekki)**:所有 wlroots 合成器统一用独立的虚拟文字键盘,每批文字重新 attach 键位表,ASCII 也按 Unicode keysym 发送;Wayland 下先走 keysym、失败再回退 uinput;输入前释放按键后同步原设备的修饰键状态,避免 Ctrl/Shift 残留。/ All wlroots compositors use a dedicated virtual text keyboard, re-attaching the keymap per batch and sending ASCII as Unicode keysyms; Wayland tries keysyms before falling back to uinput, and modifier state is re-synced to the original device so Ctrl/Shift do not stick.
### 验证范围 / Validation
单元测试与 CI;贡献者在 Hyprland 0.56.2 + fcitx5 实机验证。niri 等其他 wlroots 合成器未实测。
### 下载 / Download
`uu-remote-linux_0.2.51_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.51-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.51`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
性能优化版:降低视频推流与输入通道的拷贝和解析开销,功能行为不变。/ Performance release: less copying and parsing on the video and input paths; no behavior change.
### 优化 / Improved
- **编码帧零拷贝(#184)**:编码完成帧改用共享缓冲,去掉每帧码流深拷贝。/ Encoded frames use shared buffers, removing a per-frame bitstream deep copy.
- **H.265 关键帧检测与 RTP 分包(#180、#182)**:IRAP 检测改为单趟流式扫描,HEVC RTP 分包改为零拷贝子切片。/ Single-pass streaming IRAP scan; zero-copy sub-slices for HEVC RTP packetization.
- **数据通道解析(#180、#191)**:数据通道包单次解码、CONTROL 通道 JSON 单次解析。/ Single-pass data-channel decoding and single JSON parse on the CONTROL channel.
- **X11 终端检测缓存(#182)**:100ms 缓存,减少高频查询。/ 100 ms cache for X11 terminal detection.
- **文字输入不阻塞(#189)**:文字输入移到阻塞线程池执行,保持先后顺序。/ Text input runs on the blocking pool while preserving order.
感谢 @ferstar 提交这批优化。/ Thanks to @ferstar for these optimizations.
### 验证范围 / Validation
单元测试与 CI;各 PR 经 Codex 审查。未做实机性能对比与 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.52_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.52-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.52`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
性能优化版:Wayland(Portal)进程内推流改为事件驱动取帧,功能行为不变。/ Performance release: event-driven frame wait for in-process Wayland (Portal) streaming; no behavior change.
### 优化 / Improved
- **Portal 取帧事件驱动(#193,关闭 #192)**:Portal VAAPI 推流循环由固定间隔休眠轮询改为条件变量等待新帧(单调时钟),新帧到达即编码,空闲时不再空转。/ The Portal VAAPI loop waits on a condition variable (monotonic clock) for new frames instead of sleep-polling, so frames are encoded as soon as they arrive and idle loops no longer spin.
感谢 @ferstar 提交这项优化。/ Thanks to @ferstar for this optimization.
### 验证范围 / Validation
单元测试与 CI;PR 经 Codex 审查。未做 Wayland 实机性能对比与 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.53_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.53-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.53`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
修复版:终端会话结束/重连归属与列表通知,iOS 上传默认目录与关闭显示器兼容。/ Fix release: terminal session termination, reconnect ownership and list notifications; iOS default upload directory and screen-off compatibility.
### 修复 / Fixed
- **终端会话生命周期(#197)**:结束会话按 JSON `session_id` 选择目标(不再误用帧头请求编号),并清理该 PTY 会话内的全部进程组;Ctrl+C 发往前台进程组;重连后只接受当前附着连接的输入/缩放/信号;会话列表补齐 shell 名称、连接状态与 `last_active_ms`,变更时发送列表通知。/ Terminal close now targets the JSON `session_id` and cleans up all process groups of that PTY session; signals go to the foreground process group; after reconnect only the attached channel may drive the session; the session list gains shell name, attach state and `last_active_ms`, with change notifications.
- **iOS 上传默认目录(#198)**:iOS 直接上传时解析 `:/Default` 默认接收目录。/ iOS direct uploads resolve the `:/Default` receive-directory alias.
- **iOS 关闭显示器(#199)**:兼容 iOS 端 `enable=0,type=3` 的关闭显示器编码。/ Accept the iOS screen-off encoding (`enable=0,type=3`).
感谢 @cnetst、@RiverOnVenus 的贡献。/ Thanks to @cnetst and @RiverOnVenus.
### 验证范围 / Validation
单元测试与 CI;#197 作者在 Ubuntu ARM64 上与官方客户端实测,#199 附 iOS 实机日志。维护方未做 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.54_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.54-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.54`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
修复版:Linux → Windows 文本剪贴板。/ Fix release: Linux → Windows text clipboard.
### 修复 / Fixed
- **Windows 文本剪贴板(#200,修 #151)**:主机提供 Windows Unicode 文本(预定义格式 id 13)时不再附带格式名字段,避免 Windows 控制端把它注册成自定义格式、导致无法粘贴。Mac 格式名、UTF-16LE 编码、CRLF 与结尾 NUL 不变。/ The host now offers predefined Windows Unicode text (id 13) without a format name, so the Windows viewer no longer registers it as a custom format and standard paste works. Mac format names, UTF-16LE encoding, CRLF and the terminating NUL are unchanged.
感谢 @max2787 的贡献。/ Thanks to @max2787.
### 验证范围 / Validation
单元测试与 CI;#200 作者在 Debian 13 / Xfce 上与官方 Windows 控制端实测双向复制粘贴(中文、多行、emoji)。维护方未做 Windows/Mac 客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.55_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.55-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.55`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
功能与修复版:防窥模式、嵌入式光标、NVENC 关键帧画质。/ Feature and fix release: privacy mode, embedded cursor, NVENC keyframe quality.
### 新增 / Added
- **嵌入式光标跟随控制端鼠标模式(#203)**:Portal 采集在控制端使用相对移动("使用被控端鼠标"、Mac 触控板模式)时请求 `cursor_mode=embedded`,让游戏光标出现在画面中;绝对移动时保持隐藏,只显示一个指针。/ Portal capture asks for an embedded cursor while the viewer sends relative motion, so the game's cursor shows in the picture; absolute motion keeps it hidden.
### 修复 / Fixed
- **Windows 控制端防窥请求(#202)**:Windows 控制端(平台 1)以 `enable=0` 加 `privacy_type` 表达意图,主机现在按类型(2 画面、3 熄屏)开启防窥,不再误判为关闭。/ The host now honours the Windows viewer's `enable=0` + `privacy_type` encoding instead of treating it as "off".
- **防窥画面模式下的新窗口(#201)**:KWin 防窥模式中后出现的窗口和桌宠会被移到虚拟输出,不再落在被遮盖的物理屏上而看不见。/ Windows that appear later in KWin picture mode are moved to the virtual output instead of the covered physical screen.
- **NVENC 关键帧模糊(#205,修 #103)**:NVENC 的 VBV 缓冲默认按 libx264 规则取码率并限制在 500–8000 kbit,关键帧不再糊;VAAPI 不变,`UU_NVENC_BUFFER_MS` 仍可覆盖。/ The NVENC VBV buffer now follows the libx264 rule (bitrate, clamped to 500–8000 kbit) so keyframes stop blurring; VAAPI is unchanged and `UU_NVENC_BUFFER_MS` still overrides.
感谢 @RiverOnVenus 与 @Chr0mium24 的贡献。/ Thanks to @RiverOnVenus and @Chr0mium24.
### 验证范围 / Validation
单元测试与 CI;#201、#203 作者在 KDE Plasma 6 Wayland 上实测。维护方未做 Windows/Mac 客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.56_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.56-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.56`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
功能与修复版:可选控制端麦克风输入、文件传输空路径防护。/ Feature and fix release: opt-in controller microphone, file-transfer empty-path guard.
### 新增 / Added
- **控制端麦克风输入(实验性,默认关闭,#207)**:设置 `UU_MICROPHONE=1` 后,主机通过已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,并提供独立虚拟麦克风 **UU-远程麦克风**(`uu-remote-microphone`),不修改系统默认输入输出。需要 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0`、`libpulse.so.0` 与 `pactl`;详见 `docs/remote-microphone.md`。/ With `UU_MICROPHONE=1` the host receives the viewer's Opus track over the authenticated desktop WebRTC connection and exposes a dedicated virtual microphone, leaving system defaults untouched. See `docs/remote-microphone.md`.
### 修复 / Fixed
- **文件传输空路径(#208)**:不带路径的 `send_request` 现在返回协议错误,不再从根目录遍历。/ A `send_request` without a path now returns a protocol error instead of walking `/`.
感谢 @JuckZ 的贡献。/ Thanks to @JuckZ.
### 验证范围 / Validation
单元测试与 CI;维护方未做麦克风实机验收。Windows 4.44.1 新下载流程与端口映射(#208)仍未支持。
### 下载 / Download
`uu-remote-linux_0.2.57_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.57-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.57`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
修复版:唤醒助手注册、锁屏监测改用 logind D-Bus、HUD 中文字体。/ Fix release: wake-helper registration, logind D-Bus lock monitoring, CJK HUD font.
### 修复 / Fixed
- **网络唤醒助手注册(#209)**:注册唤醒助手时补发 `inner_ip`,云端不再以 422 拒绝,`UU_WOL_HELPER=1` 的主机可以接收唤醒推送并发送魔术包。/ The wake helper registration now sends `inner_ip`, so the cloud accepts it and forwards wake-on-LAN pushes.
- **锁屏监测(#217、#218)**:改为通过 D-Bus 订阅 logind `LockedHint`,不再每秒启动 `loginctl`,减少进程轮询与审计日志噪声;无图形会话时保持订阅、不阻塞启动。/ Lock state is now watched via logind D-Bus `LockedHint` instead of spawning `loginctl` every second.
- **HUD 中文显示(#219)**:HUD 字体选择优先含汉字的字体,修复部分系统(如 Omarchy)HUD 中文显示为方框。/ The HUD prefers a CJK-capable font, fixing tofu boxes on some systems.
感谢 @enrzh、@AYssu、@Onekki 的贡献。/ Thanks to @enrzh, @AYssu and @Onekki.
### 验证范围 / Validation
单元测试与 CI;#209 由贡献者端到端实测(iOS 控制端唤醒 Windows PC)。维护方未做锁屏监测与 HUD 字体实机验收。
### 下载 / Download
`uu-remote-linux_0.2.58_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.58-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.58`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+79
View File
@@ -0,0 +1,79 @@
# Remote microphone / 控制端麦克风(实验性)
Opt-in controller-to-host Opus audio uses the existing authenticated desktop WebRTC connection and exposes a dedicated virtual microphone to Linux applications.
可选功能:通过原有、已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,为 Linux 应用提供独立虚拟麦克风。
## Enable / 启用
Requires Linux, running PipeWire-pulse or PulseAudio 13+, the `libopus.so.0` / `libpulse.so.0` runtimes, and `pactl`. Debian/Ubuntu: install `libopus0 pulseaudio-utils`; Arch: install `opus libpulse`. No administrator privileges or additional network listener are needed at runtime. Both libraries are loaded only when requested; ordinary builds need no PulseAudio or Opus development package or extra link-time dependency.
需要 Linux、已运行的 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0` / `libpulse.so.0` 和 `pactl`。Debian/Ubuntu 对应 `libopus0 pulseaudio-utils`;Arch 对应 `opus libpulse`。运行时无需管理员权限,也不新增监听端口;普通构建无需安装 PulseAudio、Opus 开发包或增加链接依赖。
```ini
# ~/.config/systemd/user/uuremote-native.service.d/microphone.conf
[Service]
Environment=UU_MICROPHONE=1
```
```sh
systemctl --user daemon-reload
systemctl --user restart uuremote-native.service
```
The host creates the input device **UU-Remote-Microphone** (`uu-remote-microphone`) and a private backing sink (`uu-remote-mic-input`). In the application that should receive your voice, select UU-Remote-Microphone as its input. This patch does not change the system default input or output device. The backing sink is an audio destination for the decoder; it is not the device to select as an application microphone.
被控端会出现 **UU-远程麦克风** 输入设备(英文界面显示 **UU-Remote-Microphone**)。在需要使用麦克风的应用中选择这个输入。设备与音频流的显示名称跟随被控端语言,技术名称 `uu-remote-microphone`、`uu-remote-mic-input` 不变。补丁不修改系统默认输入、输出;底层的 `uu-remote-mic-input` 是解码器内部输出目标,不是应用应选择的麦克风。
Device and stream display labels follow the host language; the technical sink/source identifiers stay unchanged.
Enable the controller's microphone in the official UU client. The host completes VirtualAudioDriverPolicyRequest (RpcRequest field 21) using RpcResponse field 17 with a correctly encoded two-byte tag. It commits the reception gate and queues its reply/notification as one ordered transition before any network send can block. CONTROL and TEXT callbacks share the same transition lock, so a stalled open reply cannot overwrite a later close. Reception starts closed; connecting alone does not request capture. Opus is decoded at 48 kHz stereo and written through libpulse with PA_STREAM_DONT_MOVE, preventing rescue to a physical output on either supported audio server. A disconnected or superseded desktop drops queued audio and closes playback. Tool-only peers cannot inject microphone audio. A new incoming track replaces the previous track of the same peer.
在官方控制端中开启麦克风。被控端通过正确编码的 RPC 响应确认虚拟声卡策略;接收开关和回复、通知的排队操作使用统一的状态锁,均在网络发送之前完成,避免拥塞时旧开麦请求覆盖后到的关麦。接收初始为关闭,单纯建立远控连接不会主动要求采集。Opus 解码为 48 kHz 双声道,通过 libpulse 的禁止迁移标志仅写入虚拟麦克风,两个支持的音频后端均不会在目标丢失后转向物理输出。断开或桌面会话被替换时清空待播放内容并停止播放;文件、终端等非桌面连接不接收麦克风。
If an external tool removes the virtual endpoints, or the audio server restarts, reception stops. Restart the host to recreate its endpoints.
如果外部工具删除了虚拟设备,或音频服务重启,接收会停止。重启被控端服务可重新创建设备。
No microphone audio is logged, saved or played through physical speakers by this receiver. Applications consuming the virtual input retain their own behavior. A 40 ms initial jitter window and a maximum 12-packet queue limit backlog. RTP timestamps determine missing audio duration for Opus loss concealment, including variable-duration packets and sequence/timestamp rollover. Each track claims a unique generation before its worker is spawned; a superseded worker checks that generation before processing audio.
接收器不记录、保存麦克风音频,也不将它播放到物理扬声器。读取虚拟输入的应用仍按各自设置工作。初始抖动缓冲为 40 毫秒,队列最多 12 包;根据 RTP 时间戳推导缺失音频时长后进行 Opus 补偿,支持可变包长与序号、时间戳回绕。新音轨在启动接收任务前取得唯一归属编号,旧任务处理音频前会核验该编号。
The endpoint lock lives in a private per-user directory under `/tmp`, independently of `UU_CONFIG`, `XDG_RUNTIME_DIR` and `TMPDIR`. Recovery requires an exact match of module kind and arguments, including the remap source's master. Cleanup checks the module id and arguments again before unloading, and the route is released on ordinary error returns as well as shutdown.
设备锁位于 `/tmp` 下的用户私有目录,不随配置目录、`XDG_RUNTIME_DIR` 或 `TMPDIR` 变化。恢复设备时严格匹配模块类型及全部参数,包括虚拟输入的 master;清理前再次核验模块编号及参数。常规错误返回与正常关闭都会释放设备。
Native PulseAudio uses its `norewinds` null-sink option to avoid the default two-second idle buffer on first playback. This Pulse-only option is not passed to PipeWire. Unsupported older PulseAudio servers leave the opt-in microphone disabled.
原生 PulseAudio 使用空设备的 `norewinds` 选项,避免首次播放时的默认两秒空闲缓冲;不向 PipeWire 传递这个专用参数。较旧、不受支持的 PulseAudio 不会启用麦克风。
## Validation / 验证
Opus-dependent unit tests print a skip diagnostic when `libopus.so.0` is unavailable, so default tests still pass without this optional runtime. CI's `inproc-av` jobs install libopus and exercise these tests. The explicitly requested audio-server smoke tests require the runtime and fail if it is missing.
缺少可选的 `libopus.so.0` 时,依赖 Opus 的单元测试会输出跳过说明,默认测试仍能通过。CI 的 `inproc-av` 任务安装 libopus 并实际运行这些测试;显式启用的音频服务真机测试需要该运行库,缺少时会失败。
```sh
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins microphone::tests
# Real audio-server smoke test: independent test endpoints, generated audio only, in memory.
UU_MICROPHONE=1 \
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins \
microphone::tests::pipewire_virtual_microphone_receives_generated_tone -- --ignored --exact
```
The smoke test creates process-specific sink/source names, plays and captures only through those endpoints, waits for its playback task to end before removing them, and never reuses the host's microphone. A separate config file alone does not isolate audio resources. Unit tests cover cross-process locking, module ownership, concurrent track claims, 10/20/40/60 ms loss, mixed-duration gaps, clock rollover, WebRTC track replacement, and CONTROL/TEXT ordering under send congestion. Earlier controller acceptance passed with Windows 4.44.0.3919 on CachyOS using the previous receiver backend. The native playback backend is checked separately with generated audio; Windows acceptance has not been repeated after that backend change.
真机测试使用进程专属的虚拟输入、输出名称,仅在测试设备之间播放和采集,等播放任务结束后再删除设备,不复用正式服务的麦克风。单独更换配置文件不能隔离音频资源。回归测试覆盖跨进程锁、模块归属、并发音轨、10/20/40/60 毫秒包的丢包、混合时长缺口、时钟回绕、WebRTC 音轨替换及拥塞时的 CONTROL/TEXT 顺序。之前的接收后端已用 Windows 4.44.0.3919 在 CachyOS 实机通过控制端验收;原生播放后端另用生成音验证,更换后尚未重复 Windows 实机验收。
An optional native PulseAudio check starts a private server with no hardware modules. It first confirms sustained generated audio, then verifies that removing its playback target closes the stream and leaves the default null sink silent. Use `--smoke` to check audio delivery alone. The wrapper verifies that the named test exists before running it, so an old `--test-binary` cannot silently pass with zero tests. It needs a PulseAudio executable; `--daemon` and `--module-dir` also support unpacked packages. It does not start or modify a system service.
可选的原生 PulseAudio 检查会启动不加载硬件模块的独立服务,先确认持续生成音正常,再验证播放目标消失后音频流关闭、默认空设备保持静音;`--smoke` 仅验证生成音传输。脚本会检查目标测试存在,旧 `--test-binary` 不会以零项测试误报成功。需要 PulseAudio 可执行文件,`--daemon`、`--module-dir` 也支持解压后的程序包,不启动或修改系统服务。
```sh
python3 contrib/check-microphone-pulse.py
python3 contrib/check-microphone-pulse.py --smoke
```
To disable, remove `microphone.conf`, reload the user manager and restart the host. The virtual endpoints are removed on normal shutdown. After a crash, the next enabled run reuses only the exact tagged modules created by this receiver.
停用时删除 `microphone.conf`,重新加载并重启用户服务。正常退出会删除虚拟设备;异常退出后,下次启用仅复用本接收器创建并标记的同名模块。
+47
View File
@@ -0,0 +1,47 @@
# Device-card wallpaper reporting
The official Windows host publishes the system wallpaper for device cards. This is separate from
the Linux viewer's local last-frame cache and does not require capturing desktop windows on disconnect.
## Static protocol evidence
Read-only analysis of the locally installed `GameViewerServer.exe` (SHA-256
`af3a15c3887e06bfa9506971e01cd8ec58f41efe8ac9eb5831e31dae1fc1cef8`) found:
- `ApplicationManager::updateWallpaper`, `getWallpaperPath`, `uploadWallpaper`, and log strings
`wallpaper check`, `wallpaper is not changed, the same md5`, `wallpaper file upload succeeded`.
The source path recorded in the executable is `server_core/business/apps/application_manager.cpp`.
- `0x140ade430`: GET `/api/v1/tool/fp/token?filetype=1`. Response parser `0x140ae3410`
reads `token`, `req_url`, `ttl`, optional `max_size` from API data.
- `0x140aeb8c0`: POST raw file bytes to `req_url`, with `Authorization` set directly to the
file token (no Bearer prefix, multipart wrapper, or account credentials).
- Upload callback `0x140ad1010` requires HTTP 200; parser `0x140ae1550` reads top-level
`fsize`, `url`, `md5`, `mime`. The wallpaper callback `0x1404206c0` uses `url`.
- `0x140b48d80`: POST `/api/v1/device/wallpaper`, JSON `{"wallpaper_url":"<uploaded URL>"}`.
Device response parsers and the official viewer also contain `wallpaper_url`.
Addresses are preferred virtual addresses for that executable only. No official binary, assets,
account data, upload tokens, desktop pictures, or account URLs are included here.
This establishes the wallpaper flow statically; it does not prove that every official client's
last-frame display uses this flow or establish the official timer interval.
## Linux behavior
Signed-in graphical hosts check the configured wallpaper on startup and every 60 seconds, upload
only changed supported image bytes, and retry failures on a later check. Guest and headless hosts skip
reporting. Account renewal replaces the reporting task; stopping the host cancels it. Network work
does not block signaling or alter peer connections. Images are bounded to 10 MiB and the file service's
advertised limit. HTTPS is required and upload redirects are disabled.
GNOME/Unity/Cinnamon use GSettings (GNOME dark preference included); KDE reads the first image
wallpaper containment, including image packages, or the installed look-and-feel's default wallpaper
when no explicit wallpaper is configured; Xfce reads the first `last-image`. Multi-monitor selection, slideshow/XML
wallpapers and unsupported formats are not inferred.
On Hyprland, Omarchy's `omarchy/current/background` link is read from `XDG_STATE_HOME`
(default `~/.local/state`), falling back to the older `XDG_CONFIG_HOME` location
(default `~/.config`). Wallpaper/theme changes are followed on the next check.
Other compositor-specific wallpaper daemons are not inferred.
`UU_WALLPAPER=/absolute/path/image.png` selects a file explicitly; `UU_WALLPAPER_UPLOAD=0` disables
reporting. PNG, JPEG, and WebP are supported. No desktop screenshot fallback is used.
Only success/failure is logged. Paths, hashes, URLs, response bodies and credentials stay out of logs.
+538
View File
@@ -0,0 +1,538 @@
//! Viewer annotation (观看模式「批注」): the viewer draws on the host screen while watching.
//!
//! RpcRequest field 27 `draw_req` (gv_pb.DrawRequest) is answered with RpcResponse field 23
//! `draw_resp` (gv_pb.DrawResponse). Schema read from the official Mac 4.42.0 build
//! (UURemoteService: SwiftProtobuf name maps and Swift field metadata):
//!
//! - DrawRequest { oneof: 1 stroke_request, 2 clear_request, 3 toggle_request }
//! - DrawResponse { oneof: 1 stroke_response, 2 clear_response, 3 toggle_response }
//! - DrawStrokeRequest { 1 uint32 stroke_id, 2 repeated DrawPoint points, 3 optional int32 screen_id,
//! 4 optional float line_width, 5 optional uint32 color }; DrawPoint { 1 float x, 2 float y }
//! - DrawClearRequest { 1 ClearType clear_type (1 all, 2 by id), 2 uint32 stroke_id, 3 optional int32 screen_id }
//! - DrawToggleRequest { 1 bool enable }
//! - Draw*Response { 1 int32 error_code }, 0 = success
//!
//! The Mac viewer sends normalized points (`annotationNormalizedPoint`) in batches that share a
//! stroke id (`flushAnnotationStrokePoints`), clears before a screen switch and toggles off on exit.
//! Without this handler the request went unanswered and the viewer showed 「批注开启失败」.
//!
//! The strokes are drawn on a click-through X11 overlay (c_engine/annotation_overlay.c), so the
//! person at the host sees them and the capture streams them back to the viewer.
use crate::protocol::{decode_wire, WireField, WireValue};
use std::sync::mpsc;
use std::sync::{Mutex, OnceLock};
use std::time::Duration;
pub const RPC_REQUEST: u32 = 27;
pub const RPC_RESPONSE: u64 = 23;
const SLOT_STROKE: u64 = 1;
const SLOT_CLEAR: u64 = 2;
const SLOT_TOGGLE: u64 = 3;
/// error_code: the overlay cannot be shown (no X display, no compositor or no ARGB visual).
const ERR_UNAVAILABLE: i32 = 1;
/// iOS system red, opaque: the viewer sends no color of its own (Mac 4.42.0).
const DEFAULT_COLOR: u32 = 0xFFFF_3B30;
#[cfg(target_os = "linux")]
extern "C" {
fn uu_annotation_open(display: *const libc::c_char, x: libc::c_int, y: libc::c_int, width: libc::c_int,
height: libc::c_int, error: *mut libc::c_int) -> *mut libc::c_void;
fn uu_annotation_size(handle: *mut libc::c_void, width: *mut libc::c_int, height: *mut libc::c_int);
fn uu_annotation_polyline(handle: *mut libc::c_void, points: *const i16, count: libc::c_int, argb: libc::c_uint,
line_width: libc::c_int);
fn uu_annotation_clear(handle: *mut libc::c_void);
fn uu_annotation_flush(handle: *mut libc::c_void);
fn uu_annotation_poll(handle: *mut libc::c_void) -> libc::c_int;
fn uu_annotation_close(handle: *mut libc::c_void);
}
// macOS development builds: no X display, so the overlay never opens.
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_open(_: *const libc::c_char, _: libc::c_int, _: libc::c_int, _: libc::c_int, _: libc::c_int,
error: *mut libc::c_int) -> *mut libc::c_void { *error = 1; std::ptr::null_mut() }
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_size(_: *mut libc::c_void, _: *mut libc::c_int, _: *mut libc::c_int) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_polyline(_: *mut libc::c_void, _: *const i16, _: libc::c_int, _: libc::c_uint, _: libc::c_int) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_clear(_: *mut libc::c_void) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_flush(_: *mut libc::c_void) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_poll(_: *mut libc::c_void) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_close(_: *mut libc::c_void) {}
#[derive(Debug, Clone, PartialEq)]
pub enum Request {
Stroke { id: u32, points: Vec<(f32, f32)>, screen: Option<i32>, width: Option<f32>, color: Option<u32> },
Clear { all: bool, id: u32 },
Toggle(bool),
}
fn varint_field(fields: &[WireField], number: u32) -> Option<u64> {
fields.iter().find_map(|f| match (f.number, &f.value) { (n, WireValue::Varint(v)) if n == number => Some(*v), _ => None })
}
fn float_field(fields: &[WireField], number: u32) -> Option<f32> {
fields.iter().find_map(|f| match (f.number, &f.value) { (n, WireValue::Fixed32(b)) if n == number => Some(f32::from_le_bytes(*b)), _ => None })
}
fn bytes_field<'a>(fields: &'a [WireField<'a>], number: u32) -> Option<&'a [u8]> {
fields.iter().find_map(|f| match (f.number, &f.value) { (n, WireValue::Bytes(b)) if n == number => Some(*b), _ => None })
}
/// Decodes a DrawRequest body (the bytes of RpcRequest field 27).
pub fn parse(body: &[u8]) -> Option<Request> {
let fields = decode_wire(body).ok()?;
if let Some(stroke) = bytes_field(&fields, 1) {
let s = decode_wire(stroke).ok()?;
let mut points = Vec::new();
for field in &s {
if let (2, WireValue::Bytes(point)) = (field.number, &field.value) {
let p = decode_wire(point).ok()?;
points.push((float_field(&p, 1).unwrap_or(0.0), float_field(&p, 2).unwrap_or(0.0)));
}
}
return Some(Request::Stroke {
id: varint_field(&s, 1).unwrap_or(0) as u32,
points,
screen: varint_field(&s, 3).map(|v| v as i32),
width: float_field(&s, 4),
color: varint_field(&s, 5).map(|v| v as u32),
});
}
if let Some(clear) = bytes_field(&fields, 2) {
let c = decode_wire(clear).ok()?;
let kind = varint_field(&c, 1).unwrap_or(0);
return Some(Request::Clear { all: kind != 2, id: varint_field(&c, 2).unwrap_or(0) as u32 });
}
if let Some(toggle) = bytes_field(&fields, 3) {
let t = decode_wire(toggle).ok()?;
return Some(Request::Toggle(varint_field(&t, 1).unwrap_or(0) != 0));
}
None
}
fn varint(mut v: u64, out: &mut Vec<u8>) {
while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; }
out.push(v as u8);
}
fn bytes(field: u64, v: &[u8], out: &mut Vec<u8>) {
varint(field << 3 | 2, out);
varint(v.len() as u64, out);
out.extend_from_slice(v);
}
/// RpcResponse { 1 response_header (echoed request header), 23 DrawResponse { slot: { 1 error_code } } }.
pub fn encode_response(header: &[u8], slot: u64, error_code: i32) -> Vec<u8> {
let mut result = Vec::new();
if error_code != 0 { varint(1 << 3, &mut result); varint(error_code as i64 as u64, &mut result); }
let mut draw = Vec::new();
bytes(slot, &result, &mut draw);
let mut out = Vec::new();
bytes(1, header, &mut out);
bytes(RPC_RESPONSE, &draw, &mut out);
out
}
/// (request header, DrawRequest body) of an RpcRequest 27 draw_req; None for every other RPC.
pub fn draw_request(rpc: &[WireField]) -> Option<(Vec<u8>, Vec<u8>)> {
let body = bytes_field(rpc, RPC_REQUEST)?;
Some((bytes_field(rpc, 1).unwrap_or(&[]).to_vec(), body.to_vec()))
}
/// The peer a request came from: the address of that peer's `PeerActions`. Its session tracker
/// holds the Arc until it has sent its last reset, so a newer peer cannot reuse the key meanwhile.
pub type Owner = usize;
pub fn owner<T>(peer: &std::sync::Arc<T>) -> Owner { std::sync::Arc::as_ptr(peer) as *const () as usize }
/// Applies a draw_req from `owner` and builds its RpcResponse. Blocking: a toggle waits for the overlay.
pub fn respond(owner: Owner, header: &[u8], body: &[u8]) -> Vec<u8> {
let Some(request) = parse(body) else {
log::warn!("Annotation request not understood: {}", crate::protocol::wire_shape(body, 3));
return encode_response(header, SLOT_TOGGLE, ERR_UNAVAILABLE);
};
let (slot, code) = match request {
Request::Toggle(enable) => {
let (reply, result) = mpsc::channel();
send(Command::Toggle { owner, enable, reply });
// Opening the overlay is a few X round trips; never stall the channel for long.
let code = result.recv_timeout(Duration::from_secs(2)).unwrap_or(ERR_UNAVAILABLE);
log::info!("Annotation toggle: enable={} error_code={}", enable, code);
(SLOT_TOGGLE, code)
}
Request::Clear { all, id } => {
log::info!("Annotation clear: all={} stroke_present={}", all, id != 0);
send(Command::Clear { owner, all, id });
(SLOT_CLEAR, 0)
}
stroke @ Request::Stroke { .. } => {
send(Command::Stroke(owner, stroke));
(SLOT_STROKE, 0)
}
};
encode_response(header, slot, code)
}
/// `owner`'s desktop session ended: remove its overlay and strokes. A delayed reset from a replaced
/// peer leaves the annotation of the viewer that took over alone.
pub fn reset(owner: Owner) {
if let Some(worker) = WORKER.get() {
let _ = worker.lock().unwrap().send(Command::Reset(owner));
}
}
enum Command {
Toggle { owner: Owner, enable: bool, reply: mpsc::Sender<i32> },
Stroke(Owner, Request),
Clear { owner: Owner, all: bool, id: u32 },
Reset(Owner),
/// Tests: (owner, overlay size, stroke count) while an overlay is shown.
#[cfg(test)]
Probe(mpsc::Sender<Option<(Owner, i32, i32, usize)>>),
}
static WORKER: OnceLock<Mutex<mpsc::Sender<Command>>> = OnceLock::new();
fn send(command: Command) {
let worker = WORKER.get_or_init(|| {
let (tx, rx) = mpsc::channel();
std::thread::Builder::new().name("annotation".into()).spawn(move || run(rx)).expect("annotation thread");
Mutex::new(tx)
});
let _ = worker.lock().unwrap().send(command);
}
/// A stroke keeps the viewer's points, so it can be laid out again when the overlay is rebuilt.
struct Stroke { id: u32, normalized: bool, argb: u32, line: Option<f32>, raw: Vec<(f32, f32)>, width: i32, points: Vec<i16> }
impl Stroke {
fn new(id: u32, raw: Vec<(f32, f32)>, line: Option<f32>, color: Option<u32>) -> Self {
let normalized = raw.iter().all(|&(x, y)| x.abs() <= 1.5 && y.abs() <= 1.5);
Self { id, normalized, argb: argb(color), line, raw, width: 0, points: Vec::new() }
}
/// Overlay pixels for all points; a single point is a dot (a zero-length round-capped segment).
fn layout(&mut self, width: i32, height: i32) {
self.width = line_width(self.line, height);
self.points = to_pixels(&self.raw, self.normalized, width, height);
if self.points.len() == 2 { self.points.extend_from_within(0..2); }
}
}
struct Overlay { handle: *mut libc::c_void, screen: Option<i32>, region: (i32, i32, i32, i32), width: i32, height: i32 }
impl Overlay {
fn open(screen: Option<i32>) -> Result<Self, i32> {
let region = region(screen);
let display = crate::capture::x11_display().and_then(|d| std::ffi::CString::new(d).ok());
let mut error = 0;
let handle = unsafe {
uu_annotation_open(display.as_ref().map_or(std::ptr::null(), |d| d.as_ptr()), region.0, region.1, region.2, region.3, &mut error)
};
if handle.is_null() { return Err(error); }
let (mut width, mut height) = (0, 0);
unsafe { uu_annotation_size(handle, &mut width, &mut height) };
log::info!("Annotation overlay shown: {}x{}+{}+{}", width, height, region.0, region.1);
Ok(Self { handle, screen, region, width, height })
}
fn draw(&self, stroke: &Stroke, from: usize) {
let points = &stroke.points[from.min(stroke.points.len())..];
if points.len() < 2 { return; }
unsafe { uu_annotation_polyline(self.handle, points.as_ptr(), (points.len() / 2) as libc::c_int, stroke.argb, stroke.width) };
}
fn repaint(&self, strokes: &[Stroke]) {
unsafe { uu_annotation_clear(self.handle) };
for stroke in strokes { self.draw(stroke, 0); }
self.flush();
}
fn flush(&self) { unsafe { uu_annotation_flush(self.handle) } }
}
impl Drop for Overlay {
fn drop(&mut self) {
unsafe { uu_annotation_close(self.handle) };
log::info!("Annotation overlay removed");
}
}
/// The capture region a screen id maps to: an X11 multi-screen monitor, else the whole root (0 size).
fn region(screen: Option<i32>) -> (i32, i32, i32, i32) {
if crate::wayland::x11_multiscreen() {
let id = screen.filter(|s| *s >= 0).map_or_else(crate::wayland::selected, |s| s as usize);
if let Some(o) = crate::wayland::source(id) { return (o.x, o.y, o.width as i32, o.height as i32); }
}
(0, 0, 0, 0)
}
/// Premultiplied ARGB for the 32-bit visual; a color without alpha is opaque.
pub fn argb(color: Option<u32>) -> u32 {
let c = color.unwrap_or(DEFAULT_COLOR);
let c = if c >> 24 == 0 { c | 0xFF00_0000 } else { c };
let a = c >> 24;
let mul = |shift: u32| (((c >> shift) & 0xFF) * a / 255) << shift;
a << 24 | mul(16) | mul(8) | mul(0)
}
/// Line width in overlay pixels: values up to 1 are a fraction of the height, larger ones pixels.
pub fn line_width(width: Option<f32>, height: i32) -> i32 {
match width {
Some(w) if w.is_finite() && w > 0.0 => (if w <= 1.0 { w * height as f32 } else { w }).round().clamp(1.0, 64.0) as i32,
_ => (height as f32 / 360.0).round().max(3.0) as i32,
}
}
pub fn to_pixels(points: &[(f32, f32)], normalized: bool, width: i32, height: i32) -> Vec<i16> {
let mut out = Vec::with_capacity(points.len() * 2);
for &(x, y) in points {
let (x, y) = if normalized { (x * width as f32, y * height as f32) } else { (x, y) };
let clamp = |v: f32| if v.is_finite() { v.round().clamp(-16_000.0, 16_000.0) as i16 } else { 0 };
out.push(clamp(x));
out.push(clamp(y));
}
out
}
/// The worker's state: one overlay at a time, owned by the peer that last toggled it on or drew.
#[derive(Default)]
struct Annotation { overlay: Option<Overlay>, strokes: Vec<Stroke>, owner: Owner, unavailable: bool, logged: usize }
impl Annotation {
fn close(&mut self) { self.overlay = None; self.strokes.clear(); }
/// A request from another peer: the newer viewer takes over and the old strokes go.
fn claim(&mut self, owner: Owner) {
if self.owner != owner { self.close(); self.owner = owner; self.unavailable = false; }
}
fn open(&mut self, screen: Option<i32>) -> bool {
match Overlay::open(screen) {
Ok(o) => { self.overlay = Some(o); true }
Err(error) => { log::warn!("Annotation overlay unavailable: error={}", error); self.unavailable = true; false }
}
}
fn stroke(&mut self, id: u32, points: Vec<(f32, f32)>, screen: Option<i32>, width: Option<f32>, color: Option<u32>) {
if self.overlay.as_ref().is_some_and(|o| o.region != region(screen)) { self.close(); }
// A stroke without a toggle (e.g. after a host restart) shows the overlay anyway, but only
// one attempt until the next toggle instead of one per batch.
if self.overlay.is_none() && (self.unavailable || !self.open(screen)) { return; }
if self.logged < 8 {
// Counts and presence only: the drawing itself is the viewer's content.
self.logged += 1;
let normalized = points.iter().all(|&(x, y)| x.abs() <= 1.5 && y.abs() <= 1.5);
log::info!("Annotation stroke batch: points={} normalized={} screen_set={} width_set={} color_set={}",
points.len(), normalized, screen.is_some(), width.is_some(), color.is_some());
}
let o = self.overlay.as_ref().unwrap();
match self.strokes.iter_mut().find(|s| s.id == id) {
Some(stroke) => {
let from = stroke.points.len().saturating_sub(2);
stroke.points.extend(to_pixels(&points, stroke.normalized, o.width, o.height));
stroke.raw.extend(points);
o.draw(stroke, from);
}
None => {
let mut stroke = Stroke::new(id, points, width, color);
stroke.layout(o.width, o.height);
o.draw(&stroke, 0);
self.strokes.push(stroke);
}
}
o.flush();
}
/// The root was resized (RandR; on X11 the viewer's resolution choice does this): rebuild the
/// overlay at the new geometry and lay the strokes out again.
fn follow_resize(&mut self) {
let Some(screen) = self.overlay.take().map(|o| o.screen) else { return };
if !self.open(screen) { self.strokes.clear(); return; }
let o = self.overlay.as_ref().unwrap();
for stroke in &mut self.strokes { stroke.layout(o.width, o.height); }
o.repaint(&self.strokes);
}
fn handle(&mut self, command: Command) {
match command {
Command::Toggle { owner, enable: true, reply } => {
self.claim(owner);
self.unavailable = false;
let code = if self.overlay.is_some() || self.open(None) { 0 } else { ERR_UNAVAILABLE };
let _ = reply.send(code);
}
Command::Toggle { owner, enable: false, reply } => {
if owner == self.owner { self.close(); }
let _ = reply.send(0);
}
Command::Reset(owner) => {
if owner != self.owner { return; }
if self.overlay.is_some() { log::info!("Annotation ended with the viewer session"); }
self.close();
self.unavailable = false;
}
Command::Clear { owner, all, id } => {
if owner != self.owner { return; }
if all { self.strokes.clear(); } else { self.strokes.retain(|s| s.id != id); }
if let Some(o) = &self.overlay { o.repaint(&self.strokes); }
}
Command::Stroke(owner, Request::Stroke { id, points, screen, width, color }) => {
self.claim(owner);
self.stroke(id, points, screen, width, color);
}
Command::Stroke(..) => {}
#[cfg(test)]
Command::Probe(reply) => {
let _ = reply.send(self.overlay.as_ref().map(|o| (self.owner, o.width, o.height, self.strokes.len())));
}
}
}
}
fn run(rx: mpsc::Receiver<Command>) {
let mut state = Annotation::default();
loop {
let wait = if state.overlay.is_some() { Duration::from_millis(50) } else { Duration::from_secs(3600) };
match rx.recv_timeout(wait) {
Ok(command) => state.handle(command),
Err(mpsc::RecvTimeoutError::Timeout) => {}
Err(mpsc::RecvTimeoutError::Disconnected) => return,
}
match state.overlay.as_ref().map_or(0, |o| unsafe { uu_annotation_poll(o.handle) }) {
2 => state.follow_resize(),
1 => if let Some(o) = &state.overlay { o.repaint(&state.strokes); },
_ => {}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn float(field: u64, v: f32, out: &mut Vec<u8>) { varint(field << 3 | 5, out); out.extend_from_slice(&v.to_le_bytes()); }
#[test]
fn parses_toggle_stroke_and_clear() {
let mut toggle = Vec::new();
bytes(3, &[8, 1], &mut toggle);
assert_eq!(parse(&toggle), Some(Request::Toggle(true)));
let mut off = Vec::new();
bytes(3, &[], &mut off);
assert_eq!(parse(&off), Some(Request::Toggle(false)));
let mut point = Vec::new();
float(1, 0.25, &mut point);
float(2, 0.75, &mut point);
let mut stroke = vec![8, 7];
bytes(2, &point, &mut stroke);
bytes(2, &point, &mut stroke);
stroke.extend_from_slice(&[24, 0]);
float(4, 4.0, &mut stroke);
stroke.push(40);
varint(0xFF00_FF00, &mut stroke);
let mut request = Vec::new();
bytes(1, &stroke, &mut request);
assert_eq!(parse(&request), Some(Request::Stroke {
id: 7, points: vec![(0.25, 0.75), (0.25, 0.75)], screen: Some(0), width: Some(4.0), color: Some(0xFF00_FF00) }));
let mut clear = Vec::new();
bytes(2, &[8, 2, 16, 9], &mut clear);
assert_eq!(parse(&clear), Some(Request::Clear { all: false, id: 9 }));
let mut clear_all = Vec::new();
bytes(2, &[8, 1], &mut clear_all);
assert_eq!(parse(&clear_all), Some(Request::Clear { all: true, id: 0 }));
}
#[test]
fn response_echoes_header_in_field_23() {
let ok = encode_response(&[8, 5], SLOT_TOGGLE, 0);
assert_eq!(ok, vec![10, 2, 8, 5, 186, 1, 2, 26, 0]);
let failed = encode_response(&[], SLOT_STROKE, 1);
assert_eq!(failed, vec![10, 0, 186, 1, 4, 10, 2, 8, 1]);
let fields = decode_wire(&failed).unwrap();
assert_eq!(fields[1].number, 23);
}
#[test]
fn answers_only_draw_requests() {
let mut other = Vec::new();
bytes(1, &[8, 1], &mut other);
bytes(28, &[], &mut other);
assert!(draw_request(&decode_wire(&other).unwrap()).is_none());
let mut draw = Vec::new();
bytes(1, &[8, 5], &mut draw);
bytes(27, &[26, 2, 8, 1], &mut draw);
assert_eq!(draw_request(&decode_wire(&draw).unwrap()), Some((vec![8, 5], vec![26, 2, 8, 1])));
}
/// Needs a composited X display: DISPLAY=:0 cargo test -- --ignored annotation_overlay_smoke
/// On a disposable display, UU_ANNOTATION_SMOKE_RESIZE=1024x768 also resizes the root (xrandr --fb).
#[test]
#[ignore]
fn annotation_overlay_smoke() {
let wait = Duration::from_secs(5);
let toggle = |owner, enable| { let (reply, r) = mpsc::channel(); send(Command::Toggle { owner, enable, reply }); r.recv_timeout(wait).unwrap() };
let probe = || { let (reply, r) = mpsc::channel(); send(Command::Probe(reply)); r.recv_timeout(wait).unwrap() };
let stroke = |owner, id, points: &[(f32, f32)], width, color| send(Command::Stroke(owner, Request::Stroke {
id, points: points.to_vec(), screen: None, width, color }));
assert_eq!(toggle(1, true), 0);
let diagonal: Vec<(f32, f32)> = (0..=20).map(|i| (0.3 + i as f32 * 0.02, 0.3 + i as f32 * 0.01)).collect();
stroke(1, 1, &diagonal[..10], None, None);
stroke(1, 1, &diagonal[10..], None, None);
stroke(1, 2, &[(0.5, 0.6)], Some(30.0), Some(0x0000FF));
std::thread::sleep(Duration::from_secs(
std::env::var("UU_ANNOTATION_SMOKE_SECS").ok().and_then(|s| s.parse().ok()).unwrap_or(3)));
assert_eq!(probe().map(|p| (p.0, p.3)), Some((1, 2)));
if let Ok(size) = std::env::var("UU_ANNOTATION_SMOKE_RESIZE") {
// xrandr may report an error for an output larger than the new size yet still resize.
let _ = std::process::Command::new("xrandr").args(["--fb", &size]).status();
std::thread::sleep(Duration::from_millis(500));
let (w, h) = size.split_once('x').map(|(w, h)| (w.parse().unwrap(), h.parse().unwrap())).unwrap();
assert_eq!(probe().map(|p| (p.1, p.2, p.3)), Some((w, h, 2)), "overlay follows the {size} root");
}
// A newer viewer takes over; the replaced peer's delayed reset and toggle-off leave it alone.
assert_eq!(toggle(2, true), 0);
reset(1);
assert_eq!(toggle(1, false), 0);
assert_eq!(probe().map(|p| (p.0, p.3)), Some((2, 0)));
stroke(2, 1, &diagonal, None, None);
assert_eq!(probe().map(|p| (p.0, p.3)), Some((2, 1)));
reset(2);
assert_eq!(probe(), None);
}
#[test]
fn strokes_are_laid_out_again_after_a_resize() {
let mut dot = Stroke::new(1, vec![(0.5, 0.5)], None, None);
dot.layout(100, 200);
assert_eq!((dot.points.clone(), dot.width), (vec![50, 100, 50, 100], 3));
dot.layout(3840, 2160);
assert_eq!((dot.points.clone(), dot.width), (vec![1920, 1080, 1920, 1080], 6));
let mut pixels = Stroke::new(2, vec![(10.0, 20.0), (30.0, 40.0)], Some(8.0), None);
pixels.layout(100, 200);
assert_eq!((pixels.normalized, pixels.points.clone(), pixels.width), (false, vec![10, 20, 30, 40], 8));
}
#[test]
fn colors_widths_and_points() {
assert_eq!(argb(None), 0xFFFF_3B30);
assert_eq!(argb(Some(0x00FF00)), 0xFF00_FF00);
assert_eq!(argb(Some(0x80FF_0000)), 0x8080_0000);
assert_eq!(line_width(None, 2160), 6);
assert_eq!(line_width(None, 720), 3);
assert_eq!(line_width(Some(8.0), 2160), 8);
assert_eq!(line_width(Some(0.01), 2000), 20);
assert_eq!(to_pixels(&[(0.5, 1.0)], true, 3840, 2160), vec![1920, 2160]);
assert_eq!(to_pixels(&[(12.4, f32::NAN)], false, 3840, 2160), vec![12, 0]);
}
}
+35 -6
View File
@@ -17,9 +17,9 @@ impl TextFormat {
} }
fn id(self)->u64{match self{Self::Windows=>UNICODE_TEXT,Self::Mac=>0}} fn id(self)->u64{match self{Self::Windows=>UNICODE_TEXT,Self::Mac=>0}}
fn name(self)->&'static str{match self{Self::Windows=>"CF_UNICODETEXT",Self::Mac=>MAC_TEXT}} fn name(self)->&'static str{match self{Self::Windows=>"CF_UNICODETEXT",Self::Mac=>MAC_TEXT}}
/// Name in a format-list offer. Official Windows peers name predefined formats `predefined_<id>`; a plain /// Issue #151 reports that Windows registers even `predefined_13` as a custom format.
/// `CF_UNICODETEXT` makes the Windows viewer register a custom format instead of id 13 (issue #151). /// Omit the name for predefined id 13; verified with the official Windows viewer on an X11 host.
fn offer_name(self)->&'static str{match self{Self::Windows=>WINDOWS_OFFER_NAME,Self::Mac=>MAC_TEXT}} fn offer_name(self)->Option<&'static str>{match self{Self::Windows=>None,Self::Mac=>Some(MAC_TEXT)}}
fn encode(self,text:&str)->Vec<u8>{match self{Self::Windows=>encode_windows(text),Self::Mac=>text.as_bytes().to_vec()}} fn encode(self,text:&str)->Vec<u8>{match self{Self::Windows=>encode_windows(text),Self::Mac=>text.as_bytes().to_vec()}}
fn decode(self,data:&[u8])->Result<String,&'static str>{ fn decode(self,data:&[u8])->Result<String,&'static str>{
match self{ match self{
@@ -34,7 +34,6 @@ impl TextFormat {
} }
} }
} }
const WINDOWS_OFFER_NAME:&str="predefined_13";
const BLOCK_BYTES:usize=0x20000; const BLOCK_BYTES:usize=0x20000;
const MAX_BYTES:usize=MAX_TEXT*2+2; const MAX_BYTES:usize=MAX_TEXT*2+2;
pub struct ResultMessages {pub messages:Vec<(u32,Vec<u8>)>,pub text:Option<String>} pub struct ResultMessages {pub messages:Vec<(u32,Vec<u8>)>,pub text:Option<String>}
@@ -100,7 +99,7 @@ impl State{
if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");} if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");}
self.local=Some(text); self.local=Some(text);
let mut list=Vec::new(); let mut list=Vec::new();
for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);string(2,kind.offer_name(),&mut format);nested(1,&format,&mut list);} for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);if let Some(name)=kind.offer_name(){string(2,name,&mut format);}nested(1,&format,&mut list);}
Ok(request(id,1,&list)) Ok(request(id,1,&list))
} }
pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{ pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{
@@ -192,6 +191,36 @@ impl State{
#[cfg(test)] #[cfg(test)]
mod tests{ mod tests{
use super::*; use super::*;
#[test]
fn windows_format_offer_omits_name_field_entirely(){
for offer in [State::default().offer(42,"hi".into()).unwrap(),State::default().offer_any_host(42,"hi".into()).unwrap()]{
assert_eq!(number(header(&offer).unwrap(),1),Ok(42));
let list=bytes(bytes(&offer,9).unwrap().unwrap(),1).unwrap().unwrap();
let formats=decode_wire(list).unwrap();
let WireValue::Bytes(windows)=formats[0].value else{panic!("missing Windows format")};
assert_eq!(windows,&[8,13]); // Only field 1: not even an empty field 2.
assert!(decode_wire(windows).unwrap().iter().all(|field|field.number!=2));
if formats.len()==2{
let WireValue::Bytes(mac)=formats[1].value else{panic!("missing Mac format")};
assert_eq!(number(mac,1),Ok(0));
assert_eq!(bytes(mac,2),Ok(Some(MAC_TEXT.as_bytes())));
}
}
}
#[test]
fn unnamed_windows_offer_still_serves_utf16le_with_crlf_and_nul(){
let mut provider=State::default();
provider.offer(1,"A中🙂\nB\r\n".into()).unwrap();
let mut ask=Vec::new();int(1,13,&mut ask);string(2,"test-key",&mut ask);
let out=provider.request(&request(2,2,&ask),&mut||3).unwrap();
assert_eq!(out.messages.iter().map(|m|m.0).collect::<Vec<_>>(),vec![22,21]);
let confirm=bytes(bytes(&out.messages[0].1,5).unwrap().unwrap(),2).unwrap().unwrap();
assert_eq!(number(confirm,1),Ok(1));assert_eq!(number(confirm,3),Ok(1));
let block=bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap();
assert_eq!(text_field(block,1),Ok("test-key"));
assert_eq!(number(block,2),Ok(0));
assert_eq!(bytes(block,3).unwrap().unwrap(),&[0x41,0,0x2d,0x4e,0x3d,0xd8,0x42,0xde,13,0,10,0,0x42,0,13,0,10,0,0,0]);
}
#[test] fn mac_utf8_text_round_trips_both_directions(){ #[test] fn mac_utf8_text_round_trips_both_directions(){
// Mac host offer: format list {1 id 0, 2 "public.utf8-plain-text"} (observed live). // Mac host offer: format list {1 id 0, 2 "public.utf8-plain-text"} (observed live).
let mut mac=Vec::new();int(1,0,&mut mac);string(2,MAC_TEXT,&mut mac); let mut mac=Vec::new();int(1,0,&mut mac);string(2,MAC_TEXT,&mut mac);
@@ -218,7 +247,7 @@ mod tests{
assert_eq!(format_ids(&host_offer),vec![13]); assert_eq!(format_ids(&host_offer),vec![13]);
let list=bytes(bytes(&host_offer,9).unwrap().unwrap(),1).unwrap().unwrap(); let list=bytes(bytes(&host_offer,9).unwrap().unwrap(),1).unwrap().unwrap();
let format=bytes(list,1).unwrap().unwrap(); let format=bytes(list,1).unwrap().unwrap();
assert_eq!(text_field(format,2),Ok(WINDOWS_OFFER_NAME)); assert_eq!(bytes(format,2),Ok(None));
} }
#[test] #[test]
fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){ fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){
+20 -2
View File
@@ -243,7 +243,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
let frame = tokio::time::timeout(Duration::from_secs(5), async { let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop { loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap(); let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); } if channel != "BINARY_DATA_CHANNEL" {
continue;
}
// The process-global terminal change watch also broadcasts the field-28
// list-invalidated notification here, which is not a TERM frame.
if let Some(frame) = crate::terminal::decode(&message) {
if frame.kind == crate::terminal::LIST_RESP && frame.session == 71 {
break frame;
}
}
} }
}).await.unwrap(); }).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 71)); assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 71));
@@ -299,7 +308,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
let frame = tokio::time::timeout(Duration::from_secs(5), async { let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop { loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap(); let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); } if channel != "BINARY_DATA_CHANNEL" {
continue;
}
// The process-global terminal change watch also broadcasts the field-28
// list-invalidated notification here, which is not a TERM frame.
if let Some(frame) = crate::terminal::decode(&message) {
if frame.kind == crate::terminal::LIST_RESP && frame.session == 72 {
break frame;
}
}
} }
}).await.unwrap(); }).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 72)); assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 72));
+5
View File
@@ -127,6 +127,11 @@ pub async fn run() -> Result<(), String> {
line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into()))); line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
println!("-- audio"); println!("-- audio");
line(crate::i18n::s("麦克风输入", "microphone input"),
crate::i18n::s("控制端 Opus 到固定虚拟输入(可选)", "controller Opus to pinned virtual input (opt-in)"));
line("UU_MICROPHONE", if crate::microphone::requested() { crate::i18n::s("已启用", "enabled") } else { crate::i18n::s("已禁用", "disabled") });
line(crate::i18n::s("虚拟麦克风", "virtual microphone"), command_output("pactl", &["list", "short", "sources"]).await
.is_some_and(|sources| sources.lines().any(|line| line.split('\t').nth(1) == Some(crate::microphone::SOURCE))));
for tool in ["pactl", "pw-cli"] { for tool in ["pactl", "pw-cli"] {
line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into())); line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into()));
} }
+70 -1
View File
@@ -147,6 +147,10 @@ fn io_error(e: &std::io::Error) -> u64 {
/// anything else is rooted at "/". /// anything else is rooted at "/".
pub fn normalize(path: &str) -> PathBuf { pub fn normalize(path: &str) -> PathBuf {
let p = path.replace('\\', "/"); let p = path.replace('\\', "/");
// Official Mac 4.46.0 UURemoteServer (x86_64, 0x10019f8a5–0x10019f9f7)
// resolves :/Default to its receive directory. iOS quick upload sends this alias;
// our receive directory is HOME, also reported in SystemMetrics/RemoteDownloadPath.
if p.trim_end_matches('/') == ":/Default" { return home(); }
// The host registers as a PC, so the viewer builds drive paths ("C:/x", or ":/" when it // The host registers as a PC, so the viewer builds drive paths ("C:/x", or ":/" when it
// knows no drive letter). Linux has a single root: any drive prefix maps to "/". // knows no drive letter). Linux has a single root: any drive prefix maps to "/".
let p = match p.split_once(':') { let p = match p.split_once(':') {
@@ -455,7 +459,10 @@ impl FileSession {
/// Upload to this host. receive_request{1 id,2 path,3 files,4 strategy,5 folder_name,6 list_data,7 task_unique_id} /// Upload to this host. receive_request{1 id,2 path,3 files,4 strategy,5 folder_name,6 list_data,7 task_unique_id}
fn receive_request(&self, rid: u64, f: &[WireField]) { fn receive_request(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f); let id = TaskId::parse(f);
let target = normalize(&get_text(f, 2)); let raw_target = get_text(f, 2);
let target = normalize(&raw_target);
log::info!("File transfer upload destination: default={} exists={}",
raw_target.replace('\\', "/").trim_end_matches('/') == ":/Default", target.is_dir());
let folder = get_text(f, 5); let folder = get_text(f, 5);
let strategy = get_uint(f, 4); let strategy = get_uint(f, 4);
let files = parse_files(get_all(f, 3), get_bytes(f, 6)); let files = parse_files(get_all(f, 3), get_bytes(f, 6));
@@ -561,6 +568,13 @@ impl FileSession {
fn send_request(self: &Arc<Self>, rid: u64, f: &[WireField]) { fn send_request(self: &Arc<Self>, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f); let id = TaskId::parse(f);
let raw = get_text(f, 2); let raw = get_text(f, 2);
// Newer viewers (Windows 4.44.1, #208) send only the task id here; an empty path must not
// become "/" and walk the whole filesystem into a misleading permission error.
if raw.trim().is_empty() {
log::info!("File transfer send_request without path: task={} fields={:?}", id.task, f.iter().map(|x| x.number).collect::<Vec<_>>());
self.respond(rid, 2, Enc::default().msg(1, id.enc()).uint(2, FT_PROTOCOL));
return;
}
let path = normalize(&raw); let path = normalize(&raw);
let collected = collect_download(&path).map_err(|e| io_error(&e)); let collected = collect_download(&path).map_err(|e| io_error(&e));
let mut body = Enc::default().msg(1, id.enc()); let mut body = Enc::default().msg(1, id.enc());
@@ -715,6 +729,61 @@ mod tests {
assert_eq!(parse_files(vec![], Some(&gz.finish().unwrap())), files); assert_eq!(parse_files(vec![], Some(&gz.finish().unwrap())), files);
} }
#[test] #[test]
fn ios_default_path_resolves_to_the_advertised_receive_directory() {
for path in [":/Default", ":\\Default", ":/Default/"] {
assert_eq!(normalize(path), home());
assert!(!is_this_pc(path));
}
assert_eq!(normalize("/Default"), PathBuf::from("/Default"));
assert_eq!(normalize("C:/Default"), PathBuf::from("/Default"));
assert_eq!(normalize(":/Default-other"), PathBuf::from("/Default-other"));
}
#[test]
fn ios_quick_upload_checks_conflicts_writes_and_completes_in_default_directory() {
let name = format!(".uu-ios-test-{}-{}", std::process::id(),
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos());
let dir = home().join(&name);
std::fs::create_dir(&dir).unwrap();
struct Cleanup(PathBuf);
impl Drop for Cleanup { fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); } }
let _cleanup = Cleanup(dir.clone());
let rel = format!("{name}/x.bin");
std::fs::write(dir.join("x.bin"), b"old").unwrap();
let (tx, mut rx) = mpsc::unbounded_channel();
let s = FileSession::new(tx, Arc::new(AtomicU64::new(1)));
let call = |case: u32, body: Enc| {
let rpc = Enc::default().msg(1, Enc::default().uint(1, 17)).msg(8, Enc::default().msg(case, body));
assert!(s.handle(&decode_wire(&crate::initialization::envelope(1, 1, 21, &rpc.0)).unwrap()));
};
let response = |m: Vec<u8>, case: u32| {
let outer = decode_wire(&m).unwrap();
let rpc = decode_wire(get_bytes(&outer, 22).unwrap()).unwrap();
assert_eq!(get_uint(&decode_wire(get_bytes(&rpc, 1).unwrap()).unwrap(), 1), 17);
let ftp = decode_wire(get_bytes(&rpc, 4).unwrap()).unwrap();
get_bytes(&ftp, case).unwrap().to_vec()
};
call(11, Enc::default().text(1, ":/Default").text(2, &rel));
let exist = response(rx.try_recv().unwrap(), 8);
let exist = decode_wire(&exist).unwrap();
assert_eq!(get_text(&exist, 1), ":/Default");
assert_eq!(get_uint(&decode_wire(get_bytes(&exist, 2).unwrap()).unwrap(), 2), 1);
let id = TaskId { task: 991, index: 1 };
let info = FileInfo { rel_path: rel, size: 6, modified: 0 };
call(1, Enc::default().msg(1, id.enc()).text(2, ":/Default").bytes(6, &list_data(&[info])));
let received = response(rx.try_recv().unwrap(), 1);
assert_eq!(get_uint(&decode_wire(&received).unwrap(), 3), FT_SUCCEEDED);
call(3, Enc::default().msg(1, id.enc()).uint(3, 6));
let confirmed = response(rx.try_recv().unwrap(), 3);
assert_eq!(get_uint(&decode_wire(&confirmed).unwrap(), 3), FT_SUCCEEDED);
call(4, Enc::default().msg(1, id.enc()).bytes(3, b"abcdef"));
let block = response(rx.try_recv().unwrap(), 4);
assert_eq!(get_uint(&decode_wire(&block).unwrap(), 3), FT_SUCCEEDED);
call(9, Enc::default().msg(1, id.enc()).uint(2, FT_SUCCEEDED));
let done = response(rx.try_recv().unwrap(), 6);
assert_eq!(get_uint(&decode_wire(&done).unwrap(), 2), FT_SUCCEEDED);
assert_eq!(std::fs::read(dir.join("x.bin")).unwrap(), b"abcdef");
}
#[test]
fn upload_writes_blocks_and_confirms() { fn upload_writes_blocks_and_confirms() {
let dir = std::env::temp_dir().join(format!("uu-up-{}", std::process::id())); let dir = std::env::temp_dir().join(format!("uu-up-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap(); std::fs::create_dir_all(&dir).unwrap();
+40
View File
@@ -36,6 +36,46 @@ pub fn payload(mtu: usize, annex_b: &[u8]) -> Result<Vec<Bytes>, String> {
Ok(out) Ok(out)
} }
/// Payload HEVC Annex-B bitstream with zero-copy sub-slicing for single NAL units <= MTU.
pub fn payload_bytes(mtu: usize, annex_b: &Bytes) -> Result<Vec<Bytes>, String> {
if mtu < 4 { return Err("HEVC payload MTU too small".into()); }
let mut starts = Vec::new();
let mut i = 0;
let bytes = annex_b.as_ref();
while i + 3 <= bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue; };
starts.push((i, i + prefix)); i += prefix;
}
if starts.is_empty() { return Err("HEVC access unit has no Annex-B start code".into()); }
let mut out = Vec::new();
for (index, &(_, start)) in starts.iter().enumerate() {
let mut end = starts.get(index + 1).map_or(bytes.len(), |s| s.0);
while end > start && bytes[end - 1] == 0 { end -= 1; } // trailing_zero_8bits
let nal_slice = &bytes[start..end];
if nal_slice.len() < 2 || nal_slice[0] & 0x80 != 0 || nal_slice[1] & 7 == 0 {
return Err("Invalid HEVC NAL header".into());
}
let kind = (nal_slice[0] >> 1) & 63;
if kind >= 48 { return Err("HEVC Annex-B contains RTP packet type".into()); }
if nal_slice.len() <= mtu {
// Zero-copy reference-counted sub-slice:
out.push(annex_b.slice(start..end));
continue;
}
let chunks = nal_slice[2..].chunks(mtu - 3);
let last = chunks.len() - 1;
for (n, chunk) in chunks.enumerate() {
let mut fu = Vec::with_capacity(3 + chunk.len());
// Keep F, LayerId and TID, replacing only the NAL type with FU=49.
fu.extend_from_slice(&[(nal_slice[0] & 0x81) | (49 << 1), nal_slice[1],
kind | if n == 0 { 0x80 } else { 0 } | if n == last { 0x40 } else { 0 }]);
fu.extend_from_slice(chunk); out.push(fu.into());
}
}
Ok(out)
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
+12 -1
View File
@@ -450,7 +450,18 @@ fn run_portal_vaapi(
if dma_disabled { log::info!("Portal VAAPI DMA-BUF disabled by setting; pipeline=host-upload"); } if dma_disabled { log::info!("Portal VAAPI DMA-BUF disabled by setting; pipeline=host-upload"); }
loop { loop {
if stop.load(Ordering::Relaxed) || units.is_closed() { return Ok(()); } if stop.load(Ordering::Relaxed) || units.is_closed() { return Ok(()); }
std::thread::sleep(next_poll.saturating_duration_since(Instant::now()).min(Duration::from_millis(20))); let wait_dur = next_poll.saturating_duration_since(Instant::now());
if wait_dur > Duration::ZERO {
match portal.wait_frame(wait_dur) {
Ok(true) | Ok(false) => (),
Err(_) => {
// Frame wait failed or stream closed/stalled: back off to next_poll
// (preventing 100% core busy-spin) and allow existing recovery in with_dmabuf
// and capture_changed to handle lock/scaling without prematurely aborting the encoder.
std::thread::sleep(wait_dur);
}
}
}
let now = Instant::now(); let now = Instant::now();
if now < next_poll { continue; } if now < next_poll { continue; }
next_poll = (next_poll + interval).max(now); next_poll = (next_poll + interval).max(now);
+234 -19
View File
@@ -43,6 +43,28 @@ struct PendingPointer {
unsafe fn x11_pointer_state(_: *mut libc::c_int,_:*mut libc::c_int,_:*mut libc::c_uint)->libc::c_int {-1} unsafe fn x11_pointer_state(_: *mut libc::c_int,_:*mut libc::c_int,_:*mut libc::c_uint)->libc::c_int {-1}
#[derive(Default)] #[derive(Default)]
struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collections::BTreeSet<u64> } struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collections::BTreeSet<u64> }
/// Inputs held through the portal session are dropped when that session is replaced; the
/// cursor-mode rebuild waits until they are released. uinput devices survive the swap.
static PORTAL_INPUT_HELD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
/// An active contact on the portal touchscreen is also lost when the session is replaced.
static PORTAL_TOUCH_HELD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
pub fn portal_input_held() -> bool {
PORTAL_INPUT_HELD.load(std::sync::atomic::Ordering::Relaxed) || PORTAL_TOUCH_HELD.load(std::sync::atomic::Ordering::Relaxed)
}
/// Inputs currently bound to the portal session; a replacement tears those devices down.
static PORTAL_HELD: std::sync::Mutex<HeldInput> = std::sync::Mutex::new(HeldInput { buttons: std::collections::BTreeSet::new(), keys: std::collections::BTreeSet::new() });
/// Serializes recording an input with retiring the records of a replaced handle.
static PORTAL_HELD_SERIAL: std::sync::Mutex<()> = std::sync::Mutex::new(());
pub fn lock_portal_held() -> std::sync::MutexGuard<'static, ()> {
PORTAL_HELD_SERIAL.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
/// The portal replaced its native devices: records of held portal inputs no longer apply.
/// The caller holds `lock_portal_held()`, so an input recorded against the new handle stays.
pub fn portal_session_replaced() {
if let Ok(mut held)=PORTAL_HELD.lock() { *held=HeldInput::default(); }
PORTAL_INPUT_HELD.store(false, std::sync::atomic::Ordering::Relaxed);
PORTAL_TOUCH_HELD.store(false, std::sync::atomic::Ordering::Relaxed);
}
/// Held modifier VKs (bit 0 Ctrl, 1 Shift, 2 Alt, 3 Win) and keys that got a synthetic Shift. /// Held modifier VKs (bit 0 Ctrl, 1 Shift, 2 Alt, 3 Win) and keys that got a synthetic Shift.
#[derive(Default)] #[derive(Default)]
struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> } struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> }
@@ -81,15 +103,22 @@ fn finger_held(finger: Finger, now: std::time::Instant) -> Option<(i32,i32)> {
/// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android, /// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android,
/// 3 ios, 4 macos, 5 tv). /// 3 ios, 4 macos, 5 tv).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Controller { #[default] Other, Mac, Mobile } pub enum Controller { #[default] Other, Windows, Mac, Mobile, Ios }
impl Controller { impl Controller {
/// Touch semantics cover both mobile platforms; the iOS RPC 7 screen-off encoding is its own quirk.
pub fn is_mobile(self) -> bool { matches!(self, Self::Mobile | Self::Ios) }
pub fn from_platform(platform: Option<&serde_json::Value>) -> Self { pub fn from_platform(platform: Option<&serde_json::Value>) -> Self {
let Some(v) = platform else { return Self::Other }; let Some(v) = platform else { return Self::Other };
let text = v.as_str().map(str::to_ascii_lowercase); 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())) { match v.as_i64().or_else(|| text.as_deref().and_then(|s| s.parse().ok())) {
Some(4) => Self::Mac, Some(4) => Self::Mac,
Some(2 | 3) => Self::Mobile, Some(3) => Self::Ios,
_ if text.is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac, Some(2) => Self::Mobile,
Some(1) => Self::Windows,
_ if text.as_deref().is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac,
_ if text.as_deref().is_some_and(|s| s.contains("ios") || s.contains("iphone") || s.contains("ipad")) => Self::Ios,
_ if text.as_deref().is_some_and(|s| s.contains("android")) => Self::Mobile,
_ if text.as_deref().is_some_and(|s| s.contains("windows")) => Self::Windows,
_ => Self::Other, _ => Self::Other,
} }
} }
@@ -99,7 +128,7 @@ impl Controller {
#[derive(Default)] #[derive(Default)]
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> } 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>, uinput_pointer: bool, 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> } 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>, uinput_pointer: bool, 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>, pointer_wake: tokio::sync::Notify }
fn active_output_count(json: &[u8]) -> Option<usize> { fn active_output_count(json: &[u8]) -> Option<usize> {
let data: serde_json::Value = serde_json::from_slice(json).ok()?; let data: serde_json::Value = serde_json::from_slice(json).ok()?;
@@ -135,7 +164,7 @@ impl InputInjector {
|| (backend == crate::desktop_backend::DesktopBackend::Portal && single_portal_output())); || (backend == crate::desktop_backend::DesktopBackend::Portal && single_portal_output()));
if uinput_pointer { log::info!("Input pointer backend: uinput (motion, buttons and wheel)"); } if uinput_pointer { log::info!("Input pointer backend: uinput (motion, buttons and wheel)"); }
else if backend == crate::desktop_backend::DesktopBackend::Portal { log::info!("Input pointer backend: portal (monitor-local coordinates)"); } else if backend == crate::desktop_backend::DesktopBackend::Portal { log::info!("Input pointer backend: portal (monitor-local coordinates)"); }
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, uinput_pointer, 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, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::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, uinput_pointer, 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, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
} }
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) { pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
@@ -153,6 +182,7 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap(); let mut pending = self.pending.lock().unwrap();
pending.absolute = Some(position); pending.absolute = Some(position);
pending.relative = (0,0); pending.relative = (0,0);
self.pointer_wake.notify_one();
} }
} }
pub fn mouse_relative(&self, dx: i32, dy: i32) { pub fn mouse_relative(&self, dx: i32, dy: i32) {
@@ -160,6 +190,7 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap(); let mut pending = self.pending.lock().unwrap();
pending.relative.0 = (pending.relative.0 + i64::from(dx)).clamp(-65535,65535); pending.relative.0 = (pending.relative.0 + i64::from(dx)).clamp(-65535,65535);
pending.relative.1 = (pending.relative.1 + i64::from(dy)).clamp(-65535,65535); pending.relative.1 = (pending.relative.1 + i64::from(dy)).clamp(-65535,65535);
self.pointer_wake.notify_one();
} }
} }
pub fn mouse_scroll(&self, dx: i32, dy: i32) { pub fn mouse_scroll(&self, dx: i32, dy: i32) {
@@ -167,15 +198,38 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap(); let mut pending = self.pending.lock().unwrap();
pending.scroll.0 = (pending.scroll.0 + i64::from(dx)).clamp(-12000,12000); pending.scroll.0 = (pending.scroll.0 + i64::from(dx)).clamp(-12000,12000);
pending.scroll.1 = (pending.scroll.1 + i64::from(dy)).clamp(-12000,12000); pending.scroll.1 = (pending.scroll.1 + i64::from(dy)).clamp(-12000,12000);
self.pointer_wake.notify_one();
} }
pub fn start_pointer_worker(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> { pub fn start_pointer_worker(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> {
let input = self.clone(); let input = self.clone();
tokio::spawn(async move { tokio::spawn(async move {
// Parked until pointer work exists: a fixed 4 ms tick burned ~250 wakeups/s
// (≈3% CPU with pow-heavy flush math) even with no viewer connected.
// notify_one() stores a permit, so an event racing the park check cannot be lost.
let mut tick = tokio::time::interval(std::time::Duration::from_millis(4)); let mut tick = tokio::time::interval(std::time::Duration::from_millis(4));
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop { tick.tick().await; input.flush_pointer(); } loop {
input.pointer_wake.notified().await;
// The first event is immediate; later events coalesce until the next tick.
tick.reset();
loop {
input.flush_pointer();
tick.tick().await;
if input.pointer_idle() { break; }
}
}
}) })
} }
/// Whether the worker may park: nothing accumulated, no full scroll notch waiting and no
/// touch gesture in flight (`Pending` needs ticks until its hold resolves, `Scroll`/`Select`
/// and `down` until release). Sub-notch scroll residue cannot inject alone, so it parks.
fn pointer_idle(&self) -> bool {
let pending = self.pending.lock().unwrap();
let touch = self.touch.lock().unwrap();
pending.absolute.is_none() && pending.relative == (0,0)
&& pending.scroll.0 / 120 == 0 && pending.scroll.1 / 120 == 0
&& !touch.down && touch.finger == Finger::Up
}
pub fn discard_pointer(&self) { *self.pending.lock().unwrap() = PendingPointer::default(); } pub fn discard_pointer(&self) { *self.pending.lock().unwrap() = PendingPointer::default(); }
pub fn flush_pointer(&self) { pub fn flush_pointer(&self) {
let _serial=self.serial.lock().unwrap(); let _serial=self.serial.lock().unwrap();
@@ -229,6 +283,8 @@ impl InputInjector {
} }
pub fn mouse_button(&self, button: i32, is_press: bool) { pub fn mouse_button(&self, button: i32, is_press: bool) {
let _serial=self.serial.lock().unwrap(); let _serial=self.serial.lock().unwrap();
// The worker cannot consume the wake and flush until this transition is published.
self.pointer_wake.notify_one();
self.flush_pointer_locked(); self.flush_pointer_locked();
if button == 1 && self.touch_button(is_press) { return; } if button == 1 && self.touch_button(is_press) { return; }
let result = self.inject_button(button,is_press); let result = self.inject_button(button,is_press);
@@ -276,7 +332,7 @@ impl InputInjector {
*self.cmd.lock().unwrap() = CmdState::default(); *self.cmd.lock().unwrap() = CmdState::default();
let mut touch = self.touch.lock().unwrap(); let mut touch = self.touch.lock().unwrap();
self.lift_finger(&mut touch); self.lift_finger(&mut touch);
let mode = if controller != Controller::Mobile || self.uinput_pointer { TouchMode::Mouse } else { let mode = if !controller.is_mobile() || self.uinput_pointer { TouchMode::Mouse } else {
match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture } match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture }
}; };
*touch = TouchDrag { mode, ..TouchDrag::default() }; *touch = TouchDrag { mode, ..TouchDrag::default() };
@@ -354,8 +410,20 @@ impl InputInjector {
}); });
} }
fn inject_touch(&self, phase: i32, x: i32, y: i32) -> i32 { fn inject_touch(&self, phase: i32, x: i32, y: i32) -> i32 {
// Serialize the contact with handle replacement: a contact sent to the new devices
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 }; let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y))) // Serialize with handle replacement while the contact is sent; portal then recording
// lock, the same order the button and key recorders use.
let _serial = lock_portal_held();
let result = self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y)));
if result == 0 {
match phase {
0 => PORTAL_TOUCH_HELD.store(true, std::sync::atomic::Ordering::Relaxed),
2 => PORTAL_TOUCH_HELD.store(false, std::sync::atomic::Ordering::Relaxed),
_ => {}
}
}
result
} }
fn terminal_focused(&self) -> bool { fn terminal_focused(&self) -> bool {
@@ -470,6 +538,16 @@ impl InputInjector {
if !keys_ok {log::warn!("Desktop input reset incomplete: backend unavailable");} if !keys_ok {log::warn!("Desktop input reset incomplete: backend unavailable");}
} }
*held=HeldInput::default(); *held=HeldInput::default();
// Inputs bound to the portal session are not covered by the uinput release above.
let (portal_buttons, portal_keys) = {
let _serial=lock_portal_held();
let mut pending=PORTAL_HELD.lock().unwrap();
(std::mem::take(&mut pending.buttons), std::mem::take(&mut pending.keys))
};
// Stop on the first failure like the sweep above: each call can wait out the portal timeout.
let buttons_ok = portal_buttons.into_iter().all(|button| self.inject_button(button,false)==0);
if buttons_ok { for key in portal_keys { if self.inject_key(key,false)!=0 { break; } } }
PORTAL_INPUT_HELD.store(false,std::sync::atomic::Ordering::Relaxed);
*self.shortcuts.lock().unwrap()=Shortcuts::default(); *self.shortcuts.lock().unwrap()=Shortcuts::default();
*self.cmd.lock().unwrap()=CmdState::default(); *self.cmd.lock().unwrap()=CmdState::default();
} }
@@ -503,7 +581,22 @@ impl InputInjector {
} }
} }
} }
/// Inputs bound to the portal session are dropped when that session is replaced.
fn record_portal_button(&self, button: i32, pressed: bool) {
// Callers hold the serial lock across the injection they are recording.
let mut held = PORTAL_HELD.lock().unwrap();
if pressed { held.buttons.insert(button); } else { held.buttons.remove(&button); }
PORTAL_INPUT_HELD.store(!held.buttons.is_empty() || !held.keys.is_empty(), std::sync::atomic::Ordering::Relaxed);
}
fn record_portal_key(&self, symbol: u64, pressed: bool) {
let mut held = PORTAL_HELD.lock().unwrap();
if pressed { held.keys.insert(symbol); } else { held.keys.remove(&symbol); }
PORTAL_INPUT_HELD.store(!held.buttons.is_empty() || !held.keys.is_empty(), std::sync::atomic::Ordering::Relaxed);
}
fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 { fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 {
// The viewer's mouse mode decides whether the stream must carry the pointer (see
// portal::note_pointer_motion); only the portal backend can change that.
if self.backend==crate::desktop_backend::DesktopBackend::Portal { crate::portal::note_pointer_motion(relative); }
if self.uinput_pointer && self.backend != crate::desktop_backend::DesktopBackend::X11 { if self.uinput_pointer && self.backend != crate::desktop_backend::DesktopBackend::X11 {
if let Some(uinput) = &self.uinput { if let Some(uinput) = &self.uinput {
if relative { return Self::uinput_result(uinput.move_relative(x,y)); } if relative { return Self::uinput_result(uinput.move_relative(x,y)); }
@@ -573,14 +666,25 @@ impl InputInjector {
// Portal: clicks follow absolute motion on the same session, so a tap cannot land // 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). // before the compositor has moved the pointer there (uinput is a separate queue).
if !self.uinput_pointer && self.backend==crate::desktop_backend::DesktopBackend::Portal && !self.virtual_uinput() { if !self.uinput_pointer && self.backend==crate::desktop_backend::DesktopBackend::Portal && !self.virtual_uinput() {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); } if let Some(portal)=self.portal.lock().unwrap().as_ref() {
// The injection and its record must both predate or both postdate a swap.
let _serial=lock_portal_held();
let result=self.portal_result("button", portal.button(button,pressed));
if result==0 { self.record_portal_button(button,pressed); }
return result;
}
} }
if let Some(uinput)=&self.uinput { 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((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)); } if let Some(code)=crate::uinput::button_code(button) { return Self::uinput_result(uinput.button(code,pressed)); }
} }
if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; } if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; }
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); } if let Some(portal)=self.portal.lock().unwrap().as_ref() {
let _serial=lock_portal_held();
let result=self.portal_result("button", portal.button(button,pressed));
if result==0 { self.record_portal_button(button,pressed); }
return result;
}
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("button", Err("Portal input session is not bound".into()));} if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("button", Err("Portal input session is not bound".into()));}
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::button(button,pressed) } if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::button(button,pressed) }
else { unsafe { x11_mouse_button(button,i32::from(pressed)) } } else { unsafe { x11_mouse_button(button,i32::from(pressed)) } }
@@ -590,7 +694,12 @@ impl InputInjector {
if let Some(code)=crate::uinput::keysym_to_evdev(symbol) { return Self::uinput_result(uinput.key(code,pressed)); } if let Some(code)=crate::uinput::keysym_to_evdev(symbol) { return Self::uinput_result(uinput.key(code,pressed)); }
} }
if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; } if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; }
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("keyboard", portal.key(symbol,pressed)); } if let Some(portal)=self.portal.lock().unwrap().as_ref() {
let _serial=lock_portal_held();
let result=self.portal_result("keyboard", portal.key(symbol,pressed));
if result==0 { self.record_portal_key(symbol,pressed); }
return result;
}
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("keyboard", Err("Portal input session is not bound".into()));} if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("keyboard", Err("Portal input session is not bound".into()));}
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::key(symbol,pressed) } 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)) } } else { unsafe { x11_key_symbol(symbol as libc::c_ulong,i32::from(pressed)) } }
@@ -715,14 +824,21 @@ impl InputInjector {
self.emit_uinput_text(&crate::uinput::text_plan(text)) self.emit_uinput_text(&crate::uinput::text_plan(text))
} }
/// Mobile input-method text (`text_input`). uinput types the layout-mappable ASCII prefix /// Mobile input-method text (`text_input`). X11 types directly. Native Wayland uses the text
/// without clipboard access. X11 types directly; native Wayland re-maps a spare /// keyboard's Unicode keysyms first: uinput sends physical keycodes, which a running input
/// keycode in the virtual keyboard's keymap. Portal and other Wayland environments inject /// method composes as pinyin, so "hello" would become candidates instead of text. uinput stays
/// via clipboard paste (Shift+Insert). Set UU_WAYLAND_TEXT=0 to disable Wayland text injection. /// as the fallback when the keymap path is unavailable. 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) { pub fn text_input(&self, text: &str) {
let _serial=self.serial.lock().unwrap(); let _serial=self.serial.lock().unwrap();
if self.backend != crate::desktop_backend::DesktopBackend::X11 { if self.backend != crate::desktop_backend::DesktopBackend::X11 {
if std::env::var("UU_WAYLAND_TEXT").is_ok_and(|v| v == "0") { return; } if std::env::var("UU_WAYLAND_TEXT").is_ok_and(|v| v == "0") { return; }
if self.backend == crate::desktop_backend::DesktopBackend::Wayland
&& crate::wayland::type_utf8(text) >= 0 {
log::info!("Desktop text input: chars={} result=keysyms", text.chars().count());
return;
}
let typed = self.type_uinput_text(text); let typed = self.type_uinput_text(text);
if typed > 0 { log::info!("Desktop text input (uinput): chars={typed}"); } if typed > 0 { log::info!("Desktop text input (uinput): chars={typed}"); }
if typed == text.len() { return; } if typed == text.len() { return; }
@@ -841,6 +957,98 @@ mod motion_tests {
input.mouse_relative(1,2); input.discard_pointer(); input.mouse_relative(1,2); input.discard_pointer();
assert_eq!(input.pending.lock().unwrap().relative,(0,0)); assert_eq!(input.pending.lock().unwrap().relative,(0,0));
} }
#[test]
fn parks_when_pointer_state_is_idle() {
let input = InputInjector::new();
assert!(input.pointer_idle());
input.mouse_relative(5,5);
assert!(!input.pointer_idle());
input.flush_pointer();
assert!(input.pointer_idle());
input.mouse_scroll(0,125); input.flush_pointer();
assert!(input.pointer_idle(), "sub-notch scroll residue cannot inject alone");
}
#[test]
fn live_touch_gesture_stays_busy_until_it_resolves() {
let input = InputInjector::new();
input.touch.lock().unwrap().finger = Finger::Pending { start: (5,5), at: std::time::Instant::now() };
assert!(!input.pointer_idle());
input.touch.lock().unwrap().finger = Finger::Scroll { last: (9,9) };
assert!(!input.pointer_idle());
*input.touch.lock().unwrap() = TouchDrag::default();
assert!(input.pointer_idle());
}
#[test]
fn button_wake_waits_for_the_serialized_transition() {
use futures_util::FutureExt;
let input = std::sync::Arc::new(InputInjector::without_desktop());
let serial = input.serial.lock().unwrap();
let ready = std::sync::Arc::new(std::sync::Barrier::new(2));
let pressing = input.clone();
let started = ready.clone();
let button = std::thread::spawn(move || { started.wait(); pressing.mouse_button(1,true); });
ready.wait();
let runtime = tokio::runtime::Builder::new_current_thread().enable_time().build().unwrap();
let premature = runtime.block_on(async {
tokio::time::timeout(std::time::Duration::from_millis(50), input.pointer_wake.notified()).await.is_ok()
});
drop(serial);
button.join().unwrap();
assert!(!premature, "a parked worker must not wake before the button owns the serial lock");
assert!(input.pointer_wake.notified().now_or_never().is_some());
}
#[tokio::test(start_paused = true)]
async fn worker_coalesces_one_ms_motion_on_four_ms_ticks() {
let input = std::sync::Arc::new(InputInjector::without_desktop());
let worker = input.start_pointer_worker();
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1, "first motion is immediate");
for ms in 1..=12 {
tokio::time::advance(std::time::Duration::from_millis(1)).await;
tokio::task::yield_now().await;
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1+ms/4, "motion at {ms} ms bypassed the cadence");
}
tokio::time::advance(std::time::Duration::from_millis(4)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],5);
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
worker.abort();
assert!(worker.await.unwrap_err().is_cancelled());
}
#[tokio::test(start_paused = true)]
async fn worker_parks_and_resets_the_tick_after_a_quiet_period() {
let input = std::sync::Arc::new(InputInjector::without_desktop());
let worker = input.start_pointer_worker();
tokio::task::yield_now().await;
// Without a notification, raw queued state must remain untouched while parked.
input.pending.lock().unwrap().relative = (1,0);
tokio::time::advance(std::time::Duration::from_secs(1)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],0);
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1);
tokio::time::advance(std::time::Duration::from_millis(4)).await;
tokio::task::yield_now().await;
input.pending.lock().unwrap().relative = (1,0);
tokio::time::advance(std::time::Duration::from_millis(997)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1, "idle ticks must stop after activity");
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],2);
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],2, "a stale interval must not flush a second time immediately");
tokio::time::advance(std::time::Duration::from_millis(4)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],3);
worker.abort();
assert!(worker.await.unwrap_err().is_cancelled());
}
} }
#[cfg(all(test, target_os = "linux"))] #[cfg(all(test, target_os = "linux"))]
@@ -921,7 +1129,7 @@ mod kernel_pointer_tests {
#[test] #[test]
fn full_uinput_bypasses_portal_binding_and_preserves_move_click_order() { fn full_uinput_bypasses_portal_binding_and_preserves_move_click_order() {
for controller in [Controller::Other, Controller::Mobile] { for controller in [Controller::Other, Controller::Mobile, Controller::Ios] {
let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test(); let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop(); let mut input = InputInjector::without_desktop();
input.uinput = Some(devices); input.uinput = Some(devices);
@@ -1088,7 +1296,7 @@ impl InputInjector {
portal_outcomes:std::array::from_fn(|_|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, 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()) } touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
} }
} }
@@ -1170,10 +1378,17 @@ mod touch_tests {
fn controller_from_platform_numbers_and_mac_strings() { fn controller_from_platform_numbers_and_mac_strings() {
use serde_json::json; use serde_json::json;
assert_eq!(Controller::from_platform(Some(&json!(2))), Controller::Mobile); 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!("3"))), Controller::Ios);
assert_eq!(Controller::from_platform(Some(&json!("ios"))), Controller::Ios);
assert_eq!(Controller::from_platform(Some(&json!("Android"))), Controller::Mobile);
assert_eq!(Controller::from_platform(Some(&json!("iPadOS"))), Controller::Ios);
assert!(Controller::Ios.is_mobile());
assert!(Controller::Mobile.is_mobile());
assert!(!Controller::Mac.is_mobile());
assert_eq!(Controller::from_platform(Some(&json!(4))), Controller::Mac); 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!("MacOS"))), Controller::Mac);
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Other); assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Windows);
assert_eq!(Controller::from_platform(Some(&json!("Windows"))), Controller::Windows);
assert_eq!(Controller::from_platform(None), Controller::Other); assert_eq!(Controller::from_platform(None), Controller::Other);
} }
#[test] #[test]
+14 -4
View File
@@ -5,6 +5,7 @@ mod ws_transport;
mod engine_plugin; mod engine_plugin;
mod doctor; mod doctor;
mod wol; mod wol;
mod wallpaper;
mod desktop_backend; mod desktop_backend;
mod desktop_mode; mod desktop_mode;
mod desktop_session; mod desktop_session;
@@ -44,9 +45,11 @@ mod damage_capture;
mod inproc_encoder; mod inproc_encoder;
mod capture_setting; mod capture_setting;
mod audio; mod audio;
mod microphone;
mod virtual_audio; mod virtual_audio;
mod privacy_screen; mod privacy_screen;
mod system_actions; mod system_actions;
mod annotation;
mod capability; mod capability;
mod protocol; mod protocol;
mod control_protocol; mod control_protocol;
@@ -647,6 +650,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
privacy_screen::recover(); privacy_screen::recover();
virtual_audio::init(); virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup; let _audio_cleanup=virtual_audio::Cleanup;
microphone::init();
let _microphone_cleanup = microphone::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION")); log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
session_ice::configure_relay_transport(); session_ice::configure_relay_transport();
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2. // Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
@@ -683,7 +688,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
} }
#[cfg(not(target_os="linux"))] #[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await; let _ = tokio::signal::ctrl_c().await;
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); } if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); microphone::shutdown().await; virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
let _ = signal_tx.send(true); let _ = signal_tx.send(true);
}); });
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None }; let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None };
@@ -714,7 +719,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// One exit path for commands, signals, transport failures and UI failures. // One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; } if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; } for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
privacy_screen::shutdown(); virtual_audio::disable(); input.shutdown(); terminal::shutdown_all(); privacy_screen::shutdown(); microphone::shutdown().await; virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same // 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 // device share: logout already withdrew it, and after a QR login the cloud moved it to the account
// (a guest cancel then fails). Only a real stop withdraws here. // (a guest cancel then fails). Only a real stop withdraws here.
@@ -775,6 +780,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
client client
}; };
let mut wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id. // 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 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 capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
@@ -812,6 +818,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
log::error!("UU login is invalid or expired; a new QR login is required"); log::error!("UU login is invalid or expired; a new QR login is required");
let stale = config::read_fresh().ok().flatten().and_then(|f| f.get("token").and_then(|t| t.as_str()).map(str::to_owned)); let stale = config::read_fresh().ok().flatten().and_then(|f| f.get("token").and_then(|t| t.as_str()).map(str::to_owned));
auth = Arc::new(UUAuthClient::new(login::wait_for_credentials(stale).await)); auth = Arc::new(UUAuthClient::new(login::wait_for_credentials(stale).await));
wallpaper_task.0.abort();
wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
continue; continue;
} }
Err(e) => { Err(e) => {
@@ -851,8 +859,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
Arc::new(cli) Arc::new(cli)
} }
Err(e) => { Err(e) => {
let _ = e; // ws_transport errors carry only a category or HTTP status, never the token or URL.
log::error!("Failed to connect signaling; retrying in 5s (details omitted)"); log::error!("Failed to connect signaling; retrying in 5s: {e}");
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await; tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
continue; continue;
} }
@@ -1033,6 +1041,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
if desktop { portal_desktop.clone() } else { None }).await { if desktop { portal_desktop.clone() } else { None }).await {
Ok(mut sess) => { Ok(mut sess) => {
sess.controller = controller; sess.controller = controller;
if desktop { crate::privacy_screen::set_viewer_controller(controller); }
if !desktop { if !desktop {
let (requests, peer) = (desktop_requests.clone(), ice.clone()); let (requests, peer) = (desktop_requests.clone(), ice.clone());
sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); }); sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); });
@@ -1114,6 +1123,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
} else { None }; } else { None };
video::warm_auto_probe(); video::check_ffmpeg_usable(); video::warm_auto_probe(); video::check_ffmpeg_usable();
input.set_controller(controller); input.set_controller(controller);
crate::privacy_screen::set_viewer_controller(controller);
input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone())); 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 // 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. // close; a promoted tool peer only stops its desktop and keeps its tools.
+439
View File
@@ -0,0 +1,439 @@
//! Controller Opus -> a dedicated virtual microphone. Never record or log audio payloads.
//! Opt in with UU_MICROPHONE=1. The normal desktop-output/monitor route is not changed.
use std::collections::HashMap;
use std::os::fd::AsRawFd;
use std::process::{Command, Stdio};
use std::sync::{Arc, Mutex, OnceLock, atomic::{AtomicBool, Ordering}};
use std::time::Duration;
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio::sync::watch;
use webrtc::{peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState},
rtp::packet::Packet, rtp_transceiver::rtp_codec::RTPCodecType, track::track_remote::TrackRemote};
mod pulse;
pub const SOURCE: &str = "uu-remote-microphone";
const SINK: &str = "uu-remote-mic-input";
const MAX_PACKETS: u16 = 12;
static AVAILABLE: AtomicBool = AtomicBool::new(false);
static ROUTE: OnceLock<Mutex<Option<Route>>> = OnceLock::new();
struct Workers { stopped: watch::Sender<bool>, active: watch::Sender<usize> }
fn workers() -> &'static Workers {
static STATE: OnceLock<Workers> = OnceLock::new();
STATE.get_or_init(|| Workers { stopped: watch::channel(false).0, active: watch::channel(0).0 })
}
struct Worker;
impl Worker {
fn new() -> Self { workers().active.send_modify(|count| *count += 1); Self }
}
impl Drop for Worker {
fn drop(&mut self) { workers().active.send_modify(|count| *count -= 1); }
}
struct Module { id: u32, kind: &'static str, args: Vec<String> }
struct Route { source: Module, sink: Module, _lock: std::fs::File }
pub fn requested() -> bool { std::env::var("UU_MICROPHONE").is_ok_and(|v| v == "1") }
pub fn available() -> bool { AVAILABLE.load(Ordering::Acquire) }
pub fn policy_request(rpc: &[crate::protocol::WireField]) -> Option<u64> {
use crate::protocol::{decode_wire, WireValue};
let body = rpc.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None })?;
let fields = decode_wire(body).ok()?;
Some(fields.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }).unwrap_or(0))
}
fn pactl(args: &[&str]) -> Result<String, String> {
let out = Command::new("pactl").args(args).env("LC_ALL", "C")
.stdin(Stdio::null()).stderr(Stdio::null()).output().map_err(|_| "pactl unavailable")?;
if !out.status.success() { return Err("PulseAudio virtual microphone operation failed".into()); }
Ok(String::from_utf8_lossy(&out.stdout).trim().to_owned())
}
impl Module {
fn matching_id(line: &str, kind: &str, args: &[String]) -> Option<u32> {
let mut fields = line.split('\t');
let id = fields.next()?.parse().ok()?;
if fields.next()? != kind { return None; }
let actual: Vec<_> = fields.next()?.split_whitespace().collect();
(actual.len() == args.len() && args.iter().all(|arg| actual.contains(&arg.as_str()))).then_some(id)
}
fn open(kind: &'static str, args: Vec<String>) -> Result<Self, String> {
let modules = pactl(&["list", "short", "modules"])?;
let key = &args[0];
let named: Vec<_> = modules.lines().filter(|line| line.split('\t').nth(2)
.is_some_and(|a| a.split_whitespace().any(|a| a == key))).collect();
let id = if named.is_empty() {
let mut command = vec!["load-module", kind];
command.extend(args.iter().map(String::as_str));
pactl(&command)?.parse().map_err(|_| "Virtual microphone module returned no id")?
} else if named.len() == 1 {
Self::matching_id(named[0], kind, &args).ok_or("Virtual microphone name already belongs to another module")?
} else {
return Err("Virtual microphone module ownership is ambiguous".into());
};
Ok(Self { id, kind, args })
}
fn unload(&self) {
// Audio-server restarts may reuse numeric ids; never unload an unrelated replacement.
if pactl(&["list", "short", "modules"]).is_ok_and(|list| list.lines()
.any(|line| Self::matching_id(line, self.kind, &self.args) == Some(self.id))) {
let _ = pactl(&["unload-module", &self.id.to_string()]);
}
}
}
fn route_lock_path(source: &str) -> Result<std::path::PathBuf, String> {
use std::os::unix::fs::{DirBuilderExt, MetadataExt};
// Fixed per-user endpoints need a lock shared even by launchers with different UU_CONFIG,
// XDG_RUNTIME_DIR or TMPDIR. Only the lock inode persists; flock releases on process exit.
let dir = std::path::PathBuf::from(format!("/tmp/uu-remote-linux-{}", unsafe { libc::geteuid() }));
std::fs::DirBuilder::new().recursive(true).mode(0o700).create(&dir)
.map_err(|_| "Microphone runtime directory unavailable")?;
let metadata = std::fs::symlink_metadata(&dir).map_err(|_| "Microphone runtime directory unavailable")?;
if !metadata.is_dir() || metadata.uid() != unsafe { libc::geteuid() } || metadata.mode() & 0o077 != 0 {
return Err("Microphone runtime directory is not private".into());
}
Ok(dir.join(format!("{source}.lock")))
}
fn route_lock(source: &str) -> Result<std::fs::File, String> {
use std::os::unix::fs::OpenOptionsExt;
let lock = std::fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).mode(0o600)
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC).open(route_lock_path(source)?)
.map_err(|_| "Microphone ownership lock unavailable")?;
if unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
return Err("Another host owns the virtual microphone".into());
}
Ok(lock)
}
fn native_pulse(info: &str) -> Result<bool, String> {
let field = |key: &str| info.lines().find_map(|line| line.strip_prefix(key).map(str::trim));
let name = field("Server Name:").ok_or("Microphone audio server unavailable")?;
if name.to_ascii_lowercase().contains("pipewire") { return Ok(false); }
if !name.eq_ignore_ascii_case("pulseaudio") { return Err("Unsupported microphone audio server".into()); }
let major = field("Server Version:").and_then(|v| v.split('.').next()).and_then(|v| v.parse::<u32>().ok());
if !major.is_some_and(|v| v >= 13) { return Err("Remote microphone requires PulseAudio 13 or newer".into()); }
Ok(true)
}
fn sink_args(name: &str) -> Result<Vec<String>, String> {
let description = crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input");
let mut args = vec![format!("sink_name={name}"), format!("sink_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()];
// PulseAudio 13+: norewinds starts the null sink with a 50 ms block instead of 2 s of
// idle silence. PipeWire's compatible module does not accept this Pulse-only argument.
if native_pulse(&pactl(&["info"])?)? { args.push("norewinds=1".into()); }
Ok(args)
}
impl Route {
fn new(sink_name: &str, source_name: &str) -> Result<Self, String> {
let lock = route_lock(source_name)?;
let sink = Module::open("module-null-sink", sink_args(sink_name)?)?;
let description = crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone");
let source = Module::open("module-remap-source", vec![format!("source_name={source_name}"),
format!("master={sink_name}.monitor"), format!("source_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()]);
match source {
Ok(source) => Ok(Route { source, sink, _lock: lock }),
Err(e) => { sink.unload(); Err(e) }
}
}
}
impl Drop for Route {
fn drop(&mut self) { self.source.unload(); self.sink.unload(); }
}
pub struct Cleanup;
impl Drop for Cleanup {
fn drop(&mut self) {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
// On an unexpected unwind leave recovery to the next run rather than move a live stream
// off its disappearing sink. Normal shutdown waits for every playback worker below.
if *workers().active.borrow() == 0 { release_route(); }
}
}
pub fn init() {
if !requested() { return; }
let mut state = ROUTE.get_or_init(|| Mutex::new(None)).lock().unwrap();
if state.is_some() { return; }
let result = (|| {
let _ = Decoder::new()?;
pulse::available()?;
Route::new(SINK, SOURCE)
})();
match result {
Ok(route) => {
*state = Some(route);
workers().stopped.send_replace(false);
AVAILABLE.store(true, Ordering::Release);
log::info!("Remote microphone virtual input ready (48 kHz stereo, pinned Pulse stream)");
}
Err(error) => log::warn!("Remote microphone unavailable: {error}"),
}
}
pub async fn shutdown() {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
let mut active = workers().active.subscribe();
let _ = active.wait_for(|count| *count == 0).await;
release_route();
}
fn release_route() {
if let Some(state) = ROUTE.get() {
state.lock().unwrap().take();
}
}
#[cfg(target_os = "linux")]
struct Opus {
_handle: usize,
create: unsafe extern "C" fn(i32, i32, *mut i32) -> *mut libc::c_void,
destroy: unsafe extern "C" fn(*mut libc::c_void),
decode: unsafe extern "C" fn(*mut libc::c_void, *const u8, i32, *mut i16, i32, i32) -> i32,
samples: unsafe extern "C" fn(*const u8, i32, i32) -> i32,
}
#[cfg(target_os = "linux")]
fn opus() -> Result<&'static Opus, String> {
static LIB: OnceLock<Option<Opus>> = OnceLock::new();
LIB.get_or_init(|| unsafe {
let handle = libc::dlopen(c"libopus.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if handle.is_null() { return None; }
let names = [c"opus_decoder_create", c"opus_decoder_destroy", c"opus_decode", c"opus_packet_get_nb_samples"];
let functions: Vec<_> = names.iter().map(|name| libc::dlsym(handle, name.as_ptr())).collect();
if functions.iter().any(|f| f.is_null()) { libc::dlclose(handle); return None; }
// The library stays loaded for the process lifetime; signatures match the public Opus API.
Some(Opus { _handle: handle as usize, create: std::mem::transmute(functions[0]),
destroy: std::mem::transmute(functions[1]), decode: std::mem::transmute(functions[2]),
samples: std::mem::transmute(functions[3]) })
}).as_ref().ok_or_else(|| "libopus runtime unavailable".into())
}
struct Decoder(*mut libc::c_void);
#[derive(Debug, PartialEq, Eq)]
enum Frame { Opus(Vec<u8>), Conceal(u32) }
// One task owns the decoder and all calls; no decoder state is shared concurrently.
unsafe impl Send for Decoder {}
impl Decoder {
fn new() -> Result<Self, String> {
#[cfg(target_os = "linux")] {
let mut error = 0;
let decoder = unsafe { (opus()?.create)(48000, 2, &mut error) };
if error == 0 && !decoder.is_null() { return Ok(Self(decoder)); }
}
Err("Opus microphone decoder unavailable".into())
}
fn decode(&mut self, frame: &Frame) -> Result<(Vec<u8>, u32), String> {
#[cfg(target_os = "linux")] {
let (packet, size) = match frame {
Frame::Opus(data) if valid_packet(data) => (Some(data.as_slice()), 5760),
Frame::Conceal(samples) if (120..=5760).contains(samples) && samples % 120 == 0 => (None, *samples as i32),
_ => return Err("Invalid microphone Opus frame".into()),
};
let data = packet.unwrap_or(&[]);
let mut pcm = vec![0i16; 5760 * 2];
let samples = unsafe { (opus()?.decode)(self.0, if packet.is_some() { data.as_ptr() } else { std::ptr::null() },
data.len() as i32, pcm.as_mut_ptr(), size, 0) };
if samples <= 0 { return Err("Microphone Opus decode failed".into()); }
let bytes = pcm[..samples as usize * 2].iter().flat_map(|s| s.to_le_bytes()).collect();
return Ok((bytes, samples as u32));
}
#[allow(unreachable_code)] { let _ = frame; Err("Microphone decoding requires Linux".into()) }
}
}
impl Drop for Decoder {
fn drop(&mut self) { #[cfg(target_os = "linux")] if let Ok(lib) = opus() { unsafe { (lib.destroy)(self.0); } } }
}
fn packet_samples(data: &[u8]) -> Option<u32> {
if data.is_empty() || data.len() > 8192 { return None; }
#[cfg(target_os = "linux")] {
let samples = unsafe { (opus().ok()?.samples)(data.as_ptr(), data.len() as i32, 48000) };
return (120..=5760).contains(&samples).then_some(samples as u32);
}
#[allow(unreachable_code)] None
}
fn valid_packet(data: &[u8]) -> bool { packet_samples(data).is_some() }
/// Fixed memory and bounded reordering across sequence wrap; stale backlog is discarded.
#[derive(Default)]
struct Jitter { next: Option<u16>, timestamp: Option<u32>, last_samples: Option<u32>, packets: HashMap<u16, QueuedPacket> }
struct QueuedPacket { timestamp: u32, samples: u32, payload: Vec<u8> }
impl Jitter {
fn push(&mut self, packet: Packet) {
let Some(samples) = packet_samples(&packet.payload) else { return; };
let seq = packet.header.sequence_number;
let next = *self.next.get_or_insert(seq);
let ahead = seq.wrapping_sub(next);
if ahead >= 0x8000 { return; }
if ahead >= MAX_PACKETS { self.packets.clear(); self.next = Some(seq); self.timestamp = None; }
self.packets.entry(seq).or_insert_with(|| QueuedPacket {
timestamp: packet.header.timestamp, samples, payload: packet.payload.to_vec(),
});
}
/// A future packet's RTP clock bounds the missing audio, including variable packet durations.
fn pop(&mut self) -> Option<Frame> {
if self.packets.is_empty() { return None; }
let seq = self.next?;
self.next = Some(seq.wrapping_add(1));
if let Some(packet) = self.packets.remove(&seq) {
self.timestamp = Some(packet.timestamp.wrapping_add(packet.samples));
self.last_samples = Some(packet.samples);
return Some(Frame::Opus(packet.payload));
}
let inferred = self.timestamp.and_then(|timestamp| {
let (&future, packet) = self.packets.iter().min_by_key(|(n, _)| n.wrapping_sub(seq))?;
let missing = u32::from(future.wrapping_sub(seq));
let gap = packet.timestamp.wrapping_sub(timestamp);
// Ignore timestamp discontinuities/DTX; do not manufacture seconds of concealment.
(missing > 0 && (missing * 120..=missing * 5760).contains(&gap) && gap % 120 == 0)
.then(|| gap / missing / 120 * 120)
});
let samples = inferred.or(self.last_samples).unwrap_or(960);
self.timestamp = self.timestamp.map(|timestamp| timestamp.wrapping_add(samples));
Some(Frame::Conceal(samples))
}
}
type Writer = std::pin::Pin<Box<dyn AsyncWrite + Send>>;
struct Playback { decoder: Decoder, writer: Writer, output: Option<pulse::Output> }
impl Playback {
fn new() -> Result<Self, String> {
Self::at(SINK)
}
fn at(sink: &str) -> Result<Self, String> {
let decoder = Decoder::new()?;
let (writer, output) = pulse::start(sink)?;
Ok(Self { decoder, writer: Box::pin(writer), output: Some(output) })
}
async fn write(&mut self, frame: &Frame) -> Result<u32, String> {
let (bytes, samples) = self.decoder.decode(frame)?;
match tokio::time::timeout(Duration::from_millis(200), self.writer.write_all(&bytes)).await {
Ok(Ok(())) => {},
Ok(Err(_)) => {
if let Some(output) = self.output.as_mut() {
if let Err(error) = output.stop().await { return Err(error); }
}
return Err("Microphone playback ended".into());
},
Err(_) => return Err("Microphone playback stalled".into()),
}
Ok(samples)
}
async fn stop(&mut self) {
if let Some(output) = self.output.as_mut() { let _ = output.stop().await; }
}
}
type Factory = Arc<dyn Fn() -> Result<Playback, String> + Send + Sync>;
#[derive(Clone)]
pub struct Session { open: watch::Sender<bool>, owner: watch::Sender<u64>, serial: Arc<Mutex<()>>, factory: Factory }
impl Session {
pub fn new() -> Self {
// Do not request or accept capture until the controller explicitly enables it.
Self { open: watch::channel(false).0, owner: watch::channel(0).0, serial: Arc::new(Mutex::new(())), factory: Arc::new(Playback::new) }
}
/// Official SimpleAction map: 23 microphone_opened, 24 microphone_closed.
pub fn action(&self, action: u64) -> bool {
self.action_with(action, || {})
}
/// Commit the gate and enqueue its notifications as one ordered transition across channels.
/// The callback only queues messages; actual network sends must happen outside this lock.
pub fn action_with(&self, action: u64, enqueue: impl FnOnce()) -> bool {
match action {
23 | 24 => {
let _serial = self.serial.lock().unwrap();
self.open.send_replace(action == 23);
enqueue();
log::info!("Remote microphone switch: open={}", action == 23);
true
},
_ => false,
}
}
fn claim_track(&self) -> (u64, watch::Receiver<u64>) {
let owner = self.owner.subscribe();
let mut generation = 0;
self.owner.send_modify(|id| { *id = id.wrapping_add(1); generation = *id; });
(generation, owner)
}
pub fn attach(&self, pc: &Arc<RTCPeerConnection>, active: watch::Receiver<bool>) {
let weak = Arc::downgrade(pc);
let session = self.clone();
pc.on_track(Box::new(move |track, _, _| {
let (session, active, weak) = (session.clone(), active.clone(), weak.clone());
Box::pin(async move {
if track.kind() != RTPCodecType::Audio { return; }
if !track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus") {
log::warn!("Incoming microphone track uses an unsupported codec"); return;
}
log::info!("Incoming microphone Opus track received");
if let Some(pc) = weak.upgrade() {
let (generation, owner) = session.claim_track();
let worker = Worker::new();
tokio::spawn(session.receive(track, pc, active, generation, owner, worker));
}
})
}));
}
async fn receive(self, track: Arc<TrackRemote>, pc: Arc<RTCPeerConnection>, mut active: watch::Receiver<bool>,
generation: u64, mut owner: watch::Receiver<u64>, _worker: Worker) {
let mut stopped = workers().stopped.subscribe();
let mut open = self.open.subscribe();
let mut jitter = Jitter::default();
let mut player: Option<Playback> = None;
let mut next = tokio::time::Instant::now();
let mut health = tokio::time::interval(Duration::from_millis(100));
let mut played = 0u64;
let mut lost = 0u64;
// TrackRemote reads are not cancel safe. Keep the same future across timer and gate ticks.
let mut pending = Box::pin(track.read_rtp());
loop {
// A worker can first run after its replacement has already subscribed. Check the id,
// not only changed(): both receivers may otherwise have marked the latest id as seen.
if *stopped.borrow() || *owner.borrow_and_update() != generation { break; }
let allowed = *open.borrow() && *active.borrow() && pc.connection_state() == RTCPeerConnectionState::Connected;
if !allowed {
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; log::info!("Remote microphone playback paused"); }
}
tokio::select! {
biased;
_ = stopped.changed() => break,
_ = owner.changed() => break,
change = open.changed() => {
if change.is_err() { break; }
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; }
},
change = active.changed() => if change.is_err() { break; },
_ = health.tick() => {
if matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) { break; }
},
_ = tokio::time::sleep_until(next), if player.is_some() && allowed => {
if let Some(packet) = jitter.pop() {
if matches!(packet, Frame::Conceal(_)) { lost += 1; }
match player.as_mut().unwrap().write(&packet).await {
Ok(samples) => {
played += 1;
next = (next + Duration::from_secs_f64(f64::from(samples) / 48000.)).max(tokio::time::Instant::now());
if played == 1 || played % 250 == 0 { log::info!("Remote microphone playback: frames={played} concealed={lost}"); }
},
Err(error) => { log::warn!("{error}"); break; }
}
} else {
next = tokio::time::Instant::now() + Duration::from_millis(10);
}
},
received = &mut pending => {
let Ok((packet, _)) = received else { break; };
pending.set(track.read_rtp());
if !allowed || !valid_packet(&packet.payload) { continue; }
if player.is_none() {
match (self.factory)() {
Ok(output) => { player = Some(output); next = tokio::time::Instant::now() + Duration::from_millis(40); },
Err(error) => { log::warn!("{error}"); break; }
}
}
jitter.push(packet);
},
}
}
if let Some(mut output) = player { output.stop().await; }
log::info!("Remote microphone track ended: frames={played} concealed={lost}");
}
}
#[cfg(test)]
mod tests;
+187
View File
@@ -0,0 +1,187 @@
//! Pulse playback pinned with PA_STREAM_DONT_MOVE, supported by PulseAudio and PipeWire-pulse.
//! Load the stable public C API at runtime so opt-out builds need no Pulse development package.
use std::ffi::{CStr, CString};
use std::sync::OnceLock;
use std::time::{Duration, Instant};
use tokio::io::{AsyncReadExt, DuplexStream};
use tokio::sync::watch;
type Handle = *mut libc::c_void;
type Free = Option<unsafe extern "C" fn(Handle)>;
#[repr(C)]
struct SampleSpec { format: i32, rate: u32, channels: u8 }
#[repr(C)]
struct BufferAttr { maxlength: u32, tlength: u32, prebuf: u32, minreq: u32, fragsize: u32 }
struct Api {
_library: usize,
mainloop_new: unsafe extern "C" fn() -> Handle,
mainloop_free: unsafe extern "C" fn(Handle),
mainloop_get_api: unsafe extern "C" fn(Handle) -> Handle,
mainloop_iterate: unsafe extern "C" fn(Handle, i32, *mut i32) -> i32,
context_new: unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle,
context_connect: unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32,
context_get_state: unsafe extern "C" fn(Handle) -> i32,
context_disconnect: unsafe extern "C" fn(Handle),
context_unref: unsafe extern "C" fn(Handle),
stream_new: unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle,
stream_connect_playback: unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32,
stream_get_state: unsafe extern "C" fn(Handle) -> i32,
stream_get_device_name: unsafe extern "C" fn(Handle) -> *const libc::c_char,
stream_writable_size: unsafe extern "C" fn(Handle) -> usize,
stream_write: unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32,
stream_disconnect: unsafe extern "C" fn(Handle) -> i32,
stream_unref: unsafe extern "C" fn(Handle),
}
fn api() -> Result<&'static Api, String> {
static API: OnceLock<Option<Api>> = OnceLock::new();
API.get_or_init(|| unsafe {
let library = libc::dlopen(c"libpulse.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if library.is_null() { return None; }
macro_rules! load {
($name:expr, $signature:ty) => {{
let function = libc::dlsym(library, $name.as_ptr());
if function.is_null() { return None; }
std::mem::transmute::<Handle, $signature>(function)
}};
}
let result = (|| Some(Api {
_library: library as usize,
mainloop_new: load!(c"pa_mainloop_new", unsafe extern "C" fn() -> Handle),
mainloop_free: load!(c"pa_mainloop_free", unsafe extern "C" fn(Handle)),
mainloop_get_api: load!(c"pa_mainloop_get_api", unsafe extern "C" fn(Handle) -> Handle),
mainloop_iterate: load!(c"pa_mainloop_iterate", unsafe extern "C" fn(Handle, i32, *mut i32) -> i32),
context_new: load!(c"pa_context_new", unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle),
context_connect: load!(c"pa_context_connect", unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32),
context_get_state: load!(c"pa_context_get_state", unsafe extern "C" fn(Handle) -> i32),
context_disconnect: load!(c"pa_context_disconnect", unsafe extern "C" fn(Handle)),
context_unref: load!(c"pa_context_unref", unsafe extern "C" fn(Handle)),
stream_new: load!(c"pa_stream_new", unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle),
stream_connect_playback: load!(c"pa_stream_connect_playback", unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32),
stream_get_state: load!(c"pa_stream_get_state", unsafe extern "C" fn(Handle) -> i32),
stream_get_device_name: load!(c"pa_stream_get_device_name", unsafe extern "C" fn(Handle) -> *const libc::c_char),
stream_writable_size: load!(c"pa_stream_writable_size", unsafe extern "C" fn(Handle) -> usize),
stream_write: load!(c"pa_stream_write", unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32),
stream_disconnect: load!(c"pa_stream_disconnect", unsafe extern "C" fn(Handle) -> i32),
stream_unref: load!(c"pa_stream_unref", unsafe extern "C" fn(Handle)),
}))();
if result.is_none() { libc::dlclose(library); }
result
}).as_ref().ok_or_else(|| "libpulse runtime unavailable".into())
}
pub(super) fn available() -> Result<(), String> { api().map(|_| ()) }
struct Stream { api: &'static Api, mainloop: Handle, context: Handle, stream: Handle }
impl Drop for Stream {
fn drop(&mut self) { unsafe {
if !self.stream.is_null() { (self.api.stream_disconnect)(self.stream); (self.api.stream_unref)(self.stream); }
if !self.context.is_null() { (self.api.context_disconnect)(self.context); (self.api.context_unref)(self.context); }
if !self.mainloop.is_null() { (self.api.mainloop_free)(self.mainloop); }
} }
}
impl Stream {
fn connect(api: &'static Api, sink: &CStr, stopped: &watch::Receiver<bool>) -> Result<Self, String> { unsafe {
let mut output = Self { api, mainloop: (api.mainloop_new)(), context: std::ptr::null_mut(), stream: std::ptr::null_mut() };
if output.mainloop.is_null() { return Err("Microphone audio loop unavailable".into()); }
let client = CString::new(crate::i18n::s("UU 远程麦克风", "UU Remote microphone")).unwrap();
output.context = (api.context_new)((api.mainloop_get_api)(output.mainloop), client.as_ptr());
// PA_CONTEXT_NOAUTOSPAWN: connecting to the configured server must not start another one.
if output.context.is_null() || (api.context_connect)(output.context, std::ptr::null(), 1, std::ptr::null_mut()) < 0 {
return Err("Microphone audio server unavailable".into());
}
let context = output.context;
output.wait(stopped, || (api.context_get_state)(context) == 4)?; // PA_CONTEXT_READY
let spec = SampleSpec { format: 3, rate: 48000, channels: 2 }; // PA_SAMPLE_S16LE
let name = CString::new(crate::i18n::s("远程麦克风", "Remote-Microphone")).unwrap();
output.stream = (api.stream_new)(context, name.as_ptr(), &spec, std::ptr::null_mut());
let attr = BufferAttr { maxlength: u32::MAX, tlength: 5760, prebuf: u32::MAX, minreq: 1920, fragsize: u32::MAX };
// pulse/def.h: PA_STREAM_DONT_MOVE | PA_STREAM_ADJUST_LATENCY. A disappearing target
// must fail closed; PipeWire-only node properties cannot enforce this on PulseAudio.
if output.stream.is_null() || (api.stream_connect_playback)(output.stream, sink.as_ptr(), &attr,
0x0200 | 0x2000, std::ptr::null_mut(), std::ptr::null_mut()) < 0 {
return Err("Microphone audio target unavailable".into());
}
let stream = output.stream;
output.wait(stopped, || (api.stream_get_state)(stream) == 2)?; // PA_STREAM_READY
let actual = (api.stream_get_device_name)(stream);
if actual.is_null() || CStr::from_ptr(actual) != sink { return Err("Microphone audio target changed".into()); }
Ok(output)
} }
fn pump(&mut self) -> Result<(), String> { unsafe {
if (self.api.mainloop_iterate)(self.mainloop, 0, std::ptr::null_mut()) < 0
|| (self.api.context_get_state)(self.context) >= 5
|| (!self.stream.is_null() && (self.api.stream_get_state)(self.stream) >= 3) {
return Err("Microphone audio connection ended".into());
}
Ok(())
} }
fn wait(&mut self, stopped: &watch::Receiver<bool>, ready: impl Fn() -> bool) -> Result<(), String> {
let deadline = Instant::now() + Duration::from_secs(3);
loop {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
if ready() { return Ok(()); }
if Instant::now() >= deadline { return Err("Microphone audio connection timed out".into()); }
std::thread::sleep(Duration::from_millis(2));
}
}
fn write(&mut self, pcm: &[u8], stopped: &watch::Receiver<bool>) -> Result<(), String> {
if pcm.len() % 4 != 0 { return Err("Invalid microphone PCM frame".into()); }
let deadline = Instant::now() + Duration::from_millis(200);
let mut offset = 0;
while offset < pcm.len() {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
let available = unsafe { (self.api.stream_writable_size)(self.stream) };
if available == usize::MAX { return Err("Microphone audio stream ended".into()); }
let count = available.min(pcm.len() - offset) & !3;
if count > 0 {
// With no free callback libpulse copies these bytes before returning.
if unsafe { (self.api.stream_write)(self.stream, pcm[offset..].as_ptr().cast(), count, None, 0, 0) } < 0 {
return Err("Microphone audio write failed".into());
}
offset += count;
} else {
if Instant::now() >= deadline {
return Err(format!("Microphone playback stalled: remaining={} writable={available}", pcm.len() - offset));
}
std::thread::sleep(Duration::from_millis(2));
}
}
self.pump()
}
}
pub(super) struct Output { stopped: watch::Sender<bool>, task: Option<tokio::task::JoinHandle<Result<(), String>>> }
impl Output {
pub(super) async fn stop(&mut self) -> Result<(), String> {
self.stopped.send_replace(true);
if let Some(task) = self.task.take() {
return task.await.map_err(|_| "Microphone audio worker aborted")?;
}
Ok(())
}
}
impl Drop for Output { fn drop(&mut self) { self.stopped.send_replace(true); } }
pub(super) fn start(sink: &str) -> Result<(DuplexStream, Output), String> {
let api = api()?;
let sink = CString::new(sink).map_err(|_| "Invalid microphone audio target")?;
let (writer, mut reader) = tokio::io::duplex(65536);
let (stop, mut stopped) = watch::channel(false);
let runtime = tokio::runtime::Handle::current();
let task = tokio::task::spawn_blocking(move || {
let mut output = Stream::connect(api, &sink, &stopped)?;
let mut buffer = [0; 23040]; // maximum 120 ms stereo PCM
loop {
if *stopped.borrow() { return Ok(()); }
let count = runtime.block_on(async { tokio::select! {
biased;
_ = stopped.changed() => Ok(0),
result = reader.read(&mut buffer) => result,
} }).map_err(|_| "Microphone PCM input ended")?;
if count == 0 { return Ok(()); }
output.write(&buffer[..count], &stopped)?;
}
});
Ok((writer, Output { stopped: stop, task: Some(task) }))
}
+533
View File
@@ -0,0 +1,533 @@
#![cfg(target_os = "linux")]
use super::*;
use tokio::io::AsyncReadExt;
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP, TrackLocalWriter};
use webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;
use webrtc::interceptor::{mock::{mock_builder::MockBuilder, mock_interceptor::MockInterceptor},
registry::Registry, Attributes, RTPReader};
fn have_opus() -> bool {
match opus() {
Ok(_) => true,
Err(error) => { eprintln!("Skipping Opus-dependent microphone test: {error}"); false }
}
}
#[derive(Default)]
struct ReadPause {
requested: AtomicBool, entered: tokio::sync::Notify,
resume: tokio::sync::Notify, completed: tokio::sync::Notify,
}
struct PausedReader { reader: Arc<dyn RTPReader + Send + Sync>, pause: Arc<ReadPause> }
#[async_trait::async_trait]
impl RTPReader for PausedReader {
async fn read(&self, buffer: &mut [u8], attributes: &Attributes) -> Result<(Packet, Attributes), webrtc::interceptor::Error> {
let result = self.reader.read(buffer, attributes).await?;
if self.pause.requested.swap(false, Ordering::AcqRel) {
// The packet has already been consumed; cancelling here would lose it.
self.pause.entered.notify_one();
self.pause.resume.notified().await;
self.pause.completed.notify_one();
}
Ok(result)
}
}
fn pause_registry(pause: Arc<ReadPause>) -> Registry {
let mut registry = Registry::new();
registry.add(Box::new(MockBuilder::new(move |_| {
let pause = pause.clone();
Ok(Arc::new(MockInterceptor { bind_remote_stream_fn: Some(Box::new(move |_, reader| {
let pause = pause.clone();
Box::pin(async move {
Arc::new(PausedReader { reader, pause }) as Arc<dyn RTPReader + Send + Sync>
})
})), ..Default::default() }))
})));
registry
}
fn tone() -> Vec<u8> {
tone_samples(960)
}
fn tone_samples(samples: usize) -> Vec<u8> {
let handle = opus().unwrap()._handle as *mut libc::c_void;
let create: unsafe extern "C" fn(i32, i32, i32, *mut i32) -> *mut libc::c_void = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_create".as_ptr()))
};
let encode: unsafe extern "C" fn(*mut libc::c_void, *const i16, i32, *mut u8, i32) -> i32 = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encode".as_ptr()))
};
let destroy: unsafe extern "C" fn(*mut libc::c_void) = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_destroy".as_ptr()))
};
let pcm: Vec<i16> = (0..samples).flat_map(|i| {
let s = ((i as f64 * std::f64::consts::TAU * 1000. / 48000.).sin() * 6000.) as i16;
[s, s]
}).collect();
let mut error = 0;
let enc = unsafe { create(48000, 2, 2048, &mut error) };
assert_eq!(error, 0);
assert!(!enc.is_null());
let mut out = vec![0; 4000];
let n = unsafe { encode(enc, pcm.as_ptr(), samples as i32, out.as_mut_ptr(), out.len() as i32) };
unsafe { destroy(enc); }
assert!(n > 0);
out.truncate(n as usize);
out
}
fn packet(seq: u16, data: &[u8]) -> Packet {
packet_at(seq, u32::from(seq) * 960, data)
}
fn packet_at(seq: u16, timestamp: u32, data: &[u8]) -> Packet {
Packet { header: webrtc::rtp::header::Header { version: 2, sequence_number: seq,
timestamp, marker: true, ..Default::default() },
payload: bytes::Bytes::copy_from_slice(data) }
}
fn rms(bytes: &[u8]) -> f64 {
let sum: f64 = bytes.chunks_exact(2).map(|s| f64::from(i16::from_le_bytes([s[0], s[1]])).powi(2)).sum();
(sum / (bytes.len() / 2).max(1) as f64).sqrt()
}
#[test]
fn opus_decodes_generated_tone_and_conceals_loss() {
if !have_opus() { return; }
assert!(!valid_packet(&[]));
assert!(!valid_packet(&vec![0; 8193]));
let data = tone();
let mut decoder = Decoder::new().unwrap();
let (pcm, frames) = decoder.decode(&Frame::Opus(data)).unwrap();
assert_eq!(frames, 960);
assert_eq!(pcm.len(), 3840);
assert!(rms(&pcm) > 1000.);
assert_eq!(decoder.decode(&Frame::Conceal(960)).unwrap().0.len(), 3840);
assert!(decoder.decode(&Frame::Opus(vec![])).is_err());
assert!(decoder.decode(&Frame::Conceal(0)).is_err());
}
#[test]
fn reorder_handles_wrap_loss_duplicates_and_bounded_backlog() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
for seq in [65535, 1, 0, 0] { jitter.push(packet(seq, &data)); }
for _ in 0..3 { assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone()))); }
assert!(jitter.pop().is_none());
jitter.push(packet(3, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // sequence 2 was lost
assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone())));
jitter.push(packet(0, &data)); // late retransmission
assert!(jitter.pop().is_none());
for seq in 4..1000 { jitter.push(packet(seq, &data)); assert!(jitter.packets.len() <= MAX_PACKETS as usize); }
assert!(jitter.next.unwrap() >= 988);
}
#[test]
fn loss_duration_follows_rtp_clock_across_wrap_and_packet_sizes() {
if !have_opus() { return; }
for samples in [480, 960, 1920, 2880] {
let data = tone_samples(samples);
let mut decoder = Decoder::new().unwrap();
let mut jitter = Jitter::default();
let timestamp = u32::MAX - 239;
jitter.push(packet_at(65535, timestamp, &data));
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
jitter.push(packet_at(1, timestamp.wrapping_add(samples as u32 * 2), &data));
let loss = jitter.pop().unwrap();
assert_eq!(loss, Frame::Conceal(samples as u32));
assert_eq!(decoder.decode(&loss).unwrap().1, samples as u32);
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
assert!(jitter.pop().is_none());
}
}
#[test]
fn variable_losses_preserve_total_time_and_bound_discontinuities() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
let mut decoder = Decoder::new().unwrap();
jitter.push(packet_at(0, 0, &data));
decoder.decode(&jitter.pop().unwrap()).unwrap();
// Two missing packets total 50 ms; their individual durations cannot be inferred.
jitter.push(packet_at(3, 960 + 2400, &data));
let mut concealed = 0;
for _ in 0..2 { concealed += decoder.decode(&jitter.pop().unwrap()).unwrap().1; }
assert_eq!(concealed, 2400);
decoder.decode(&jitter.pop().unwrap()).unwrap();
jitter.push(packet_at(5, 48_000_000, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // discontinuity is not a huge loss
}
#[test]
fn ownership_lock_is_shared_across_config_directories() {
const CHILD: &str = "UU_MICROPHONE_TEST_LOCK";
if let Ok(source) = std::env::var(CHILD) {
assert!(route_lock(&source).is_err(), "a different UU_CONFIG bypassed the endpoint lock");
return;
}
let source = format!("uu-microphone-test-{}", std::process::id());
let lock = route_lock(&source).unwrap();
for config in ["first/config.json", "second/config.json"] {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::ownership_lock_is_shared_across_config_directories", "--exact"])
.env(CHILD, &source).env("UU_CONFIG", std::env::temp_dir().join(config))
.env("XDG_RUNTIME_DIR", std::env::temp_dir().join(config).with_extension("runtime"))
.env("TMPDIR", std::env::temp_dir().join(config).with_extension("temporary"))
.output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
}
drop(lock);
drop(route_lock(&source).expect("the lock must be released on drop"));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
#[test]
fn recovery_requires_exact_module_arguments_and_master() {
let args = vec!["source_name=uu-remote-microphone".into(), "master=uu-remote-mic-input.monitor".into(),
"source_properties=device.description=UU-Remote-Microphone".into(), "rate=48000".into(), "channels=2".into()];
let line = format!("42\tmodule-remap-source\t{}", args.join(" "));
assert_eq!(Module::matching_id(&line, "module-remap-source", &args), Some(42));
for foreign in [line.replace("master=uu-remote-mic-input.monitor", "master=physical-microphone"),
line.replace("description=UU-Remote-Microphone", "description=UU-Remote-Microphone-Foreign"),
format!("{line} remix=no")] {
assert_eq!(Module::matching_id(&foreign, "module-remap-source", &args), None);
}
}
#[test]
fn native_sink_options_are_not_applied_to_pipewire_or_unsupported_servers() {
assert_eq!(native_pulse("Server Name: pulseaudio\nServer Version: 13.0"), Ok(true));
assert_eq!(native_pulse("Server Name: PulseAudio (on PipeWire 1.6.9)\nServer Version: 15.0.0"), Ok(false));
assert!(native_pulse("Server Name: pulseaudio\nServer Version: 12.2").is_err());
assert!(native_pulse("Server Name: unsupported\nServer Version: 99.0").is_err());
assert!(native_pulse("").is_err());
}
#[test]
fn concurrent_track_claims_have_only_one_current_owner() {
let session = Session::new();
let claimed = Arc::new(std::sync::Barrier::new(2));
let workers: Vec<_> = (0..2).map(|_| {
let (session, claimed) = (session.clone(), claimed.clone());
std::thread::spawn(move || {
let (generation, mut owner) = session.claim_track();
claimed.wait(); // both workers start receiving only after both tracks have claimed
let current = *owner.borrow_and_update() == generation;
(generation, current)
})
}).collect();
let owners: Vec<_> = workers.into_iter().map(|w| w.join().unwrap()).collect();
assert_eq!(owners.iter().filter(|(_, current)| *current).count(), 1);
assert!(owners.contains(&(2, true)));
assert!(owners.contains(&(1, false)));
}
#[tokio::test]
async fn congested_reply_cannot_overwrite_a_later_close() {
let session = Session::new();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let (pending, wait_pending) = tokio::sync::oneshot::channel();
let (resume, wait_resume) = tokio::sync::oneshot::channel();
let sending = tokio::spawn(async move {
let notice = rx.recv().await.unwrap();
pending.send(()).unwrap();
wait_resume.await.unwrap(); // the ordered outbox is blocked in its network send
notice
});
session.action_with(23, || { tx.send(23).unwrap(); });
wait_pending.await.unwrap();
assert!(*session.open.borrow());
session.action(24); // independent TEXT callback closes while the CONTROL reply is pending
assert!(!*session.open.borrow());
resume.send(()).unwrap();
assert_eq!(sending.await.unwrap(), 23);
assert!(!*session.open.borrow(), "completing an old send must not apply an old policy");
}
#[test]
fn state_and_notice_enqueue_are_serialized_across_channels() {
let session = Session::new();
let notices = Arc::new(Mutex::new(Vec::new()));
let (inside, entered) = std::sync::mpsc::channel();
let release = Arc::new(std::sync::Barrier::new(2));
let open = {
let (session, notices, release) = (session.clone(), notices.clone(), release.clone());
std::thread::spawn(move || { session.action_with(23, || {
inside.send(()).unwrap();
release.wait();
notices.lock().unwrap().push(23);
}); })
};
entered.recv().unwrap();
let close = {
let (session, notices) = (session.clone(), notices.clone());
std::thread::spawn(move || { session.action_with(24, || { notices.lock().unwrap().push(24); }); })
};
release.wait();
open.join().unwrap(); close.join().unwrap();
assert_eq!(*notices.lock().unwrap(), [23, 24]);
assert!(!*session.open.borrow());
}
#[tokio::test]
async fn shutdown_waits_for_receivers_before_removing_endpoints() {
const CHILD: &str = "UU_MICROPHONE_TEST_SHUTDOWN";
if std::env::var_os(CHILD).is_none() {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::shutdown_waits_for_receivers_before_removing_endpoints", "--exact"])
.env(CHILD, "1").output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
return;
}
let worker = Worker::new();
let stopped = Arc::new(AtomicBool::new(false));
let finished = stopped.clone();
let task = tokio::spawn(async move {
let mut stopping = workers().stopped.subscribe();
stopping.wait_for(|stopped| *stopped).await.unwrap();
tokio::time::sleep(Duration::from_millis(20)).await;
finished.store(true, Ordering::Release);
drop(worker);
});
tokio::time::timeout(Duration::from_secs(1), shutdown()).await.unwrap();
assert!(stopped.load(Ordering::Acquire));
task.await.unwrap();
}
#[tokio::test]
async fn webrtc_microphone_obeys_mute_desktop_role_and_disconnect() {
if !have_opus() { return; }
tokio::time::timeout(Duration::from_secs(15), async {
let (left, right, router) = crate::test_network::virtual_network().await;
async fn peer(settings: webrtc::api::setting_engine::SettingEngine, registry: Registry) -> Arc<RTCPeerConnection> {
let mut m = webrtc::api::media_engine::MediaEngine::default();
m.register_default_codecs().unwrap();
Arc::new(webrtc::api::APIBuilder::new().with_media_engine(m).with_setting_engine(settings).with_interceptor_registry(registry)
.build().new_peer_connection(Default::default()).await.unwrap())
}
let pause = Arc::new(ReadPause::default());
let sender = peer(left, Registry::new()).await;
let host = peer(right, pause_registry(pause.clone())).await;
// Match the real host: its existing desktop sound track negotiates a bidirectional m-line.
host.add_track(Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "desktop-sound".into(), "host".into()))).await.unwrap();
let track = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "mic".into(), "generated-tone".into()));
sender.add_track(track.clone()).await.unwrap();
let replacement = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "replacement-mic".into(), "generated-tone".into()));
sender.add_track(replacement.clone()).await.unwrap();
let (created, mut outputs) = tokio::sync::mpsc::unbounded_channel();
let session = Session { factory: Arc::new(move || {
let (writer, reader) = tokio::io::duplex(65536);
created.send(reader).unwrap();
Ok(Playback { decoder: Decoder::new()?, writer: Box::pin(writer), output: None })
}), ..Session::new() };
assert!(!session.action(2));
assert!(session.action(24));
let (desktop, active) = watch::channel(true);
session.attach(&host, active);
let mut gathered = sender.gathering_complete_promise().await;
let offer = sender.create_offer(None).await.unwrap();
sender.set_local_description(offer).await.unwrap(); gathered.recv().await;
host.set_remote_description(sender.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.gathering_complete_promise().await;
let answer = host.create_answer(None).await.unwrap();
host.set_local_description(answer).await.unwrap(); gathered.recv().await;
sender.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while sender.connection_state() != RTCPeerConnectionState::Connected { tokio::time::sleep(Duration::from_millis(10)).await; }
let data = tone();
let sending = tokio::spawn(async move {
for seq in 0..500 { let _ = track.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(outputs.try_recv().is_err()); // muted before the first packet
session.action(23);
let mut pcm = outputs.recv().await.unwrap();
let mut frame = vec![0; 3840];
pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
// Playback must keep pace with a continuous 20 ms source, not add a polling delay
// to every frame (which eventually overflows the jitter buffer and skips speech).
let mut played_frames = 0;
let _ = tokio::time::timeout(Duration::from_millis(600), async {
loop { pcm.read_exact(&mut frame).await.unwrap(); played_frames += 1; }
}).await;
assert!((25..=35).contains(&played_frames), "wrong real-time playout rate: {played_frames} frames / 600 ms");
pause.requested.store(true, Ordering::Release);
pause.entered.notified().await;
// Span several playout ticks and at least two health ticks with a consumed RTP packet.
tokio::time::sleep(Duration::from_millis(250)).await;
pause.resume.notify_one();
tokio::time::timeout(Duration::from_secs(1), pause.completed.notified()).await
.expect("timer ticks cancelled a pending RTP read and lost its packet");
let data = tone();
let replacing = tokio::spawn(async move {
for seq in 0..500 { let _ = replacement.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
let mut replacement_pcm = outputs.recv().await.unwrap();
replacement_pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
let mut pcm = replacement_pcm;
session.action(24);
let mut remainder = Vec::new();
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut remainder)).await.unwrap().unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err());
desktop.send_replace(false);
session.action(23);
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err()); // a demoted desktop cannot inject audio
desktop.send_replace(true);
let mut resumed = outputs.recv().await.unwrap();
resumed.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
host.close().await.unwrap(); sender.close().await.unwrap();
tokio::time::timeout(Duration::from_secs(1), resumed.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
sending.abort(); replacing.abort(); router.lock().await.stop().await.unwrap();
}).await.expect("microphone WebRTC integration timed out");
}
/// Explicit opt-in only; records the generated tone from our isolated virtual source in memory.
#[tokio::test]
#[ignore]
async fn pipewire_virtual_microphone_receives_generated_tone() {
assert!(requested(), "run with UU_MICROPHONE=1; the test creates independent audio endpoints");
let sink = format!("uu-mic-test-input-{}", std::process::id());
let source = format!("uu-mic-test-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
let mut player = Playback::at(&sink).unwrap();
let (stop, mut stopped) = watch::channel(false);
let generating = tokio::spawn(async move {
let data = tone();
for _ in 0..100 {
if *stopped.borrow() { break; }
player.write(&Frame::Opus(data.clone())).await.unwrap();
tokio::select! { _ = stopped.changed() => break, _ = tokio::time::sleep(Duration::from_millis(20)) => {} }
}
player.stop().await;
});
let received = tokio::time::timeout(Duration::from_secs(4), async {
let mut frame = vec![0; 3840];
loop { capture.read_exact(&mut frame).await?; if rms(&frame) > 1000. { return Ok::<_, std::io::Error>(()); } }
}).await;
let inputs = pactl(&["--format=json", "list", "sink-inputs"]);
let devices = [pactl(&["--format=json", "list", "sinks"]), pactl(&["--format=json", "list", "sources"])];
let stopped = recorder.kill().await;
stop.send_replace(true);
let generated = generating.await;
drop(route);
let sources = pactl(&["list", "short", "sources"]).unwrap();
assert!(!sources.lines().any(|line| line.split('\t').nth(1) == Some(source.as_str())));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
stopped.unwrap();
assert!(!generated.is_err_and(|e| e.is_panic()), "tone generator panicked");
received.expect("generated tone did not reach the virtual microphone").unwrap();
let inputs: serde_json::Value = serde_json::from_str(&inputs.unwrap()).unwrap();
let pid = std::process::id().to_string();
let properties = inputs.as_array().unwrap().iter().find_map(|input| {
let properties = input.get("properties")?;
(properties.get("application.process.id")?.as_str()? == pid
&& properties.get("media.name")?.as_str()? == crate::i18n::s("远程麦克风", "Remote-Microphone")).then_some(properties)
}).expect("localized microphone stream missing");
assert_eq!(properties["application.name"], crate::i18n::s("UU 远程麦克风", "UU Remote microphone"));
for (data, name, description) in [
(&devices[0], &sink, crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input")),
(&devices[1], &source, crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone")),
] {
let devices: serde_json::Value = serde_json::from_str(data.as_ref().unwrap()).unwrap();
let device = devices.as_array().unwrap().iter().find(|device| device["name"] == name.as_str()).unwrap();
assert_eq!(device["description"], description);
}
}
/// Run through contrib/check-microphone-pulse.py, never against the desktop's audio server.
#[tokio::test]
#[ignore]
async fn pulse_target_loss_never_routes_to_default_output() {
assert_eq!(std::env::var("UU_MICROPHONE_ISOLATED_TEST").as_deref(), Ok("1"));
assert!(std::env::var("PULSE_SERVER").is_ok_and(|s| s.starts_with("unix:")));
assert!(pactl(&["list", "short", "sinks"]).unwrap().is_empty(), "requires an empty isolated server");
assert!(pactl(&["list", "short", "sources"]).unwrap().is_empty(), "requires an empty isolated server");
let fallback_name = format!("uu-mic-test-default-{}", std::process::id());
let fallback = Module::open("module-null-sink", sink_args(&fallback_name).unwrap()).unwrap();
struct Fallback(Module);
impl Drop for Fallback { fn drop(&mut self) { self.0.unload(); } }
let _fallback = Fallback(fallback);
pactl(&["set-default-sink", &fallback_name]).unwrap();
let sink = format!("uu-mic-test-pinned-{}", std::process::id());
let source = format!("uu-mic-test-pinned-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut player = Playback::at(&sink).unwrap();
let generating = tokio::spawn(async move {
let frame = Frame::Opus(tone());
let mut failed_closed = false;
for _ in 0..150 {
if player.write(&frame).await.is_err() { failed_closed = true; break; }
tokio::time::sleep(Duration::from_millis(20)).await;
}
player.stop().await;
failed_closed
});
tokio::time::timeout(Duration::from_secs(3), async {
while pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
}).await.unwrap();
let mut probe = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut baseline = probe.stdout.take().unwrap();
let flowing = tokio::time::timeout(Duration::from_secs(3), async {
let mut frame = vec![0; 3840];
let mut audible = 0;
loop {
baseline.read_exact(&mut frame).await?;
audible = if rms(&frame) > 1000. { audible + 1 } else { 0 };
if audible >= 15 { return Ok::<_, std::io::Error>(()); } // 300 ms of healthy playback
}
}).await;
let probe_stopped = probe.kill().await;
if !matches!(&flowing, Ok(Ok(()))) {
generating.abort(); let _ = generating.await;
panic!("no sustained generated tone before removing the target: {flowing:?}");
}
probe_stopped.unwrap();
flowing.expect("no sustained generated tone before removing the target").unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={fallback_name}.monitor"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(!generating.is_finished(), "playback failed before the target was removed");
route.source.unload(); route.sink.unload(); // remove the target while audio is still flowing
let mut generating = generating;
let ended = tokio::time::timeout(Duration::from_secs(2), &mut generating).await;
if ended.is_err() { generating.abort(); let _ = generating.await; }
let mut peak = 0.0_f64;
let observed = async {
let deadline = tokio::time::sleep(Duration::from_millis(350));
tokio::pin!(deadline);
let mut frame = vec![0; 3840];
loop { tokio::select! {
_ = &mut deadline => break,
read = capture.read_exact(&mut frame) => { read?; peak = peak.max(rms(&frame)); },
} }
Ok::<_, std::io::Error>(())
}.await;
recorder.kill().await.unwrap();
observed.unwrap();
assert!(ended.expect("playback did not stop after its target disappeared").unwrap());
assert!(pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty());
assert_eq!(peak, 0.0, "microphone audio reached the default output");
drop(route);
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
+532 -66
View File
@@ -35,19 +35,25 @@ mod permissions;
#[cfg(all(target_os = "linux", feature = "portal"))] #[cfg(all(target_os = "linux", feature = "portal"))]
mod native { mod native {
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}}; use std::{ffi::c_void, ptr::NonNull, sync::{Arc, Mutex, MutexGuard, TryLockError}};
crate::engine_ffi! { crate::engine_plugin::Engine::Portal; crate::engine_ffi! { crate::engine_plugin::Engine::Portal;
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void; fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void; fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void; fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_open_persist_capture(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void; fn uu_portal_open_persist_capture(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_open_detailed(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void, i32, i32, i32), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, source_types: u32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_set_cursor_mode(mode: i32);
fn uu_portal_cursor_mode(portal: *mut c_void) -> i32;
fn uu_portal_cursor_modes(portal: *mut c_void) -> i32;
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32; fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
fn uu_portal_clipboard_ready(portal: *mut c_void) -> i32; fn uu_portal_clipboard_ready(portal: *mut c_void) -> i32;
fn uu_portal_clipboard_set(portal: *mut c_void, text: *const u8, length: usize) -> i32; fn uu_portal_clipboard_set(portal: *mut c_void, text: *const u8, length: usize) -> i32;
fn uu_portal_clipboard_copy(from: *mut c_void, to: *mut c_void) -> i32;
fn uu_portal_clipboard_poll(portal: *mut c_void, text: *mut u8, capacity: usize) -> i32; fn uu_portal_clipboard_poll(portal: *mut c_void, text: *mut u8, capacity: usize) -> i32;
fn uu_portal_close(portal: *mut c_void); fn uu_portal_close(portal: *mut c_void);
fn uu_portal_alive(portal: *mut c_void) -> i32; fn uu_portal_alive(portal: *mut c_void) -> i32;
fn uu_portal_capture_alive(portal: *mut c_void) -> i32; fn uu_portal_capture_alive(portal: *mut c_void) -> i32;
fn uu_portal_wait_frame(portal: *mut c_void, timeout_us: i64) -> i32;
fn uu_portal_input_dispatch(portal: *mut c_void); fn uu_portal_input_dispatch(portal: *mut c_void);
fn uu_portal_reset_frame(portal: *mut c_void); fn uu_portal_reset_frame(portal: *mut c_void);
fn uu_portal_capture_since(portal: *mut c_void, bgra: *mut u8, length: usize, revision: *mut u64) -> i32; fn uu_portal_capture_since(portal: *mut c_void, bgra: *mut u8, length: usize, revision: *mut u64) -> i32;
@@ -67,15 +73,22 @@ mod native {
} }
struct Handle(NonNull<c_void>); struct Handle(NonNull<c_void>);
fn pack(width: u32, height: u32) -> u64 { (u64::from(width) << 32) | u64::from(height) } 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. // Calls are serialized by Session's mutex except wait_frame, whose C-side
// condition wait synchronizes with callbacks and input through the engine lock.
unsafe impl Send for Handle {} unsafe impl Send for Handle {}
unsafe impl Sync for Handle {}
impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } } impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } }
fn lease_handle<T>(current: &Mutex<Arc<T>>) -> Result<Arc<T>, String> {
current.lock().map(|handle| Arc::clone(&handle)).map_err(|_| "Portal session lock poisoned".into())
}
fn blank_changed(frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> bool { fn blank_changed(frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> bool {
if *version == Some(super::FrameVersion(0, 0)) { return false; } if *version == Some(super::FrameVersion(0, 0)) { return false; }
super::blank(frame); *version = Some(super::FrameVersion(0, 0)); true super::blank(frame); *version = Some(super::FrameVersion(0, 0)); true
} }
// Portal preparation and native teardown can wait for consent or D-Bus. // Portal preparation and native teardown can wait for consent or D-Bus.
// Only the swap may hold the mutex shared with input and clipboard. // Only the swap may hold the mutex shared with input and clipboard.
// Only the unit tests swap a test handle now; production swaps carry the clipboard.
#[cfg(test)]
fn replace_handle<T>(current: &Mutex<T>, locked: MutexGuard<'_, T>, prepare: impl FnOnce() -> Result<Option<T>, String>) -> Result<bool, String> { fn replace_handle<T>(current: &Mutex<T>, locked: MutexGuard<'_, T>, prepare: impl FnOnce() -> Result<Option<T>, String>) -> Result<bool, String> {
drop(locked); drop(locked);
let Some(replacement) = prepare()? else { return Ok(false); }; let Some(replacement) = prepare()? else { return Ok(false); };
@@ -86,6 +99,24 @@ mod native {
drop(old); drop(old);
Ok(true) Ok(true)
} }
/// Like `replace_handle`, but carries the viewer's clipboard text before the old session
/// closes. Clipboard writers wait from before the swap until the carry-over finishes.
fn replace_handle_carrying(current: &Mutex<Arc<Handle>>, clipboard_write: &Mutex<()>, locked: MutexGuard<'_, Arc<Handle>>, prepare: impl FnOnce() -> Result<Option<Arc<Handle>>, String>) -> Result<bool, String> {
drop(locked);
let Some(replacement) = prepare()? else { return Ok(false); };
let _clipboard = clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned")?;
let _serial = crate::input::lock_portal_held();
let (old, installed) = {
let mut handle = current.lock().map_err(|_| "Portal session lock poisoned")?;
let old = std::mem::replace(&mut *handle, replacement);
(old, Arc::clone(&*handle))
};
unsafe { uu_portal_clipboard_copy(old.0.as_ptr(), installed.0.as_ptr()) };
drop(old);
// The replaced devices took any held portal input with them.
crate::input::portal_session_replaced();
Ok(true)
}
#[derive(Default)] #[derive(Default)]
struct Recovery { retry_at: Option<std::time::Instant>, failed_until: Option<std::time::Instant>, denied: bool } struct Recovery { retry_at: Option<std::time::Instant>, failed_until: Option<std::time::Instant>, denied: bool }
impl Recovery { impl Recovery {
@@ -111,7 +142,7 @@ mod native {
was_locked.store(false, std::sync::atomic::Ordering::Release); 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>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool } pub struct Session { handle: Mutex<Arc<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>>, virtual_output: std::sync::atomic::AtomicBool, clipboard_write: Mutex<()>, end_generation: Arc<std::sync::atomic::AtomicU64> }
impl Session { impl Session {
fn take_lock_observation(&self) -> Result<bool, String> { fn take_lock_observation(&self) -> Result<bool, String> {
// A recovery in progress must see the lock even if another capture // A recovery in progress must see the lock even if another capture
@@ -132,6 +163,44 @@ mod native {
Ok(()) Ok(())
} }
} }
/// Swap `replacement` in, carrying the viewer's clipboard text before the old session
/// closes. `expected` rejects a desktop end that raced the open.
fn install_replacement(&self, replacement: Self, expected: Option<u64>, defer_held: bool, refresh_privacy: bool) -> Result<(u32, u32), String> {
let size = replacement.size();
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned".to_string())?;
let clipboard = self.clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned".to_string())?;
// Records made against the new handle must postdate the reset below.
let serial = crate::input::lock_portal_held();
// Checked under the serial lock: an input recorded after an earlier check would
// otherwise be destroyed with the session it was sent to.
if defer_held && crate::input::portal_input_held() { return Err("input held during the swap".into()); }
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned".to_string())?;
if expected.is_some_and(|generation| self.end_generation.load(std::sync::atomic::Ordering::Acquire) != generation) {
return Err("desktop session ended during the rebuild".into());
}
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
let previous_handle = std::mem::replace(&mut *handle, next);
let installed = Arc::clone(&*handle);
drop(handle);
if unsafe { uu_portal_clipboard_copy(previous_handle.0.as_ptr(), installed.0.as_ptr()) } < 0 {
log::warn!("Portal clipboard ownership could not be carried over");
}
drop(clipboard);
drop(previous_handle);
// The replaced devices took any held portal input with them.
crate::input::portal_session_replaced();
drop(serial);
// A replaced virtual output can move in the layout; absolute input needs its new share.
if refresh_privacy { crate::privacy_screen::refresh_pointer_region(); }
Ok(size)
}
/// Point the host and the engine at the cursor mode the installed session really has.
fn restore_installed_cursor_mode(&self, fallback: bool) {
let installed = self.handle.lock().ok().map(|handle| unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) }).unwrap_or(0);
let embedded = if installed > 0 { installed == 2 } else { fallback };
unsafe { uu_portal_set_cursor_mode(if embedded { 2 } else { 1 }); }
super::CURSOR_MODE.store(if embedded { 2 } else { 1 }, std::sync::atomic::Ordering::Release);
}
pub fn is_alive(&self) -> bool { pub fn is_alive(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 }) self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
} }
@@ -153,6 +222,7 @@ mod native {
let directory = super::permissions::directory(); let directory = super::permissions::directory();
let key = super::permissions::desktop_key(); let key = super::permissions::desktop_key();
let wanted = if virtual_output { None } else { monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor) }; let wanted = if virtual_output { None } else { monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor) };
let wanted_key = wanted.as_deref().map(super::permissions::monitor_key);
let virtual_key = format!("{key}-virtual"); let virtual_key = format!("{key}-virtual");
// One opener at a time: consent tokens are single-use, and two concurrent openers // One opener at a time: consent tokens are single-use, and two concurrent openers
// (privacy virtual-output switch and closure recovery after a quick reconnect) each // (privacy virtual-output switch and closure recovery after a quick reconnect) each
@@ -163,71 +233,110 @@ mod native {
let taken = directory.as_deref().filter(|_| !fresh).and_then(|dir| { let taken = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
let take = |k: String| super::permissions::take(dir, &k).map(|v| (k, v)); let take = |k: String| super::permissions::take(dir, &k).map(|v| (k, v));
if virtual_output { return take(virtual_key.clone()); } if virtual_output { return take(virtual_key.clone()); }
wanted.as_deref().and_then(|name| take(super::permissions::monitor_key(name))).or_else(|| take(key.to_owned())) wanted_key.as_ref().and_then(|name| take(super::permissions::pending_key(name)).or_else(|| take(name.clone())))
.or_else(|| take(super::permissions::pending_key(key))).or_else(|| take(key.to_owned()))
}); });
let token = taken.as_ref().and_then(|(_, value)| std::ffi::CString::new(value.as_str()).ok()); let token = taken.as_ref().and_then(|(_, value)| std::ffi::CString::new(value.as_str()).ok());
// The new token is saved once the granted monitor is known (after open). let requested_key = if virtual_output { &virtual_key } else { wanted_key.as_deref().unwrap_or(key) };
let mut cache: Option<String> = None; struct TokenCache { rotation: super::permissions::Rotation, virtual_key: Option<String>, fresh: bool }
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) { let mut cache = TokenCache {
// Callback is synchronous during open; cache lives through the call. rotation: super::permissions::Rotation::new(directory.clone(), requested_key),
virtual_key: virtual_output.then(|| virtual_key.clone()), fresh,
};
extern "C" fn save_detailed(token: *const libc::c_char, data: *mut c_void, has_position: i32, x: i32, y: i32) {
let result = std::panic::catch_unwind(|| unsafe { let result = std::panic::catch_unwind(|| unsafe {
let cache = &mut *(data as *mut Option<String>); let cache = &mut *(data as *mut TokenCache);
*cache = std::ffi::CStr::from_ptr(token).to_str().ok().map(str::to_owned); if let Ok(token) = std::ffi::CStr::from_ptr(token).to_str() {
if cache.fresh { cache.rotation.remember(token); return; }
let granted = cache.virtual_key.clone().or_else(||
(has_position != 0).then(|| crate::wayland::portal_monitor_at(x, y)).flatten()
.map(|name| super::permissions::monitor_key(&name)));
if cache.rotation.record(token, granted.as_deref()).is_err() { log::warn!("Portal permission cache could not be saved"); }
}
}); });
if result.is_err() { log::warn!("Portal permission cache callback failed"); } if result.is_err() { log::warn!("Portal permission cache callback failed"); }
} }
// Older plugins lack the position-aware entry point; use the pending slot.
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
save_detailed(token, data, 0, 0, 0);
}
let restore = token.as_ref().map_or(std::ptr::null(), |value| value.as_ptr()); let restore = token.as_ref().map_or(std::ptr::null(), |value| value.as_ptr());
// A failed open must not cost the saved consent: put the token back unless the let failed = |code: i32, cache: &TokenCache| {
// portal handed out a new one. A stale token only makes the next open ask again. if let (Some(dir), Some((k, value)), false) = (directory.as_deref(), taken.as_ref(), cache.rotation.received()) {
let failed = |code: i32, cache: &Option<String>| {
if let (Some(dir), Some((k, value)), None) = (directory.as_deref(), taken.as_ref(), cache.as_ref()) {
if super::permissions::save(dir, k, value).is_err() { log::warn!("Portal permission cache could not be restored"); } if super::permissions::save(dir, k, value).is_err() { log::warn!("Portal permission cache could not be restored"); }
} }
super::PortalError { code } super::PortalError { code }
}; };
// Release packages can temporarily have an older libuu-portal.so than the host.
#[cfg(feature = "engine-plugins")]
let detailed = crate::engine_plugin::symbol(crate::engine_plugin::Engine::Portal, "uu_portal_open_detailed\0") != 0;
#[cfg(not(feature = "engine-plugins"))]
let detailed = true;
#[allow(unused_mut)] #[allow(unused_mut)]
let mut pointer: *mut c_void = std::ptr::null_mut(); let mut prefer_dmabuf = false;
#[cfg(feature = "inproc-av")] #[cfg(feature = "inproc-av")]
if !virtual_output && crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal) if !virtual_output && crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal)
&& !std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0") { && !std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0") {
let callback = cancelled.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32); prefer_dmabuf = true;
let cancel_data = cancelled.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
pointer = unsafe { uu_portal_open_persist_capture(
restore, save_token, &mut cache as *mut _ as *mut c_void, callback, cancel_data, 1,
&mut error, &mut width, &mut height,
) };
if pointer.is_null() && error != 0 { return Err(failed(error, &cache)); }
if pointer.is_null() { log::warn!("Portal engine lacks DMA-BUF initialization; falling back to legacy initialization"); }
} }
let pointer = if !pointer.is_null() { pointer } else { unsafe { let pointer = if detailed {
if virtual_output { // Virtual shares can wait for consent too; cancel them like monitor opens.
uu_portal_open_virtual(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height) let cancel = cancelled;
} else if let Some(cancelled) = cancelled { let callback = cancel.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
uu_portal_open_persist_cancellable( let cancel_data = cancel.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
restore, save_token, &mut cache as *mut _ as *mut c_void, unsafe { uu_portal_open_detailed(
is_cancelled, cancelled as *const _ as *mut c_void, restore, save_detailed, &mut cache as *mut _ as *mut c_void, callback, cancel_data,
i32::from(prefer_dmabuf), if virtual_output { 4 } else { 1 },
&mut error, &mut width, &mut height,
) }
} else {
#[allow(unused_mut)]
let mut pointer: *mut c_void = std::ptr::null_mut();
#[cfg(feature = "inproc-av")]
if prefer_dmabuf {
let callback = cancelled.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
let cancel_data = cancelled.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
pointer = unsafe { uu_portal_open_persist_capture(
restore, save_token, &mut cache as *mut _ as *mut c_void, callback, cancel_data, 1,
&mut error, &mut width, &mut height, &mut error, &mut width, &mut height,
) ) };
} else { if pointer.is_null() && error != 0 { return Err(failed(error, &cache)); }
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height) if pointer.is_null() { log::warn!("Portal engine lacks DMA-BUF initialization; falling back to legacy initialization"); }
} }
} }; if !pointer.is_null() { pointer } else { unsafe {
let Some(handle) = NonNull::new(pointer) else { return Err(failed(error, &cache)) }; if virtual_output {
uu_portal_open_virtual(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
} else if let Some(cancelled) = cancelled {
uu_portal_open_persist_cancellable(restore, save_token, &mut cache as *mut _ as *mut c_void,
is_cancelled, cancelled as *const _ as *mut c_void, &mut error, &mut width, &mut height)
} else {
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
}
} }
};
let Some(handle) = NonNull::new(pointer) else { return Err(failed(if error == 0 { 15 } else { error }, &cache)) };
let (mut x, mut y) = (0, 0); let (mut x, mut y) = (0, 0);
let granted = (!virtual_output && unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0) let granted = (!virtual_output && unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
.then(|| crate::wayland::portal_monitor_at(x, y)).flatten(); .then(|| crate::wayland::portal_monitor_at(x, y)).flatten();
if let (Some(dir), Some(token)) = (directory.as_deref(), cache.take()) { let saved = match &granted {
let saved = match &granted { _ if virtual_output => virtual_key.clone(),
_ if virtual_output => virtual_key.clone(), Some(name) => super::permissions::monitor_key(name),
Some(name) => super::permissions::monitor_key(name), None => key.to_owned(),
None => key.to_owned(), };
}; if cache.rotation.finish(&saved, fresh || virtual_output || granted.is_some()).is_err() {
if super::permissions::save(dir, &saved, &token).is_err() { log::warn!("Portal permission cache could not be saved"); } log::warn!("Portal permission cache could not be saved");
} }
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); } if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
// Keep a freshly granted compositor frame regardless of lock state. Discarding it // Keep a freshly granted compositor frame regardless of lock state. Discarding it
// before new damage can leave a static desktop permanently blank (#2). // before new damage can leave a static desktop permanently blank (#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()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into() }) let handle = Arc::new(Handle(handle));
// The engine records what it actually requested; a backend can refuse the mode the
// environment or a runtime switch asked for.
let available = unsafe { uu_portal_cursor_modes(handle.0.as_ptr()) };
let applied = unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) };
if applied > 0 { super::CURSOR_MODE.store(if applied == 2 { 2 } else { 1 }, std::sync::atomic::Ordering::Release); }
if available > 0 { super::CURSOR_EMBED.store(if available & 2 != 0 { 2 } else { 1 }, std::sync::atomic::Ordering::Release); }
Ok(Self { handle: Mutex::new(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), virtual_output: virtual_output.into(), clipboard_write: Mutex::new(()), end_generation: Arc::new(std::sync::atomic::AtomicU64::new(0)) })
} }
/// Frame pixels of the monitor the stream currently follows. /// Frame pixels of the monitor the stream currently follows.
pub fn size(&self) -> (u32, u32) { pub fn size(&self) -> (u32, u32) {
@@ -237,7 +346,13 @@ mod native {
/// End the compositor session (screen-share indicator off); the next desktop /// End the compositor session (screen-share indicator off); the next desktop
/// connection reopens it with the saved consent. /// connection reopens it with the saved consent.
pub fn end(&self) { pub fn end(&self) {
// Invalidate an open that is still waiting for consent: it must not install a share
// after the desktop was ended (viewer disconnect, idle shutdown, capture teardown).
self.end_generation.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
if let Ok(handle) = self.handle.lock() { unsafe { uu_portal_end(handle.0.as_ptr()) }; } if let Ok(handle) = self.handle.lock() { unsafe { uu_portal_end(handle.0.as_ptr()) }; }
// The ended session's native devices are gone; forget the inputs bound to them.
let _serial = crate::input::lock_portal_held();
crate::input::portal_session_replaced();
} }
/// Mutter connector of the monitor this session captures, when several are advertised. /// 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()) } pub fn monitor(&self) -> Option<String> { self.monitor.lock().ok().and_then(|m| m.clone()) }
@@ -245,19 +360,15 @@ mod native {
/// time GNOME asks on the host) and swap it in, so every holder of this Arc follows. /// 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> { pub fn switch_to(&self, connector: &str) -> Result<(), String> {
if self.monitor().as_deref() == Some(connector) { return Ok(()); } if self.monitor().as_deref() == Some(connector) { return Ok(()); }
// Both this and the cursor-mode rebuild replace the handle: serialize them so the
// later open cannot install a stale source over the other.
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
let replacement = Self::open_inner(None, Some(connector), false, false).map_err(|error| error.to_string())?; let replacement = Self::open_inner(None, Some(connector), false, false).map_err(|error| error.to_string())?;
if replacement.monitor().as_deref() != Some(connector) { if replacement.monitor().as_deref() != Some(connector) {
return Err("Another monitor was shared; choose this monitor in the host dialog".into()); return Err("Another monitor was shared; choose this monitor in the host dialog".into());
} }
let size = replacement.size(); self.install_replacement(replacement, None, false, false)?;
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()); } if let Ok(mut monitor) = self.monitor.lock() { *monitor = Some(connector.to_owned()); }
drop(previous);
Ok(()) Ok(())
} }
pub fn is_virtual(&self) -> bool { self.virtual_output.load(std::sync::atomic::Ordering::Acquire) } pub fn is_virtual(&self) -> bool { self.virtual_output.load(std::sync::atomic::Ordering::Acquire) }
@@ -272,18 +383,116 @@ mod native {
// exists (seen live: 3968x1280 = panel + virtual), so end the virtual share first. // exists (seen live: 3968x1280 = panel + virtual), so end the virtual share first.
if !on { self.end(); } if !on { self.end(); }
let replacement = Self::open_inner(None, monitor.as_deref(), false, on).map_err(|error| error.to_string())?; let replacement = Self::open_inner(None, monitor.as_deref(), false, on).map_err(|error| error.to_string())?;
let size = replacement.size(); let size = self.install_replacement(replacement, None, false, false)?;
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?; self.virtual_output.store(on, std::sync::atomic::Ordering::Release);
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);
self.virtual_output.store(on, std::sync::atomic::Ordering::Release);
std::mem::replace(&mut *handle, next)
};
drop(previous);
log::info!("Portal capture source: virtual={on} size={}x{}", size.0, size.1); log::info!("Portal capture source: virtual={on} size={}x{}", size.0, size.1);
Ok(()) Ok(())
} }
/// Ask the compositor to draw the pointer into the stream (embedded) or keep it out
/// (hidden). The portal only reads this when the session is created, so swap in a fresh
/// session with the saved consent; every holder of this Arc follows the new handle.
/// Ok(true): the mode changed. Ok(false): nothing to do, or the desktop is locked and the
/// next unlocked motion retries.
pub fn set_cursor_embedded(&self, embedded: bool) -> Result<bool, String> {
use std::sync::atomic::{AtomicBool, Ordering};
if super::cursor_embedded() == embedded { return Ok(false); }
// Sample before waiting for `recovery`: an end that happens while this worker is
// queued must invalidate the rebuild below.
let generation = self.end_generation.load(Ordering::Acquire);
if *self.locked.borrow() != Some(false) { return Ok(false); }
// A backend without the embedded cursor mode never applies the request; remember it
// so motion does not spawn a rebuild every few events.
let modes = self.handle.lock().map(|handle| unsafe { uu_portal_cursor_modes(handle.0.as_ptr()) }).unwrap_or(0);
if modes > 0 && modes & 2 == 0 { super::CURSOR_EMBED.store(1, Ordering::Release); return Ok(false); }
if modes & 2 != 0 { super::CURSOR_EMBED.store(2, Ordering::Release); }
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
if super::cursor_embedded() == embedded { return Ok(false); }
if *self.locked.borrow() != Some(false) { return Ok(false); }
// The session this rebuild replaces must still be running: a viewer that left or an
// idle shutdown ends it, and a replacement opened afterwards would share with nobody.
if !self.is_alive() { return Ok(false); }
if crate::input::portal_input_held() { return Ok(false); }
let previous = super::cursor_embedded();
let virtual_output = self.is_virtual();
let monitor = self.monitor();
// A lock or desktop end during the open must cancel the consent request, not wait
// out its timeout.
let cancel = Arc::new(AtomicBool::new(false));
let stop = Arc::new(AtomicBool::new(false));
let watcher = {
let locked = self.locked.clone();
let end_generation = self.end_generation.clone();
let cancel = cancel.clone();
let stop = stop.clone();
std::thread::Builder::new().name("portal-cursor-lock".into()).spawn(move || {
while !stop.load(Ordering::Acquire) {
if *locked.borrow() != Some(false) || end_generation.load(Ordering::Acquire) != generation {
cancel.store(true, Ordering::Release);
return;
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
}).ok()
};
unsafe { uu_portal_set_cursor_mode(if embedded { 2 } else { 1 }); }
let result = (|| -> Result<Option<((u32, u32), i32)>, String> {
let replacement = Self::open_inner(Some(&cancel), monitor.as_deref(), false, virtual_output)
.map_err(|error| error.to_string())?;
if *self.locked.borrow() != Some(false) { return Err("desktop locked during the rebuild".into()); }
if self.end_generation.load(Ordering::Acquire) != generation {
return Err("desktop session ended during the rebuild".into());
}
// A source change that finished meanwhile must not be undone by this swap.
if self.is_virtual() != virtual_output || (!virtual_output && self.monitor() != monitor) {
return Err("capture source changed during the rebuild".into());
}
// A restored consent must not silently move the share to another monitor.
if !virtual_output && monitor.is_some() && replacement.monitor() != monitor {
return Err("another monitor was shared; choose this monitor in the host dialog".into());
}
// KDE does not report the connector, so a size change is the signal that the
// replacement follows another output.
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
// A key or button can go down while the open waits for consent.
if crate::input::portal_input_held() { return Ok(None); }
let size = match self.install_replacement(replacement, Some(generation), true, virtual_output) {
Ok(size) => size,
Err(error) if error == "input held during the swap" => return Ok(None),
Err(error) => return Err(error),
};
let applied = self.handle.lock().ok().map(|handle| unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) }).unwrap_or(0);
Ok(Some((size, applied)))
})();
stop.store(true, Ordering::Release);
drop(watcher);
match result {
Ok(Some(((width, height), applied))) => {
let applied_embedded = applied == 2;
super::CURSOR_MODE.store(if applied_embedded { 2 } else { 1 }, Ordering::Release);
if applied_embedded != embedded {
// The backend refused the mode (or cannot report support); retrying would
// rebuild the session every motion run without changing anything.
super::CURSOR_EMBED.store(1, Ordering::Release);
unsafe { uu_portal_set_cursor_mode(applied) };
log::info!("Portal backend did not apply the embedded cursor");
return Ok(false);
}
log::info!("Portal cursor mode: embedded={embedded} size={width}x{height}");
Ok(true)
}
Ok(None) => {
// Deferred (input went down during the open): open_inner published the
// replacement's mode, but that session is never installed.
self.restore_installed_cursor_mode(previous);
Ok(false)
}
Err(error) => {
// Leave the engine on the mode the installed session actually has.
self.restore_installed_cursor_mode(previous);
Err(error)
}
}
}
pub fn open() -> Result<Self, String> { pub fn open() -> Result<Self, String> {
Self::open_inner(None, None, false, false).map_err(|error| error.to_string()) Self::open_inner(None, None, false, false).map_err(|error| error.to_string())
} }
@@ -298,6 +507,8 @@ mod native {
pub fn upgrade_touch(&self) -> Result<bool, String> { 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); 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); } if !available || self.touch_supported() { return Ok(false); }
// Serialize with recovery and the cursor-mode rebuild: all replace the handle.
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
log::info!("Portal touch consent: asking the host again for the touchscreen"); log::info!("Portal touch consent: asking the host again for the touchscreen");
let monitor = self.monitor(); let monitor = self.monitor();
let replacement = Self::open_inner(None, monitor.as_deref(), true, self.is_virtual()).map_err(|error| error.to_string())?; let replacement = Self::open_inner(None, monitor.as_deref(), true, self.is_virtual()).map_err(|error| error.to_string())?;
@@ -305,9 +516,7 @@ mod native {
if replacement.monitor() != monitor { return Err("another monitor was shared".into()); } if replacement.monitor() != monitor { return Err("another monitor was shared".into()); }
if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); } if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); }
self.check_geometry(&replacement).map_err(|error| error.to_string())?; self.check_geometry(&replacement).map_err(|error| error.to_string())?;
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?; self.install_replacement(replacement, None, false, self.is_virtual())?;
let previous = std::mem::replace(&mut *self.handle.lock().map_err(|_| "Portal session lock poisoned")?, next);
drop(previous);
Ok(true) Ok(true)
} }
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> { pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
@@ -342,9 +551,19 @@ mod native {
let result = super::open_then_install(cancelled, || Self::open_inner(Some(cancelled), monitor.as_deref(), false, virtual_output), |replacement| { let result = super::open_then_install(cancelled, || Self::open_inner(Some(cancelled), monitor.as_deref(), false, virtual_output), |replacement| {
self.check_geometry(&replacement)?; self.check_geometry(&replacement)?;
let replacement_handle = replacement.handle.into_inner().map_err(|_| super::PortalError { code: 3 })?; let replacement_handle = replacement.handle.into_inner().map_err(|_| super::PortalError { code: 3 })?;
let clipboard = self.clipboard_write.lock().map_err(|_| super::PortalError { code: 3 })?;
let serial = crate::input::lock_portal_held();
let mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?; let mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
if cancelled.load(Ordering::Acquire) { return Err(super::PortalError { code: 13 }); } if cancelled.load(Ordering::Acquire) { return Err(super::PortalError { code: 13 }); }
*handle = replacement_handle; let previous_handle = std::mem::replace(&mut *handle, replacement_handle);
let installed = Arc::clone(&*handle);
drop(handle);
unsafe { uu_portal_clipboard_copy(previous_handle.0.as_ptr(), installed.0.as_ptr()) };
drop(clipboard);
drop(previous_handle);
// The replaced devices took any held portal input with them.
crate::input::portal_session_replaced();
drop(serial);
clear_pause_for_unlocked_replacement(&self.was_locked, *self.locked.borrow()); clear_pause_for_unlocked_replacement(&self.was_locked, *self.locked.borrow());
log::info!("Portal capture session restored after closure"); log::info!("Portal capture session restored after closure");
Ok(()) Ok(())
@@ -435,7 +654,7 @@ mod native {
Err(TryLockError::WouldBlock) => return Ok(blank_changed(frame, version)), Err(TryLockError::WouldBlock) => return Ok(blank_changed(frame, version)),
Err(TryLockError::Poisoned(_)) => return Err("Portal recovery lock poisoned".into()), Err(TryLockError::Poisoned(_)) => return Err("Portal recovery lock poisoned".into()),
}; };
if replace_handle(&self.handle, handle, || { if replace_handle_carrying(&self.handle, &self.clipboard_write, handle, || {
{ {
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?; let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } != 0 { if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } != 0 {
@@ -491,11 +710,25 @@ mod native {
pub fn clipboard_supported(&self) -> bool { pub fn clipboard_supported(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_supported(handle.0.as_ptr()) != 0 }) self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_supported(handle.0.as_ptr()) != 0 })
} }
pub fn wait_frame(&self, timeout: std::time::Duration) -> Result<bool, String> {
let handle = lease_handle(&self.handle)?;
// Retain sub-millisecond precision across the FFI boundary and clamp to 5s.
let us = (timeout.as_micros().min(5_000_000) as i64).max(1);
let ret = unsafe { uu_portal_wait_frame(handle.0.as_ptr(), us) };
if ret < 0 {
Err("Portal stream closed or failed during frame wait".into())
} else {
Ok(ret > 0)
}
}
pub fn clipboard_ready(&self) -> bool { pub fn clipboard_ready(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_ready(handle.0.as_ptr()) != 0 }) self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_ready(handle.0.as_ptr()) != 0 })
} }
pub fn clipboard_set(&self, text: &str) -> Result<(), String> { pub fn clipboard_set(&self, text: &str) -> Result<(), String> {
if text.len()>crate::clipboard::MAX_TEXT || *self.locked.borrow()!=Some(false) { return Err("Portal clipboard unavailable".into()); } if text.len()>crate::clipboard::MAX_TEXT || *self.locked.borrow()!=Some(false) { return Err("Portal clipboard unavailable".into()); }
// Serialize with the cursor-session swap: it carries the old text over before
// releasing this lock, so a update that arrives during the swap wins afterwards.
let _write=self.clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned")?;
let handle=self.handle.lock().map_err(|_| "Portal session lock poisoned")?; let handle=self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
if unsafe { uu_portal_clipboard_set(handle.0.as_ptr(),text.as_ptr(),text.len()) }==0 {Ok(())} else {Err("Portal clipboard ownership failed".into())} if unsafe { uu_portal_clipboard_set(handle.0.as_ptr(),text.as_ptr(),text.len()) }==0 {Ok(())} else {Err("Portal clipboard ownership failed".into())}
} }
@@ -568,12 +801,14 @@ mod native {
fn new(physical: (u32, u32)) -> Self { fn new(physical: (u32, u32)) -> Self {
let (_, locked) = tokio::sync::watch::channel(None); let (_, locked) = tokio::sync::watch::channel(None);
Self(ManuallyDrop::new(Session { Self(ManuallyDrop::new(Session {
handle: Mutex::new(Handle(NonNull::dangling())), handle: Mutex::new(Arc::new(Handle(NonNull::dangling()))),
locked, locked,
was_locked: std::sync::atomic::AtomicBool::new(false), was_locked: std::sync::atomic::AtomicBool::new(false),
recovery: Mutex::new(Recovery::default()), recovery: Mutex::new(Recovery::default()),
size: pack(physical.0, physical.1).into(), size: pack(physical.0, physical.1).into(),
monitor: Mutex::new(None), virtual_output: false.into(), monitor: Mutex::new(None), virtual_output: false.into(),
clipboard_write: Mutex::new(()),
end_generation: Arc::new(std::sync::atomic::AtomicU64::new(0)),
})) }))
} }
@@ -607,6 +842,35 @@ mod native {
button_held: bool, button_held: bool,
retirement: Option<(std::sync::mpsc::Sender<()>, std::sync::mpsc::Receiver<()>)>, retirement: Option<(std::sync::mpsc::Sender<()>, std::sync::mpsc::Receiver<()>)>,
} }
#[test]
fn frame_wait_lease_keeps_replaced_handle_alive_without_blocking_input() {
use std::sync::{atomic::{AtomicBool, Ordering}, mpsc::channel};
struct Tracked(Arc<AtomicBool>);
impl Drop for Tracked { fn drop(&mut self) { self.0.store(true, Ordering::SeqCst); } }
let dropped = Arc::new(AtomicBool::new(false));
let current = Arc::new(Mutex::new(Arc::new(Tracked(dropped.clone()))));
let (waiting, ready) = channel();
let (resume, resumed) = channel();
let worker = {
let current = current.clone();
std::thread::spawn(move || {
let lease = lease_handle(&current).unwrap();
waiting.send(()).unwrap();
resumed.recv_timeout(std::time::Duration::from_secs(3)).unwrap();
assert!(!lease.0.load(Ordering::SeqCst));
})
};
ready.recv_timeout(std::time::Duration::from_secs(3)).unwrap();
let old = {
let mut guard = current.try_lock().expect("frame wait must not block input");
std::mem::replace(&mut *guard, Arc::new(Tracked(Arc::new(AtomicBool::new(false)))))
};
drop(old);
assert!(!dropped.load(Ordering::SeqCst));
resume.send(()).unwrap();
worker.join().unwrap();
assert!(dropped.load(Ordering::SeqCst));
}
impl Drop for TestHandle { impl Drop for TestHandle {
fn drop(&mut self) { fn drop(&mut self) {
if let Some((entered, resume)) = self.retirement.take() { if let Some((entered, resume)) = self.retirement.take() {
@@ -841,6 +1105,7 @@ impl PortalSession {
pub fn end(&self) {} pub fn end(&self) {}
pub fn switch_to(&self, _: &str) -> Result<(), String> { Err(error(15)) } pub fn switch_to(&self, _: &str) -> Result<(), String> { Err(error(15)) }
pub fn set_virtual(&self, _: bool) -> Result<(), String> { Err(error(15)) } pub fn set_virtual(&self, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn set_cursor_embedded(&self, _: bool) -> Result<bool, String> { Err(error(15)) }
pub fn is_virtual(&self) -> bool { false } pub fn is_virtual(&self) -> bool { false }
} }
#[cfg(not(all(target_os = "linux", feature = "portal")))] #[cfg(not(all(target_os = "linux", feature = "portal")))]
@@ -863,6 +1128,7 @@ impl PortalSession {
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(15)) } pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(15)) }
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(15)) } pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(15)) }
pub fn disable_dmabuf(&self) {} pub fn disable_dmabuf(&self) {}
pub fn wait_frame(&self, _: std::time::Duration) -> Result<bool, String> { Err(error(15)) }
pub fn with_dmabuf<T>(&self, _: &mut Option<FrameVersion>, _: impl FnOnce(&DmaFrame, bool) -> Result<T, String>) -> Result<DmaCapture<T>, String> { pub fn with_dmabuf<T>(&self, _: &mut Option<FrameVersion>, _: impl FnOnce(&DmaFrame, bool) -> Result<T, String>) -> Result<DmaCapture<T>, String> {
Ok(DmaCapture::Unavailable(-1)) Ok(DmaCapture::Unavailable(-1))
} }
@@ -880,9 +1146,14 @@ impl PortalSession {
static ACTIVE: std::sync::Mutex<Option<std::sync::Weak<PortalSession>>> = std::sync::Mutex::new(None); 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 permissions_directory() -> Option<std::path::PathBuf> { permissions::directory() }
pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connector) } pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connector) }
pub fn permission_exists(dir: &std::path::Path, key: &str) -> bool { permissions::exists(dir, key) }
pub fn register(session: &Arc<PortalSession>) { pub fn register(session: &Arc<PortalSession>) {
*ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session)); *ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session));
} }
/// Whether a desktop capture session is registered for monitor/virtual switching.
pub fn available() -> bool {
ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade).is_some()
}
/// Privacy screen: see `Session::set_virtual`. Restoring without a live session is a no-op; /// Privacy screen: see `Session::set_virtual`. Restoring without a live session is a no-op;
/// failures switching a live session must reach the controller so its recovery record survives. /// failures switching a live session must reach the controller so its recovery record survives.
pub fn set_virtual_active(on: bool) -> Result<(), String> { pub fn set_virtual_active(on: bool) -> Result<(), String> {
@@ -895,6 +1166,128 @@ pub fn switch_active(connector: &str) -> Result<(), String> {
.ok_or("Portal desktop unavailable")?; .ok_or("Portal desktop unavailable")?;
session.switch_to(connector) session.switch_to(connector)
} }
/// Whether the capture stream carries the compositor's pointer. 0 is "not asked yet"; the
/// startup answer has to match what the engine reads from UU_PORTAL_CURSOR_MODE.
static CURSOR_MODE: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
/// Embedded cursor support reported by a session: 0 unknown, 1 unavailable, 2 available.
static CURSOR_EMBED: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
fn cursor_embedded() -> bool {
use std::sync::atomic::Ordering;
match CURSOR_MODE.load(Ordering::Acquire) {
0 => {
let embedded = std::env::var("UU_PORTAL_CURSOR_MODE").is_ok_and(|value| value.eq_ignore_ascii_case("embedded"));
CURSOR_MODE.store(if embedded { 2 } else { 1 }, Ordering::Release);
embedded
}
mode => mode == 2,
}
}
/// Ask the running session for a stream with (or without) the compositor cursor.
pub fn set_cursor_embedded(embedded: bool) -> Result<bool, 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.set_cursor_embedded(embedded)
}
/// A release package can carry an older libuu-portal.so without the runtime cursor switch;
/// rebuilding the session would be wasted work there.
fn cursor_switch_available() -> bool {
#[cfg(all(target_os = "linux", feature = "portal", feature = "engine-plugins"))]
{
static AVAILABLE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
*AVAILABLE.get_or_init(|| crate::engine_plugin::symbol(crate::engine_plugin::Engine::Portal, "uu_portal_set_cursor_mode\0") != 0)
}
#[cfg(not(all(target_os = "linux", feature = "portal", feature = "engine-plugins")))]
{ cfg!(all(target_os = "linux", feature = "portal")) }
}
/// Relative motion has no position the viewer could draw a cursor at, so the stream has to carry
/// one. Absolute motion means the viewer draws its own and an embedded copy would trail it. Both
/// need a fresh portal session, so wait for a run of the same kind before rebuilding it.
struct PointerMode {
candidate: Option<bool>,
streak: u32,
first: Option<std::time::Instant>,
switching: bool,
blocked_until: Option<std::time::Instant>,
}
static POINTER_MODE: std::sync::Mutex<PointerMode> = std::sync::Mutex::new(PointerMode {
candidate: None, streak: 0, first: None, switching: false, blocked_until: None,
});
const POINTER_STREAK: u32 = 5;
/// A burst at connect must not rebuild the session, so the run has to span time as well.
const POINTER_WINDOW: std::time::Duration = std::time::Duration::from_millis(200);
/// After a failed rebuild the consent may be gone; do not retry on the next few events.
const POINTER_COOLDOWN: std::time::Duration = std::time::Duration::from_secs(5);
fn pointer_decision(state: &mut PointerMode, current: bool, relative: bool, now: std::time::Instant) -> Option<bool> {
if current == relative {
state.candidate = None;
state.streak = 0;
state.first = None;
return None;
}
if state.switching || state.blocked_until.is_some_and(|until| now < until) { return None; }
match state.candidate {
Some(candidate) if candidate == relative => {
state.streak += 1;
if state.streak >= POINTER_STREAK
&& state.first.is_some_and(|first| now.duration_since(first) >= POINTER_WINDOW) {
return Some(relative);
}
}
_ => {
state.candidate = Some(relative);
state.streak = 1;
state.first = Some(now);
}
}
None
}
pub fn note_pointer_motion(relative: bool) {
if !cursor_switch_available() { return; }
// The backend does not advertise an embedded cursor: nothing to switch to.
if CURSOR_EMBED.load(std::sync::atomic::Ordering::Acquire) == 1 { return; }
// A swap closes the portal input devices; do not drop keys or buttons the viewer holds.
if crate::input::portal_input_held() { return; }
let decision = {
let Ok(mut state) = POINTER_MODE.lock() else { return; };
let decision = pointer_decision(&mut state, cursor_embedded(), relative, std::time::Instant::now());
if decision.is_some() {
state.switching = true;
state.candidate = None;
state.streak = 0;
state.first = None;
}
decision
};
let Some(target) = decision else { return; };
let spawned = std::thread::Builder::new().name("portal-cursor".into()).spawn(move || {
let result = set_cursor_embedded(target);
let mut state = POINTER_MODE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
state.switching = false;
state.candidate = None;
state.streak = 0;
state.first = None;
match result {
Ok(true) => {
state.blocked_until = None;
drop(state);
log::info!("Cursor mode follows the pointer: embedded={target}");
}
Ok(false) => {
// Locked, or something else changed the mode first; the next motion retries.
state.blocked_until = None;
drop(state);
}
Err(error) => {
state.blocked_until = Some(std::time::Instant::now() + POINTER_COOLDOWN);
drop(state);
log::warn!("Portal cursor switch failed: {error}");
}
}
});
if spawned.is_err() {
if let Ok(mut state) = POINTER_MODE.lock() { state.switching = false; }
}
}
pub struct Monitor { pub connector: String, pub width: u32, pub height: u32, pub x: i32, pub y: i32, pub primary: bool } 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"))] #[cfg(all(target_os = "linux", feature = "portal"))]
pub use native::monitors; pub use native::monitors;
@@ -980,3 +1373,76 @@ mod tests {
assert_eq!(*handle.lock().unwrap(), 11); assert_eq!(*handle.lock().unwrap(), 11);
} }
} }
#[cfg(test)]
mod pointer_mode_tests {
use super::{pointer_decision, PointerMode, POINTER_COOLDOWN, POINTER_WINDOW};
use std::time::{Duration, Instant};
fn state() -> PointerMode {
PointerMode { candidate: None, streak: 0, first: None, switching: false, blocked_until: None }
}
#[test]
fn a_connect_burst_does_not_rebuild_the_session() {
let mut state = state();
let start = Instant::now();
for step in 0..20 {
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step)), None);
}
}
#[test]
fn a_sustained_change_decides_once_the_run_spans_the_window() {
let mut state = state();
let start = Instant::now();
let mut decided = None;
for step in 0..40 {
let now = start + Duration::from_millis(step * 10);
if let Some(value) = pointer_decision(&mut state, true, false, now) {
assert!(now.duration_since(start) >= POINTER_WINDOW);
decided = Some(value);
break;
}
}
assert_eq!(decided, Some(false));
}
#[test]
fn an_opposite_event_restarts_the_run() {
let mut state = state();
let start = Instant::now();
for step in 0..10 { pointer_decision(&mut state, true, false, start + Duration::from_millis(step)); }
pointer_decision(&mut state, true, true, start + Duration::from_millis(10));
for step in 11..19 {
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step)), None);
}
}
#[test]
fn a_failed_switch_waits_out_the_cooldown() {
let mut state = state();
let start = Instant::now();
state.blocked_until = Some(start + POINTER_COOLDOWN);
for step in 0..40 {
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step * 10)), None);
}
let after = start + POINTER_COOLDOWN + Duration::from_millis(1);
let mut decided = None;
for step in 0..30 {
let now = after + Duration::from_millis(step * 10);
if let Some(value) = pointer_decision(&mut state, true, false, now) { decided = Some(value); break; }
}
assert_eq!(decided, Some(false));
}
#[test]
fn a_switch_in_flight_ignores_more_events() {
let mut state = state();
let start = Instant::now();
state.switching = true;
for step in 0..40 {
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step * 10)), None);
}
}
}
+109
View File
@@ -26,6 +26,58 @@ pub fn desktop_key() -> &'static str {
/// Consent for one monitor (Mutter connector); connectors are checked to be file-name safe. /// 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 monitor_key(connector: &str) -> String { format!("{}@{}", desktop_key(), connector) }
/// An unclassified grant is kept separately until its monitor is known.
pub fn pending_key(key: &str) -> String { format!("{key}.pending") }
pub fn exists(dir: &Path, key: &str) -> bool {
dir.join(key).exists() || dir.join(pending_key(key)).exists()
}
pub struct Rotation {
directory: Option<PathBuf>,
pending: String,
saved: Option<String>,
token: Option<String>,
}
impl Rotation {
pub fn new(directory: Option<PathBuf>, requested_key: &str) -> Self {
Self { directory, pending: pending_key(requested_key), saved: None, token: None }
}
pub fn received(&self) -> bool { self.token.is_some() }
/// A fresh request has not consumed the old grant; keep it until the new session opens.
pub fn remember(&mut self, token: &str) { self.token = Some(token.to_owned()); }
/// Persist before PipeWire starts; `known_key` comes from the actual granted source.
pub fn record(&mut self, token: &str, known_key: Option<&str>) -> std::io::Result<()> {
self.remember(token);
let Some(dir) = self.directory.as_deref() else { return Ok(()); };
let destination = known_key.unwrap_or(&self.pending);
save(dir, destination, token)?;
self.saved = Some(destination.to_owned());
if let Some(key) = known_key { let _ = fs::remove_file(dir.join(pending_key(key))); }
Ok(())
}
/// Move, rather than copy, so a single-use token never has two cache entries.
pub fn finish(&mut self, destination: &str, replace: bool) -> std::io::Result<()> {
let (Some(dir), Some(token)) = (self.directory.as_deref(), self.token.as_deref()) else { return Ok(()); };
if self.saved.as_deref() == Some(destination) { return Ok(()); }
if !replace && dir.join(destination).exists() { return Ok(()); }
if let Some(source) = self.saved.as_deref() {
fs::rename(dir.join(source), dir.join(destination))?;
fs::File::open(dir)?.sync_all()?;
} else {
save(dir, destination, token)?;
}
self.saved = Some(destination.to_owned());
let _ = fs::remove_file(dir.join(pending_key(destination)));
Ok(())
}
}
pub fn take(dir: &Path, key: &str) -> Option<String> { pub fn take(dir: &Path, key: &str) -> Option<String> {
let path = dir.join(key); let path = dir.join(key);
let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?; let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?;
@@ -71,4 +123,61 @@ mod tests {
assert!(save(&dir, "gnome", &"x".repeat(4097)).is_err()); assert!(save(&dir, "gnome", &"x".repeat(4097)).is_err());
fs::remove_dir_all(dir).unwrap(); fs::remove_dir_all(dir).unwrap();
} }
#[test]
fn rotated_grant_survives_failure_and_is_moved_after_success() {
let dir = std::env::temp_dir().join(format!("uu-rotation-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
save(&dir, "gnome@other", "other-grant").unwrap();
let mut rotation = Rotation::new(Some(dir.clone()), "gnome@wanted");
rotation.record("new-grant", None).unwrap();
// Simulate capture failure: no finish callback runs.
assert!(exists(&dir, "gnome@wanted"));
assert_eq!(take(&dir, &pending_key("gnome@wanted")).as_deref(), Some("new-grant"));
assert!(!exists(&dir, "gnome@wanted"));
assert_eq!(take(&dir, "gnome@other").as_deref(), Some("other-grant"));
let mut rotation = Rotation::new(Some(dir.clone()), "gnome@wanted");
rotation.record("newer-grant", None).unwrap();
rotation.finish("gnome@actual", true).unwrap();
assert!(!dir.join(pending_key("gnome@wanted")).exists());
assert_eq!(take(&dir, "gnome@actual").as_deref(), Some("newer-grant"));
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn known_grants_replace_only_their_monitor_and_unknown_grants_do_not_overwrite() {
let dir = std::env::temp_dir().join(format!("uu-rotation-known-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
save(&dir, "gnome", "existing-grant").unwrap();
save(&dir, "gnome@other", "other-grant").unwrap();
let mut unknown = Rotation::new(Some(dir.clone()), "gnome@wanted");
unknown.record("unknown-grant", None).unwrap();
unknown.finish("gnome", false).unwrap();
assert_eq!(take(&dir, "gnome").as_deref(), Some("existing-grant"));
assert_eq!(take(&dir, &pending_key("gnome@wanted")).as_deref(), Some("unknown-grant"));
let mut known = Rotation::new(Some(dir.clone()), "gnome@wanted");
known.record("known-grant", Some("gnome@actual")).unwrap();
assert_eq!(take(&dir, "gnome@actual").as_deref(), Some("known-grant"));
assert_eq!(take(&dir, "gnome@other").as_deref(), Some("other-grant"));
let mut no_token = Rotation::new(Some(dir.clone()), "gnome");
no_token.finish("gnome", true).unwrap();
assert!(!no_token.received());
assert!(!dir.join("gnome").exists());
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn fresh_request_keeps_existing_grant_until_open_succeeds() {
let dir = std::env::temp_dir().join(format!("uu-rotation-fresh-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
save(&dir, "gnome", "existing-grant").unwrap();
let mut fresh = Rotation::new(Some(dir.clone()), "gnome");
fresh.remember("fresh-grant");
assert_eq!(fs::read_to_string(dir.join("gnome")).unwrap(), "existing-grant");
assert!(!dir.join(pending_key("gnome")).exists());
fresh.finish("gnome", true).unwrap();
assert_eq!(take(&dir, "gnome").as_deref(), Some("fresh-grant"));
fs::remove_dir_all(dir).unwrap();
}
} }
+3
View File
@@ -20,6 +20,9 @@ pub trait Backend: Send + Sync {
fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String>; fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String>;
/// Undo `data` from `enter`. Also used for crash recovery, where no desktop stream exists. /// Undo `data` from `enter`. Also used for crash recovery, where no desktop stream exists.
fn leave(&self, data: &serde_json::Value) -> Result<(), String>; fn leave(&self, data: &serde_json::Value) -> Result<(), String>;
/// Recompute `Entered::pointer_region` after the virtual output was recreated. None keeps
/// the stored region (backends without a virtual output, or a layout not settled yet).
fn refresh_pointer_region(&self) -> Option<[f64; 4]> { None }
} }
/// The backend for this session, if the desktop has one. /// The backend for this session, if the desktop has one.
+172 -12
View File
@@ -1,24 +1,87 @@
//! Local input devices through KWin's InputDevice D-Bus interface (sysName `eventN`). KWin saves //! Local input devices through KWin's InputDevice D-Bus interface (sysName `eventN`). KWin saves
//! the enabled flag, which is why the controller runs the guard. //! the enabled flag, which is why the controller runs the guard.
//!
//! `eventN` comes from udev enumeration and can change between boots, while a recovery record may
//! be replayed after a reboot. Records therefore store the name/product/vendor KWin reports next
//! to the sysName, and a restore matches the current device by that identity.
use super::super::tool::{gdbus, variant}; use super::super::tool::{gdbus, variant};
use serde::{Deserialize, Serialize};
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) } fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
/// One blocked device. `Legacy` is a record written before identities were stored.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Device {
Named { sys: String, name: String, product: u32, vendor: u32 },
Legacy(String),
}
impl Device {
pub fn sys(&self) -> &str {
match self { Self::Named { sys, .. } | Self::Legacy(sys) => sys }
}
fn name(&self) -> &str {
match self { Self::Named { name, .. } => name, Self::Legacy(sys) => sys }
}
fn identity(&self) -> Option<(&str, u32, u32)> {
match self { Self::Named { name, product, vendor, .. } => Some((name, *product, *vendor)), Self::Legacy(_) => None }
}
}
/// `'key': <uint32 16500>` carries a type prefix; strings and booleans do not.
fn number(text: &str, key: &str) -> Option<u32> { variant(text, key)?.split_whitespace().last()?.parse().ok() }
#[derive(Clone, Copy, Default)]
struct Flags { keyboard: bool, pointer: bool, touch: bool, switch: bool, enabled: bool }
/// Every device KWin lists, blocked or not: restore must find a device that is still disabled.
/// The flag says whether a property read failed. A restore re-enables the readable devices, then
/// returns the flag as an error so its record and the guard stay for another attempt; blocking
/// skips such a device, which is all it can do.
fn enumerate() -> Result<(Vec<(Device, Flags)>, bool), String> {
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?;
let mut devices = Vec::new();
let mut incomplete = false;
for sys in list.split('\'').skip(1).step_by(2).filter(|n| n.strip_prefix("event").is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))) {
let text = match call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) {
Ok(text) => text,
Err(_) => { incomplete = true; continue; }
};
let yes = |key| variant(&text, key) == Some("true");
devices.push((Device::Named {
sys: sys.to_owned(),
name: variant(&text, "name").unwrap_or_default().to_owned(),
product: number(&text, "product").unwrap_or(0),
vendor: number(&text, "vendor").unwrap_or(0),
}, Flags { keyboard: yes("keyboard"), pointer: yes("pointer"), touch: yes("touch"), switch: yes("switchDevice"), enabled: yes("enabled") }));
}
Ok((devices, incomplete))
}
/// Keyboards, pointers and touch to block: everything except our own uinput devices, the power /// Keyboards, pointers and touch to block: everything except our own uinput devices, the power
/// button and switches (lid). Software devices fed by local hardware (gesture daemons, ydotoold) /// button and switches (lid). Software devices fed by local hardware (gesture daemons, ydotoold)
/// are blocked too. /// are blocked too.
pub fn local() -> Result<Vec<String>, String> { pub fn local() -> Result<Vec<Device>, String> {
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?; Ok(enumerate()?.0.into_iter().filter(|(d, f)| {
let mut blocked = Vec::new(); (f.keyboard || f.pointer || f.touch) && !f.switch && f.enabled
for sys in list.split('\'').skip(1).step_by(2).filter(|n| n.strip_prefix("event").is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))) { && !d.name().starts_with("uu-remote-linux") && d.name() != "Power Button"
let Ok(text) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) else { continue }; }).map(|(d, _)| d).collect())
let yes = |key| variant(&text, key) == Some("true");
let name = variant(&text, "name").unwrap_or_default();
if (yes("keyboard") || yes("pointer") || yes("touch")) && !yes("switchDevice") && yes("enabled")
&& !name.starts_with("uu-remote-linux") && name != "Power Button" { blocked.push(sys.to_owned()); }
}
Ok(blocked)
} }
pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
/// Every current device matching `wanted`: same name/product/vendor, or the exact sysName for a
/// legacy record. Several devices can share one identity (two identical keyboards, or one receiver
/// exposing several event nodes under the same name), so callers must handle every match.
fn matching<'a>(devices: &'a [Device], wanted: &Device) -> impl Iterator<Item = &'a Device> + 'a {
let identity = wanted.identity().map(|(name, product, vendor)| (name.to_owned(), product, vendor));
let sys = wanted.sys().to_owned();
devices.iter().filter(move |d| match (&identity, d.identity()) {
(Some((name, product, vendor)), Some((current, p, v))) => current == name && p == *product && v == *vendor,
_ => d.sys() == sys,
})
}
fn set_sys<'a>(devices: impl Iterator<Item = &'a str>, enabled: bool) -> Result<(), String> {
let value = if enabled { "<true>" } else { "<false>" }; let value = if enabled { "<true>" } else { "<false>" };
let mut failure = None; let mut failure = None;
for sys in devices { for sys in devices {
@@ -28,3 +91,100 @@ pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
} }
failure.map_or(Ok(()), Err) failure.map_or(Ok(()), Err)
} }
pub fn set(devices: &[Device], enabled: bool) -> Result<(), String> {
set_sys(devices.iter().map(Device::sys), enabled)
}
/// Current sysNames to re-enable and how many record entries have no current match.
fn restore_targets<'a>(now: &'a [Device], recorded: &[Device]) -> (Vec<&'a str>, usize) {
let mut targets: Vec<&str> = Vec::new();
let mut gone = 0;
for wanted in recorded {
let mut found = false;
for current in matching(now, wanted) {
found = true;
if !targets.contains(&current.sys()) { targets.push(current.sys()); }
}
if !found { gone += 1; }
}
(targets, gone)
}
/// Re-enables every current device matching a record entry, deduplicated by sysName: two record
/// entries can describe the same device, and one identity can cover several devices. A recorded
/// device that no longer exists is skipped: its `eventN` may belong to a different device after a
/// reboot, and failing the whole restore would keep the recovery record forever. A device that
/// exists but cannot be enabled still fails the restore, so the record and the guard stay for the
/// next attempt.
pub fn restore(devices: &[Device]) -> Result<(), String> {
if devices.is_empty() { return Ok(()); }
let (found, incomplete) = enumerate()?;
let now: Vec<Device> = found.into_iter().map(|(d, _)| d).collect();
let (targets, gone) = restore_targets(&now, devices);
// Counts only: device names and sysNames are not logged (AGENTS.md).
if gone > 0 { log::warn!("Privacy restore: {gone} recorded device(s) are gone; skipping"); }
// Re-enable the readable devices first: one unreadable device must not keep every other one
// off. The error afterwards keeps the record and the guard for another attempt.
set_sys(targets.into_iter(), true)?;
if incomplete { return Err("input device properties could not be read; retrying later".into()); }
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn named(sys: &str, name: &str, product: u32, vendor: u32) -> Device {
Device::Named { sys: sys.into(), name: name.into(), product, vendor }
}
#[test]
fn parses_numbered_variants() {
let text = "({'name': <'Logitech G304'>, 'product': <uint32 16500>, 'vendor': <uint32 1133>},)";
assert_eq!(number(text, "product"), Some(16500));
assert_eq!(number(text, "vendor"), Some(1133));
assert_eq!(number(text, "missing"), None);
}
#[test]
fn reads_legacy_and_named_records() {
let legacy: Vec<Device> = serde_json::from_str(r#"["event5","event6"]"#).unwrap();
assert!(matches!(&legacy[0], Device::Legacy(sys) if sys == "event5"));
let named: Device = serde_json::from_str(r#"{"sys":"event12","name":"Logitech G304","product":16500,"vendor":1133}"#).unwrap();
assert_eq!(named.identity(), Some(("Logitech G304", 16500, 1133)));
}
#[test]
fn matches_a_renumbered_device_by_identity() {
let mouse = named("event12", "Logitech G304", 16500, 1133);
let keyboard = named("event3", "AT Translated Set 2 keyboard", 1, 1);
let recorded = [named("event14", "Logitech G304", 16500, 1133)];
let now = [keyboard, mouse];
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event12"], 0));
}
#[test]
fn enables_every_device_sharing_an_identity_once() {
let first = named("event12", "Logitech G304", 16500, 1133);
let second = named("event15", "Logitech G304", 16500, 1133);
let now = [first, second];
// Two record entries for one identity, as a receiver exposing several event nodes produces.
let recorded = [named("event14", "Logitech G304", 16500, 1133), named("event16", "Logitech G304", 16500, 1133)];
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event12", "event15"], 0));
}
#[test]
fn a_missing_device_counts_as_gone() {
let recorded = [named("event14", "Logitech G304", 16500, 1133)];
let now = [named("event3", "AT Translated Set 2 keyboard", 1, 1)];
assert_eq!(super::restore_targets(&now, &recorded), (Vec::new(), 1));
}
#[test]
fn a_legacy_record_matches_the_exact_sysname() {
let recorded = [Device::Legacy("event5".into())];
let now = [named("event5", "AT Translated Set 2 keyboard", 1, 1)];
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event5"], 0));
}
}
+80 -8
View File
@@ -1,12 +1,28 @@
//! One-shot KWin scripts (org.kde.kwin.Scripting). //! KWin scripts (org.kde.kwin.Scripting): one-shot ones, plus the new-window keeper that picture
//! mode leaves loaded for the whole privacy session.
use super::super::tool::gdbus; use super::super::tool::gdbus;
const ONE_SHOT: &str = "uu-privacy";
const KEEP_WINDOWS: &str = "uu-privacy-windows";
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) } fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
fn script(js: &str) -> Result<(), String> { /// Output names go into a JS string literal.
fn escape(output: &str) -> String { output.replace('\\', "\\\\").replace('"', "\\\"") }
/// Windows that belong on the captured output. Desktop pets and tool palettes use toolbar/utility
/// windows, which `normalWindow` misses; panels, the desktop and transient popups stay where they
/// are, so the layout of the physical outputs is unchanged.
const MOVABLE: &str = r#"function movable(w) {
if (!w || w.desktopWindow || w.dock) return false;
if (w.tooltip || w.popupMenu || w.dropdownMenu || w.comboBox || w.dndIcon) return false;
return w.normalWindow || w.dialog || w.toolbar || w.utility || w.splash;
}"#;
/// Loads `js` under `name` and runs it. `keep` leaves it loaded with its signal connections alive;
/// otherwise it is unloaded after the run, as the one-shot scripts expect.
fn script(js: &str, name: &str, keep: bool) -> Result<(), String> {
let dir = std::env::var_os("XDG_RUNTIME_DIR").map(std::path::PathBuf::from).ok_or("missing runtime directory")?; let dir = std::env::var_os("XDG_RUNTIME_DIR").map(std::path::PathBuf::from).ok_or("missing runtime directory")?;
let file = dir.join(format!("uu-privacy-{}.js", std::process::id())); let file = dir.join(format!("uu-privacy-{name}-{}.js", std::process::id()));
std::fs::write(&file, js).map_err(|e| e.kind().to_string())?; std::fs::write(&file, js).map_err(|e| e.kind().to_string())?;
let name = "uu-privacy"; // A script left loaded by a host that died would keep running with a stale target.
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]); let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
let result = call("/Scripting", "org.kde.kwin.Scripting.loadScript", &[&file.to_string_lossy(), name]).and_then(|out| { let result = call("/Scripting", "org.kde.kwin.Scripting.loadScript", &[&file.to_string_lossy(), name]).and_then(|out| {
let id: String = out.chars().filter(char::is_ascii_digit).collect(); let id: String = out.chars().filter(char::is_ascii_digit).collect();
@@ -14,12 +30,68 @@ fn script(js: &str) -> Result<(), String> {
call(&format!("/Scripting/Script{id}"), "org.kde.kwin.Script.run", &[]) call(&format!("/Scripting/Script{id}"), "org.kde.kwin.Script.run", &[])
}); });
std::thread::sleep(std::time::Duration::from_millis(300)); std::thread::sleep(std::time::Duration::from_millis(300));
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]); // A failed run must not leave a half-started keeper behind.
if !keep || result.is_err() { let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]); }
let _ = std::fs::remove_file(file); let _ = std::fs::remove_file(file);
result.map(|_| ()) result.map(|_| ())
} }
/// Sends every normal window and dialog to `output` (a name from kscreen-doctor, file-name safe). /// Sends every movable window to `output` (a name from kscreen-doctor).
pub fn move_windows_to(output: &str) -> Result<(), String> { pub fn move_windows_to(output: &str) -> Result<(), String> {
script(&format!(r#"const v = workspace.screens.find(o => o.name == "{output}"); let output = escape(output);
if (v) for (const w of workspace.windowList()) if (w.normalWindow || w.dialog) workspace.sendClientToScreen(w, v);"#)) script(&format!(r#"{movable}
const v = workspace.screens.find(o => o.name == "{output}");
if (v) for (const w of workspace.windowList()) if (movable(w)) workspace.sendClientToScreen(w, v);"#, movable = MOVABLE), ONE_SHOT, false)
}
/// Keeps windows on `output`. Picture mode turns the physical outputs back on as secondaries, and
/// KWin then places a new window on the screen it considers active, which can be one hidden under
/// the cover: the viewer would never see it. Every window is checked when it appears and whenever
/// its geometry changes, so an application that places itself on a physical output is sent back.
/// `frameGeometryChanged` is the trigger because KWin 6.8 does not emit `outputChanged` for
/// `sendClientToScreen` moves (verified live). Unloaded by `unload_keep_windows` on restore.
pub fn keep_windows_on(output: &str) -> Result<(), String> {
let output = escape(output);
script(&format!(r#"{movable}
function keep(w) {{
if (!movable(w)) return;
// The cover windows belong on the physical outputs.
if (w.resourceClass === "uuremote-server" || (w.caption || "").indexOf("uu-remote-linux privacy") === 0) return;
const screen = workspace.screens.find(o => o.name === "{output}");
if (!screen || (w.output && w.output.name === "{output}")) return;
workspace.sendClientToScreen(w, screen);
}}
function watch(w) {{
if (!w) return;
// One window that cannot be moved or observed must not stop the others.
try {{
keep(w);
w.frameGeometryChanged.connect(function () {{ keep(w); }});
}} catch (e) {{}}
}}
// New windows first: a throwing sweep must not leave them unhandled.
workspace.windowAdded.connect(watch);
workspace.windowList().forEach(watch);
"#, movable = MOVABLE), KEEP_WINDOWS, true)
}
/// Stops following new windows. A name that is not loaded (screen-off mode, a restarted KWin
/// session) reports false without an error.
pub fn unload_keep_windows() -> Result<(), String> {
call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[KEEP_WINDOWS]).map(|_| ())
}
/// Hides the cover window from the task manager. GTK's skip-taskbar hint is an X11 hint and KWin
/// ignores it on Wayland, so the cover showed up as an unidentified window with the theme's
/// generic "wayland" icon. `skipTaskbar` is writable through KWin scripting. Picture mode creates
/// one cover per physical monitor with the same title, and KWin appends " <2>" and so on to
/// duplicate captions, so match the title as a prefix.
pub fn hide_cover_from_taskbar() -> Result<(), String> {
script(r#"for (const w of workspace.windowList())
if (w.resourceClass === "uuremote-server" && w.caption.indexOf("uu-remote-linux privacy") === 0) w.skipTaskbar = true;"#, ONE_SHOT, false)
}
#[cfg(test)]
mod tests {
#[test]
fn escapes_output_names_for_the_script() {
assert_eq!(super::escape("DP-3"), "DP-3");
assert_eq!(super::escape(r#"a"b\c"#), r#"a\"b\\c"#);
}
} }
+29 -4
View File
@@ -5,7 +5,8 @@
//! physical outputs before the virtual one exists (KWin applies stored configs on creation), //! physical outputs before the virtual one exists (KWin applies stored configs on creation),
//! re-enable them before the virtual output goes away, and never disable the virtual output //! re-enable them before the virtual output goes away, and never disable the virtual output
//! itself (KWin bug 527747 persists that and breaks later virtual shares). //! itself (KWin bug 527747 persists that and breaks later virtual shares).
//! Picture mode then turns the physical outputs back on as secondary ones and covers them. //! Picture mode then turns the physical outputs back on as secondary ones and covers them, and a
//! second KWin script keeps windows that appear later on the virtual output too.
mod input; mod input;
mod kwin; mod kwin;
mod outputs; mod outputs;
@@ -16,7 +17,7 @@ pub const NAME: &str = "kde";
pub struct Kde; pub struct Kde;
#[derive(Default, serde::Serialize, serde::Deserialize)] #[derive(Default, serde::Serialize, serde::Deserialize)]
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<String> } struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<input::Device> }
impl Kde { impl Kde {
pub fn detected() -> bool { pub fn detected() -> bool {
@@ -39,6 +40,12 @@ fn wallpaper() -> Option<std::path::PathBuf> {
/// secondary outputs, keep the windows on the virtual one, and cover the physical ones. /// secondary outputs, keep the windows on the virtual one, and cover the physical ones.
fn cover(data: &Data) -> Result<[f64; 4], String> { fn cover(data: &Data) -> Result<[f64; 4], String> {
let virtual_name = outputs::layout()?.into_iter().map(|o| o.name).find(|n| !data.outputs.contains(n)).ok_or("virtual output not found")?; let virtual_name = outputs::layout()?.into_iter().map(|o| o.name).find(|n| !data.outputs.contains(n)).ok_or("virtual output not found")?;
// Loaded before the physical outputs come back: from then on KWin places a new window on the
// screen it considers active, which may be one that is about to be covered.
match kwin::keep_windows_on(&virtual_name) {
Ok(()) => log::info!("Privacy new-window keeper: loaded"),
Err(e) => log::warn!("Privacy new-window keeper: {e}"),
}
outputs::set(&data.outputs, true).map_err(|e| format!("enable outputs: {e}"))?; outputs::set(&data.outputs, true).map_err(|e| format!("enable outputs: {e}"))?;
if let Err(e) = outputs::set_primary(&virtual_name) { log::warn!("Privacy virtual output priority: {e}"); } if let Err(e) = outputs::set_primary(&virtual_name) { log::warn!("Privacy virtual output priority: {e}"); }
kwin::move_windows_to(&virtual_name).map_err(|e| format!("move windows: {e}"))?; kwin::move_windows_to(&virtual_name).map_err(|e| format!("move windows: {e}"))?;
@@ -47,6 +54,13 @@ fn cover(data: &Data) -> Result<[f64; 4], String> {
if physical.len() != data.outputs.len() { return Err("physical outputs did not come back".into()); } if physical.len() != data.outputs.len() { return Err("physical outputs did not come back".into()); }
let region = outputs::region(&layout, &virtual_name).ok_or("virtual output geometry")?; let region = outputs::region(&layout, &virtual_name).ok_or("virtual output geometry")?;
super::cover::show(wallpaper().as_deref(), &physical)?; super::cover::show(wallpaper().as_deref(), &physical)?;
// The cover is a plain Wayland toplevel: GTK's skip-taskbar hint is X11-only, so without this
// the task manager shows it as an unidentified window with the theme's generic "wayland" icon.
// KWin lists a freshly mapped window asynchronously, so one more pass catches a late cover.
for pass in 0..2 {
if let Err(e) = kwin::hide_cover_from_taskbar() { log::warn!("Privacy cover taskbar: {e}"); break; }
if pass == 0 { std::thread::sleep(std::time::Duration::from_millis(200)); }
}
Ok(region) Ok(region)
} }
@@ -74,11 +88,22 @@ impl Backend for Kde {
log::info!("Privacy KDE: outputs={} input_devices={}", data.outputs.len(), data.devices.len()); log::info!("Privacy KDE: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
Ok(entered) Ok(entered)
} }
fn refresh_pointer_region(&self) -> Option<[f64; 4]> {
// The old virtual output disappears with the replaced session; wait for the layout to
// settle on the new one before taking its share of the bounding box.
let layout = outputs::layout().ok()?;
let virtuals: Vec<_> = layout.iter().filter(|o| o.name.starts_with("Virtual")).collect();
let target = match virtuals.as_slice() { [only] => *only, _ => return None };
outputs::region(&layout, &target.name)
}
fn leave(&self, data: &serde_json::Value) -> Result<(), String> { fn leave(&self, data: &serde_json::Value) -> Result<(), String> {
let data: Data = serde_json::from_value(data.clone()).map_err(|_| "invalid KDE recovery data")?; let data: Data = serde_json::from_value(data.clone()).map_err(|_| "invalid KDE recovery data")?;
// KWin persists the device flag: a failure is returned (after restoring the outputs) so the // KWin persists the device flag: a failure is returned (after restoring the outputs) so the
// controller keeps the recovery record and the guard for the next attempt. // controller keeps the recovery record and the guard for the next attempt. A device that
let devices = input::set(&data.devices, true).map_err(|e| format!("enable input devices: {e}")); // no longer exists is skipped, so a record replayed after a reboot cannot wedge recovery.
let devices = input::restore(&data.devices).map_err(|e| format!("enable input devices: {e}"));
// Stop following new windows before the virtual output goes away.
if let Err(e) = kwin::unload_keep_windows() { log::warn!("Privacy new-window keeper: {e}"); }
// Physical outputs first: switching back opens a monitor share, which needs them enabled. // Physical outputs first: switching back opens a monitor share, which needs them enabled.
// The wait also matters: a share opened before KWin applies the mode got the virtual // The wait also matters: a share opened before KWin applies the mode got the virtual
// output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920). // output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920).
+115 -5
View File
@@ -21,8 +21,22 @@ static STATE: Mutex<State> = Mutex::new(State { sessions: 0, active: None });
static ACTIVE: AtomicBool = AtomicBool::new(false); static ACTIVE: AtomicBool = AtomicBool::new(false);
static PICTURE: AtomicBool = AtomicBool::new(false); static PICTURE: AtomicBool = AtomicBool::new(false);
static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None); static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
/// Set by any viewer RPC 7 during the current desktop sessions and cleared when the last one
/// ends. An auto-enable never overrides it, including an RPC that arrives after the connection
/// opens but before `session_started` bumps the counter.
static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false);
/// iOS viewers encode "screen off" as `enable=0, type=3`, and Windows viewers carry every request
/// in `type` with `enable=0`; see `protocol::Request::normalize_ios_screen_off` and
/// `protocol::Request::normalize_windows`.
static VIEWER_IOS: AtomicBool = AtomicBool::new(false);
static VIEWER_WINDOWS: AtomicBool = AtomicBool::new(false);
pub fn supported() -> bool { backend::detect().is_some() } pub fn supported() -> bool { backend::detect().is_some() }
/// Record the desktop controller's platform for the RPC 7 encoder quirks.
pub fn set_viewer_controller(controller: crate::input::Controller) {
VIEWER_IOS.store(controller == crate::input::Controller::Ios, Ordering::Relaxed);
VIEWER_WINDOWS.store(controller == crate::input::Controller::Windows, Ordering::Relaxed);
}
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) } pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
/// The viewer's privacy_type now in effect. /// The viewer's privacy_type now in effect.
pub fn current_type() -> u8 { pub fn current_type() -> u8 {
@@ -34,6 +48,18 @@ pub fn state_message(seq: u64, timestamp: u64) -> Vec<u8> {
} }
/// See `backend::Entered::pointer_region`. /// See `backend::Entered::pointer_region`.
pub fn pointer_region() -> Option<[f64; 4]> { *POINTER.lock().ok()? } pub fn pointer_region() -> Option<[f64; 4]> { *POINTER.lock().ok()? }
/// A session rebuild replaced the virtual output: refresh the region absolute input maps into.
pub fn refresh_pointer_region() {
if !active() { return; }
for _ in 0..10 {
if let Some(region) = backend::detect().and_then(backend::Backend::refresh_pointer_region) {
if let Ok(mut pointer) = POINTER.lock() { *pointer = Some(region); }
return;
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
log::warn!("Privacy pointer region not refreshed: virtual output layout did not settle");
}
fn publish(active: Option<&Active>) { fn publish(active: Option<&Active>) {
ACTIVE.store(active.is_some(), Ordering::Relaxed); ACTIVE.store(active.is_some(), Ordering::Relaxed);
@@ -80,7 +106,9 @@ fn save_preference(mode: Mode) {
if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_type = Some(mode.wire_type())) { log::warn!("Privacy mode not saved: {e}"); } if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_type = Some(mode.wire_type())) { log::warn!("Privacy mode not saved: {e}"); }
} }
/// RPC 7: `mode` is None for an unknown privacy_type. /// RPC 7: `mode` is None for an unknown privacy_type.
fn set(enable: bool, mode: Option<Mode>) -> Result<(), String> { fn set(enable: bool, mode: Option<Mode>) -> Result<(), String> { set_inner(enable, mode, true) }
/// `save` records the viewer's preference; the auto-enable path must not overwrite it.
fn set_inner(enable: bool, mode: Option<Mode>, save: bool) -> Result<(), String> {
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?; let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
if !enable { return leave(&mut state); } if !enable { return leave(&mut state); }
let mode = mode.ok_or("unsupported privacy type")?; let mode = mode.ok_or("unsupported privacy type")?;
@@ -89,7 +117,7 @@ fn set(enable: bool, mode: Option<Mode>) -> Result<(), String> {
// A failed rollback keeps the record and the guard: the next request, exit or start retries. // A failed rollback keeps the record and the guard: the next request, exit or start retries.
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } } if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
drop(state); drop(state);
if result.is_ok() { save_preference(mode); } if result.is_ok() && save { save_preference(mode); }
result result
} }
/// Why RPC 7 cannot be served at all; checked before answering. /// Why RPC 7 cannot be served at all; checked before answering.
@@ -106,7 +134,16 @@ pub struct Accepted { enable: bool, mode: Option<Mode> }
/// (error 9998 + n in its RPC failure handler) and a switch takes longer. A later failure is /// (error 9998 + n in its RPC failure handler) and a switch takes longer. A later failure is
/// reported as ReportError -7, which the viewer handles by resetting its privacy menu. /// reported as ReportError -7, which the viewer handles by resetting its privacy menu.
pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option<Accepted>)> { pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option<Accepted>)> {
let (header, request) = protocol::parse(rpc)?; let (header, mut request) = protocol::parse(rpc)?;
if request.normalize_ios_screen_off(VIEWER_IOS.load(Ordering::Relaxed)) {
// The viewer chose a mode even if the switch is refused below; cancel a pending auto-enable
// as an accepted request would.
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
log::info!("Privacy request: iOS screen-off encoding normalized (enable=0 type=3)");
} else if request.normalize_windows(VIEWER_WINDOWS.load(Ordering::Relaxed)) {
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
log::info!("Privacy request: Windows encoding normalized (enable=0 mode={:?})", request.mode);
}
if let Some(e) = refuse(request.enable, request.mode) { if let Some(e) = refuse(request.enable, request.mode) {
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode); log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
return Some((protocol::response(&header, &request, true, current_type()), None)); return Some((protocol::response(&header, &request, true, current_type()), None));
@@ -119,21 +156,83 @@ pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option
pub const REPORT_ERROR: i32 = -7; pub const REPORT_ERROR: i32 = -7;
impl Accepted { impl Accepted {
pub fn apply(self) -> Result<(), String> { pub fn apply(self) -> Result<(), String> {
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
let result = set(self.enable, self.mode); let result = set(self.enable, self.mode);
if let Err(e) = &result { log::warn!("Privacy request failed: enable={} mode={:?}: {e}", self.enable, self.mode); } if let Err(e) = &result { log::warn!("Privacy request failed: enable={} mode={:?}: {e}", self.enable, self.mode); }
result result
} }
} }
pub fn session_started() { if let Ok(mut s) = STATE.lock() { s.sessions += 1; } } /// `UU_PRIVACY_AUTO` accepts `picture`/`2` and `screen-off`/`3`; anything else leaves the viewer
/// in charge (and so does the viewer's own RPC 7, which cancels a pending auto-enable).
fn parse_auto(value: &str) -> Option<Mode> {
match value.trim().to_ascii_lowercase().as_str() {
"2" | "picture" => Some(Mode::Picture),
"3" | "screen-off" | "screen_off" => Some(Mode::ScreenOff),
_ => None,
}
}
fn auto_mode() -> Option<Mode> { std::env::var("UU_PRIVACY_AUTO").ok().as_deref().and_then(parse_auto) }
/// Enter the auto mode with the viewer-override check inside the STATE lock, so a request that
/// lands between the caller's check and this lock still wins. Ok(false): the viewer overrode it.
fn auto_set(mode: Mode) -> Result<bool, String> {
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
if VIEWER_OVERRIDE.load(Ordering::Relaxed) { return Ok(false); }
if state.sessions == 0 { return Err("no active desktop session".into()); }
let result = enter(&mut state, mode);
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
result.map(|_| true)
}
/// The capture session and the viewer's CONTROL state need a moment after the peer connects;
/// retry while the portal session is still missing, and let the viewer's RPC 7 win if it arrives.
fn auto_enable(mode: Mode) {
for attempt in 1..=5 {
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
log::info!("Privacy auto: skipped, the viewer already chose a mode");
return;
}
// Not a failure yet: the desktop capture opens its portal session a moment after the peer
// connects, and entering without it would roll back and log a restore for nothing.
if !crate::portal::available() {
log::info!("Privacy auto: waiting for the desktop capture (attempt {attempt})");
std::thread::sleep(std::time::Duration::from_secs(1));
continue;
}
match auto_set(mode) {
Ok(true) => { log::info!("Privacy auto: enabled mode={mode:?} on attempt {attempt}"); return; }
Ok(false) => { log::info!("Privacy auto: skipped, the viewer already chose a mode"); return; }
Err(e) if e.contains("no active desktop session") => return,
Err(e) if e.contains("Portal desktop unavailable") => {
log::info!("Privacy auto: desktop capture not ready (attempt {attempt})");
std::thread::sleep(std::time::Duration::from_secs(1));
}
Err(e) => { log::warn!("Privacy auto failed: {e}"); return; }
}
}
log::warn!("Privacy auto: giving up; the viewer can still enable the privacy screen");
}
pub fn session_started() {
let auto = auto_mode();
let first = STATE.lock().ok().is_some_and(|mut s| { s.sessions += 1; s.sessions == 1 });
let Some(mode) = auto else { return };
if !first { return; }
std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(1500));
auto_enable(mode);
});
}
pub fn session_ended() { pub fn session_ended() {
if let Ok(mut s) = STATE.lock() { if let Ok(mut s) = STATE.lock() {
s.sessions = s.sessions.saturating_sub(1); s.sessions = s.sessions.saturating_sub(1);
if s.sessions == 0 { if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); } } if s.sessions == 0 {
VIEWER_OVERRIDE.store(false, Ordering::Relaxed);
if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); }
}
} }
} }
pub fn shutdown() { pub fn shutdown() {
if let Ok(mut s) = STATE.lock() { if let Ok(mut s) = STATE.lock() {
s.sessions = 0; s.sessions = 0;
VIEWER_OVERRIDE.store(false, Ordering::Relaxed);
if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); } if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); }
} }
} }
@@ -167,6 +266,17 @@ pub fn cover_main(args: &[String]) -> i32 { cover::main(args) }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
#[test]
fn parses_auto_privacy_modes() {
use super::{parse_auto, Mode};
assert_eq!(parse_auto("picture"), Some(Mode::Picture));
assert_eq!(parse_auto("2"), Some(Mode::Picture));
assert_eq!(parse_auto(" screen-off "), Some(Mode::ScreenOff));
assert_eq!(parse_auto("3"), Some(Mode::ScreenOff));
assert_eq!(parse_auto("0"), None);
assert_eq!(parse_auto("off"), None);
assert_eq!(parse_auto(""), None);
}
#[test] #[test]
fn enabling_without_a_backend_is_refused_and_reports_off() { fn enabling_without_a_backend_is_refused_and_reports_off() {
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3]; let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
+72
View File
@@ -5,6 +5,30 @@ use super::Mode;
pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 } pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 }
impl Request {
/// iOS viewers encode "turn off the display" as `enable=0, privacy_type=3`: their enable bit is
/// the picture-mode switch, and the explicit screen-off type carries the intent. iOS "off" is
/// `enable=0, type=1` (seen live), so rewrite only this exact combination. Android 4.43.0 was
/// verified with the field-1 semantics, so the rewrite is iOS-only.
pub fn normalize_ios_screen_off(&mut self, ios: bool) -> bool {
if ios && !self.enable && self.mode == Some(Mode::ScreenOff) {
self.enable = true;
return true;
}
false
}
/// Windows viewers send every privacy request with `enable=0` and carry the intent in
/// `privacy_type`: `0/0` is off, `0/2` picture and `0/3` screen-off (verified live on the
/// Windows client). Android 4.43.0 and macOS keep field 1 as the master switch.
pub fn normalize_windows(&mut self, windows: bool) -> bool {
if windows && !self.enable && self.mode.is_some() {
self.enable = true;
return true;
}
false
}
}
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> { pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
use crate::protocol::{decode_wire, WireValue}; use crate::protocol::{decode_wire, WireValue};
let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None }); let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None });
@@ -71,4 +95,52 @@ mod tests {
let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap(); let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap();
assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]); assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]);
} }
#[test]
fn normalizes_ios_screen_off_only() {
let screen_off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 3]).unwrap();
let (_, mut request) = parse(&screen_off).unwrap();
assert!(request.normalize_ios_screen_off(true));
assert!(request.enable);
assert_eq!(request.mode, Some(Mode::ScreenOff));
let (_, mut request) = parse(&screen_off).unwrap();
assert!(!request.normalize_ios_screen_off(false));
assert!(!request.enable);
// An iOS "off" (type 1) and a Mac-style enable (1,3) must stay untouched.
let off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 1]).unwrap();
let (_, mut request) = parse(&off).unwrap();
assert!(!request.normalize_ios_screen_off(true));
assert!(!request.enable);
let mac = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 3]).unwrap();
let (_, mut request) = parse(&mac).unwrap();
assert!(!request.normalize_ios_screen_off(true));
assert!(request.enable);
}
#[test]
fn normalizes_windows_encoding_only() {
// Windows: enable is always 0, the type carries the intent.
for (wire, mode) in [(2u8, Mode::Picture), (3u8, Mode::ScreenOff)] {
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
assert!(request.normalize_windows(true));
assert!(request.enable);
assert_eq!(request.mode, Some(mode));
}
// Off stays off: type 0 (seen when the Windows switch is turned off) and type 1.
for wire in [0u8, 1] {
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
assert!(!request.normalize_windows(true));
assert!(!request.enable);
}
// Other platforms and explicit enables are untouched.
let picture = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 2]).unwrap();
let (_, mut request) = parse(&picture).unwrap();
assert!(!request.normalize_windows(false));
assert!(!request.enable);
let explicit = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 2]).unwrap();
let (_, mut request) = parse(&explicit).unwrap();
assert!(!request.normalize_windows(true));
assert!(request.enable);
}
} }
+74 -19
View File
@@ -11,11 +11,15 @@
//! (`loginctl unlock-session`, allowed for the session owner), which avoids remote keystrokes //! (`loginctl unlock-session`, allowed for the session owner), which avoids remote keystrokes
//! and gives an exact wrong-password result. The password is never logged or stored. //! and gives an exact wrong-password result. The password is never logged or stored.
use std::process::Command; use std::process::{Command, Stdio};
use std::path::{Path, PathBuf};
use std::sync::OnceLock; use std::sync::OnceLock;
use std::time::Duration; use std::time::Duration;
use tokio::sync::watch; use tokio::sync::watch;
mod logind;
/// Official UnlockResult cases (LockScreenManager). /// Official UnlockResult cases (LockScreenManager).
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UnlockResult { Success, WrongPassword, NoLoggedInUser, NoPermission, Failed } pub enum UnlockResult { Success, WrongPassword, NoLoggedInUser, NoPermission, Failed }
@@ -29,10 +33,44 @@ extern "C" {
fn uu_pam_check(service: *const libc::c_char, user: *const libc::c_char, password: *const libc::c_char) -> libc::c_int; fn uu_pam_check(service: *const libc::c_char, user: *const libc::c_char, password: *const libc::c_char) -> libc::c_int;
} }
// Resolve once: execvp's unsuccessful PATH candidates are also recorded by auditd.
fn loginctl_path() -> Option<&'static Path> {
static PATH: OnceLock<Option<PathBuf>> = OnceLock::new();
PATH.get_or_init(|| {
std::env::var_os("PATH").into_iter().flat_map(|p| std::env::split_paths(&p).collect::<Vec<_>>())
.map(|dir| dir.join("loginctl"))
.find(|path| path.is_file() && std::ffi::CString::new(path.as_os_str().as_encoded_bytes())
.map(|p| unsafe { libc::access(p.as_ptr(), libc::X_OK) == 0 }).unwrap_or(false))
.and_then(|path| std::fs::canonicalize(path).ok())
}).as_deref()
}
#[cfg(test)]
static COMMAND_STARTS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
fn bounded_command(path: &Path, args: &[&str], timeout: Duration) -> Option<String> {
use std::io::Read;
#[cfg(test)]
COMMAND_STARTS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
let mut child = Command::new(path).args(args).stdin(Stdio::null()).stdout(Stdio::piped())
.stderr(Stdio::null()).spawn().ok()?;
let deadline = std::time::Instant::now() + timeout;
loop {
match child.try_wait() {
Ok(Some(status)) => {
if !status.success() { return None; }
let mut text = String::new();
child.stdout.take()?.take(4096).read_to_string(&mut text).ok()?;
return Some(text.trim().to_owned());
}
Ok(None) if std::time::Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),
_ => { let _ = child.kill(); let _ = child.wait(); return None; }
}
}
}
fn loginctl(args: &[&str]) -> Option<String> { fn loginctl(args: &[&str]) -> Option<String> {
let out = Command::new("loginctl").args(args).output().ok()?; bounded_command(loginctl_path()?, args, Duration::from_secs(3)).filter(|s| !s.is_empty())
if !out.status.success() { return None; }
Some(String::from_utf8_lossy(&out.stdout).trim().to_string()).filter(|s| !s.is_empty())
} }
/// The logind session that owns this user's graphical display. /// The logind session that owns this user's graphical display.
@@ -44,7 +82,7 @@ fn display_session() -> Option<String> {
pub fn locked_now() -> Option<bool> { display_session().as_deref().and_then(session_locked) } pub fn locked_now() -> Option<bool> { display_session().as_deref().and_then(session_locked) }
fn session_locked(session: &str) -> Option<bool> { fn session_locked(session: &str) -> Option<bool> {
loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).map(|v| v == "yes") loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).and_then(|v| match v.as_str() { "yes" => Some(true), "no" => Some(false), _ => None })
} }
fn user_name() -> Option<String> { fn user_name() -> Option<String> {
@@ -78,30 +116,28 @@ pub fn supported() -> bool {
*SUPPORTED.get_or_init(|| pam_available() && display_session().is_some()) *SUPPORTED.get_or_init(|| pam_available() && display_session().is_some())
} }
/// Current lock state (None = unknown), refreshed every second by one background thread. /// Current lock state (None = unknown), shared by all desktop connections.
pub fn watch_locked() -> watch::Receiver<Option<bool>> { pub fn watch_locked() -> watch::Receiver<Option<bool>> {
static STATE: OnceLock<watch::Sender<Option<bool>>> = OnceLock::new(); static STATE: OnceLock<watch::Sender<Option<bool>>> = OnceLock::new();
STATE.get_or_init(|| { STATE.get_or_init(|| {
let (tx, _) = watch::channel(None); let (tx, _) = watch::channel(None);
let sender = tx.clone(); let sender = tx.clone();
std::thread::Builder::new().name("uu-lock-state".into()).spawn(move || { std::thread::Builder::new().name("uu-lock-state".into()).spawn(move || {
let mut session = None; tokio::runtime::Builder::new_current_thread().enable_all().build()
loop { .expect("lock monitor runtime").block_on(logind::monitor(sender));
if session.is_none() { session = display_session(); }
let locked = session.as_deref().and_then(session_locked);
if locked.is_none() { session = None; } // session ended or changed: look it up again
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
*current = locked; true
} else { false });
std::thread::sleep(Duration::from_secs(1));
}
}).expect("spawn lock state thread"); }).expect("spawn lock state thread");
tx tx
}).subscribe() }).subscribe()
} }
fn publish_lock_state(sender: &watch::Sender<Option<bool>>, locked: Option<bool>) {
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
*current = locked; true
} else { false });
}
/// Verifies the session user's password and unlocks the display session. Blocking (PAM may /// Verifies the session user's password and unlocks the display session. Blocking (PAM may
/// delay a failure by seconds); call from spawn_blocking. Consumes and wipes the password. /// delay a failure by seconds); call from spawn_blocking. Consumes and wipes the password.
pub fn unlock(password: String) -> UnlockResult { pub fn unlock(password: String) -> UnlockResult {
@@ -117,7 +153,7 @@ fn unlock_with(password: &str) -> UnlockResult {
let Some(user) = user_name() else { return UnlockResult::NoLoggedInUser }; let Some(user) = user_name() else { return UnlockResult::NoLoggedInUser };
if password.is_empty() || password.contains('\0') { return UnlockResult::WrongPassword; } if password.is_empty() || password.contains('\0') { return UnlockResult::WrongPassword; }
match pam_check(&user, password) { 0 => {}, 1 => return UnlockResult::WrongPassword, _ => return UnlockResult::Failed } match pam_check(&user, password) { 0 => {}, 1 => return UnlockResult::WrongPassword, _ => return UnlockResult::Failed }
if Command::new("loginctl").args(["unlock-session", &session]).status().map(|s| !s.success()).unwrap_or(true) { if loginctl_path().and_then(|path| bounded_command(path, &["unlock-session", &session], Duration::from_secs(3))).is_none() {
return UnlockResult::NoPermission; return UnlockResult::NoPermission;
} }
if let Err(error) = crate::capture::keep_display_awake() { if let Err(error) = crate::capture::keep_display_awake() {
@@ -204,6 +240,25 @@ pub fn password_from_args(args: &[u8]) -> Option<String> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
#[test]
fn unknown_state_is_preserved_and_repeated_states_do_not_notify() {
let (tx, mut rx) = watch::channel(Some(true));
publish_lock_state(&tx, None);
assert_eq!(*rx.borrow_and_update(), None);
publish_lock_state(&tx, None);
assert!(!rx.has_changed().unwrap());
publish_lock_state(&tx, Some(false));
assert!(rx.has_changed().unwrap());
assert_eq!(*rx.borrow_and_update(), Some(false));
}
#[test]
fn hung_fallback_is_killed_and_reaped() {
let start = std::time::Instant::now();
assert_eq!(bounded_command(Path::new("/bin/sleep"), &["10"], Duration::from_millis(30)), None);
assert!(start.elapsed() < Duration::from_secs(2));
}
#[test] #[test]
fn password_comes_from_the_official_key_field() { fn password_comes_from_the_official_key_field() {
assert_eq!(password_from_args(br#"{"key":"p@ss word"}"#).as_deref(), Some("p@ss word")); assert_eq!(password_from_args(br#"{"key":"p@ss word"}"#).as_deref(), Some("p@ss word"));
+208
View File
@@ -0,0 +1,208 @@
//! logind signals replace per-second process spawning; loginctl is a bounded fallback.
use super::{publish_lock_state, Duration};
use futures_util::StreamExt;
use tokio::sync::watch;
use zbus::{Connection, MatchRule, MessageStream, Proxy, proxy::CacheProperties};
const SERVICE: &str = "org.freedesktop.login1";
const ROOT: &str = "/org/freedesktop/login1";
const CALL_TIMEOUT: Duration = Duration::from_secs(5);
const RETRY: Duration = Duration::from_secs(30);
async fn locked(connection: &Connection) -> zbus::Result<Option<bool>> {
let path = format!("{ROOT}/user/_{}", unsafe { libc::getuid() });
let user = zbus::proxy::Builder::<Proxy<'_>>::new(connection).destination(SERVICE)?
.path(path)?.interface("org.freedesktop.login1.User")?
.cache_properties(CacheProperties::No).build().await?;
// No cached property reads: signals, including invalidations, trigger a fresh snapshot.
let display: (String, zbus::zvariant::OwnedObjectPath) = user.get_property("Display").await?;
if display.0.is_empty() { return Ok(None); }
let session = zbus::proxy::Builder::<Proxy<'_>>::new(connection).destination(SERVICE)?
.path(display.1)?.interface("org.freedesktop.login1.Session")?
.cache_properties(CacheProperties::No).build().await?;
session.get_property("LockedHint").await.map(Some)
}
async fn snapshot(connection: &Connection) -> zbus::Result<Option<bool>> {
tokio::time::timeout(CALL_TIMEOUT, locked(connection)).await
.map_err(|_| zbus::Error::Failure("lock query timed out".into()))?
}
async fn monitor_connection(connection: &Connection, sender: &watch::Sender<Option<bool>>) -> zbus::Result<()> {
// Subscribe before reading: any change during the first snapshot stays queued.
// Watch all logind signals so User.Display, SessionNew/Removed and invalidated
// properties also re-resolve the graphical session instead of trusting a stale path.
let rule = MatchRule::builder().msg_type(zbus::message::Type::Signal)
.sender(SERVICE)?.path_namespace(ROOT)?.build();
let mut signals = tokio::time::timeout(CALL_TIMEOUT, MessageStream::for_match_rule(rule, connection, Some(64))).await
.map_err(|_| zbus::Error::Failure("lock subscription timed out".into()))??;
publish_lock_state(sender, snapshot(connection).await?);
let mut reconcile = tokio::time::interval(RETRY);
reconcile.tick().await;
loop {
tokio::select! {
event = signals.next() => { event.ok_or_else(|| zbus::Error::Failure("system bus closed".into()))??; },
_ = reconcile.tick() => {},
}
publish_lock_state(sender, snapshot(connection).await?);
}
}
pub(super) async fn monitor(sender: watch::Sender<Option<bool>>) {
let mut degraded = false;
loop {
let result = tokio::time::timeout(CALL_TIMEOUT, async { zbus::connection::Builder::system()?.method_timeout(CALL_TIMEOUT).build().await }).await;
if let Ok(Ok(connection)) = result {
if !degraded { log::debug!("Desktop lock monitor: logind D-Bus"); }
// Recovery is announced only after a valid snapshot, via the state channel.
let _ = monitor_connection(&connection, &sender).await;
}
publish_lock_state(&sender, None);
if !degraded { log::warn!("Desktop lock monitor unavailable; retrying D-Bus with bounded loginctl fallback every 30s"); }
degraded = true;
let fallback = tokio::task::spawn_blocking(super::locked_now).await.ok().flatten();
publish_lock_state(&sender, fallback);
tokio::time::sleep(RETRY).await;
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Arc, Mutex, atomic::{AtomicBool, Ordering}};
use zbus::zvariant::{OwnedObjectPath, Value};
struct User(Arc<Mutex<String>>);
#[zbus::interface(name = "org.freedesktop.login1.User")]
impl User {
#[zbus(property)]
fn display(&self) -> (String, OwnedObjectPath) {
let id = self.0.lock().unwrap().clone();
let path = if id.is_empty() { "/".into() } else { format!("{ROOT}/session/{id}") };
(id, OwnedObjectPath::try_from(path).unwrap())
}
}
struct Session { locked: Arc<AtomicBool>, valid: Arc<AtomicBool> }
#[zbus::interface(name = "org.freedesktop.login1.Session")]
impl Session {
#[zbus(property)]
fn locked_hint(&self) -> zbus::fdo::Result<bool> {
if !self.valid.load(Ordering::SeqCst) { return Err(zbus::fdo::Error::Failed("unavailable".into())); }
Ok(self.locked.load(Ordering::SeqCst))
}
}
async fn expect(rx: &mut watch::Receiver<Option<bool>>, value: Option<bool>) {
tokio::time::timeout(Duration::from_secs(3), async {
loop {
let current = *rx.borrow_and_update();
if current == value { return; }
rx.changed().await.unwrap();
}
}).await.expect("lock state update");
}
async fn invalidated(server: &Connection, path: &str, interface: &str, property: &str) {
// An invalidation has no replacement value: the client must re-read it.
let changed = std::collections::HashMap::<&str, Value<'_>>::new();
server.emit_signal(None::<&str>, path, "org.freedesktop.DBus.Properties", "PropertiesChanged",
&(interface, changed, vec![property])).await.unwrap();
}
#[tokio::test]
#[ignore = "isolated D-Bus integration; requires dbus-daemon, never changes the real desktop"]
async fn private_bus_tracks_initial_state_invalidation_session_change_and_failure() {
use tokio::io::{AsyncBufReadExt, BufReader};
let mut daemon = tokio::process::Command::new("dbus-daemon")
.args(["--session", "--nofork", "--print-address=1"])
.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::null())
.kill_on_drop(true).spawn().unwrap();
let mut address = String::new();
tokio::time::timeout(Duration::from_secs(3), BufReader::new(daemon.stdout.take().unwrap()).read_line(&mut address)).await.unwrap().unwrap();
let address = address.trim();
let display = Arc::new(Mutex::new(String::new()));
let locked = Arc::new(AtomicBool::new(true));
let valid = Arc::new(AtomicBool::new(true));
let user_path = format!("{ROOT}/user/_{}", unsafe { libc::getuid() });
let server = zbus::connection::Builder::address(address).unwrap().name(SERVICE).unwrap()
.serve_at(user_path.clone(), User(display.clone())).unwrap()
.serve_at(format!("{ROOT}/session/a"), Session { locked: locked.clone(), valid: valid.clone() }).unwrap()
.serve_at(format!("{ROOT}/session/b"), Session { locked: Arc::new(AtomicBool::new(true)), valid: valid.clone() }).unwrap()
.build().await.unwrap();
let client = zbus::connection::Builder::address(address).unwrap().build().await.unwrap();
let (tx, mut rx) = watch::channel(Some(false));
let monitor = tokio::spawn(async move {
let result = monitor_connection(&client, &tx).await;
publish_lock_state(&tx, None);
result
});
expect(&mut rx, None).await;
assert!(!monitor.is_finished(), "no graphical session must keep the D-Bus subscription alive");
*display.lock().unwrap() = "a".into();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, Some(true)).await; // login is observed without waiting for the retry timer
locked.store(false, Ordering::SeqCst);
invalidated(&server, &format!("{ROOT}/session/a"), "org.freedesktop.login1.Session", "LockedHint").await;
expect(&mut rx, Some(false)).await;
*display.lock().unwrap() = "b".into();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, Some(true)).await;
display.lock().unwrap().clear();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, None).await;
assert!(!monitor.is_finished(), "logout must keep the D-Bus subscription alive");
*display.lock().unwrap() = "b".into();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, Some(true)).await;
valid.store(false, Ordering::SeqCst);
invalidated(&server, &format!("{ROOT}/session/b"), "org.freedesktop.login1.Session", "LockedHint").await;
expect(&mut rx, None).await; // failure must not become unlocked
assert!(monitor.await.unwrap().is_err());
// A fresh connection must recover after a service/property failure.
valid.store(true, Ordering::SeqCst);
let client = zbus::connection::Builder::address(address).unwrap().build().await.unwrap();
let close = client.clone();
let (tx, mut rx) = watch::channel(None);
let monitor = tokio::spawn(async move {
let result = monitor_connection(&client, &tx).await;
publish_lock_state(&tx, None);
result
});
expect(&mut rx, Some(true)).await;
close.close().await.unwrap();
expect(&mut rx, None).await;
assert!(monitor.await.unwrap().is_err());
daemon.kill().await.unwrap();
daemon.wait().await.unwrap();
}
#[tokio::test]
#[ignore = "manual acceptance: observes a real lock/unlock for up to three minutes"]
async fn live_lock_unlock_signals() {
let before = super::super::COMMAND_STARTS.load(Ordering::SeqCst);
let mut rx = super::super::watch_locked();
let start = std::time::Instant::now();
tokio::time::timeout(Duration::from_secs(180), async {
let mut saw_lock = false;
loop {
let state = *rx.borrow_and_update();
println!("live lock state: {state:?}; elapsed_ms={}", start.elapsed().as_millis());
if state == Some(true) { saw_lock = true; }
if saw_lock && state == Some(false) { break; }
rx.changed().await.unwrap();
}
}).await.expect("please lock and unlock the desktop during this probe");
let started = super::super::COMMAND_STARTS.load(Ordering::SeqCst) - before;
println!("lock monitor command starts: {started}");
assert_eq!(started, 0, "healthy D-Bus monitoring should not spawn loginctl");
}
#[tokio::test]
#[ignore = "read-only live logind probe; requires an active graphical logind session"]
async fn live_logind_snapshot_matches_loginctl_without_changing_lock_state() {
let connection = Connection::system().await.unwrap();
let dbus = snapshot(&connection).await.unwrap();
let command = tokio::task::spawn_blocking(super::super::locked_now).await.unwrap();
assert_eq!(dbus, command);
}
}
+1 -1
View File
@@ -248,7 +248,7 @@ impl SignalingClient {
let mut req = ws_url let mut req = ws_url
.clone() .clone()
.into_client_request() .into_client_request()
.map_err(|e| format!("Invalid WS request: {}", e))?; .map_err(|_| "Invalid WS request".to_string())?;
req.headers_mut().insert( req.headers_mut().insert(
"X-NRD-AUTH", "X-NRD-AUTH",
+27 -2
View File
@@ -300,15 +300,26 @@ impl PeerActions {
/// 0 is always sent), 21 virtual_audio_driver_policy_req -> 17 (no virtual driver needed: the /// 0 is always sent), 21 virtual_audio_driver_policy_req -> 17 (no virtual driver needed: the
/// sink monitor is captured directly). Responses carry error_code 0 (default). /// sink monitor is captured directly). Responses carry error_code 0 (default).
pub fn session_rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> { pub fn session_rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
session_rpc_response_with_error(rpc, 0)
}
pub fn session_rpc_response_with_error(rpc: &[crate::protocol::WireField], error: u8) -> Option<Vec<u8>> {
use crate::protocol::{decode_wire, WireValue}; 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 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, response_field) = [(15u32, 11u8), (21, 17)].into_iter().find_map(|(req, resp)| body(req).map(|b| (b, resp)))?; let (request, response_field) = [(15u32, 11u8), (21, 17)].into_iter().find_map(|(req, resp)| body(req).map(|b| (b, resp)))?;
let value = decode_wire(request).ok().and_then(|f| f.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None })); let value = decode_wire(request).ok().and_then(|f| f.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }));
log::info!("Session RPC answered: response_field={} value={:?}", response_field, value); log::info!("Session RPC answered: response_field={} value={:?}", response_field, value);
let header = body(1).unwrap_or(&[]); let header = body(1).unwrap_or(&[]);
let mut out = vec![10, header.len() as u8]; fn varint(mut value: usize, out: &mut Vec<u8>) {
while value >= 128 { out.push((value as u8 & 127) | 128); value >>= 7; }
out.push(value as u8);
}
let mut out = vec![10];
varint(header.len(), &mut out);
out.extend_from_slice(header); out.extend_from_slice(header);
out.extend_from_slice(&[response_field << 3 | 2, 0]); // Field 17 has a two-byte tag (0x8a 0x01). A truncated tag prevents the client's
// microphone request from completing even though the data channel delivers it.
varint(usize::from(response_field) << 3 | 2, &mut out);
if error == 0 { out.push(0); } else { out.extend([2, 8, error]); }
Some(out) Some(out)
} }
@@ -337,6 +348,20 @@ pub fn plugin_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
mod tests { mod tests {
use super::*; use super::*;
#[test] #[test]
fn virtual_audio_policy_reply_completes_field_17_and_preserves_request_id() {
use crate::protocol::{decode_wire, WireValue};
let request = [10, 2, 8, 9, 170, 1, 2, 8, 1];
let rpc = decode_wire(&request).unwrap();
let response = session_rpc_response(&rpc).unwrap();
let fields = decode_wire(&response).expect("valid protobuf reply, including the field 17 tag");
assert_eq!(fields[0].value, WireValue::Bytes(&[8, 9]));
assert_eq!(fields[1].number, 17);
assert_eq!(fields[1].value, WireValue::Bytes(&[]));
let denied = session_rpc_response_with_error(&rpc, 1).unwrap();
let fields = decode_wire(&denied).unwrap();
assert_eq!(fields[1].value, WireValue::Bytes(&[8, 1]));
}
#[test]
fn toggle_values_from_value_field_json_and_text() { fn toggle_values_from_value_field_json_and_text() {
assert!(!toggle_value(Some(0), b"1")); assert!(!toggle_value(Some(0), b"1"));
assert!(toggle_value(Some(1), b"")); assert!(toggle_value(Some(1), b""));
+306 -21
View File
@@ -9,7 +9,7 @@
use std::collections::{HashMap, VecDeque}; use std::collections::{HashMap, VecDeque};
use std::io::Read; use std::io::Read;
use std::os::fd::{AsRawFd, OwnedFd}; use std::os::fd::{AsRawFd, OwnedFd};
use std::sync::atomic::{AtomicU32, Ordering}; use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock}; use std::sync::{Arc, Mutex, OnceLock};
use tokio::sync::mpsc::UnboundedSender; use tokio::sync::mpsc::UnboundedSender;
@@ -67,6 +67,7 @@ struct Session {
id: u32, id: u32,
shell: String, shell: String,
created_ms: u64, created_ms: u64,
last_active_ms: AtomicU64,
master: OwnedFd, master: OwnedFd,
pid: i32, pid: i32,
sink: Mutex<Option<UnboundedSender<Vec<u8>>>>, sink: Mutex<Option<UnboundedSender<Vec<u8>>>>,
@@ -75,9 +76,11 @@ struct Session {
} }
impl Session { impl Session {
fn touch(&self) { self.last_active_ms.fetch_max(now_ms(), Ordering::Relaxed); }
/// Lock order sink → scrollback matches OPEN, so a reattach snapshot sees each /// Lock order sink → scrollback matches OPEN, so a reattach snapshot sees each
/// chunk either in the replay or live, never both. /// chunk either in the replay or live, never both.
fn record_output(&self, data: &[u8]) { fn record_output(&self, data: &[u8]) {
self.touch();
let mut sink = self.sink.lock().unwrap(); let mut sink = self.sink.lock().unwrap();
{ {
let mut sb = self.scrollback.lock().unwrap(); let mut sb = self.scrollback.lock().unwrap();
@@ -123,6 +126,7 @@ impl Session {
}); });
} }
fn write(&self, data: &[u8]) { fn write(&self, data: &[u8]) {
if !data.is_empty() { self.touch(); }
let mut off = 0; let mut off = 0;
while off < data.len() { while off < data.len() {
let n = unsafe { libc::write(self.master.as_raw_fd(), data[off..].as_ptr().cast(), data.len() - off) }; let n = unsafe { libc::write(self.master.as_raw_fd(), data[off..].as_ptr().cast(), data.len() - off) };
@@ -131,6 +135,31 @@ impl Session {
} }
} }
fn signal(&self, sig: i32) { unsafe { libc::kill(-self.pid, sig); } } fn signal(&self, sig: i32) { unsafe { libc::kill(-self.pid, sig); } }
fn signal_foreground(&self, sig: i32) {
self.touch();
// Job-control shells put commands such as top in their own process group.
let pgid = unsafe { libc::tcgetpgrp(self.master.as_raw_fd()) };
if pgid > 0 { unsafe { libc::kill(-pgid, sig); } } else { self.signal(sig); }
}
fn terminate(&self) {
// Job-control shells give foreground/background jobs separate process groups.
// Limit cleanup to this PTY's POSIX session, never other desktop/tool peers.
if self.pid <= 0 { return; }
#[cfg(target_os = "linux")]
if let Ok(entries) = std::fs::read_dir("/proc") {
let mut groups = std::collections::HashSet::new();
for entry in entries.flatten() {
let Some(pid) = entry.file_name().to_str().and_then(|s| s.parse::<i32>().ok()) else { continue; };
if unsafe { libc::getsid(pid) } == self.pid {
let group = unsafe { libc::getpgid(pid) };
if group > 0 && group != self.pid { groups.insert(group); }
}
}
for group in groups { unsafe { libc::kill(-group, libc::SIGKILL); } }
}
self.signal_foreground(libc::SIGKILL);
self.signal(libc::SIGKILL);
}
} }
fn registry() -> &'static Mutex<HashMap<u32, Arc<Session>>> { fn registry() -> &'static Mutex<HashMap<u32, Arc<Session>>> {
@@ -139,6 +168,28 @@ fn registry() -> &'static Mutex<HashMap<u32, Arc<Session>>> {
} }
static NEXT_ID: AtomicU32 = AtomicU32::new(1); static NEXT_ID: AtomicU32 = AtomicU32::new(1);
fn changes() -> &'static tokio::sync::watch::Sender<u64> {
static CHANGES: OnceLock<tokio::sync::watch::Sender<u64>> = OnceLock::new();
CHANGES.get_or_init(|| tokio::sync::watch::channel(0).0)
}
fn notify_changes() { changes().send_modify(|revision| *revision = revision.wrapping_add(1)); }
pub fn subscribe_changes() -> tokio::sync::watch::Receiver<u64> { changes().subscribe() }
pub fn changed_message(sequence: u64, timestamp: u64) -> Vec<u8> {
// Official Mac 4.42.0: Message name map 0x100a1eb98 gives field 28;
// notifyTerminalListInvalidated (0x1001a341c) sends the empty message on BINARY (channel 3).
crate::initialization::envelope(sequence, timestamp, 28, &[])
}
fn remove_session(session: &Arc<Session>) -> bool {
let mut sessions = registry().lock().unwrap();
// An old reader may finish after OPEN has reused the same requested ID.
if sessions.get(&session.id).is_some_and(|current| Arc::ptr_eq(current, session)) {
sessions.remove(&session.id);
drop(sessions);
notify_changes(); true
} else { false }
}
fn now_ms() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_millis() as u64 } fn now_ms() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_millis() as u64 }
fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, String> { fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, String> {
@@ -172,9 +223,11 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
if id != 0 && !registry().lock().unwrap().contains_key(&id) { break id; } if id != 0 && !registry().lock().unwrap().contains_key(&id) { break id; }
} }
}; };
let session = Arc::new(Session { id, shell: shell.clone(), created_ms: now_ms(), pid: child.id() as i32, let created_ms = now_ms();
let session = Arc::new(Session { id, shell: shell.clone(), created_ms, last_active_ms: AtomicU64::new(created_ms), pid: child.id() as i32,
master: pty.master, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((cols, rows)) }); master: pty.master, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((cols, rows)) });
let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?); let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?);
registry().lock().unwrap().insert(id, session.clone());
let worker = session.clone(); let worker = session.clone();
std::thread::Builder::new().name(format!("uu-term-{id}")).spawn(move || { std::thread::Builder::new().name(format!("uu-term-{id}")).spawn(move || {
let mut buf = vec![0u8; OUTPUT_CHUNK]; let mut buf = vec![0u8; OUTPUT_CHUNK];
@@ -187,9 +240,10 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1); let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1);
log::info!("Terminal session exited: id={} exit_code={}", worker.id, code); log::info!("Terminal session exited: id={} exit_code={}", worker.id, code);
worker.emit(EXIT, serde_json::json!({"exit_code": code}).to_string().as_bytes()); worker.emit(EXIT, serde_json::json!({"exit_code": code}).to_string().as_bytes());
registry().lock().unwrap().remove(&worker.id); remove_session(&worker);
}).map_err(|e| format!("reader thread failed: {e}"))?; }).map_err(|e| {
registry().lock().unwrap().insert(id, session.clone()); remove_session(&session); session.terminate(); format!("reader thread failed: {e}")
})?;
log::info!("Terminal session spawned: id={} cols={} rows={}", id, cols, rows); log::info!("Terminal session spawned: id={} cols={} rows={}", id, cols, rows);
Ok(session) Ok(session)
} }
@@ -201,7 +255,7 @@ pub fn shutdown_all() {
for s in &sessions { s.signal(libc::SIGHUP); } for s in &sessions { s.signal(libc::SIGHUP); }
if !sessions.is_empty() { if !sessions.is_empty() {
std::thread::sleep(std::time::Duration::from_millis(300)); std::thread::sleep(std::time::Duration::from_millis(300));
for s in &sessions { s.signal(libc::SIGKILL); } for s in &sessions { s.terminate(); }
log::info!("Terminal sessions closed on shutdown: count={}", sessions.len()); log::info!("Terminal sessions closed on shutdown: count={}", sessions.len());
} }
} }
@@ -226,13 +280,26 @@ fn signal_number(payload: &[u8]) -> i32 {
fn reply(code: i64, message: &str) -> Vec<u8> { serde_json::json!({"code": code, "message": message}).to_string().into_bytes() } fn reply(code: i64, message: &str) -> Vec<u8> { serde_json::json!({"code": code, "message": message}).to_string().into_bytes() }
/// One viewer connection's terminal endpoint; `out` sends complete frames on BINARY_DATA_CHANNEL. /// One viewer connection's terminal endpoint; `out` sends complete frames on BINARY_DATA_CHANNEL.
pub struct TerminalConn { out: UnboundedSender<Vec<u8>> } pub struct TerminalConn { out: UnboundedSender<Vec<u8>>, closed: AtomicBool }
impl TerminalConn { impl TerminalConn {
pub fn new(out: UnboundedSender<Vec<u8>>) -> Self { Self { out } } pub fn new(out: UnboundedSender<Vec<u8>>) -> Self { Self { out, closed: AtomicBool::new(false) } }
fn send(&self, kind: u8, session: u32, payload: &[u8]) { let _ = self.out.send(encode(kind, session, payload)); } fn send(&self, kind: u8, session: u32, payload: &[u8]) { let _ = self.out.send(encode(kind, session, payload)); }
pub fn disconnect(&self) {
self.closed.store(true, Ordering::Release);
let sessions: Vec<_> = registry().lock().unwrap().values().cloned().collect();
let mut changed = false;
for s in sessions {
let mut sink = s.sink.lock().unwrap();
if sink.as_ref().is_some_and(|tx| tx.same_channel(&self.out)) {
*sink = None; s.touch(); changed = true;
}
}
if changed { notify_changes(); }
}
pub fn handle(&self, data: &[u8]) { pub fn handle(&self, data: &[u8]) {
if self.closed.load(Ordering::Acquire) { return; }
let Some(frame) = decode(data) else { log::warn!("Terminal frame rejected: bytes={}", data.len()); return; }; let Some(frame) = decode(data) else { log::warn!("Terminal frame rejected: bytes={}", data.len()); return; };
if frame.kind != STDIN { log::info!("Terminal frame: type={} session={} payload_bytes={}", frame.kind, frame.session, frame.payload.len()); } if frame.kind != STDIN { log::info!("Terminal frame: type={} session={} payload_bytes={}", frame.kind, frame.session, frame.payload.len()); }
let existing = registry().lock().unwrap().get(&frame.session).cloned(); let existing = registry().lock().unwrap().get(&frame.session).cloned();
@@ -247,6 +314,7 @@ impl TerminalConn {
}; };
match session { match session {
Ok(s) => { Ok(s) => {
s.touch();
// Queue the acknowledgement before the PTY reader can emit live output. // Queue the acknowledgement before the PTY reader can emit live output.
let mut sink = s.sink.lock().unwrap(); let mut sink = s.sink.lock().unwrap();
self.send(OPEN_RESP, s.id, &reply(0, "ok")); self.send(OPEN_RESP, s.id, &reply(0, "ok"));
@@ -257,30 +325,55 @@ impl TerminalConn {
drop(sink); drop(sink);
// The replay tail starts mid-redraw for full-screen programs. // The replay tail starts mid-redraw for full-screen programs.
if reattach { s.force_redraw(); } if reattach { s.force_redraw(); }
notify_changes();
} }
Err(e) => { log::warn!("Terminal open failed: {}", e); self.send(OPEN_RESP, frame.session, &reply(1, &e)); } Err(e) => { log::warn!("Terminal open failed: {}", e); self.send(OPEN_RESP, frame.session, &reply(1, &e)); }
} }
} }
STDIN => if let Some(s) = existing { s.write(&frame.payload) }, STDIN | RESIZE | SIGNAL | CLOSE | DETACH => if let Some(s) = existing {
RESIZE => if let Some(s) = existing { let (c, r) = dims(&json(&frame.payload)); s.resize(c, r) }, let mut sink = s.sink.lock().unwrap();
SIGNAL => if let Some(s) = existing { s.signal(signal_number(&frame.payload)) }, // Reattach transfers ownership. Late input/DETACH from the old viewer
CLOSE => if let Some(s) = existing { *s.sink.lock().unwrap() = None; s.signal(libc::SIGHUP); }, // must not affect the new attachment or inject a second copy of input.
DETACH => if let Some(s) = existing { *s.sink.lock().unwrap() = None }, if !sink.as_ref().is_some_and(|tx| tx.same_channel(&self.out)) { return; }
match frame.kind {
// PTY writes may block during a large paste. Keep output draining.
STDIN => { drop(sink); s.write(&frame.payload); }
RESIZE => { let (c, r) = dims(&json(&frame.payload)); s.resize(c, r); }
SIGNAL => s.signal_foreground(signal_number(&frame.payload)),
CLOSE | DETACH => {
*sink = None; s.touch();
if frame.kind == CLOSE { s.signal(libc::SIGHUP); }
notify_changes();
}
_ => unreachable!(),
}
},
KILL_REQ => { KILL_REQ => {
let id = if frame.session != 0 { frame.session } else { // Official Mac 4.42.0 handleKillSessionReq (0x100189ca0, 0x10018be64):
json(&frame.payload).get("session_id").and_then(|x| x.as_u64()).unwrap_or(0) as u32 // JSON session_id selects the target; the frame header correlates the reply.
let Some(id) = json(&frame.payload).get("session_id").and_then(|x| x.as_u64()).and_then(|id| u32::try_from(id).ok()) else {
self.send(KILL_RESP, frame.session, &reply(400, "Invalid payload")); return;
}; };
let target = registry().lock().unwrap().get(&id).cloned(); let target = registry().lock().unwrap().remove(&id);
match target { match target {
Some(s) => { *s.sink.lock().unwrap() = None; s.signal(libc::SIGHUP); s.signal(libc::SIGKILL); self.send(KILL_RESP, id, &reply(0, "ok")); } Some(s) => {
None => self.send(KILL_RESP, id, &reply(1, "Session not found")), s.terminate();
self.send(KILL_RESP, frame.session, &reply(0, "ok"));
notify_changes();
log::info!("Terminal session terminated: id={} request={}", id, frame.session);
}
None => self.send(KILL_RESP, frame.session, &reply(404, "Session not found")),
} }
} }
LIST_REQ => { LIST_REQ => {
let sessions: Vec<serde_json::Value> = registry().lock().unwrap().values().map(|s| { let sessions: Vec<serde_json::Value> = registry().lock().unwrap().values().map(|s| {
let attached = s.sink.lock().unwrap().is_some(); let attached = s.sink.lock().unwrap().as_ref().is_some_and(|tx| !tx.is_closed());
serde_json::json!({"session_id": s.id, "name": format!("bash-{}", s.id), "shell": s.shell, let name = std::path::Path::new(&s.shell).file_name().and_then(|n| n.to_str()).unwrap_or("shell");
"state": if attached { "running" } else { "detached" }, "created_at_ms": s.created_ms}) // Official Mac 4.42.0 snapshot at 0x1001b82c8–0x1001b8524
// includes last_active_ms even when the session is detached.
serde_json::json!({"session_id": s.id, "name": format!("{}-{}", name, s.id), "shell": s.shell,
"state": if attached { "running" } else { "detached" }, "created_at_ms": s.created_ms,
"last_active_ms": s.last_active_ms.load(Ordering::Relaxed)})
}).collect(); }).collect();
log::info!("Terminal list sessions: count={}", sessions.len()); log::info!("Terminal list sessions: count={}", sessions.len());
// Official Mac 4.42.0 (handleListSessionsReq) sends a bare array with the request's header ID. // Official Mac 4.42.0 (handleListSessionsReq) sends a bare array with the request's header ID.
@@ -323,9 +416,200 @@ mod tests {
} }
} }
#[test] #[test]
fn kill_uses_payload_id_preserves_request_id_and_updates_list_before_reply() {
let victim = spawn(u32::MAX - 5, 80, 24, Some("/bin/sh")).unwrap();
let decoy = spawn(u32::MAX - 6, 80, 24, Some("/bin/sh")).unwrap();
struct Cleanup(Vec<Arc<Session>>);
impl Drop for Cleanup {
fn drop(&mut self) { for s in &self.0 { s.signal(libc::SIGHUP); s.signal(libc::SIGKILL); } }
}
let _cleanup = Cleanup(vec![victim.clone(), decoy.clone()]);
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let conn = TerminalConn::new(tx);
let payload = serde_json::json!({"session_id": victim.id}).to_string();
// A request ID may happen to equal another live session ID. Never kill it.
conn.handle(&encode(KILL_REQ, decoy.id, payload.as_bytes()));
let response = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!((response.kind, response.session), (KILL_RESP, decoy.id));
assert_eq!(json(&response.payload)["code"], 0);
conn.handle(&encode(LIST_REQ, 123, &[]));
let response = decode(&rx.try_recv().unwrap()).unwrap();
let list = json(&response.payload);
assert!(!list.as_array().unwrap().iter().any(|s| s["session_id"] == victim.id), "terminated session must be absent before acknowledgement");
assert!(list.as_array().unwrap().iter().any(|s| s["session_id"] == decoy.id), "request correlation must not select a session");
assert_eq!(unsafe { libc::kill(decoy.pid, 0) }, 0);
conn.handle(&encode(KILL_REQ, 123, payload.as_bytes()));
let response = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!(response.session, 123);
assert_eq!(json(&response.payload)["code"], 404);
for invalid in [b"{}".as_slice(), b"", br#"{"session_id":-1}"#, br#"{"session_id":4294967296}"#] {
conn.handle(&encode(KILL_REQ, decoy.id, invalid));
let response = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!(response.session, decoy.id);
assert_eq!(json(&response.payload)["code"], 400);
assert!(registry().lock().unwrap().contains_key(&decoy.id));
}
}
#[test]
fn session_changed_matches_official_empty_binary_notification() {
use crate::protocol::WireValue;
let message = changed_message(17, 1234);
let fields = crate::protocol::decode_wire(&message).unwrap();
assert_eq!(fields.iter().map(|f| f.number).collect::<Vec<_>>(), vec![1, 2, 28]);
assert_eq!(fields[2].value, WireValue::Bytes(&[]));
}
#[test]
#[cfg(target_os = "linux")]
fn kill_ends_foreground_and_background_jobs() {
let session = spawn(u32::MAX - 8, 80, 24, Some("/bin/sh")).unwrap();
struct Cleanup(Arc<Session>);
impl Drop for Cleanup { fn drop(&mut self) { self.0.terminate(); } }
let _cleanup = Cleanup(session.clone());
session.write(b"sleep 30 & sleep 30\n");
let mut jobs = Vec::new();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline {
jobs = std::fs::read_to_string(format!("/proc/{}/task/{}/children", session.pid, session.pid)).unwrap_or_default()
.split_whitespace().filter_map(|s| s.parse::<i32>().ok())
.filter(|pid| std::fs::read_to_string(format!("/proc/{pid}/comm")).is_ok_and(|s| s.trim() == "sleep")).collect();
if jobs.len() == 2 { break; }
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert_eq!(jobs.len(), 2, "foreground and background jobs must be running");
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&encode(KILL_REQ, 123, serde_json::json!({"session_id":session.id}).to_string().as_bytes()));
assert_eq!(json(&decode(&rx.try_recv().unwrap()).unwrap().payload)["code"], 0);
jobs.push(session.pid);
let alive = |pid| std::fs::read_to_string(format!("/proc/{pid}/stat"))
.is_ok_and(|s| s.rsplit_once(") ").is_some_and(|(_, fields)| !fields.starts_with('Z')));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline && jobs.iter().any(|pid| alive(*pid)) {
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert!(!jobs.iter().any(|pid| alive(*pid)), "termination must end all job-control groups");
}
#[test]
fn reattach_rejects_old_input_and_detach_but_preserves_intentional_repeats() {
let pty = nix::pty::openpty(None, None).unwrap();
let id = u32::MAX - 7;
let mut termios = nix::sys::termios::tcgetattr(&pty.slave).unwrap();
nix::sys::termios::cfmakeraw(&mut termios);
nix::sys::termios::tcsetattr(&pty.slave, nix::sys::termios::SetArg::TCSANOW, &termios).unwrap();
let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(), last_active_ms: AtomicU64::new(now_ms()),
master: pty.master, pid: 0, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((80, 24)) });
registry().lock().unwrap().insert(id, session.clone());
struct Cleanup(Arc<Session>);
impl Drop for Cleanup { fn drop(&mut self) { remove_session(&self.0); } }
let _cleanup = Cleanup(session.clone());
let (old_tx, _old_rx) = tokio::sync::mpsc::unbounded_channel();
let old = TerminalConn::new(old_tx);
let (new_tx, _new_rx) = tokio::sync::mpsc::unbounded_channel();
let new = TerminalConn::new(new_tx);
old.handle(&encode(OPEN, id, b"{}"));
new.handle(&encode(OPEN, id, b"{}"));
old.handle(&encode(STDIN, id, b"stale"));
old.handle(&encode(DETACH, id, &[]));
old.disconnect();
let input = b"\x1b[A";
new.handle(&encode(STDIN, id, input));
new.handle(&encode(STDIN, id, input));
let mut slave = std::fs::File::from(pty.slave);
let mut bytes = [0; 6];
slave.read_exact(&mut bytes).unwrap();
assert!(bytes == input.repeat(2).as_slice(), "only current input should arrive, including intentional repeats");
assert!(session.sink.lock().unwrap().as_ref().is_some_and(|tx| tx.same_channel(&new.out)));
new.disconnect();
assert!(session.sink.lock().unwrap().is_none());
new.handle(&encode(OPEN, id, b"{}"));
assert!(session.sink.lock().unwrap().is_none(), "a closed connection must not reattach");
}
#[test]
fn nonempty_list_matches_official_snapshot_and_survives_reattach() {
// Official Mac 4.42.0 TerminalSession snapshot (0x1001b82c8–0x1001b8524):
// all six fields exist, including the Int64 last_active_ms timestamp.
#[derive(serde::Deserialize)]
struct Snapshot { session_id: u32, name: String, shell: String, state: String,
created_at_ms: i64, last_active_ms: i64 }
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let mut conn = TerminalConn::new(tx);
let id = u32::MAX - 3;
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24,"shell":"/bin/sh"}"#));
assert_eq!(decode(&rx.blocking_recv().unwrap()).unwrap().kind, OPEN_RESP);
struct Cleanup(u32);
impl Drop for Cleanup {
fn drop(&mut self) {
if let Some(s) = registry().lock().unwrap().get(&self.0).cloned() { s.signal(libc::SIGHUP); }
}
}
let _cleanup = Cleanup(id);
let snapshot = |request| {
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&encode(LIST_REQ, request, &[]));
let reply = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!((reply.kind, reply.session), (LIST_RESP, request));
serde_json::from_slice::<Vec<Snapshot>>(&reply.payload).expect("official nonempty session schema")
.into_iter().find(|s| s.session_id == id).unwrap()
};
let first = snapshot(100);
assert_eq!(first.state, "running");
assert_eq!(first.shell, "/bin/sh");
assert_eq!(first.name, format!("sh-{id}"));
assert!(first.created_at_ms > 0 && first.last_active_ms >= first.created_at_ms);
for request in [101, 102] {
conn.handle(&encode(DETACH, id, &[]));
let detached = snapshot(request);
assert_eq!(detached.state, "detached");
std::thread::sleep(std::time::Duration::from_millis(5));
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
conn = TerminalConn::new(tx);
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24}"#));
assert_eq!(decode(&rx.blocking_recv().unwrap()).unwrap().kind, OPEN_RESP);
let attached = snapshot(request + 100);
assert_eq!(attached.state, "running");
assert_eq!(attached.created_at_ms, first.created_at_ms);
assert!(attached.last_active_ms > detached.last_active_ms);
}
}
#[test]
#[cfg(target_os = "linux")]
fn interrupt_reaches_foreground_job_without_exiting_shell() {
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let conn = TerminalConn::new(tx);
let id = u32::MAX - 4;
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24,"shell":"/bin/sh"}"#));
assert_eq!(decode(&rx.blocking_recv().unwrap()).unwrap().kind, OPEN_RESP);
let session = registry().lock().unwrap().get(&id).unwrap().clone();
struct Cleanup(Arc<Session>);
impl Drop for Cleanup {
fn drop(&mut self) { self.0.signal_foreground(libc::SIGKILL); self.0.signal(libc::SIGHUP); }
}
let _cleanup = Cleanup(session.clone());
let foreground = || unsafe { libc::tcgetpgrp(session.master.as_raw_fd()) };
// The shell can foreground its child before exec resets inherited signals.
let job_ready = || {
let pgid = foreground();
pgid > 0 && pgid != session.pid &&
std::fs::read_to_string(format!("/proc/{pgid}/comm")).is_ok_and(|name| name.trim() == "sleep")
};
conn.handle(&encode(STDIN, id, b"sleep 30\n"));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline && !job_ready() {
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert!(job_ready(), "job must be executing in a separate foreground group");
conn.handle(&encode(SIGNAL, id, br#"{"signal":"SIGINT"}"#));
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while std::time::Instant::now() < deadline && foreground() != session.pid {
std::thread::sleep(std::time::Duration::from_millis(10));
}
assert_eq!(foreground(), session.pid, "interrupt must return control to the shell");
assert_eq!(unsafe { libc::kill(session.pid, 0) }, 0, "shell must stay alive");
}
#[test]
fn force_redraw_shrinks_then_restores_latest_size() { fn force_redraw_shrinks_then_restores_latest_size() {
let pty = nix::pty::openpty(None, None).unwrap(); let pty = nix::pty::openpty(None, None).unwrap();
let session = Arc::new(Session { id: u32::MAX - 2, shell: "/bin/sh".into(), created_ms: now_ms(), let session = Arc::new(Session { id: u32::MAX - 2, shell: "/bin/sh".into(), created_ms: now_ms(),
last_active_ms: AtomicU64::new(now_ms()),
master: pty.master, pid: 0, sink: Mutex::new(None), master: pty.master, pid: 0, sink: Mutex::new(None),
scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((80, 24)) }); scrollback: Mutex::new(VecDeque::new()), size: Mutex::new((80, 24)) });
let rows = |s: &Session| { let rows = |s: &Session| {
@@ -346,6 +630,7 @@ mod tests {
let id = u32::MAX - 1; let id = u32::MAX - 1;
let history: Vec<u8> = (0..SCROLLBACK).map(|n| (n % 251) as u8).collect(); let history: Vec<u8> = (0..SCROLLBACK).map(|n| (n % 251) as u8).collect();
let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(), let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(),
last_active_ms: AtomicU64::new(now_ms()),
master: pty.master, pid: 0, sink: Mutex::new(None), master: pty.master, pid: 0, sink: Mutex::new(None),
scrollback: Mutex::new(history.iter().copied().collect()), size: Mutex::new((80, 24)) }); scrollback: Mutex::new(history.iter().copied().collect()), size: Mutex::new((80, 24)) });
registry().lock().unwrap().insert(id, session.clone()); registry().lock().unwrap().insert(id, session.clone());
+45 -22
View File
@@ -154,8 +154,25 @@ fn is_independent_frame_for(bytes: &[u8], codec: VideoCodec) -> bool {
match codec { match codec {
VideoCodec::H264 => !nal_offsets_for(bytes, 5, codec).is_empty() && nal_offsets_for(bytes, 1, codec).is_empty(), VideoCodec::H264 => !nal_offsets_for(bytes, 5, codec).is_empty() && nal_offsets_for(bytes, 1, codec).is_empty(),
// BLA/IDR/CRA are IRAP (RFC 7798 §4.1); no leading pictures with our no-B-frame encoder. // BLA/IDR/CRA are IRAP (RFC 7798 §4.1); no leading pictures with our no-B-frame encoder.
VideoCodec::H265 => (16..=21).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty()) VideoCodec::H265 => {
&& !(0..16).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty()), let mut has_irap = false;
let mut has_non_irap_vcl = false;
let mut i = 0;
while i + 3 < bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue };
let header = i + prefix;
if let Some(kind) = hevc_nal_kind(bytes, header) {
if (16..=21).contains(&kind) {
has_irap = true;
} else if kind < 16 {
has_non_irap_vcl = true;
}
}
i += prefix;
}
has_irap && !has_non_irap_vcl
}
} }
} }
#[cfg(test)] #[cfg(test)]
@@ -169,7 +186,7 @@ struct CompleteFrame {
codec: VideoCodec, codec: VideoCodec,
sequence: u64, sequence: u64,
completed_at: Instant, completed_at: Instant,
data: Vec<u8>, data: bytes::Bytes,
_permit: Option<OwnedSemaphorePermit>, _permit: Option<OwnedSemaphorePermit>,
} }
@@ -769,7 +786,7 @@ async fn read_inprocess(
let mut gate = DependencyGate::default(); let mut gate = DependencyGate::default();
while let Some(unit) = units.recv().await { while let Some(unit) = units.recv().await {
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1; let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: source.1, source_id: source.0, codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) })); gate.submit(&latest, Arc::new(CompleteFrame { source_generation: source.1, source_id: source.0, codec, sequence, completed_at: unit.completed_at, data: unit.data.into(), _permit: Some(unit.permit) }));
if latest.is_closed() { break; } if latest.is_closed() { break; }
} }
// Dropping the receiver also unblocks the encoder if it is waiting to send. // Dropping the receiver also unblocks the encoder if it is waiting to send.
@@ -778,11 +795,11 @@ async fn read_inprocess(
job.await.map_err(|e| format!("Encoder task: {e}"))? job.await.map_err(|e| format!("Encoder task: {e}"))?
} }
/// Rate-control arguments: constant quality capped at 30M (自动), or capped at the viewer's /// VBV buffer in kbit. libx264 and NVENC need room for a whole IDR frame, otherwise large desktops get
/// chosen bitrate. The VBV buffer stays at most 500k so a cap never adds queueing latency. /// keyframes quantized into a blur that sharpens over the GOP (#8 libx264, #103 NVENC). Half a second of
/// VBV buffer in kbit. NVENC ull and VAAPI keep the small low-latency buffer; libx264 needs room for a /// bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not. The 8000 kbit
/// whole IDR frame, otherwise large desktops get near-grey keyframes that sharpen over the GOP (#8). /// cap bounds the keyframe burst: 4K hevc_nvenc CQ18 IDRs measured 0.45 MB (desktop) to 0.76 MB (photo).
/// Half a second of bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not. /// VAAPI keeps the small low-latency buffer unless UU_VAAPI_BUFFER_MS asks for more.
fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 { fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
let env = match encoder { let env = match encoder {
Encoder::Cpu => return max_kbps.clamp(500, 8000), Encoder::Cpu => return max_kbps.clamp(500, 8000),
@@ -790,13 +807,14 @@ fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
Encoder::Nvenc => "UU_NVENC_BUFFER_MS", Encoder::Nvenc => "UU_NVENC_BUFFER_MS",
}; };
let requested = std::env::var(env).ok(); let requested = std::env::var(env).ok();
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500)) let default = if encoder == Encoder::Nvenc { max_kbps.clamp(500, 8000) } else { (max_kbps / 8).clamp(100, 500) };
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or(default)
} }
/// Opt-in hardware VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` / /// Hardware VBV buffer override: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
/// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With the 100-500 kbit default the encoder quantizes a /// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With VAAPI's 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). /// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42); a small NVENC value
/// Unset, out of range or unparsable values keep the default buffer. /// brings back the old low-latency buffer. Unset, out of range or unparsable values keep the default buffer.
fn buffer_ms_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))?; let ms = value?.trim().parse::<u32>().ok().filter(|ms| (10..=1000).contains(ms))?;
Some((max_kbps.saturating_mul(ms) / 1000).max(1)) Some((max_kbps.saturating_mul(ms) / 1000).max(1))
@@ -808,6 +826,8 @@ fn buffer_for(settings: &VideoSettings, encoder: Encoder) -> u32 {
} else { buffer_kbits(settings.max_kbps().unwrap_or(30_000), encoder) } } else { buffer_kbits(settings.max_kbps().unwrap_or(30_000), encoder) }
} }
/// Rate-control arguments: constant quality capped at 30M (自动), or capped at the viewer's
/// chosen bitrate.
fn rate_args(settings: &VideoSettings, encoder: Encoder) -> (String, String) { fn rate_args(settings: &VideoSettings, encoder: Encoder) -> (String, String) {
let max_kbps = settings.max_kbps().unwrap_or(30_000); let max_kbps = settings.max_kbps().unwrap_or(30_000);
(format!("{max_kbps}k"), format!("{}k", buffer_for(settings, encoder))) (format!("{max_kbps}k"), format!("{}k", buffer_for(settings, encoder)))
@@ -988,7 +1008,7 @@ async fn read_encoder_with(
if aud.len() < 2 { break; } if aud.len() < 2 { break; }
let next = aud[1]; let next = aud[1];
if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); } if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
let frame: Vec<u8> = pending.drain(..next).collect(); let frame: bytes::Bytes = pending.drain(..next).collect::<Vec<u8>>().into();
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1; let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
let permit=if wayland {Some(permits_rx.recv().await.ok_or("Capture producer stopped")?)} else {None}; let permit=if wayland {Some(permits_rx.recv().await.ok_or("Capture producer stopped")?)} else {None};
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: settings.source_generation, source_id: settings.source_id, gate.submit(&latest, Arc::new(CompleteFrame { source_generation: settings.source_generation, source_id: settings.source_id,
@@ -1330,7 +1350,7 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis()); max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis());
// Continue monitoring close even if the network send stalls. // Continue monitoring close even if the network send stalls.
let sample = Sample { let sample = Sample {
data: frame.data.clone().into(), duration, ..Default::default() data: frame.data.clone(), duration, ..Default::default()
}; };
let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()]; let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()];
let sent_before=track.revision(); let sent_before=track.revision();
@@ -1480,7 +1500,7 @@ mod tests {
for sequence in 1..=2 { for sequence in 1..=2 {
let permit=budget.clone().acquire_owned().await.unwrap(); let permit=budget.clone().acquire_owned().await.unwrap();
gate.submit(&tx,Arc::new(CompleteFrame { source_generation: 0, source_id: 0,codec:VideoCodec::H264,sequence,completed_at:Instant::now(), gate.submit(&tx,Arc::new(CompleteFrame { source_generation: 0, source_id: 0,codec:VideoCodec::H264,sequence,completed_at:Instant::now(),
data:vec![0,0,1,5,42],_permit:Some(permit)})); data:vec![0,0,1,5,42].into(),_permit:Some(permit)}));
} }
let sending=rx.recv().await.unwrap(); let sending=rx.recv().await.unwrap();
assert_eq!(budget.available_permits(),0); assert_eq!(budget.available_permits(),0);
@@ -1596,7 +1616,10 @@ mod tests {
#[test] #[test]
fn x264_buffer_fits_keyframes() { fn x264_buffer_fits_keyframes() {
assert_eq!(buffer_kbits(2000, Encoder::Nvenc), 250); // NVENC follows libx264 (#103): one second of the cap within 500-8000 kbit.
assert_eq!(buffer_kbits(2000, Encoder::Nvenc), 2000);
assert_eq!(buffer_kbits(300, Encoder::Nvenc), 500);
assert_eq!(buffer_kbits(30_000, Encoder::Nvenc), 8000);
assert_eq!(buffer_kbits(2000, Encoder::Vaapi), 250); assert_eq!(buffer_kbits(2000, Encoder::Vaapi), 250);
assert_eq!(buffer_kbits(2000, Encoder::Cpu), 2000); assert_eq!(buffer_kbits(2000, Encoder::Cpu), 2000);
assert_eq!(buffer_kbits(300, Encoder::Cpu), 500); assert_eq!(buffer_kbits(300, Encoder::Cpu), 500);
@@ -1642,7 +1665,7 @@ mod tests {
let (started_tx, started_rx) = tokio::sync::oneshot::channel(); let (started_tx, started_rx) = tokio::sync::oneshot::channel();
let frame = |sequence, idr| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, let frame = |sequence, idr| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None,
sequence, codec: VideoCodec::H264, completed_at: Instant::now(), sequence, codec: VideoCodec::H264, completed_at: Instant::now(),
data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42], data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42].into(),
}); });
let mut reader = EncoderTask(tokio::spawn(async move { let mut reader = EncoderTask(tokio::spawn(async move {
let _stopped = MarkStopped(old_stopped); let _stopped = MarkStopped(old_stopped);
@@ -1735,7 +1758,7 @@ mod tests {
async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){ async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){
let(tx,mut rx)=mpsc::channel(1); let(tx,mut rx)=mpsc::channel(1);
let mut gate=DependencyGate::default(); let mut gate=DependencyGate::default();
let frame=|sequence,idr|Arc::new(CompleteFrame{source_generation:0,source_id:0,_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]}); let frame=|sequence,idr|Arc::new(CompleteFrame{source_generation:0,source_id:0,_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42].into()});
gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet
gate.submit(&tx,frame(2,true)); gate.submit(&tx,frame(2,true));
gate.submit(&tx,frame(3,false)); // queue full: P3 lost gate.submit(&tx,frame(3,false)); // queue full: P3 lost
@@ -1808,7 +1831,7 @@ mod tests {
let (tx, mut rx) = mpsc::channel(1); let (tx, mut rx) = mpsc::channel(1);
let mut gate = DependencyGate::default(); let mut gate = DependencyGate::default();
let frame = |sequence, irap| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, codec: VideoCodec::H265, let frame = |sequence, irap| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, codec: VideoCodec::H265,
sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42] }); sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42].into() });
gate.submit(&tx, frame(1, false)); gate.submit(&tx, frame(1, false));
assert!(rx.try_recv().is_err()); assert!(rx.try_recv().is_err());
gate.submit(&tx, frame(2, true)); gate.submit(&tx, frame(2, true));
@@ -1855,7 +1878,7 @@ mod screen_frame_tests {
use super::*; use super::*;
#[test] #[test]
fn source_restart_rejects_queued_frames_even_with_same_screen_and_codec() { fn source_restart_rejects_queued_frames_even_with_same_screen_and_codec() {
let frame=CompleteFrame {source_id:0,source_generation:7,codec:VideoCodec::H264,sequence:1,completed_at:Instant::now(),data:vec![],_permit:None}; let frame=CompleteFrame {source_id:0,source_generation:7,codec:VideoCodec::H264,sequence:1,completed_at:Instant::now(),data:vec![].into(),_permit:None};
let mut settings=VideoSettings {source_id:0,source_generation:7,..Default::default()}; let mut settings=VideoSettings {source_id:0,source_generation:7,..Default::default()};
assert!(frame.matches(&settings)); assert!(frame.matches(&settings));
settings.source_generation=9;assert!(!frame.matches(&settings)); settings.source_generation=9;assert!(!frame.matches(&settings));
+1 -1
View File
@@ -57,7 +57,7 @@ impl VideoTrack {
// Leave room for the RTP header and negotiated UU extensions below the 1200 byte MTU. // Leave room for the RTP header and negotiated UU extensions below the 1200 byte MTU.
let payloads = match codec { let payloads = match codec {
VideoCodec::H264 => state.h264.payload(1160, &sample.data).map_err(Error::Rtp)?, VideoCodec::H264 => state.h264.payload(1160, &sample.data).map_err(Error::Rtp)?,
VideoCodec::H265 => crate::hevc::payload(1160, &sample.data).map_err(Error::new)?, VideoCodec::H265 => crate::hevc::payload_bytes(1160, &sample.data).map_err(Error::new)?,
}; };
let count = payloads.len(); let count = payloads.len();
let mut complete = count > 0; let mut complete = count > 0;
+1 -1
View File
@@ -31,7 +31,7 @@ pub(super) async fn encode(latest: mpsc::Sender<Arc<CompleteFrame>>, settings: V
let frame = Arc::new(CompleteFrame { let frame = Arc::new(CompleteFrame {
source_generation: settings.source_generation, source_id: settings.source_id, source_generation: settings.source_generation, source_id: settings.source_id,
codec: settings.codec, sequence: sequence.fetch_add(1, Ordering::Relaxed) + 1, 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), completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2].into(), _permit: Some(permit),
}); });
if latest.send(frame).await.is_err() { return Ok(()); } if latest.send(frame).await.is_err() { return Ok(()); }
} }
+135
View File
@@ -0,0 +1,135 @@
//! Session-scoped remote pointer shapes. Wire evidence is documented in src/cursor.rs.
use crate::protocol::{decode_wire,WireValue};
use std::sync::{Arc,Mutex};
const MAX_SIDE:u32=512;
const MAX_PNG:usize=1024*1024;
#[derive(Clone,Debug,PartialEq)]
pub struct Shape {pub width:u32,pub height:u32,pub hot_x:u32,pub hot_y:u32,pub scale_x:f64,pub scale_y:f64,pub png:Vec<u8>}
fn blob(data:&[u8],field:u32)->Option<&[u8]>{decode_wire(data).ok()?.into_iter().find_map(|f|match(f.number,f.value){(n,WireValue::Bytes(v))if n==field=>Some(v),_=>None})}
fn parse(data:&[u8])->Result<Option<Shape>,()> {
if data.len()>MAX_PNG+512{return Err(())}
let Some(change)=blob(data,15) else{return Ok(None)};
let Some(shape)=blob(change,2) else{return Ok(None)};
let fields=decode_wire(shape).map_err(|_|())?;
let uint=|n|fields.iter().find_map(|f|match(f.number,&f.value){(i,WireValue::Varint(v))if i==n=>Some(*v),_=>None}).unwrap_or(0);
let scale=|n|fields.iter().find_map(|f|match(f.number,&f.value){(i,WireValue::Fixed64(v))if i==n=>Some(f64::from_le_bytes(*v)),_=>None}).unwrap_or(1.);
let png=blob(shape,5).unwrap_or_default();
// Type-only/unsupported shapes restore the local arrow instead of leaving a stale resize cursor.
if png.is_empty(){return Ok(Some(Shape{width:0,height:0,hot_x:0,hot_y:0,scale_x:1.,scale_y:1.,png:Vec::new()}))}
let(width,height)=(u32::try_from(uint(3)).map_err(|_|())?,u32::try_from(uint(4)).map_err(|_|())?);
let(hot_x,hot_y)=(u32::try_from(uint(1)).map_err(|_|())?,u32::try_from(uint(2)).map_err(|_|())?);
let(scale_x,scale_y)=(scale(7),scale(8));
if width==0||height==0||width>MAX_SIDE||height>MAX_SIDE||hot_x>=width||hot_y>=height
|| ![scale_x,scale_y].iter().all(|v|v.is_finite()&&*v>0.&&*v<=16.) {return Err(())}
if png.len()<33||png.len()>MAX_PNG||!png.starts_with(b"\x89PNG\r\n\x1a\n")||&png[12..16]!=b"IHDR"{return Err(())}
let pw=u32::from_be_bytes(png[16..20].try_into().unwrap());let ph=u32::from_be_bytes(png[20..24].try_into().unwrap());
if pw==0||ph==0||pw>MAX_SIDE||ph>MAX_SIDE{return Err(())}
Ok(Some(Shape{width,height,hot_x,hot_y,scale_x,scale_y,png:png.to_vec()}))
}
#[derive(Default)] struct Latest {last:Option<Arc<Shape>>,pending:Option<Arc<Shape>>,count:u64}
#[derive(Clone,Default)] pub struct State(Arc<Mutex<Latest>>);
impl State {
pub fn receive(&self,data:&[u8]) {
let Ok(Some(shape))=parse(data) else{return};let mut state=self.0.lock().unwrap();
if state.last.as_deref()==Some(&shape){return}
state.count+=1;
if state.count<=3 || state.count%100==0 {log::info!("Viewer remote cursor: count={} size={}x{} png_bytes={}",state.count,shape.width,shape.height,shape.png.len());}
let shape=Arc::new(shape);state.last=Some(shape.clone());state.pending=Some(shape);
}
pub fn take(&self)->Option<Arc<Shape>>{self.0.lock().unwrap().pending.take()}
}
#[cfg(feature="viewer-sdl")]
mod display {
use super::*;
use sdl2::{mouse::{Cursor,SystemCursor},surface::Surface,pixels::PixelFormatEnum};
struct Image {shape:Arc<Shape>,width:u32,height:u32,rgba:Vec<u8>}
fn decode(shape:Arc<Shape>)->Result<Image,()> {
let mut decoder=png::Decoder::new_with_limits(std::io::Cursor::new(&shape.png),png::Limits{bytes:4*MAX_PNG});
decoder.set_ignore_text_chunk(true);decoder.set_ignore_iccp_chunk(true);
decoder.set_transformations(png::Transformations::EXPAND|png::Transformations::STRIP_16);
let mut reader=decoder.read_info().map_err(|_|())?;
let size=reader.output_buffer_size().filter(|v|*v<=MAX_SIDE as usize*MAX_SIDE as usize*4).ok_or(())?;
let mut data=vec![0;size];let info=reader.next_frame(&mut data).map_err(|_|())?;
if info.width==0||info.height==0||info.width>MAX_SIDE||info.height>MAX_SIDE{return Err(())}
data.truncate(info.buffer_size());let mut rgba=Vec::with_capacity(info.width as usize*info.height as usize*4);
match info.color_type {
png::ColorType::Rgba=>rgba=data,
png::ColorType::Rgb=>for p in data.chunks_exact(3){rgba.extend_from_slice(&[p[0],p[1],p[2],255]);},
png::ColorType::Grayscale=>for p in data {rgba.extend_from_slice(&[p,p,p,255]);},
png::ColorType::GrayscaleAlpha=>for p in data.chunks_exact(2){rgba.extend_from_slice(&[p[0],p[0],p[0],p[1]]);},
_=>return Err(()),
}
if rgba.len()!=info.width as usize*info.height as usize*4{return Err(())}
Ok(Image{shape,width:info.width,height:info.height,rgba})
}
fn geometry(s:&Shape)->(u32,u32,i32,i32) {
// Cursor width/hotspot are the host's cursor units. Video coordinate
// scales belong to pointer position mapping, not the local OS cursor.
// Keep the cursor readable when a large remote desktop is fitted down.
let w=s.width.clamp(1,256);let h=s.height.clamp(1,256);
let x=(s.hot_x as f64*w as f64/s.width as f64).round().clamp(0.,(w-1) as f64) as i32;
let y=(s.hot_y as f64*h as f64/s.height as f64).round().clamp(0.,(h-1) as f64) as i32;
(w,h,x,y)
}
pub struct Display {arrow:Option<Cursor>,remote:Option<Cursor>,image:Option<Image>,geometry:Option<(u32,u32,i32,i32)>,active:bool,applied:u64}
impl Display {
pub fn new()->Self {Self{arrow:Cursor::from_system(SystemCursor::Arrow).ok(),remote:None,image:None,geometry:None,active:false,applied:0}}
pub fn reset(&mut self){if let Some(cursor)=&self.arrow{cursor.set();}self.active=false;}
pub fn update(&mut self,shape:Option<Arc<Shape>>,active:bool){
if let Some(shape)=shape {
self.reset();self.remote=None;self.geometry=None;
self.image=if shape.png.is_empty(){None}else{match decode(shape){Ok(image)=>Some(image),Err(())=>{log::warn!("Viewer remote cursor PNG rejected");None}}};
}
if let Some(image)=self.image.as_mut(){
let size=geometry(&image.shape);
if self.geometry!=Some(size) {
let result=(||->Result<Cursor,String>{
let mut src=Surface::from_data(&mut image.rgba,image.width,image.height,image.width*4,PixelFormatEnum::RGBA32)?;
src.set_blend_mode(sdl2::render::BlendMode::None)?;
let mut target=Surface::new(size.0,size.1,PixelFormatEnum::RGBA32)?;
src.blit_scaled(None,&mut target,None)?;
Cursor::from_surface(&target,size.2,size.3)
})();
self.reset();self.remote=match result {Ok(cursor)=>{self.applied+=1;if self.applied<=3||self.applied%100==0{log::info!("Viewer cursor applied: count={} size={}x{}",self.applied,size.0,size.1);}Some(cursor)},Err(_)=>{log::warn!("Viewer remote cursor unavailable on this display");None}};self.geometry=Some(size);
}
}
let active=active&&self.remote.is_some();
if active!=self.active {
if active {self.remote.as_ref().unwrap().set();self.active=true;}else{self.reset();}
}
}
}
impl Drop for Display {fn drop(&mut self){self.reset();}}
#[cfg(test)] mod tests {
use super::*;
#[test] fn png_pixels_and_retina_hotspot_use_stable_cursor_units(){
let mut png=Vec::new();{
let mut encoder=png::Encoder::new(&mut png,4,4);encoder.set_color(png::ColorType::Rgba);encoder.set_depth(png::BitDepth::Eight);
encoder.write_header().unwrap().write_image_data(&[128;64]).unwrap();
}
let shape=Arc::new(Shape{width:2,height:2,hot_x:1,hot_y:1,scale_x:2.,scale_y:2.,png});
let image=decode(shape.clone()).unwrap();assert_eq!(image.rgba,vec![128;64]);
assert_eq!(geometry(&shape),(2,2,1,1));
let mut changed=(*shape).clone();changed.scale_x=0.25;changed.scale_y=0.25;assert_eq!(geometry(&changed),(2,2,1,1));
let mut bad=(*shape).clone();bad.png[40]^=255;assert!(decode(Arc::new(bad)).is_err());
}
}
}
#[cfg(feature="viewer-sdl")] pub use display::Display;
#[cfg(test)] mod tests {
use super::*;
fn packet(w:u64,hot:u64,scale:f64,png:&[u8])->Vec<u8>{
let mut shape=Vec::new();super::super::wire::int(3,w,&mut shape);super::super::wire::int(4,w,&mut shape);super::super::wire::int(1,hot,&mut shape);
super::super::wire::bytes(5,png,&mut shape);shape.push(7<<3|1);shape.extend_from_slice(&scale.to_le_bytes());
let mut change=Vec::new();super::super::wire::bytes(2,&shape,&mut change);super::super::wire::envelope(1,15,&change)
}
#[test] fn shape_bounds_and_latest_only_updates(){
let png=include_bytes!("../../tests/fixtures/clipboard-test.png");
let state=State::default();let valid=packet(16,2,1.,png);state.receive(&valid);state.receive(&valid);
assert_eq!(state.take().unwrap().width,16);assert!(state.take().is_none());
for bad in [packet(0,0,1.,png),packet(513,0,1.,png),packet(16,16,1.,png),packet(16,0,f64::NAN,png),packet(16,0,0.,png)] {assert!(parse(&bad).is_err());state.receive(&bad);assert!(state.take().is_none());}
state.receive(&packet(20,2,1.,png));state.receive(&packet(24,2,1.,png));assert_eq!(state.take().unwrap().width,24);
state.receive(&packet(0,0,1.,&[]));assert!(state.take().unwrap().png.is_empty());
assert!(parse(&vec![0;MAX_PNG+513]).is_err());
}
}
+3 -1
View File
@@ -67,7 +67,9 @@ pub fn load_font() -> Option<FontVec> {
let (path, index) = match std::env::var("UU_VIEWER_FONT") { let (path, index) = match std::env::var("UU_VIEWER_FONT") {
Ok(p) if !p.is_empty() => (p, 0), 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()?; // Request U+63A7 (控, from 控制中心) to prefer a CJK-capable font;
// the HUD uses a single font without per-glyph fallback.
let out = std::process::Command::new("fc-match").args(["-f", "%{file}\t%{index}", "sans-serif:lang=zh-cn:charset=63a7"]).output().ok()?;
let line = String::from_utf8(out.stdout).ok()?; let line = String::from_utf8(out.stdout).ok()?;
let (file, index) = line.split_once('\t').unwrap_or((line.as_str(), "0")); 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. // fontconfig puts the variable-font named instance in the upper 16 bits; the face is below.
+1
View File
@@ -25,6 +25,7 @@ pub mod native_gamepad;
pub mod native_rumble; pub mod native_rumble;
pub mod clipboard; pub mod clipboard;
pub mod cursor;
pub mod power; pub mod power;
pub mod secure_input; pub mod secure_input;
pub mod type_ipc; pub mod type_ipc;
+6 -4
View File
@@ -45,6 +45,7 @@ pub struct Peer {
clipboard:super::clipboard::Bridge, clipboard:super::clipboard::Bridge,
pub tools:super::tools::Inbox, pub tools:super::tools::Inbox,
pub rumble:super::native_rumble::Feedback, pub rumble:super::native_rumble::Feedback,
pub cursor:super::cursor::State,
pub pc:Arc<RTCPeerConnection>, pub pc:Arc<RTCPeerConnection>,
pub channels:Vec<Arc<RTCDataChannel>>, pub channels:Vec<Arc<RTCDataChannel>>,
pub observed:Arc<Observed>, pub observed:Arc<Observed>,
@@ -80,6 +81,7 @@ impl Peer {
let pc=Arc::new(api.new_peer_connection(config).await.map_err(|e|format!("Peer creation failed: {}",crate::auth::transport_error(&e)))?); let pc=Arc::new(api.new_peer_connection(config).await.map_err(|e|format!("Peer creation failed: {}",crate::auth::transport_error(&e)))?);
let tools:super::tools::Inbox=Arc::new(std::sync::Mutex::new(None)); let tools:super::tools::Inbox=Arc::new(std::sync::Mutex::new(None));
let rumble=super::native_rumble::Feedback::default(); let rumble=super::native_rumble::Feedback::default();
let cursor=super::cursor::State::default();
let inbox=tools.clone(); let inbox=tools.clone();
pc.on_peer_connection_state_change(Box::new(move |state|{ pc.on_peer_connection_state_change(Box::new(move |state|{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState; use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
@@ -205,11 +207,11 @@ impl Peer {
if [0,3,4].contains(&index){closed.lock().unwrap().take();} if [0,3,4].contains(&index){closed.lock().unwrap().take();}
})})); })}));
let state=observed.clone();let inbox=tools.clone();let clipboard_tx=clipboard.sender(); let state=observed.clone();let inbox=tools.clone();let clipboard_tx=clipboard.sender();
let feedback=rumble.clone(); let feedback=rumble.clone();let pointer=cursor.clone();
let control_for_echo=if index==0 {Arc::downgrade(&channel)} else {std::sync::Weak::new()}; let control_for_echo=if index==0 {Arc::downgrade(&channel)} else {std::sync::Weak::new()};
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();let feedback=feedback.clone();Box::pin(async move { channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();let feedback=feedback.clone();let pointer=pointer.clone();Box::pin(async move {
if index==0 { if index==0 {
feedback.receive(&message.data); feedback.receive(&message.data);pointer.receive(&message.data);
let (codecs,chroma)=wire::media_control(&message.data); let (codecs,chroma)=wire::media_control(&message.data);
if let Some(codecs)=codecs {state.encoder_codecs.store(codecs,Ordering::Release);} if let Some(codecs)=codecs {state.encoder_codecs.store(codecs,Ordering::Release);}
if let Some(chroma)=chroma { if let Some(chroma)=chroma {
@@ -257,7 +259,7 @@ impl Peer {
Ok::<_,String>((channels,tools,clipboard)) Ok::<_,String>((channels,tools,clipboard))
}.await; }.await;
match result { match result {
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,rumble,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}), Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,rumble,cursor,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
Err(e)=>{let _=pc.close().await;Err(e)}, Err(e)=>{let _=pc.close().await;Err(e)},
} }
} }
+96 -3
View File
@@ -1,7 +1,7 @@
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session}; use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect}; use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
#[derive(Debug)] enum Command { Files, Type } #[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, pub struct Window {cursor:super::cursor::Display,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 } pub last_frame:Option<Frame>, chrome:Chrome }
/// In-window chrome state (src/viewer/hud.rs): menu, network panel, loading screen. /// In-window chrome state (src/viewer/hud.rs): menu, network panel, loading screen.
@@ -32,10 +32,18 @@ impl Window {
title:crate::tr!("正在连接 {name}","Connecting to {name}"),stage:crate::i18n::s("正在连接远端设备…","Contacting the remote device…").into(),labels:Default::default(),menu_cache:None}; 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 events=sdl.event_pump()?;let clipboard=video.clipboard();
let(clipboard_tx,clipboard_requests)=tokio::sync::mpsc::channel(16); 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,last_frame:None,chrome}) Ok(Self{cursor:super::cursor::Display::new(),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 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;} pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
fn sync_cursor(&mut self,state:&super::cursor::State){
let mouse=self.events.mouse_state();let(x,y)=(mouse.x() as f64,mouse.y() as f64);let v=self.viewport();
let tab=hud::tab_rect(self.chrome.font.as_ref(),self.canvas.window().size(),self.chrome.scale);
let active=self.focused&&self.canvas.window().has_mouse_focus()&&!self.chrome.menu.open
&&x>=v.x&&y>=v.y&&x<v.x+v.width&&y<v.y+v.height
&&!(self.tab_visible()&&tab.contains(x as f32,y as f32));
self.cursor.update(state.take(),active);
}
fn viewport(&self)->Viewport { fn viewport(&self)->Viewport {
let window=self.canvas.window().size(); let window=self.canvas.window().size();
if !self.chrome.state.one_to_one {return Viewport::fit(window,self.frame)} if !self.chrome.state.one_to_one {return Viewport::fit(window,self.frame)}
@@ -345,7 +353,13 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
if !repeat{*files=true;messages.extend(input.release_all());}None if !repeat{*files=true;messages.extend(input.release_all());}None
}, },
_ if !*focused || !input.enabled()=>None, _ if !*focused || !input.enabled()=>None,
Event::KeyDown{scancode:Some(s),repeat:false,..}=>input.key(s as i32,true), Event::KeyDown{scancode:Some(s),keymod,repeat:false,..}=>{
// FocusLost releases remote keys, while a modifier may remain physically held.
// SDL_Keysym.mod is the event-time snapshot: restore it before the next key,
// without querying the final state of a whole polled batch or typing text.
if !(224..=231).contains(&(s as i32)){messages.extend(sync_modifiers(input,keymod));}
input.key(s as i32,true)
},
Event::KeyUp{scancode:Some(s),..}=>input.key(s as i32,false), Event::KeyUp{scancode:Some(s),..}=>input.key(s as i32,false),
Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64), 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::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)),
@@ -366,6 +380,18 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
} (quit,messages) } (quit,messages)
} }
fn sync_modifiers(input:&mut Input,keymod:sdl2::keyboard::Mod)->Vec<serde_json::Value>{
use sdl2::keyboard::Mod as M;
let modifiers=[(224,M::LCTRLMOD),(225,M::LSHIFTMOD),(226,M::LALTMOD),(227,M::LGUIMOD),
(228,M::RCTRLMOD),(229,M::RSHIFTMOD),(230,M::RALTMOD),(231,M::RGUIMOD)];
let mut out=Vec::new();
// Release stale modifiers before pressing new ones. Input deduplicates transitions.
// Caps/Num/Scroll Lock and MODE are not physical held modifiers.
for down in [false,true]{for (scan,flag) in modifiers{
if keymod.contains(flag)==down{out.extend(input.key(scan,down));}
}}out
}
fn needs_redraw(event:&Event)->bool{ fn needs_redraw(event:&Event)->bool{
matches!(event,Event::Window{win_event:WindowEvent::SizeChanged(..)|WindowEvent::Resized(..)|WindowEvent::Exposed|WindowEvent::Maximized|WindowEvent::Restored,..}) matches!(event,Event::Window{win_event:WindowEvent::SizeChanged(..)|WindowEvent::Resized(..)|WindowEvent::Exposed|WindowEvent::Maximized|WindowEvent::Restored,..})
} }
@@ -478,6 +504,7 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
_=tick.tick()=>{ _=tick.tick()=>{
if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}} if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}}
let (quit,mut messages)=window.poll(&mut input); let (quit,mut messages)=window.poll(&mut input);
window.sync_cursor(&session.peer.cursor);
if !window.has_picture() {window.loading_frame(false);} if !window.has_picture() {window.loading_frame(false);}
if !restored && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false) {restored=true;window.restore_remote_settings();} if !restored && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false) {restored=true;window.restore_remote_settings();}
for command in window.take_commands() { for command in window.take_commands() {
@@ -709,6 +736,72 @@ async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Wi
} }
} }
#[cfg(test)] mod modifier_tests {
use super::*;
use sdl2::keyboard::{Scancode as S,Mod as M};
fn key(scan:S,down:bool,mods:M)->Event{
if down{Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(scan),keymod:mods,repeat:false}}
else{Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(scan),keymod:mods,repeat:false}}
}
fn focus(event:WindowEvent)->Event{Event::Window{timestamp:0,window_id:1,win_event:event}}
fn send(input:&mut Input,focused:&mut bool,events:impl IntoIterator<Item=Event>)->Vec<serde_json::Value>{
translate(events,input,Viewport::fit((800,600),(1920,1080)),focused).1
}
fn codes(messages:&[serde_json::Value])->Vec<(&str,i64)>{
messages.iter().map(|m|(m["action"].as_str().unwrap(),m["key"].as_i64().unwrap())).collect()
}
#[test] fn held_left_and_right_modifiers_recover_after_focus_return(){
for mac in [false,true]{for (scan,flag) in [(S::LCtrl,M::LCTRLMOD),(S::LShift,M::LSHIFTMOD),
(S::LAlt,M::LALTMOD),(S::LGui,M::LGUIMOD),(S::RCtrl,M::RCTRLMOD),(S::RShift,M::RSHIFTMOD),
(S::RAlt,M::RALTMOD),(S::RGui,M::RGUIMOD)]{
let code=|scan:S|i64::from(if mac{super::super::input::mac_keycode(scan as i32)}else{super::super::input::windows_vk(scan as i32)}.unwrap());
let mut input=Input::default();input.set_mac(mac);let mut focused=true;
let out=send(&mut input,&mut focused,[key(scan,true,flag),focus(WindowEvent::FocusLost)]);
assert_eq!(codes(&out),vec![("kbd_press",code(scan)),("kbd_release",code(scan))]);
assert!(!focused);
let out=send(&mut input,&mut focused,[focus(WindowEvent::FocusGained),key(S::Num2,true,flag),
key(S::Num2,false,flag),key(scan,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_press",code(scan)),("kbd_press",code(S::Num2)),
("kbd_release",code(S::Num2)),("kbd_release",code(scan))]);
assert!(input.release_all().is_empty());
}}
}
#[test] fn combined_snapshot_releases_stale_modifiers_before_new_chord(){
let mut input=Input::default();input.set_mac(true);let mut focused=true;
send(&mut input,&mut focused,[key(S::LShift,true,M::LSHIFTMOD),key(S::RGui,true,M::LSHIFTMOD|M::RGUIMOD)]);
let mods=M::RSHIFTMOD|M::LCTRLMOD|M::LALTMOD;
let out=send(&mut input,&mut focused,[key(S::A,true,mods),key(S::A,false,mods),
key(S::B,true,M::NOMOD),key(S::B,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_release",56),("kbd_release",54),
("kbd_press",59),("kbd_press",58),("kbd_press",60),("kbd_press",0),("kbd_release",0),
("kbd_release",59),("kbd_release",58),("kbd_release",60),("kbd_press",11),("kbd_release",11)]);
assert!(input.release_all().is_empty());
}
#[test] fn complete_chords_and_overlapping_letters_are_not_duplicated(){
let mut input=Input::default();input.set_mac(true);let mut focused=true;
let mods=M::LSHIFTMOD|M::RSHIFTMOD;
let out=send(&mut input,&mut focused,[key(S::LShift,true,M::LSHIFTMOD),key(S::RShift,true,mods),
key(S::A,true,mods),key(S::B,true,mods),key(S::A,false,mods),key(S::LShift,false,M::RSHIFTMOD),
key(S::B,false,M::RSHIFTMOD),key(S::RShift,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_press",56),("kbd_press",60),("kbd_press",0),("kbd_press",11),
("kbd_release",0),("kbd_release",56),("kbd_release",11),("kbd_release",60)]);
assert!(input.release_all().is_empty());
}
#[test] fn snapshot_is_event_time_and_does_not_create_lock_or_view_only_keys(){
let mut input=Input::default();let mut focused=true;
let out=send(&mut input,&mut focused,[key(S::Num2,true,M::LSHIFTMOD|M::CAPSMOD|M::NUMMOD|M::MODEMOD),
key(S::Num2,false,M::LSHIFTMOD),key(S::A,true,M::NOMOD),key(S::A,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_press",0xa0),("kbd_press",0x32),("kbd_release",0x32),
("kbd_release",0xa0),("kbd_press",0x41),("kbd_release",0x41)]);
for watch in [false,true]{
let mut input=Input::new(watch);let mut focused=false;
assert!(send(&mut input,&mut focused,[key(S::A,true,M::LSHIFTMOD)]).is_empty());
if watch{assert!(send(&mut input,&mut focused,[focus(WindowEvent::FocusGained),key(S::A,true,M::LSHIFTMOD)]).is_empty());}
assert!(input.release_all().is_empty());
}
}
}
#[cfg(test)] mod tests { #[cfg(test)] mod tests {
use super::*; use super::*;
#[cfg_attr(target_os="macos",ignore)] #[cfg_attr(target_os="macos",ignore)]
+473
View File
@@ -0,0 +1,473 @@
//! Official device-card background reporting. Protocol evidence: docs/wallpaper-protocol.md.
use std::{path::PathBuf, sync::Arc, time::Duration};
use sha2::{Digest, Sha256};
use tokio::io::AsyncReadExt;
use crate::auth::UUAuthClient;
const LIMIT: usize = 10 * 1024 * 1024;
const TIMEOUT: Duration = Duration::from_secs(20);
pub fn start(auth: Arc<UUAuthClient>) -> tokio::task::AbortHandle {
tokio::spawn(async move {
if auth.creds.user_id.is_empty() || crate::desktop_backend::headless()
|| std::env::var("UU_WALLPAPER_UPLOAD").as_deref() == Ok("0") { return; }
let mut previous = None;
loop {
if let Some(path) = source().await {
match read_image(&path).await {
Ok(image) => {
let hash = Sha256::digest(&image).to_vec();
if previous.as_ref() != Some(&hash) {
match publish(&auth, image).await {
Ok(()) => { previous = Some(hash); log::info!("Device wallpaper synchronized"); }
Err(stage) => log::warn!("Device wallpaper synchronization failed: stage={stage}; will retry"),
}
}
}
Err(()) => log::debug!("Device wallpaper unavailable or unsupported"),
}
}
tokio::time::sleep(Duration::from_secs(60)).await;
}
}).abort_handle()
}
async fn command(program: &str, args: &[&str]) -> Option<String> {
let output = tokio::time::timeout(Duration::from_secs(3), tokio::process::Command::new(program)
.args(args).kill_on_drop(true).output()).await.ok()?.ok()?;
output.status.success().then(|| String::from_utf8(output.stdout).ok()).flatten()
}
async fn kde_config(programs: &[&str], args: &[&str]) -> Option<String> {
for program in programs {
if let Some(value) = command(program, args).await { return Some(value); }
}
None
}
async fn source() -> Option<PathBuf> {
if let Some(path) = std::env::var_os("UU_WALLPAPER") {
let path = PathBuf::from(path); return path.is_absolute().then_some(path);
}
let desktop = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().to_lowercase();
if desktop.split(':').any(|name| name == "hyprland") {
let home = std::env::var_os("HOME").map(PathBuf::from);
let xdg = |name, fallback| std::env::var_os(name).map(PathBuf::from)
.filter(|p| p.is_absolute()).or_else(|| home.as_ref().map(|p| p.join(fallback)));
return omarchy_background(xdg("XDG_STATE_HOME", ".local/state").as_deref(),
xdg("XDG_CONFIG_HOME", ".config").as_deref()).await;
}
if desktop.contains("gnome") || desktop.contains("unity") || desktop.contains("cinnamon") {
let schema = if desktop.contains("cinnamon") { "org.cinnamon.desktop.background" } else { "org.gnome.desktop.background" };
if schema == "org.gnome.desktop.background" && command("gsettings", &["get", "org.gnome.desktop.interface", "color-scheme"])
.await.is_some_and(|v| v.contains("prefer-dark")) {
if let Some(path) = command("gsettings", &["get", schema, "picture-uri-dark"]).await.and_then(|v| gsettings_path(&v)) { return Some(path); }
}
return command("gsettings", &["get", schema, "picture-uri"]).await.and_then(|v| gsettings_path(&v));
}
if desktop.contains("kde") {
let config = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from)
.filter(|p| p.is_absolute()).or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))?;
let text = tokio::fs::read_to_string(config.join("plasma-org.kde.plasma.desktop-appletsrc")).await.unwrap_or_default();
if let Some(path) = kde_image(&text) { return package_image(path).await; }
// Plasma omits Image for the look-and-feel's default wallpaper.
if !kde_default_allowed(&text) { return None; }
let readers = ["kreadconfig6", "kreadconfig5"];
let theme = kde_config(&readers, &["--file", "kdeglobals", "--group", "KDE", "--key", "LookAndFeelPackage"])
.await.unwrap_or_default();
let theme = if theme.trim().is_empty() { "org.kde.breeze.desktop" } else { theme.trim() };
if theme.contains('/') || theme.contains("..") { return None; }
let defaults = format!("/usr/share/plasma/look-and-feel/{theme}/contents/defaults");
let image = kde_config(&readers, &["--file", &defaults, "--group", "Wallpaper", "--key", "Image"]).await?;
let image = image.trim();
if image.is_empty() || image.contains('/') || image.contains("..") { return None; }
return package_image(PathBuf::from("/usr/share/wallpapers").join(image)).await;
}
if desktop.contains("xfce") {
let text = command("xfconf-query", &["-c", "xfce4-desktop", "-lv"]).await?;
for line in text.lines() {
if let Some((key, value)) = line.trim().split_once(char::is_whitespace) {
if key.ends_with("/last-image") { if let Some(path) = local_path(value) { return Some(path); } }
}
}
}
None
}
// Omarchy maintains this link when changing wallpaper/theme. Prefer its current
// XDG state location, while supporting older installations using XDG config.
async fn omarchy_background(state: Option<&std::path::Path>, config: Option<&std::path::Path>) -> Option<PathBuf> {
for root in [state, config].into_iter().flatten() {
let path = root.join("omarchy/current/background");
if tokio::fs::metadata(&path).await.is_ok_and(|meta| meta.is_file()) { return Some(path); }
}
None
}
async fn package_image(path: PathBuf) -> Option<PathBuf> {
if tokio::fs::metadata(&path).await.ok()?.is_file() { return Some(path); }
let mut entries = tokio::fs::read_dir(path.join("contents/images")).await.ok()?;
let mut candidates = Vec::new();
while let Some(entry) = entries.next_entry().await.ok()? {
if !tokio::fs::metadata(entry.path()).await.is_ok_and(|meta| meta.is_file()) { continue; }
let path = entry.path();
let Some((w,h)) = path.file_stem().and_then(|s| s.to_str()).and_then(|s| s.split_once('x'))
.and_then(|(w,h)| Some((w.parse::<u32>().ok()?,h.parse::<u32>().ok()?))) else { continue; };
candidates.push(((w < h, u64::from(w) * u64::from(h)), path));
}
candidates.sort_by_key(|(score, _)| *score);
candidates.into_iter().next().map(|(_, path)| path)
}
fn kde_image(text: &str) -> Option<PathBuf> {
let plugins = kde_plugins(text);
let mut image_section = false;
for line in text.lines().map(str::trim) {
if line.starts_with('[') {
image_section = line.strip_prefix("[Containments][").and_then(|s| s.split_once(']'))
.is_some_and(|(id, section)| section == "[Wallpaper][org.kde.image][General]"
&& plugins.get(id).map_or(true, |plugin| *plugin == KdeWallpaper::Image));
}
if image_section { if let Some(value) = line.strip_prefix("Image=") { if let Some(path) = local_path(value) { return Some(path); } } }
}
None
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum KdeWallpaper { Image, Unsupported }
fn kde_plugins(text: &str) -> std::collections::HashMap<&str, KdeWallpaper> {
let mut containment = None;
let mut plugins = std::collections::HashMap::new();
let mut panels = Vec::new();
for line in text.lines().map(str::trim) {
if line.starts_with('[') {
containment = line.strip_prefix("[Containments][").and_then(|s| s.split_once(']'))
.filter(|(_, section)| section.is_empty()).map(|(id, _)| id);
}
if let Some(id) = containment {
plugins.entry(id).or_insert(KdeWallpaper::Image);
if line.strip_prefix("plugin=").is_some_and(|plugin| plugin.trim() == "org.kde.panel") { panels.push(id); }
if let Some(plugin) = line.strip_prefix("wallpaperplugin=") {
plugins.insert(id, if plugin.trim() == "org.kde.image" { KdeWallpaper::Image } else { KdeWallpaper::Unsupported });
}
}
}
// Panels can keep an image wallpaper setting, but do not supply a desktop background.
for id in panels { plugins.insert(id, KdeWallpaper::Unsupported); }
plugins
}
fn kde_default_allowed(text: &str) -> bool {
let plugins = kde_plugins(text);
if !plugins.is_empty() { return plugins.values().any(|plugin| *plugin == KdeWallpaper::Image); }
!text.contains("[Wallpaper][") || text.contains("[Wallpaper][org.kde.image]")
}
fn gsettings_path(value: &str) -> Option<PathBuf> {
// gsettings prints a GVariant string, with either quote style and C/Unicode escapes.
// https://docs.gtk.org/glib/gvariant-text-format.html#strings
let mut chars = value.trim().chars();
let quote = chars.next()?;
if quote != '\'' && quote != '"' { return None; }
let mut decoded = String::new();
while let Some(ch) = chars.next() {
if ch == quote { return chars.as_str().is_empty().then(|| local_path(&decoded)).flatten(); }
if ch != '\\' { decoded.push(ch); continue; }
let escaped = chars.next()?;
decoded.push(match escaped {
'a' => '\x07', 'b' => '\x08', 'f' => '\x0c', 'n' => '\n',
'r' => '\r', 't' => '\t', 'v' => '\x0b', '\\' => '\\', '\'' => '\'', '"' => '"',
'u' | 'U' => {
let mut code = 0u32;
for _ in 0..if escaped == 'u' { 4 } else { 8 } { code = u32::checked_add(code.checked_mul(16)?, chars.next()?.to_digit(16)?)?; }
char::from_u32(code).filter(|c| *c != '\0')?
}
'\n' => continue,
_ => escaped,
});
}
None
}
fn local_path(value: &str) -> Option<PathBuf> {
let value = value.trim();
let path = if value.starts_with("file:") {
let url = reqwest::Url::parse(value).ok()?;
if url.query().is_some() || url.fragment().is_some() { return None; }
url.to_file_path().ok()?
} else { PathBuf::from(value) };
path.is_absolute().then_some(path)
}
async fn read_image(path: &std::path::Path) -> Result<Vec<u8>, ()> {
if !tokio::fs::metadata(path).await.map_err(|_| ())?.is_file() { return Err(()); }
let file = tokio::fs::File::open(path).await.map_err(|_| ())?;
if !file.metadata().await.map_err(|_| ())?.is_file() { return Err(()); }
let mut image = Vec::new();
file.take((LIMIT + 1) as u64).read_to_end(&mut image).await.map_err(|_| ())?;
if image.len() > LIMIT || image_type(&image).is_none() { return Err(()); }
Ok(image)
}
fn image_type(image: &[u8]) -> Option<&'static str> {
if image.starts_with(b"\x89PNG\r\n\x1a\n") { Some("image/png") }
else if image.starts_with(b"\xff\xd8\xff") { Some("image/jpeg") }
else if image.starts_with(b"RIFF") && image.get(8..12) == Some(b"WEBP") { Some("image/webp") }
else { None }
}
fn api_data(status: u16, body: &serde_json::Value) -> Result<&serde_json::Value, ()> {
if status != 200 || body.get("code").and_then(|v| v.as_i64()) != Some(0) { return Err(()); }
body.get("data").ok_or(())
}
async fn publish(auth: &UUAuthClient, image: Vec<u8>) -> Result<(), &'static str> {
let http = crate::auth::http_client_builder().redirect(reqwest::redirect::Policy::none()).build().map_err(|_| "http-client")?;
publish_to(auth, image, crate::auth::BASE_URL, &http).await
}
async fn json(request: reqwest::RequestBuilder) -> Result<(u16, serde_json::Value), ()> {
let mut response = request.timeout(TIMEOUT).send().await.map_err(|_| ())?;
let status = response.status().as_u16();
let mut bytes = Vec::new();
while let Some(chunk) = response.chunk().await.map_err(|_| ())? {
if bytes.len() + chunk.len() > 65536 { return Err(()); }
bytes.extend_from_slice(&chunk);
}
Ok((status, serde_json::from_slice(&bytes).map_err(|_| ())?))
}
async fn publish_to(auth: &UUAuthClient, image: Vec<u8>, base: &str, http: &reqwest::Client) -> Result<(), &'static str> {
let path = "/api/v1/tool/fp/token?filetype=1";
let result = json(http.get(format!("{base}{path}")).headers(auth.build_headers("GET", path, ""))).await.map_err(|_| "token-request")?;
let data = api_data(result.0, &result.1).map_err(|_| "token-response")?;
let token = data.get("token").and_then(|v| v.as_str()).filter(|v| !v.is_empty()).ok_or("file-token")?;
let url = data.get("req_url").and_then(|v| v.as_str()).ok_or("upload-url")?;
let url = https_url(url).map_err(|_| "upload-url")?;
let max = data.get("max_size").and_then(|v| v.as_u64()).filter(|n| *n > 0).unwrap_or(LIMIT as u64);
if image.len() as u64 > max { return Err("file-size"); }
// Filepicker takes raw bytes and its own Authorization value, never account headers.
let response = json(http.post(url).header("Authorization", token)
.header("Content-Type", image_type(&image).ok_or("file-type")?).body(image)
).await.map_err(|_| "file-upload")?;
if response.0 != 200 { return Err("file-upload-status"); }
let url = response.1.get("url").and_then(|v| v.as_str()).ok_or("file-response")?;
https_url(url).map_err(|_| "file-response-url")?;
let path = "/api/v1/device/wallpaper";
let body = serde_json::json!({"wallpaper_url": url}).to_string();
let result = json(http.post(format!("{base}{path}")).headers(auth.build_headers("POST", path, &body)).body(body)).await.map_err(|_| "report-request")?;
if result.0 != 200 || result.1.get("code").and_then(|v| v.as_i64()) != Some(0) { return Err("report-response"); }
Ok(())
}
fn https_url(value: &str) -> Result<reqwest::Url, ()> {
let url = reqwest::Url::parse(value).map_err(|_| ())?;
if url.scheme() != "https" || url.host_str().is_none() || !url.username().is_empty() || url.password().is_some() { return Err(()); }
Ok(url)
}
#[cfg(test)]
mod tests {
use super::*;
use tokio::io::AsyncWriteExt;
#[tokio::test]
async fn kde_config_uses_plasma5_when_plasma6_reader_is_unavailable() {
use std::os::unix::fs::PermissionsExt;
let root = std::env::temp_dir().join(format!("uu-kreadconfig-test-{}-{}", std::process::id(), rand::random::<u64>()));
std::fs::create_dir(&root).unwrap();
let five = root.join("kreadconfig5"); let six = root.join("kreadconfig6");
std::fs::write(&five, "#!/bin/sh\ncase \"$*\" in *LookAndFeelPackage*) echo org.kde.breeze.desktop;; *Image*) echo Next;; esac\n").unwrap();
std::fs::set_permissions(&five, std::fs::Permissions::from_mode(0o700)).unwrap();
let readers = [six.to_str().unwrap(), five.to_str().unwrap()];
assert_eq!(kde_config(&readers, &["--key", "LookAndFeelPackage"]).await.as_deref(), Some("org.kde.breeze.desktop\n"));
assert_eq!(kde_config(&readers, &["--key", "Image"]).await.as_deref(), Some("Next\n"));
std::fs::write(&six, "#!/bin/sh\necho Plasma6\n").unwrap();
std::fs::set_permissions(&six, std::fs::Permissions::from_mode(0o700)).unwrap();
assert_eq!(kde_config(&readers, &["--key", "Image"]).await.as_deref(), Some("Plasma6\n"));
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn omarchy_follows_current_wallpaper_links_and_supports_legacy_location() {
use std::os::unix::fs::symlink;
let root = std::env::temp_dir().join(format!("uu-omarchy-{}-{}", std::process::id(), rand::random::<u64>()));
let state = root.join("custom-state");
let config = root.join("custom-config");
for dir in [&state, &config] { std::fs::create_dir_all(dir.join("omarchy/current")).unwrap(); }
let current = state.join("omarchy/current/background");
let legacy = config.join("omarchy/current/background");
let first = root.join("first.png");
let second = root.join("second.jpg");
std::fs::write(&first, b"\x89PNG\r\n\x1a\n").unwrap();
std::fs::write(&second, b"\xff\xd8\xff").unwrap();
symlink(&second, &legacy).unwrap();
let detect = || omarchy_background(Some(&state), Some(&config));
assert_eq!(detect().await, Some(legacy.clone()));
symlink(&first, &current).unwrap();
assert_eq!(detect().await, Some(current.clone()));
assert_eq!(read_image(&detect().await.unwrap()).await.unwrap(), std::fs::read(&first).unwrap());
std::fs::remove_file(&current).unwrap(); symlink(&second, &current).unwrap();
assert_eq!(read_image(&detect().await.unwrap()).await.unwrap(), std::fs::read(&second).unwrap());
std::fs::remove_file(&current).unwrap(); symlink(root.join("missing"), &current).unwrap();
assert_eq!(detect().await, Some(legacy.clone()));
std::fs::remove_file(&current).unwrap(); symlink(&root, &current).unwrap();
assert_eq!(detect().await, Some(legacy.clone()));
std::fs::remove_file(&legacy).unwrap();
assert_eq!(detect().await, None);
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn kde_packages_select_landscape_and_image_reads_are_bounded() {
let root = std::env::temp_dir().join(format!("uu-wallpaper-test-{}-{}", std::process::id(), rand::random::<u64>()));
let images = root.join("contents/images");
std::fs::create_dir_all(&images).unwrap();
for name in ["1440x2960.png", "5120x2880.png", "7680x2160.png"] {
std::fs::write(images.join(name), b"\x89PNG\r\n\x1a\n").unwrap();
}
let image = package_image(root.clone()).await.unwrap();
assert_eq!(image.file_name().unwrap(), "5120x2880.png");
assert_eq!(package_image(image.clone()).await, Some(image.clone()));
assert!(read_image(&image).await.is_ok());
std::fs::write(&image, b"private text is not an image").unwrap();
assert!(read_image(&image).await.is_err());
std::fs::OpenOptions::new().write(true).open(&image).unwrap().set_len((LIMIT + 1) as u64).unwrap();
assert!(read_image(&image).await.is_err());
assert!(read_image(&root).await.is_err());
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn kde_packages_follow_image_symlinks_and_skip_invalid_targets() {
use std::os::unix::fs::symlink;
let root = std::env::temp_dir().join(format!("uu-wallpaper-links-test-{}-{}", std::process::id(), rand::random::<u64>()));
let images = root.join("contents/images");
std::fs::create_dir_all(&images).unwrap();
let target = root.join("shared.png");
std::fs::write(&target, b"\x89PNG\r\n\x1a\n").unwrap();
let image = images.join("1920x1080.png");
symlink("../../shared.png", &image).unwrap();
symlink("../../missing.png", images.join("640x480.png")).unwrap();
symlink(&root, images.join("800x600.png")).unwrap();
assert_eq!(package_image(root.clone()).await, Some(image.clone()));
assert!(read_image(&image).await.is_ok());
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn reporting_protocol_keeps_file_token_separate_and_stops_on_failures() {
use tokio_rustls::{rustls, TlsAcceptor};
use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer};
let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
let der = cert.serialize_der().unwrap();
let http = reqwest::Client::builder().no_proxy().redirect(reqwest::redirect::Policy::none())
.add_root_certificate(reqwest::Certificate::from_der(&der).unwrap()).build().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(der)], PrivateKeyDer::Pkcs8(
PrivatePkcs8KeyDer::from(cert.serialize_private_key_der()))).unwrap();
let acceptor = TlsAcceptor::from(Arc::new(config));
let auth = UUAuthClient::new(crate::auth::Credentials {
token: "fixture-account-token".into(), csrf: "fixture-csrf".into(),
sign_key: "fixture-key".into(), ..Default::default()
});
for scenario in ["success", "token-failed", "too-large", "upload-failed", "report-failed"] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("https://localhost:{}", listener.local_addr().unwrap().port());
let server_base = base.clone(); let acceptor = acceptor.clone();
let steps = match scenario { "token-failed" | "too-large" => 1, "upload-failed" => 2, _ => 3 };
let server = tokio::spawn(async move {
for step in 0..steps {
let (socket, _) = listener.accept().await.unwrap();
let mut tls = acceptor.accept(socket).await.unwrap();
let mut bytes = Vec::new(); let mut byte = [0u8; 1];
while !bytes.ends_with(b"\r\n\r\n") {
tls.read_exact(&mut byte).await.unwrap(); bytes.push(byte[0]); assert!(bytes.len() < 16384);
}
let headers = String::from_utf8(bytes).unwrap().to_lowercase();
let length: usize = headers.lines().find_map(|l| l.strip_prefix("content-length:")
.and_then(|s| s.trim().parse().ok())).unwrap_or(0);
let mut body = vec![0; length]; tls.read_exact(&mut body).await.unwrap();
let (status, reply) = match step {
0 => {
assert!(headers.starts_with("get /api/v1/tool/fp/token?filetype=1 "));
assert!(headers.contains("authorization: bearer fixture-account-token\r\n"));
assert!(headers.contains("x-param-sign:")); assert!(body.is_empty());
(200, serde_json::json!({"code":if scenario=="token-failed" {1120}else{0},
"data":{"token":"fixture-file-token","req_url":format!("{server_base}/upload"),"ttl":60,
"max_size":if scenario=="too-large" {1}else{1024}}}))
}
1 => {
assert!(headers.starts_with("post /upload "));
assert!(headers.contains("authorization: fixture-file-token\r\n"));
for secret in ["fixture-account-token", "fixture-csrf", "cookie:", "x-param-"] { assert!(!headers.contains(secret)); }
assert_eq!(body, b"\x89PNG\r\n\x1a\n");
(if scenario=="upload-failed" {500}else{200}, serde_json::json!({"url":"https://example.invalid/wallpaper.png","fsize":8,"md5":"fixture","mime":"image/png"}))
}
_ => {
assert!(headers.starts_with("post /api/v1/device/wallpaper "));
assert!(headers.contains("authorization: bearer fixture-account-token\r\n"));
assert!(!headers.contains("fixture-file-token"));
assert_eq!(serde_json::from_slice::<serde_json::Value>(&body).unwrap(), serde_json::json!({"wallpaper_url":"https://example.invalid/wallpaper.png"}));
(200, serde_json::json!({"code":if scenario=="report-failed" {1120}else{0}}))
}
};
let reply = reply.to_string();
tls.write_all(format!("HTTP/1.1 {status} Fixture\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{reply}", reply.len()).as_bytes()).await.unwrap();
tls.shutdown().await.unwrap();
}
});
let result = tokio::time::timeout(Duration::from_secs(5), publish_to(&auth, b"\x89PNG\r\n\x1a\n".to_vec(), &base, &http)).await.unwrap();
assert_eq!(result.is_ok(), scenario == "success", "{scenario}");
tokio::time::timeout(Duration::from_secs(5), server).await.unwrap().unwrap();
}
}
#[test] fn wallpaper_sources_are_local_and_scoped() {
assert_eq!(gsettings_path("'file:///usr/share/a%20b.png'"), Some(PathBuf::from("/usr/share/a b.png")));
for value in ["", "relative.png", "https://example.com/a.png", "file://remote/a.png", "file:///tmp/a.png?token=secret"] { assert!(local_path(value).is_none()); }
assert_eq!(kde_image("[Other]\nImage=/wrong.png\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=file:///right.png"), Some(PathBuf::from("/right.png")));
}
#[test] fn gsettings_decodes_quotes_backslashes_and_unicode() {
assert_eq!(gsettings_path("\"file:///tmp/it's.png\""), Some(PathBuf::from("/tmp/it's.png")));
assert_eq!(gsettings_path(r#"'file:///tmp/it\'s.png'"#), Some(PathBuf::from("/tmp/it's.png")));
assert_eq!(gsettings_path(r#"'/tmp/a\\b\t\u00e9\U0001f600.png'"#), Some(PathBuf::from("/tmp/a\\b\té😀.png")));
for value in ["'unterminated", "'/tmp/a' trailing", r#"'/tmp/\uD800'"#, r#"'/tmp/\Uffffffff'"#] { assert!(gsettings_path(value).is_none()); }
assert_eq!(gsettings_path(r#"'/tmp/\x41'"#), Some(PathBuf::from("/tmp/x41")));
assert_eq!(local_path("/tmp/it's.png"), Some(PathBuf::from("/tmp/it's.png")));
}
#[test] fn kde_default_survives_saved_image_settings_but_not_other_plugins() {
let image = "[Containments][1]\nwallpaperplugin=org.kde.image\n[Containments][1][Wallpaper][org.kde.image][General]\nFillMode=1\n";
assert!(kde_image(image).is_none()); assert!(kde_default_allowed(image));
assert!(kde_default_allowed("[Containments][1][Wallpaper][org.kde.image][General]\nFillMode=1"));
assert!(kde_default_allowed(""));
assert!(!kde_default_allowed(&image.replace("wallpaperplugin=org.kde.image", "wallpaperplugin=org.kde.slideshow")));
assert!(!kde_default_allowed("[Containments][1][Wallpaper][org.kde.slideshow][General]\nSlidePaths=/tmp"));
}
#[test] fn kde_stored_images_belong_to_the_same_active_image_containment() {
let stale = "[Containments][1]\nwallpaperplugin=org.kde.slideshow\n[Containments][1][Wallpaper][org.kde.image][General]\nImage=/tmp/previous.png\n";
assert!(kde_image(stale).is_none());
assert!(!kde_default_allowed(stale));
let mixed = format!("{stale}[Containments][2]\nwallpaperplugin=org.kde.image\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=/tmp/current.png\n");
assert_eq!(kde_image(&mixed), Some(PathBuf::from("/tmp/current.png")));
assert_eq!(kde_image(&stale.replace("org.kde.slideshow", "org.kde.image")), Some(PathBuf::from("/tmp/previous.png")));
}
#[test] fn kde_panels_do_not_enable_default_wallpaper_or_supply_saved_images() {
let panel = "[Containments][2]\nwallpaperplugin=org.kde.image\nplugin=org.kde.panel\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=/tmp/panel.png\n";
let slideshow = "[Containments][1]\nplugin=org.kde.plasma.folder\nwallpaperplugin=org.kde.slideshow\n";
assert!(!kde_default_allowed(slideshow));
assert!(!kde_default_allowed(&format!("{slideshow}{panel}")));
assert!(kde_image(&format!("{slideshow}{panel}")).is_none());
assert!(!kde_default_allowed(panel));
let desktop = "[Containments][1]\nplugin=org.kde.plasma.folder\n";
assert!(kde_default_allowed(&format!("{desktop}{panel}")));
}
#[test] fn only_supported_image_files_are_uploaded() {
assert_eq!(image_type(b"\x89PNG\r\n\x1a\n"), Some("image/png"));
assert_eq!(image_type(b"\xff\xd8\xff"), Some("image/jpeg"));
assert_eq!(image_type(b"RIFF1234WEBP"), Some("image/webp"));
assert_eq!(image_type(b"<wallpaper>private text</wallpaper>"), None);
}
#[test] fn failed_api_responses_and_unsafe_upload_urls_are_rejected() {
assert!(api_data(200, &serde_json::json!({"code":0,"data":{}})).is_ok());
assert!(api_data(422, &serde_json::json!({"code":1120})).is_err());
assert!(api_data(200, &serde_json::json!({"data":{}})).is_err());
for url in ["http://example.com", "file:///tmp/a", "https://[email protected]"] { assert!(https_url(url).is_err()); }
}
}
+1 -1
View File
@@ -261,7 +261,7 @@ fn portal_outputs()->Vec<Output> {
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(); 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. // Screen 0 is the one opened first: the monitor whose consent is already saved, else the primary.
let dir=crate::portal::permissions_directory(); 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 granted=|name:&str|dir.as_deref().is_some_and(|d|crate::portal::permission_exists(d,&crate::portal::monitor_key(name)));
let primary=monitors.iter().find(|m|m.primary).map(|m|m.connector.clone()).unwrap_or_default(); 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.sort_by_key(|o|(!granted(&o.name),o.name!=primary,o.x,o.y));
outputs.truncate(16); outputs.truncate(16);
+172 -74
View File
@@ -140,6 +140,8 @@ fn track_session(end_pc: Arc<RTCPeerConnection>, actions: Arc<crate::system_acti
let closed = matches!(end_pc.connection_state(), State::Closed | State::Failed); let closed = matches!(end_pc.connection_state(), State::Closed | State::Failed);
let ending = actions.clone(); let ending = actions.clone();
let _ = tokio::task::spawn_blocking(move || ending.session_ended()).await; let _ = tokio::task::spawn_blocking(move || ending.session_ended()).await;
// Strokes belong to the viewer that drew them: never leave them on the host screen.
crate::annotation::reset(crate::annotation::owner(&actions));
if closed { return; } if closed { return; }
} }
}); });
@@ -272,6 +274,8 @@ impl WebRtcSession {
let role = Arc::new(DesktopRole::new(desktop)); let role = Arc::new(DesktopRole::new(desktop));
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); } if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); }
let microphone = crate::microphone::Session::new();
if crate::microphone::available() { microphone.attach(&pc, role.active.subscribe()); }
let context = Arc::new(Mutex::new(SessionContext::default())); let context = Arc::new(Mutex::new(SessionContext::default()));
crate::network_diagnostics::start(Arc::downgrade(&pc)); crate::network_diagnostics::start(Arc::downgrade(&pc));
@@ -528,6 +532,7 @@ impl WebRtcSession {
// Settings arrive on CONTROL or TEXT; serialize both queues for this peer. // Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
let settings_serial=Arc::new(Mutex::new(())); let settings_serial=Arc::new(Mutex::new(()));
let data_role = role.clone(); let data_role = role.clone();
let data_microphone = microphone.clone();
// 监听 DataChannel // 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| { pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string(); let label = d.label().to_string();
@@ -536,6 +541,7 @@ impl WebRtcSession {
let peer_settings_serial=settings_serial.clone(); let peer_settings_serial=settings_serial.clone();
let input_inst = input_clone.clone(); let input_inst = input_clone.clone();
let channel_role=data_role.clone(); let channel_role=data_role.clone();
let channel_microphone = data_microphone.clone();
let screen = control_capture.clone(); let screen = control_capture.clone();
let portal_desktop = portal_desktop.clone(); let portal_desktop = portal_desktop.clone();
let desktop_pc = desktop_pc.clone(); let desktop_pc = desktop_pc.clone();
@@ -602,14 +608,33 @@ impl WebRtcSession {
let out_channel = d.clone(); let out_channel = d.clone();
let out_label = label.clone(); let out_label = label.clone();
let outbound_rx = outbound_rx.clone(); let outbound_rx = outbound_rx.clone();
let change_sequence = out_sequence.clone();
let terminal_changes = crate::terminal::subscribe_changes();
let start_drain = move || { let start_drain = move || {
let out_channel = out_channel.clone(); let out_channel = out_channel.clone();
let out_label = out_label.clone(); let out_label = out_label.clone();
let outbound_rx = outbound_rx.clone(); let outbound_rx = outbound_rx.clone();
let change_sequence = change_sequence.clone();
let mut terminal_changes = terminal_changes.clone();
Box::pin(async move { Box::pin(async move {
let Some(mut outbound_rx) = take_outbound_once(&outbound_rx).await else { return; }; let Some(mut outbound_rx) = take_outbound_once(&outbound_rx).await else { return; };
tokio::spawn(async move { tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await { let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
loop {
let message = tokio::select! {
message = outbound_rx.recv() => match message { Some(message) => message, None => break },
changed = terminal_changes.changed(), if out_label == "BINARY_DATA_CHANNEL" => {
if changed.is_err() { break; }
if out_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { continue; }
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
crate::terminal::changed_message(change_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts)
},
_ = health.tick(), if out_label == "BINARY_DATA_CHANNEL" => {
use webrtc::data_channel::data_channel_state::RTCDataChannelState;
if matches!(out_channel.ready_state(), RTCDataChannelState::Closing | RTCDataChannelState::Closed) { break; }
continue;
},
};
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await { if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break; log::warn!("{} send failed: {}", out_label, e); break;
} }
@@ -794,6 +819,13 @@ impl WebRtcSession {
(Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))), (Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))),
_ => None, _ => None,
}; };
if let Some(terminal) = &terminal_conn {
let closing = terminal.clone();
d.on_close(Box::new(move || {
let closing = closing.clone();
Box::pin(async move { closing.disconnect(); })
}));
}
if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" { if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" {
let channel = d.clone(); let channel = d.clone();
let initial_sequence = out_sequence.clone(); let initial_sequence = out_sequence.clone();
@@ -1002,6 +1034,7 @@ impl WebRtcSession {
// Default file-transfer folder: the desktop user's home directory. // Default file-transfer folder: the desktop user's home directory.
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into()); let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
let (mut desktop, mut promoted, mut lock_reported) = (desktop, false, desktop); let (mut desktop, mut promoted, mut lock_reported) = (desktop, false, desktop);
let mut privacy_reported = false;
let mut screen = screen; let mut screen = screen;
loop { loop {
loop { loop {
@@ -1056,11 +1089,20 @@ impl WebRtcSession {
if !lock_reported { if !lock_reported {
lock_reported = true; lock_reported = true;
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked())); tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked()));
}
// The viewer's menu only learns about a mode it did not ask for (an
// auto-enable) from this push, so desktop peers need it too, not only a
// tool peer promoted to desktop.
if !privacy_reported && crate::privacy_screen::supported() {
privacy_reported = true;
let (channel, sequence, actions) = (channel.clone(), sequence.clone(), init_actions.clone()); let (channel, sequence, actions) = (channel.clone(), sequence.clone(), init_actions.clone());
let portal = portal_desktop.clone(); let portal = portal_desktop.clone();
let text_out = text_out.clone(); let text_out = text_out.clone();
tokio::spawn(async move { tokio::spawn(async move {
let mut previous = crate::privacy_screen::current_type(); // 0 is not a wire type: the first tick must push the effective state.
// An auto-enable can land before this task starts, and the viewer
// never sent an RPC to learn the mode from a response.
let mut previous = 0u8;
let mut tick = tokio::time::interval(std::time::Duration::from_secs(1)); let mut tick = tokio::time::interval(std::time::Duration::from_secs(1));
loop { loop {
tick.tick().await; tick.tick().await;
@@ -1068,6 +1110,7 @@ impl WebRtcSession {
let current = crate::privacy_screen::current_type(); let current = crate::privacy_screen::current_type();
if current == previous { continue; } if current == previous { continue; }
previous = current; previous = current;
log::info!("Privacy state change pushed: type={current}");
let permission = portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(true)); let permission = portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(true));
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let payload = actions.metrics_payload(desktop_sound, permission); let payload = actions.metrics_payload(desktop_sound, permission);
@@ -1075,6 +1118,9 @@ impl WebRtcSession {
text_out.metrics(message.clone()); text_out.metrics(message.clone());
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; } if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
let state = crate::privacy_screen::state_message(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts); let state = crate::privacy_screen::state_message(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts);
// Android 4.43.0 handles privacy replies on TEXT; CONTROL stays for
// viewers that only read the desktop channel.
let _ = text_out.send(state.clone());
if channel.send(&bytes::Bytes::from(state)).await.is_err() { return; } if channel.send(&bytes::Bytes::from(state)).await.is_err() { return; }
} }
}); });
@@ -1127,6 +1173,7 @@ impl WebRtcSession {
let input_worker = inp.clone(); let input_worker = inp.clone();
let message_input_session=channel_role.input(); let message_input_session=channel_role.input();
let message_role=channel_role.clone(); let message_role=channel_role.clone();
let message_microphone = channel_microphone.clone();
let terminal_worker = terminal_conn.clone(); let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone(); let rpc_out = outbound.clone();
let text_out = text_out.clone(); let text_out = text_out.clone();
@@ -1161,7 +1208,8 @@ impl WebRtcSession {
} }
return; return;
} }
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { let proto_fields = crate::protocol::decode_wire(&msg.data).ok();
if let Some(fields) = proto_fields.as_deref() {
use crate::protocol::WireValue; 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.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()); let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok());
@@ -1191,23 +1239,57 @@ impl WebRtcSession {
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response)); let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return; return;
} }
if let Some((header, body)) = rpc_fields.as_deref().and_then(crate::annotation::draw_request) {
// A toggle waits for the X overlay to open: keep it off the async workers.
let owner = crate::annotation::owner(&actions);
let Ok(response) = tokio::task::spawn_blocking(move || crate::annotation::respond(owner, &header, &body)).await else { return };
// draw_req arrives on CONTROL, but a CONTROL reply timed out (9998) on Mac 4.42.0:
// answer on TEXT like the privacy RPCs above.
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return;
}
if let Some(policy) = rpc_fields.as_deref().and_then(crate::microphone::policy_request) {
let supported = policy <= 1 && crate::microphone::available() && message_role.is_desktop();
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let next = || out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let response = crate::system_actions::session_rpc_response_with_error(rpc_fields.as_deref().unwrap(), u8::from(!supported)).unwrap();
let response = crate::initialization::envelope(next(), ts, 22, &response);
// Windows NevaudioHelper completes the request on TEXT; mirror CONTROL
// for viewers that dispatch responses there, as for privacy RPCs.
let enqueue = |message: Vec<u8>| {
let _ = text_out.send(message.clone());
if channel_name != "TEXT_DATA_CHANNEL" { let _ = rpc_out.send(message); }
};
if supported {
let action = if policy == 1 { 23 } else { 24 };
// Use the channel's ordered outbox: a stalled SCTP send must
// never delay this state transition past a later close on TEXT.
message_microphone.action_with(action, || {
enqueue(response);
enqueue(crate::initialization::envelope(next(), ts, 3, &[8, action as u8]));
});
} else { enqueue(response); }
log::info!("Remote microphone policy: value={policy} supported={supported}");
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))) { 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 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)); let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return; return;
} }
if let Some(response) = rpc.and_then(|r| crate::protocol::decode_wire(r).ok()).and_then(|r| crate::terminal::rpc_response(&r)) { if let Some(response) = rpc_fields.as_deref().and_then(crate::terminal::rpc_response) {
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); 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)); let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return; return;
} }
} }
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { if let Some(fields) = proto_fields.as_deref() {
if mapping.handle(&fields, &channel_name) { return; } if mapping.handle(fields, &channel_name) { return; }
} }
if let Some(files) = &file_worker { if let Some(files) = &file_worker {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { if let Some(fields) = proto_fields.as_deref() {
if files.handle(&fields) { if files.handle(fields) {
static ROUTE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); static ROUTE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if ROUTE.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 20 { if ROUTE.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 20 {
log::info!("File transfer RPC received on {}", channel_name); log::info!("File transfer RPC received on {}", channel_name);
@@ -1233,16 +1315,16 @@ impl WebRtcSession {
} }
} }
shape(&value,0).to_string() shape(&value,0).to_string()
} else if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { } else if let Some(fields) = proto_fields.as_deref() {
format!("protobuf fields={:?}",fields.iter().map(|f|f.number).collect::<Vec<_>>()) format!("protobuf fields={:?}",fields.iter().map(|f|f.number).collect::<Vec<_>>())
} else { "opaque".to_string() }; } else { "opaque".to_string() };
log::info!("Clipboard channel schema: channel={} bytes={} schema={}",channel_name,msg.data.len(),shape); log::info!("Clipboard channel schema: channel={} bytes={} schema={}",channel_name,msg.data.len(),shape);
} }
} }
if channel_name == "CONTROL_DATA_CHANNEL" || channel_name == "TEXT_DATA_CHANNEL" { if channel_name == "CONTROL_DATA_CHANNEL" || channel_name == "TEXT_DATA_CHANNEL" {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) { if let Some(fields) = proto_fields.as_deref() {
use crate::protocol::WireValue; use crate::protocol::WireValue;
for field in &fields { for field in fields {
if let (22,WireValue::Bytes(payload))=(field.number,&field.value) { if let (22,WireValue::Bytes(payload))=(field.number,&field.value) {
let update=rich_incoming.lock().unwrap().response(payload); let update=rich_incoming.lock().unwrap().response(payload);
match update { match update {
@@ -1259,8 +1341,6 @@ impl WebRtcSession {
} }
} }
} }
}
for field in &fields {
if let (21, WireValue::Bytes(payload)) = (field.number,&field.value) { if let (21, WireValue::Bytes(payload)) = (field.number,&field.value) {
let ids=crate::clipboard_rich::format_ids(payload); let ids=crate::clipboard_rich::format_ids(payload);
if !ids.is_empty(){log::info!("Clipboard offered format IDs: {:?}",ids);} if !ids.is_empty(){log::info!("Clipboard offered format IDs: {:?}",ids);}
@@ -1298,8 +1378,6 @@ impl WebRtcSession {
Err(reason)=>log::warn!("Clipboard RPC rejected: {}",reason), Err(reason)=>log::warn!("Clipboard RPC rejected: {}",reason),
} }
} }
}
for field in &fields {
if let (17, WireValue::Bytes(payload)) = (field.number, &field.value) { if let (17, WireValue::Bytes(payload)) = (field.number, &field.value) {
match clipboard_assembly.lock().unwrap().accept(payload) { match clipboard_assembly.lock().unwrap().accept(payload) {
Ok(Some(text)) => { Ok(Some(text)) => {
@@ -1403,6 +1481,8 @@ impl WebRtcSession {
} else { } else {
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route"); log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route");
} }
} else if matches!(action, 23 | 24) && crate::microphone::available() && message_role.is_desktop() {
message_microphone.action(action);
} else if action > 1 && action != 15 { } 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(&[]); 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)); log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));
@@ -1426,69 +1506,87 @@ impl WebRtcSession {
} }
if let Ok(txt) = std::str::from_utf8(&msg.data) { if let Ok(txt) = std::str::from_utf8(&msg.data) {
log::debug!("DataChannel [{}] received UTF-8 data: {} bytes", channel_name, txt.len()); log::debug!("DataChannel [{}] received UTF-8 data: {} bytes", channel_name, txt.len());
if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) { if channel_name.contains("CONTROL") {
if !channel_name.contains("CONTROL") { match crate::control_protocol::decode_control(&msg.data) {
// Input JSON on another channel (mobile input-method text was missing from CONTROL, #13/#46): Ok(crate::control_protocol::ControlMessage::Input(event)) => {
// record action names only, once per name, and accept text_input wherever it arrives. // A ready compositor source remains controllable on its lock screen.
if let Some(action) = val.get("action").and_then(serde_json::Value::as_str) { if screen.backend == crate::desktop_backend::DesktopBackend::Portal
static SEEN: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new()); && (screen.init_error.is_some() || !desktop_ready) { return; }
let mut seen = SEEN.lock().unwrap(); if !crate::wayland::input_ready() {return;}
if seen.len() < 32 && action.len() <= 40 && action.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') && !seen.iter().any(|s| s == action) { use crate::control_protocol::ControlInput;
seen.push(action.to_owned()); // Separate receipt budgets keep motion floods from hiding clicks.
log::info!("JSON action on {} channel: action={}", if channel_name.contains("STREAMER") {"STREAMER"} else if channel_name.contains("TEXT") {"TEXT"} else {"other"}, action); static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
let (slot, kind) = match &event {
ControlInput::MouseButton {..} | ControlInput::MouseClick {..} => (0, "button"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} | ControlInput::TextInput {..} => (1, "keyboard"),
_ => (2, "motion"),
};
if RECEIPTS[slot].fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
log::info!("CONTROL input received: kind={}", kind);
} }
} if let Some(session)=message_input_session.as_ref() {
if let Ok(crate::control_protocol::ControlMessage::Input(crate::control_protocol::ControlInput::TextInput {text})) = crate::control_protocol::decode_control(&msg.data) { if matches!(&event, ControlInput::TextInput {..}) {
if let Some(session)=message_input_session.as_ref() { session.with_input(|| {if crate::wayland::input_ready() {input_worker.text_input(&text);}}); } let (session, input, text) = match &event {
ControlInput::TextInput {text} => (session.clone(), input_worker.clone(), text.clone()),
_ => unreachable!(),
};
let _ = tokio::task::spawn_blocking(move || {
session.with_input(|| {
if crate::wayland::input_ready() { input.text_input(&text); }
});
}).await;
} else {
session.with_input(|| {
if !crate::wayland::input_ready() {return;}
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
_ => {}
}
});
}
}
},
Ok(crate::control_protocol::ControlMessage::Unsupported(v)) => {
// Action name and key names only, never values (an IME text event would carry typed text).
static UNSUPPORTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if UNSUPPORTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
let action = v.get("action").and_then(serde_json::Value::as_str)
.filter(|a| a.len() <= 40 && a.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')).unwrap_or("?");
let keys: Vec<&str> = v.as_object().map(|o| o.keys().map(String::as_str).take(12).collect()).unwrap_or_default();
log::info!("Unsupported CONTROL input: action={action} keys={keys:?}");
}
},
_ => {}
}
} else if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) {
// Input JSON on another channel (mobile input-method text was missing from CONTROL, #13/#46):
// record action names only, once per name, and accept text_input wherever it arrives.
if let Some(action) = val.get("action").and_then(serde_json::Value::as_str) {
static SEEN: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
let mut seen = SEEN.lock().unwrap();
if seen.len() < 32 && action.len() <= 40 && action.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') && !seen.iter().any(|s| s == action) {
seen.push(action.to_owned());
log::info!("JSON action on {} channel: action={}", if channel_name.contains("STREAMER") {"STREAMER"} else if channel_name.contains("TEXT") {"TEXT"} else {"other"}, action);
} }
} }
if channel_name.contains("CONTROL") { if let Ok(crate::control_protocol::ControlMessage::Input(crate::control_protocol::ControlInput::TextInput {text})) = crate::control_protocol::decode_control(&msg.data) {
match crate::control_protocol::decode_control(&msg.data) { if let Some(session)=message_input_session.as_ref() {
Ok(crate::control_protocol::ControlMessage::Input(event)) => { let (session, input) = (session.clone(), input_worker.clone());
// A ready compositor source remains controllable on its lock screen. let _ = tokio::task::spawn_blocking(move || {
if screen.backend == crate::desktop_backend::DesktopBackend::Portal session.with_input(|| {
&& (screen.init_error.is_some() || !desktop_ready) { return; } if crate::wayland::input_ready() { input.text_input(&text); }
if !crate::wayland::input_ready() {return;} });
use crate::control_protocol::ControlInput; }).await;
// Separate receipt budgets keep motion floods from hiding clicks.
static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
let (slot, kind) = match &event {
ControlInput::MouseButton {..} | ControlInput::MouseClick {..} => (0, "button"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} | ControlInput::TextInput {..} => (1, "keyboard"),
_ => (2, "motion"),
};
if RECEIPTS[slot].fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
log::info!("CONTROL input received: kind={}", kind);
}
if let Some(session)=message_input_session.as_ref() {session.with_input(|| {
if !crate::wayland::input_ready() {return;}
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
ControlInput::TextInput {text} => input_worker.text_input(text),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
_ => {}
}
});}
},
Ok(crate::control_protocol::ControlMessage::Unsupported(v)) => {
// Action name and key names only, never values (an IME text event would carry typed text).
static UNSUPPORTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if UNSUPPORTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
let action = v.get("action").and_then(serde_json::Value::as_str)
.filter(|a| a.len() <= 40 && a.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')).unwrap_or("?");
let keys: Vec<&str> = v.as_object().map(|o| o.keys().map(String::as_str).take(12).collect()).unwrap_or_default();
log::info!("Unsupported CONTROL input: action={action} keys={keys:?}");
}
},
_ => {}
} }
} else if channel_name.contains("STREAMER") { }
if channel_name.contains("STREAMER") {
log::debug!("STREAMER channel JSON received"); log::debug!("STREAMER channel JSON received");
if let Some(event)=val.get("connection_period_stats_event") { if let Some(event)=val.get("connection_period_stats_event") {
let nums=crate::viewer_metrics::collect(event); let nums=crate::viewer_metrics::collect(event);
+60 -1
View File
@@ -17,6 +17,11 @@ struct Viewer {
} }
async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>) async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>)
-> (WebRtcSession, Viewer) {
connect_channels(desktop, portal, &["CONTROL_DATA_CHANNEL"]).await
}
async fn connect_channels(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>, labels: &[&str])
-> (WebRtcSession, Viewer) { -> (WebRtcSession, Viewer) {
let input = Arc::new(InputInjector::without_desktop()); let input = Arc::new(InputInjector::without_desktop());
let (host_setting, viewer_setting, router) = crate::test_network::virtual_network().await; let (host_setting, viewer_setting, router) = crate::test_network::virtual_network().await;
@@ -26,7 +31,7 @@ async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::Porta
let pc = Arc::new(APIBuilder::new().with_setting_engine(viewer_setting).build().new_peer_connection(RTCConfiguration::default()).await.unwrap()); let pc = Arc::new(APIBuilder::new().with_setting_engine(viewer_setting).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let (tx, messages) = mpsc::unbounded_channel(); let (tx, messages) = mpsc::unbounded_channel();
let mut channels = HashMap::new(); let mut channels = HashMap::new();
for label in ["CONTROL_DATA_CHANNEL"] { for &label in labels {
let channel = pc.create_data_channel(label, None).await.unwrap(); let channel = pc.create_data_channel(label, None).await.unwrap();
let (tx, name) = (tx.clone(), label.to_string()); let (tx, name) = (tx.clone(), label.to_string());
channel.on_message(Box::new(move |message| { channel.on_message(Box::new(move |message| {
@@ -227,3 +232,57 @@ async fn tool_peer_applies_capture_settings_without_a_desktop() {
viewer.router.lock().await.stop().await.unwrap(); viewer.router.lock().await.stop().await.unwrap();
}).await.expect("tool capture-setting regression exceeded deadline"); }).await.expect("tool capture-setting regression exceeded deadline");
} }
/// Exercise the locally patched notifications and close handler through real SCTP,
/// alongside the upstream CONTROL drain. No cloud or live host session is used.
#[tokio::test]
async fn terminal_notifications_and_disconnect_preserve_control_channel() {
use crate::terminal::{self, TerminalConn};
tokio::time::timeout(Duration::from_secs(20), async {
let id = u32::MAX - 100;
struct Cleanup(u32);
impl Drop for Cleanup {
fn drop(&mut self) {
let (tx, _rx) = mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&terminal::encode(terminal::KILL_REQ, 999,
serde_json::json!({"session_id": self.0}).to_string().as_bytes()));
}
}
let _cleanup = Cleanup(id);
let (host, mut viewer) = connect_channels(false, None,
&["CONTROL_DATA_CHANNEL", "BINARY_DATA_CHANNEL"]).await;
viewer.channels["BINARY_DATA_CHANNEL"].send(&terminal::encode(terminal::OPEN, id,
br#"{"cols":80,"rows":24,"shell":"/bin/sh"}"#).into()).await.unwrap();
tokio::time::timeout(Duration::from_secs(3), async {
let (mut opened, mut notified) = (false, false);
while !(opened && notified) {
let (label, bytes) = viewer.messages.recv().await.expect("terminal channel closed");
if label != "BINARY_DATA_CHANNEL" { continue; }
if let Some(frame) = terminal::decode(&bytes) {
if frame.kind == terminal::OPEN_RESP && frame.session == id {
assert_eq!(serde_json::from_slice::<serde_json::Value>(&frame.payload).unwrap()["code"], 0);
opened = true;
}
} else if body(&bytes, 28) == Some(&[][..]) { notified = true; }
}
}).await.expect("open response and list notification must both reach the viewer");
let state = || {
let (tx, mut rx) = mpsc::unbounded_channel();
TerminalConn::new(tx).handle(&terminal::encode(terminal::LIST_REQ, 998, &[]));
let frame = terminal::decode(&rx.try_recv().unwrap()).unwrap();
serde_json::from_slice::<Vec<serde_json::Value>>(&frame.payload).unwrap().into_iter()
.find(|s| s["session_id"] == id).unwrap()["state"].as_str().unwrap().to_owned()
};
assert_eq!(state(), "running");
viewer.channels["BINARY_DATA_CHANNEL"].close().await.unwrap();
tokio::time::timeout(Duration::from_secs(3), async {
while state() != "detached" { tokio::time::sleep(Duration::from_millis(20)).await; }
}).await.expect("channel closure must detach its terminal session");
viewer.channels["CONTROL_DATA_CHANNEL"].send(&echo_request(123).into()).await.unwrap();
assert!(receive(&mut viewer.messages, 3, Duration::from_secs(3)).await.is_some(),
"terminal closure must leave CONTROL responsive");
viewer.pc.close().await.unwrap();
host.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("terminal lifecycle regression exceeded deadline");
}
+18 -1
View File
@@ -83,10 +83,18 @@ pub fn lan_info() -> Option<(String, String, String)> {
#[cfg(not(target_os = "linux"))] #[cfg(not(target_os = "linux"))]
pub fn lan_info() -> Option<(String, String, String)> { None } pub fn lan_info() -> Option<(String, String, String)> { None }
/// Body of the helper registration request (same address as `inner_ip` and `ip`: this host has one LAN address).
fn report_body(mac: &str, ip: &str, subnet_mask: &str) -> serde_json::Value {
serde_json::json!({ "mac": mac, "inner_ip": ip, "ip": ip, "subnet_mask": subnet_mask })
}
/// Report this host's LAN identity like the official host after sign-in. /// Report this host's LAN identity like the official host after sign-in.
/// The server rejects the report (HTTP 422, code 1001) unless `inner_ip` is present; the official macOS
/// client sends `inner_ip`, `ip`, `mac` and `subnet_mask`. Verified live: with `inner_ip` the helper is
/// accepted (HTTP 200) and the cloud forwards `wake_on_lan` pushes to this host.
pub async fn report(auth: &crate::auth::UUAuthClient) { pub async fn report(auth: &crate::auth::UUAuthClient) {
let Some((mac, ip, subnet_mask)) = lan_info() else { log::warn!("WOL helper: no IPv4 default-route interface"); return; }; let Some((mac, ip, subnet_mask)) = lan_info() else { log::warn!("WOL helper: no IPv4 default-route interface"); return; };
let body = serde_json::json!({ "mac": mac, "ip": ip, "subnet_mask": subnet_mask }); let body = report_body(&mac, &ip, &subnet_mask);
match auth.post_json_url("https://api-ipv4.nrd.nie.163.com", "/api/v1/device/wake_on_lan/info", &body).await { match auth.post_json_url("https://api-ipv4.nrd.nie.163.com", "/api/v1/device/wake_on_lan/info", &body).await {
Ok((status, value)) => log::info!("WOL helper: LAN info reported: status={status} code={:?} turn_on_wol={:?}", Ok((status, value)) => log::info!("WOL helper: LAN info reported: status={status} code={:?} turn_on_wol={:?}",
value.get("code").and_then(serde_json::Value::as_i64), value.get("code").and_then(serde_json::Value::as_i64),
@@ -108,6 +116,15 @@ mod tests {
assert_eq!(&packet[..6], &[0xff; 6]); assert_eq!(&packet[..6], &[0xff; 6]);
assert_eq!(&packet[96..], &[1, 2, 3, 4, 5, 6]); assert_eq!(&packet[96..], &[1, 2, 3, 4, 5, 6]);
} }
#[test]
fn report_body_has_inner_ip() {
let body = report_body("aa:bb:cc:dd:ee:01", "192.168.2.29", "255.255.255.0");
assert_eq!(body["inner_ip"], "192.168.2.29");
assert_eq!(body["ip"], "192.168.2.29");
assert_eq!(body["mac"], "aa:bb:cc:dd:ee:01");
assert_eq!(body["subnet_mask"], "255.255.255.0");
}
#[test] #[test]
fn directed_broadcast() { fn directed_broadcast() {
assert_eq!(subnet_broadcast("192.168.2.29", "255.255.255.0"), Some(Ipv4Addr::new(192, 168, 2, 255))); assert_eq!(subnet_broadcast("192.168.2.29", "255.255.255.0"), Some(Ipv4Addr::new(192, 168, 2, 255)));
Binary file not shown.

After

Width:  |  Height:  |  Size: 68 B

+17
View File
@@ -419,7 +419,24 @@ static void authorization_still_required(void) {
g_variant_unref(reply); g_variant_unref(reply);
} }
} }
static void saved_token_with_position(const char *token, void *data, int has_position, int32_t x, int32_t y) {
int *calls = data;
assert(!strcmp(token, "synthetic-grant"));
assert(has_position && x == 25 && y == 50);
(*calls)++;
}
static void rotated_token_callback(void) {
struct uu_portal p = {0};
int calls = 0;
save_restore_token(&p, NULL, saved_token_with_position, &calls);
assert(calls == 0);
p.restore_token = "synthetic-grant";
p.has_position = 1; p.position_x = 25; p.position_y = 50;
save_restore_token(&p, NULL, saved_token_with_position, &calls);
assert(calls == 1);
}
int main(void) { int main(void) {
rotated_token_callback();
portal_renegotiation_timeout(); portal_renegotiation_timeout();
portal_renegotiation_recovery(); portal_renegotiation_recovery();
portal_renegotiation_event_order_and_healthy_states(); portal_renegotiation_event_order_and_healthy_states();