Compare commits

...
21 Commits
Author SHA1 Message Date
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
35 changed files with 1749 additions and 264 deletions

No files matched your search

+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` |
Generated
+1 -1
View File
@@ -2804,7 +2804,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]] [[package]]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.50" version = "0.2.56"
dependencies = [ dependencies = [
"ab_glyph", "ab_glyph",
"async-trait", "async-trait",
+1 -1
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.50" version = "0.2.56"
edition = "2021" edition = "2021"
default-run = "uuremote-server" default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"] authors = ["uu-remote-linux contributors"]
+4 -3
View File
@@ -80,8 +80,8 @@ Protocol strings and messages that come from the UU servers are shown as the ser
| 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 | | 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 |
@@ -394,10 +394,11 @@ 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) |
+4 -3
View File
@@ -69,8 +69,8 @@ UU_LANG=en uuremote-server
| 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 Linux 屏幕上,并随画面传回控制端(X11,需要合成器;覆盖层不拦截鼠标);关闭批注或断开连接时清除。已用 Mac 控制端 4.42.0 实测,手机控制端未测 | | 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 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 校验密码并解锁当前会话 |
| 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 | | 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 |
| 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 | | 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 |
@@ -357,10 +357,11 @@ 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` | 凭证缺失时不自动弹出登录窗口 |
+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;
+74 -7
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; }
@@ -616,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; }
@@ -653,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);
@@ -832,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);
} }
@@ -997,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);
+12
View File
@@ -18,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);
+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;
} }
+11
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
@@ -79,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`
+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.**
+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(){
+63 -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));
@@ -715,6 +722,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);
+111 -15
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,
} }
} }
@@ -303,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() };
@@ -381,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 {
@@ -497,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();
} }
@@ -530,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)); }
@@ -600,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)) } }
@@ -617,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)) } }
@@ -742,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; }
@@ -1040,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);
@@ -1289,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]
+2
View File
@@ -1038,6 +1038,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()); });
@@ -1119,6 +1120,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.
+456 -28
View File
@@ -35,20 +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_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;
@@ -68,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); };
@@ -87,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 {
@@ -112,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
@@ -133,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 })
} }
@@ -212,7 +280,8 @@ mod native {
prefer_dmabuf = true; prefer_dmabuf = true;
} }
let pointer = if detailed { let pointer = if detailed {
let cancel = cancelled.filter(|_| !virtual_output); // Virtual shares can wait for consent too; cancel them like monitor opens.
let cancel = cancelled;
let callback = cancel.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32); let callback = cancel.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
let cancel_data = cancel.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void); let cancel_data = cancel.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
unsafe { uu_portal_open_detailed( unsafe { uu_portal_open_detailed(
@@ -260,7 +329,14 @@ mod native {
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) {
@@ -270,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()) }
@@ -278,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) }
@@ -305,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())
} }
@@ -331,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())?;
@@ -338,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> {
@@ -375,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(())
@@ -468,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 {
@@ -524,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())}
} }
@@ -601,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)),
})) }))
} }
@@ -640,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() {
@@ -874,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")))]
@@ -896,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))
} }
@@ -933,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;
@@ -1018,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);
}
}
}
+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.
+72 -9
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,14 +30,52 @@ 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 /// 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 /// ignores it on Wayland, so the cover showed up as an unidentified window with the theme's
@@ -30,5 +84,14 @@ if (v) for (const w of workspace.windowList()) if (w.normalWindow || w.dialog) w
/// duplicate captions, so match the title as a prefix. /// duplicate captions, so match the title as a prefix.
pub fn hide_cover_from_taskbar() -> Result<(), String> { pub fn hide_cover_from_taskbar() -> Result<(), String> {
script(r#"for (const w of workspace.windowList()) script(r#"for (const w of workspace.windowList())
if (w.resourceClass === "uuremote-server" && w.caption.indexOf("uu-remote-linux privacy") === 0) w.skipTaskbar = true;"#) 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"#);
}
} }
+18 -1
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;
@@ -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}"))?;
@@ -81,12 +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. A device that // controller keeps the recovery record and the guard for the next attempt. A device that
// no longer exists is skipped, so a record replayed after a reboot cannot wedge recovery. // 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}")); 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).
+32 -1
View File
@@ -25,8 +25,18 @@ static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
/// ends. An auto-enable never overrides it, including an RPC that arrives after the connection /// ends. An auto-enable never overrides it, including an RPC that arrives after the connection
/// opens but before `session_started` bumps the counter. /// opens but before `session_started` bumps the counter.
static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false); 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 {
@@ -38,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);
@@ -112,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));
+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);
}
} }
+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(()); }
} }
+114 -73
View File
@@ -604,14 +604,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;
} }
@@ -796,6 +815,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();
@@ -1177,7 +1203,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());
@@ -1222,18 +1249,18 @@ impl WebRtcSession {
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);
@@ -1259,16 +1286,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 {
@@ -1285,8 +1312,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);}
@@ -1324,8 +1349,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)) => {
@@ -1452,69 +1475,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");
}